?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(fish_linear_abort): type accuracy.
[midnight-commander.git] / src / vfs / fish / fish.c
blob36ce56cf74abbab60a12df5867a9a63c6ffdaa22
1 /*
2 Virtual File System: FISH implementation for transfering files over
3 shell connections.
4
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2007, 2008, 2009, 2010, 2011
7 The Free Software Foundation, Inc.
8
9 Written by:
10 Pavel Machek, 1998
11 Michal Svec, 2000
12 Andrew Borodin <aborodin@vmail.ru>, 2010
13 Slava Zanko <slavazanko@gmail.com>, 2010
14 Ilia Maslakov <il.smind@gmail.com>, 2010
15
16 Derived from ftpfs.c.
17
18 This file is part of the Midnight Commander.
19
20 The Midnight Commander is free software: you can redistribute it
21 and/or modify it under the terms of the GNU General Public License as
22 published by the Free Software Foundation, either version 3 of the License,
23 or (at your option) any later version.
24
25 The Midnight Commander is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
29
30 You should have received a copy of the GNU General Public License
31 along with this program. If not, see <http://www.gnu.org/licenses/>.
32 */
33
34 /**
35 * \file
36 * \brief Source: Virtual File System: FISH implementation for transfering files over
37 * shell connections
38 * \author Pavel Machek
39 * \author Michal Svec
40 * \date 1998, 2000
41 *
42 * Derived from ftpfs.c
43 * Read README.fish for protocol specification.
44 *
45 * Syntax of path is: \verbatim sh://user@host[:Cr]/path \endverbatim
46 * where C means you want compressed connection,
47 * and r means you want to use rsh
48 *
49 * Namespace: fish_vfs_ops exported.
50 */
51
52 /* Define this if your ssh can take -I option */
53
54 #include <config.h>
55 #include <errno.h>
56 #include <fcntl.h>
57 #include <pwd.h>
58 #include <grp.h>
59 #include <sys/time.h> /* gettimeofday() */
60 #include <stdlib.h>
61 #include <string.h>
62 #include <inttypes.h> /* uintmax_t */
63
64 #include "lib/global.h"
65 #include "lib/tty/tty.h" /* enable/disable interrupt key */
66 #include "lib/strescape.h"
67 #include "lib/unixcompat.h"
68 #include "lib/fileloc.h"
69 #include "lib/mcconfig.h"
70
71 #include "src/execute.h" /* pre_exec, post_exec */
72
73 #include "lib/vfs/vfs.h"
74 #include "lib/vfs/utilvfs.h"
75 #include "lib/vfs/netutil.h"
76 #include "lib/vfs/xdirentry.h"
77 #include "lib/vfs/gc.h" /* vfs_stamp_create */
78
79 #include "fish.h"
80 #include "fishdef.h"
81
82 /*** global variables ****************************************************************************/
83
84 int fish_directory_timeout = 900;
85
86 /*** file scope macro definitions ****************************************************************/
87
88 #define DO_RESOLVE_SYMLINK 1
89 #define DO_OPEN 2
90 #define DO_FREE_RESOURCE 4
91
92 #define FISH_FLAG_COMPRESSED 1
93 #define FISH_FLAG_RSH 2
94
95 #define OPT_FLUSH 1
96 #define OPT_IGNORE_ERROR 2
97
98 /*
99 * Reply codes.
100 */
101 #define PRELIM 1 /* positive preliminary */
102 #define COMPLETE 2 /* positive completion */
103 #define CONTINUE 3 /* positive intermediate */
104 #define TRANSIENT 4 /* transient negative completion */
105 #define ERROR 5 /* permanent negative completion */
106
107 /* command wait_flag: */
108 #define NONE 0x00
109 #define WAIT_REPLY 0x01
110 #define WANT_STRING 0x02
111
112 /* environment flags */
113 #define FISH_HAVE_HEAD 1
114 #define FISH_HAVE_SED 2
115 #define FISH_HAVE_AWK 4
116 #define FISH_HAVE_PERL 8
117 #define FISH_HAVE_LSQ 16
118 #define FISH_HAVE_DATE_MDYT 32
119 #define FISH_HAVE_TAIL 64
120
121 #define SUP ((fish_super_data_t *) super->data)
122
123 /*** file scope type declarations ****************************************************************/
124
125 typedef struct
126 {
127 int sockr;
128 int sockw;
129 char *scr_ls;
130 char *scr_chmod;
131 char *scr_utime;
132 char *scr_exists;
133 char *scr_mkdir;
134 char *scr_unlink;
135 char *scr_chown;
136 char *scr_rmdir;
137 char *scr_ln;
138 char *scr_mv;
139 char *scr_hardlink;
140 char *scr_get;
141 char *scr_send;
142 char *scr_append;
143 char *scr_info;
144 int host_flags;
145 char *scr_env;
146 } fish_super_data_t;
147
148 typedef struct
149 {
150 off_t got;
151 off_t total;
152 gboolean append;
153 } fish_fh_data_t;
154
155 /*** file scope variables ************************************************************************/
156
157 static char reply_str[80];
158
159 static struct vfs_class vfs_fish_ops;
160
161 /*** file scope functions ************************************************************************/
162 /* --------------------------------------------------------------------------------------------- */
163
164 static char *
165 fish_load_script_from_file (const char *hostname, const char *script_name, const char *def_content)
166 {
167 char *scr_filename = NULL;
168 char *scr_content;
169 gsize scr_len = 0;
170
171 /* 1st: scan user directory */
172 scr_filename = g_build_path (PATH_SEP_STR, mc_config_get_data_path (), FISH_PREFIX, hostname,
173 script_name, (char *) NULL);
174 /* silent about user dir */
175 g_file_get_contents (scr_filename, &scr_content, &scr_len, NULL);
176 g_free (scr_filename);
177 /* 2nd: scan system dir */
178 if (scr_content == NULL)
179 {
180 scr_filename =
181 g_build_path (PATH_SEP_STR, LIBEXECDIR, FISH_PREFIX, script_name, (char *) NULL);
182 g_file_get_contents (scr_filename, &scr_content, &scr_len, NULL);
183 g_free (scr_filename);
184 }
185
186 if (scr_content != NULL)
187 return scr_content;
188
189 return g_strdup (def_content);
190 }
191
192 /* --------------------------------------------------------------------------------------------- */
193
194 static int
195 fish_decode_reply (char *s, gboolean was_garbage)
196 {
197 int code;
198
199 if (sscanf (s, "%d", &code) == 0)
200 {
201 code = 500;
202 return 5;
203 }
204 if (code < 100)
205 return was_garbage ? ERROR : (code == 0 ? COMPLETE : PRELIM);
206 return code / 100;
207 }
208
209 /* --------------------------------------------------------------------------------------------- */
210 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
211
212 static int
213 fish_get_reply (struct vfs_class *me, int sock, char *string_buf, int string_len)
214 {
215 char answer[BUF_1K];
216 gboolean was_garbage = FALSE;
217
218 while (TRUE)
219 {
220 if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n'))
221 {
222 if (string_buf != NULL)
223 *string_buf = '\0';
224 return 4;
225 }
226
227 if (strncmp (answer, "### ", 4) == 0)
228 return fish_decode_reply (answer + 4, was_garbage ? 1 : 0);
229
230 was_garbage = TRUE;
231 if (string_buf != NULL)
232 g_strlcpy (string_buf, answer, string_len);
233 }
234 }
235
236 /* --------------------------------------------------------------------------------------------- */
237
238 static int
239 fish_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, const char *fmt, ...)
240 {
241 va_list ap;
242 char *str;
243 ssize_t status;
244 FILE *logfile = MEDATA->logfile;
245
246 va_start (ap, fmt);
247
248 str = g_strdup_vprintf (fmt, ap);
249 va_end (ap);
250
251 if (logfile)
252 {
253 size_t ret;
254 ret = fwrite (str, strlen (str), 1, logfile);
255 ret = fflush (logfile);
256 }
257
258 tty_enable_interrupt_key ();
259
260 status = write (SUP->sockw, str, strlen (str));
261 g_free (str);
262
263 tty_disable_interrupt_key ();
264 if (status < 0)
265 return TRANSIENT;
266
267 if (wait_reply)
268 return fish_get_reply (me, SUP->sockr,
269 (wait_reply & WANT_STRING) ? reply_str :
270 NULL, sizeof (reply_str) - 1);
271 return COMPLETE;
272 }
273
274 /* --------------------------------------------------------------------------------------------- */
275
276 static void
277 fish_free_archive (struct vfs_class *me, struct vfs_s_super *super)
278 {
279 if ((SUP->sockw != -1) || (SUP->sockr != -1))
280 {
281 vfs_print_message (_("fish: Disconnecting from %s"), super->name ? super->name : "???");
282 fish_command (me, super, NONE, "#BYE\nexit\n");
283 close (SUP->sockw);
284 close (SUP->sockr);
285 SUP->sockw = SUP->sockr = -1;
286 }
287 g_free (SUP->scr_ls);
288 g_free (SUP->scr_exists);
289 g_free (SUP->scr_mkdir);
290 g_free (SUP->scr_unlink);
291 g_free (SUP->scr_chown);
292 g_free (SUP->scr_chmod);
293 g_free (SUP->scr_utime);
294 g_free (SUP->scr_rmdir);
295 g_free (SUP->scr_ln);
296 g_free (SUP->scr_mv);
297 g_free (SUP->scr_hardlink);
298 g_free (SUP->scr_get);
299 g_free (SUP->scr_send);
300 g_free (SUP->scr_append);
301 g_free (SUP->scr_info);
302 g_free (SUP->scr_env);
303 g_free (SUP);
304 super->data = NULL;
305 }
306
307 /* --------------------------------------------------------------------------------------------- */
308
309 static void
310 fish_pipeopen (struct vfs_s_super *super, const char *path, const char *argv[])
311 {
312 int fileset1[2], fileset2[2];
313 int res;
314
315 if ((pipe (fileset1) < 0) || (pipe (fileset2) < 0))
316 vfs_die ("Cannot pipe(): %m.");
317
318 res = fork ();
319
320 if (res != 0)
321 {
322 if (res < 0)
323 vfs_die ("Cannot fork(): %m.");
324 /* We are the parent */
325 close (fileset1[0]);
326 SUP->sockw = fileset1[1];
327 close (fileset2[1]);
328 SUP->sockr = fileset2[0];
329 }
330 else
331 {
332 res = dup2 (fileset1[0], 0);
333 close (fileset1[0]);
334 close (fileset1[1]);
335 res = dup2 (fileset2[1], 1);
336 close (2);
337 /* stderr to /dev/null */
338 res = open ("/dev/null", O_WRONLY);
339 close (fileset2[0]);
340 close (fileset2[1]);
341 execvp (path, const_cast (char **, argv));
342 _exit (3);
343 }
344 }
345
346 /* --------------------------------------------------------------------------------------------- */
347
348 static char *
349 fish_set_env (int flags)
350 {
351 GString *tmp;
352
353 tmp = g_string_sized_new (250);
354 g_string_assign (tmp, "");
355
356 if ((flags & FISH_HAVE_HEAD) != 0)
357 g_string_append (tmp, "FISH_HAVE_HEAD=1 export FISH_HAVE_HEAD; ");
358
359 if ((flags & FISH_HAVE_SED) != 0)
360 g_string_append (tmp, "FISH_HAVE_SED=1 export FISH_HAVE_SED; ");
361
362 if ((flags & FISH_HAVE_AWK) != 0)
363 g_string_append (tmp, "FISH_HAVE_AWK=1 export FISH_HAVE_AWK; ");
364
365 if ((flags & FISH_HAVE_PERL) != 0)
366 g_string_append (tmp, "FISH_HAVE_PERL=1 export FISH_HAVE_PERL; ");
367
368 if ((flags & FISH_HAVE_LSQ) != 0)
369 g_string_append (tmp, "FISH_HAVE_LSQ=1 export FISH_HAVE_LSQ; ");
370
371 if ((flags & FISH_HAVE_DATE_MDYT) != 0)
372 g_string_append (tmp, "FISH_HAVE_DATE_MDYT=1 export FISH_HAVE_DATE_MDYT; ");
373
374 if ((flags & FISH_HAVE_TAIL) != 0)
375 g_string_append (tmp, "FISH_HAVE_TAIL=1 export FISH_HAVE_TAIL; ");
376
377 return g_string_free (tmp, FALSE);
378 }
379
380 /* --------------------------------------------------------------------------------------------- */
381
382 static gboolean
383 fish_info (struct vfs_class *me, struct vfs_s_super *super)
384 {
385 char buffer[BUF_8K];
386 if (fish_command (me, super, NONE, SUP->scr_info) == COMPLETE)
387 {
388 while (TRUE)
389 {
390 int res;
391
392 res = vfs_s_get_line_interruptible (me, buffer, sizeof (buffer), SUP->sockr);
393 if ((res == 0) || (res == EINTR))
394 ERRNOR (ECONNRESET, FALSE);
395 if (strncmp (buffer, "### ", 4) == 0)
396 break;
397 SUP->host_flags = atol (buffer);
398 }
399 return TRUE;
400 }
401 ERRNOR (E_PROTO, FALSE);
402 }
403
404
405 /* --------------------------------------------------------------------------------------------- */
406
407 static void
408 fish_open_archive_pipeopen (struct vfs_s_super *super)
409 {
410 char gbuf[10];
411 const char *argv[10]; /* All of 10 is used now */
412 const char *xsh = (super->path_element->port == FISH_FLAG_RSH ? "rsh" : "ssh");
413 int i = 0;
414
415 argv[i++] = xsh;
416 if (super->path_element->port == FISH_FLAG_COMPRESSED)
417 argv[i++] = "-C";
418
419 if (super->path_element->port > FISH_FLAG_RSH)
420 {
421 argv[i++] = "-p";
422 g_snprintf (gbuf, sizeof (gbuf), "%d", super->path_element->port);
423 argv[i++] = gbuf;
424 }
425
426 /*
427 * Add the user name to the ssh command line only if it was explicitly
428 * set in vfs URL. rsh/ssh will get current user by default
429 * plus we can set convenient overrides in ~/.ssh/config (explicit -l
430 * option breaks it for some)
431 */
432
433 if (super->path_element->user != NULL)
434 {
435 argv[i++] = "-l";
436 argv[i++] = super->path_element->user;
437 }
438 else
439 {
440 /* The rest of the code assumes it to be a valid username */
441 super->path_element->user = vfs_get_local_username ();
442 }
443
444 argv[i++] = super->path_element->host;
445 argv[i++] = "echo FISH:; /bin/sh";
446 argv[i++] = NULL;
447
448 fish_pipeopen (super, xsh, argv);
449 }
450
451 /* --------------------------------------------------------------------------------------------- */
452
453 static gboolean
454 fish_open_archive_talk (struct vfs_class *me, struct vfs_s_super *super)
455 {
456 char answer[2048];
457
458 printf ("\n%s\n", _("fish: Waiting for initial line..."));
459
460 if (!vfs_s_get_line (me, SUP->sockr, answer, sizeof (answer), ':'))
461 return FALSE;
462
463 if (strstr (answer, "assword") != NULL)
464 {
465 /* Currently, this does not work. ssh reads passwords from
466 /dev/tty, not from stdin :-(. */
467
468 printf ("\n%s\n", _("Sorry, we cannot do password authenticated connections for now."));
469
470 return FALSE;
471 #if 0
472 if (super->path_element->password == NULL)
473 {
474 char *p, *op;
475 p = g_strdup_printf (_("fish: Password is required for %s"), super->path_element->user);
476 op = vfs_get_password (p);
477 g_free (p);
478 if (op == NULL)
479 return FALSE;
480 super->path_element->password = op;
481
482 }
483
484 printf ("\n%s\n", _("fish: Sending password..."));
485
486 {
487 size_t str_len;
488
489 str_len = strlen (super->path_element->password);
490 if ((write (SUP.sockw, super->path_element->password, str_len) != (ssize_t) str_len)
491 || (write (SUP->sockw, "\n", 1) != 1))
492 return FALSE;
493 }
494 #endif
495 }
496 return TRUE;
497 }
498
499 /* --------------------------------------------------------------------------------------------- */
500
501 static int
502 fish_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
503 {
504 gboolean ftalk;
505 /* hide panels */
506 pre_exec ();
507
508 /* open pipe */
509 fish_open_archive_pipeopen (super);
510
511 /* Start talk with ssh-server (password prompt, etc ) */
512 ftalk = fish_open_archive_talk (me, super);
513
514 /* show panels */
515 post_exec ();
516
517 if (!ftalk)
518 ERRNOR (E_PROTO, -1);
519
520 vfs_print_message (_("fish: Sending initial line..."));
521 /*
522 * Run `start_fish_server'. If it doesn't exist - no problem,
523 * we'll talk directly to the shell.
524 */
525
526 if (fish_command
527 (me, super, WAIT_REPLY,
528 "#FISH\necho; start_fish_server 2>&1; echo '### 200'\n") != COMPLETE)
529 ERRNOR (E_PROTO, -1);
530
531 vfs_print_message (_("fish: Handshaking version..."));
532 if (fish_command (me, super, WAIT_REPLY, "#VER 0.0.3\necho '### 000'\n") != COMPLETE)
533 ERRNOR (E_PROTO, -1);
534
535 /* Set up remote locale to C, otherwise dates cannot be recognized */
536 if (fish_command
537 (me, super, WAIT_REPLY,
538 "LANG=C LC_ALL=C LC_TIME=C; export LANG LC_ALL LC_TIME;\n" "echo '### 200'\n") != COMPLETE)
539 ERRNOR (E_PROTO, -1);
540
541 vfs_print_message (_("fish: Getting host info..."));
542 if (fish_info (me, super))
543 SUP->scr_env = fish_set_env (SUP->host_flags);
544
545 #if 0
546 super->name =
547 g_strconcat ("sh://", super->path_element->user, "@", super->path_element->host, "/",
548 (char *) NULL);
549 #else
550 super->name = g_strdup (PATH_SEP_STR);
551 #endif
552
553 super->root = vfs_s_new_inode (me, super, vfs_s_default_stat (me, S_IFDIR | 0755));
554 return 0;
555 }
556
557 /* --------------------------------------------------------------------------------------------- */
558
559 static int
560 fish_open_archive (struct vfs_s_super *super,
561 const vfs_path_t * vpath, const vfs_path_element_t * vpath_element)
562 {
563 (void) vpath;
564
565 super->data = g_new0 (fish_super_data_t, 1);
566 super->path_element = vfs_path_element_clone (vpath_element);
567
568 if (strncmp (vpath_element->vfs_prefix, "rsh", 3) == 0)
569 super->path_element->port = FISH_FLAG_RSH;
570
571 SUP->scr_ls =
572 fish_load_script_from_file (super->path_element->host, FISH_LS_FILE, FISH_LS_DEF_CONTENT);
573 SUP->scr_exists =
574 fish_load_script_from_file (super->path_element->host, FISH_EXISTS_FILE,
575 FISH_EXISTS_DEF_CONTENT);
576 SUP->scr_mkdir =
577 fish_load_script_from_file (super->path_element->host, FISH_MKDIR_FILE,
578 FISH_MKDIR_DEF_CONTENT);
579 SUP->scr_unlink =
580 fish_load_script_from_file (super->path_element->host, FISH_UNLINK_FILE,
581 FISH_UNLINK_DEF_CONTENT);
582 SUP->scr_chown =
583 fish_load_script_from_file (super->path_element->host, FISH_CHOWN_FILE,
584 FISH_CHOWN_DEF_CONTENT);
585 SUP->scr_chmod =
586 fish_load_script_from_file (super->path_element->host, FISH_CHMOD_FILE,
587 FISH_CHMOD_DEF_CONTENT);
588 SUP->scr_utime =
589 fish_load_script_from_file (super->path_element->host, FISH_UTIME_FILE,
590 FISH_UTIME_DEF_CONTENT);
591 SUP->scr_rmdir =
592 fish_load_script_from_file (super->path_element->host, FISH_RMDIR_FILE,
593 FISH_RMDIR_DEF_CONTENT);
594 SUP->scr_ln =
595 fish_load_script_from_file (super->path_element->host, FISH_LN_FILE, FISH_LN_DEF_CONTENT);
596 SUP->scr_mv =
597 fish_load_script_from_file (super->path_element->host, FISH_MV_FILE, FISH_MV_DEF_CONTENT);
598 SUP->scr_hardlink =
599 fish_load_script_from_file (super->path_element->host, FISH_HARDLINK_FILE,
600 FISH_HARDLINK_DEF_CONTENT);
601 SUP->scr_get =
602 fish_load_script_from_file (super->path_element->host, FISH_GET_FILE, FISH_GET_DEF_CONTENT);
603 SUP->scr_send =
604 fish_load_script_from_file (super->path_element->host, FISH_SEND_FILE,
605 FISH_SEND_DEF_CONTENT);
606 SUP->scr_append =
607 fish_load_script_from_file (super->path_element->host, FISH_APPEND_FILE,
608 FISH_APPEND_DEF_CONTENT);
609 SUP->scr_info =
610 fish_load_script_from_file (super->path_element->host, FISH_INFO_FILE,
611 FISH_INFO_DEF_CONTENT);
612
613 return fish_open_archive_int (vpath_element->class, super);
614 }
615
616 /* --------------------------------------------------------------------------------------------- */
617
618 static int
619 fish_archive_same (const vfs_path_element_t * vpath_element, struct vfs_s_super *super,
620 const vfs_path_t * vpath, void *cookie)
621 {
622 vfs_path_element_t *path_element;
623 int result;
624
625 (void) vpath;
626 (void) cookie;
627
628 path_element = vfs_path_element_clone (vpath_element);
629
630 if (path_element->user == NULL)
631 path_element->user = vfs_get_local_username ();
632
633 result = ((strcmp (path_element->host, super->path_element->host) == 0)
634 && (strcmp (path_element->user, super->path_element->user) == 0)
635 && (path_element->port == super->path_element->port)) ? 1 : 0;
636
637 vfs_path_element_free (path_element);
638
639 return result;
640 }
641
642 /* --------------------------------------------------------------------------------------------- */
643
644 static int
645 fish_dir_load (struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
646 {
647 struct vfs_s_super *super = dir->super;
648 char buffer[8192];
649 struct vfs_s_entry *ent = NULL;
650 FILE *logfile;
651 char *quoted_path;
652 int reply_code;
653 gchar *shell_commands;
654
655 /*
656 * Simple FISH debug interface :]
657 */
658 #if 0
659 if (!(MEDATA->logfile))
660 {
661 MEDATA->logfile = fopen ("/tmp/mc-FISH.sh", "w");
662 }
663 #endif
664 logfile = MEDATA->logfile;
665
666 vfs_print_message (_("fish: Reading directory %s..."), remote_path);
667
668 gettimeofday (&dir->timestamp, NULL);
669 dir->timestamp.tv_sec += fish_directory_timeout;
670 quoted_path = strutils_shell_escape (remote_path);
671 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_ls, (char *) NULL);
672 fish_command (me, super, NONE, shell_commands, quoted_path);
673 g_free (shell_commands);
674 g_free (quoted_path);
675 ent = vfs_s_generate_entry (me, NULL, dir, 0);
676 while (TRUE)
677 {
678 int res = vfs_s_get_line_interruptible (me, buffer, sizeof (buffer), SUP->sockr);
679 if ((!res) || (res == EINTR))
680 {
681 vfs_s_free_entry (me, ent);
682 me->verrno = ECONNRESET;
683 goto error;
684 }
685 if (logfile)
686 {
687 fputs (buffer, logfile);
688 fputs ("\n", logfile);
689 fflush (logfile);
690 }
691 if (!strncmp (buffer, "### ", 4))
692 break;
693 if ((!buffer[0]))
694 {
695 if (ent->name)
696 {
697 vfs_s_insert_entry (me, dir, ent);
698 ent = vfs_s_generate_entry (me, NULL, dir, 0);
699 }
700 continue;
701 }
702
703 #define ST ent->ino->st
704
705 switch (buffer[0])
706 {
707 case ':':
708 {
709 char *temp;
710 char *data_start = buffer + 1;
711 char *filename = data_start;
712 char *filename_bound;
713
714 filename_bound = filename + strlen (filename);
715
716 if (!strcmp (data_start, "\".\"") || !strcmp (data_start, "\"..\""))
717 break; /* We'll do "." and ".." ourselves */
718
719 if (S_ISLNK (ST.st_mode))
720 {
721 char *linkname;
722 char *linkname_bound;
723 /* we expect: "escaped-name" -> "escaped-name"
724 // -> cannot occur in filenames,
725 // because it will be escaped to -\> */
726
727
728 linkname_bound = filename_bound;
729
730 if (*filename == '"')
731 ++filename;
732
733 linkname = strstr (filename, "\" -> \"");
734 if (!linkname)
735 {
736 /* broken client, or smth goes wrong */
737 linkname = filename_bound;
738 if (filename_bound > filename && *(filename_bound - 1) == '"')
739 --filename_bound; /* skip trailing " */
740 }
741 else
742 {
743 filename_bound = linkname;
744 linkname += 6; /* strlen ("\" -> \"") */
745 if (*(linkname_bound - 1) == '"')
746 --linkname_bound; /* skip trailing " */
747 }
748
749 ent->name = g_strndup (filename, filename_bound - filename);
750 temp = ent->name;
751 ent->name = strutils_shell_unescape (ent->name);
752 g_free (temp);
753
754 ent->ino->linkname = g_strndup (linkname, linkname_bound - linkname);
755 temp = ent->ino->linkname;
756 ent->ino->linkname = strutils_shell_unescape (ent->ino->linkname);
757 g_free (temp);
758 }
759 else
760 {
761 /* we expect: "escaped-name" */
762 if (filename_bound - filename > 2)
763 {
764 /*
765 there is at least 2 "
766 and we skip them
767 */
768 if (*filename == '"')
769 ++filename;
770 if (*(filename_bound - 1) == '"')
771 --filename_bound;
772 }
773 ent->name = g_strndup (filename, filename_bound - filename);
774 temp = ent->name;
775 ent->name = strutils_shell_unescape (ent->name);
776 g_free (temp);
777 }
778 break;
779 }
780 case 'S':
781 #ifdef HAVE_ATOLL
782 ST.st_size = (off_t) atoll (buffer + 1);
783 #else
784 ST.st_size = (off_t) atof (buffer + 1);
785 #endif
786 break;
787 case 'P':
788 {
789 size_t skipped;
790 vfs_parse_filemode (buffer + 1, &skipped, &ST.st_mode);
791 break;
792 }
793 case 'R':
794 {
795 /*
796 raw filemode:
797 we expect: Roctal-filemode octal-filetype uid.gid
798 */
799 size_t skipped;
800 vfs_parse_raw_filemode (buffer + 1, &skipped, &ST.st_mode);
801 break;
802 }
803 case 'd':
804 {
805 vfs_split_text (buffer + 1);
806 if (!vfs_parse_filedate (0, &ST.st_ctime))
807 break;
808 ST.st_atime = ST.st_mtime = ST.st_ctime;
809 }
810 break;
811 case 'D':
812 {
813 struct tm tim;
814 if (sscanf (buffer + 1, "%d %d %d %d %d %d", &tim.tm_year, &tim.tm_mon,
815 &tim.tm_mday, &tim.tm_hour, &tim.tm_min, &tim.tm_sec) != 6)
816 break;
817 ST.st_atime = ST.st_mtime = ST.st_ctime = mktime (&tim);
818 }
819 break;
820 case 'E':
821 {
822 int maj, min;
823 if (sscanf (buffer + 1, "%d,%d", &maj, &min) != 2)
824 break;
825 #ifdef HAVE_STRUCT_STAT_ST_RDEV
826 ST.st_rdev = makedev (maj, min);
827 #endif
828 }
829 }
830 }
831
832 vfs_s_free_entry (me, ent);
833 reply_code = fish_decode_reply (buffer + 4, 0);
834 if (reply_code == COMPLETE)
835 {
836 vfs_print_message (_("%s: done."), me->name);
837 return 0;
838 }
839
840 me->verrno = reply_code == ERROR ? EACCES : E_REMOTE;
841
842 error:
843 vfs_print_message (_("%s: failure"), me->name);
844 return -1;
845 }
846
847 /* --------------------------------------------------------------------------------------------- */
848
849 static int
850 fish_file_store (struct vfs_class *me, vfs_file_handler_t * fh, char *name, char *localname)
851 {
852 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
853 gchar *shell_commands = NULL;
854 struct vfs_s_super *super = FH_SUPER;
855 int code;
856 off_t total;
857 char buffer[BUF_8K];
858 struct stat s;
859 int h;
860 char *quoted_name;
861
862 h = open (localname, O_RDONLY);
863 if (h == -1)
864 ERRNOR (EIO, -1);
865 if (fstat (h, &s) < 0)
866 {
867 close (h);
868 ERRNOR (EIO, -1);
869 }
870
871 /* First, try this as stor:
872 *
873 * ( head -c number ) | ( cat > file; cat >/dev/null )
874 *
875 * If `head' is not present on the remote system, `dd' will be used.
876 * Unfortunately, we cannot trust most non-GNU `head' implementations
877 * even if `-c' options is supported. Therefore, we separate GNU head
878 * (and other modern heads?) using `-q' and `-' . This causes another
879 * implementations to fail (because of "incorrect options").
880 *
881 * Fallback is:
882 *
883 * rest=<number>
884 * while [ $rest -gt 0 ]
885 * do
886 * cnt=`expr \( $rest + 255 \) / 256`
887 * n=`dd bs=256 count=$cnt | tee -a <target_file> | wc -c`
888 * rest=`expr $rest - $n`
889 * done
890 *
891 * `dd' was not designed for full filling of input buffers,
892 * and does not report exact number of bytes (not blocks).
893 * Therefore a more complex shell script is needed.
894 *
895 * On some systems non-GNU head writes "Usage:" error report to stdout
896 * instead of stderr. It makes impossible the use of "head || dd"
897 * algorithm for file appending case, therefore just "dd" is used for it.
898 */
899
900 quoted_name = strutils_shell_escape (name);
901 vfs_print_message (_("fish: store %s: sending command..."), quoted_name);
902
903 /* FIXME: File size is limited to ULONG_MAX */
904 if (fish->append)
905 {
906 shell_commands =
907 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILESIZE=%" PRIuMAX ";\n",
908 SUP->scr_append, (char *) NULL);
909
910 code = fish_command (me, super, WAIT_REPLY, shell_commands, quoted_name,
911 (uintmax_t) s.st_size);
912 g_free (shell_commands);
913 }
914 else
915 {
916 shell_commands =
917 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILESIZE=%" PRIuMAX ";\n",
918 SUP->scr_send, (char *) NULL);
919 code = fish_command (me, super, WAIT_REPLY, shell_commands, quoted_name,
920 (uintmax_t) s.st_size);
921 g_free (shell_commands);
922 }
923 if (code != PRELIM)
924 {
925 close (h);
926 ERRNOR (E_REMOTE, -1);
927 }
928
929 total = 0;
930
931 while (TRUE)
932 {
933 ssize_t n, t;
934
935 while ((n = read (h, buffer, sizeof (buffer))) < 0)
936 {
937 if ((errno == EINTR) && tty_got_interrupt ())
938 continue;
939 vfs_print_message (_("fish: Local read failed, sending zeros"));
940 close (h);
941 h = open ("/dev/zero", O_RDONLY);
942 }
943
944 if (n == 0)
945 break;
946
947 t = write (SUP->sockw, buffer, n);
948 if (t != n)
949 {
950 if (t == -1)
951 me->verrno = errno;
952 else
953 me->verrno = EIO;
954 goto error_return;
955 }
956 tty_disable_interrupt_key ();
957 total += n;
958 vfs_print_message ("%s: %" PRIuMAX "/%" PRIuMAX, _("fish: storing file"),
959 (uintmax_t) total, (uintmax_t) s.st_size);
960 }
961 close (h);
962 g_free (quoted_name);
963
964 if (fish_get_reply (me, SUP->sockr, NULL, 0) != COMPLETE)
965 ERRNOR (E_REMOTE, -1);
966 return 0;
967
968 error_return:
969 close (h);
970 fish_get_reply (me, SUP->sockr, NULL, 0);
971 g_free (quoted_name);
972 return -1;
973 }
974
975 /* --------------------------------------------------------------------------------------------- */
976
977 static int
978 fish_linear_start (struct vfs_class *me, vfs_file_handler_t * fh, off_t offset)
979 {
980 fish_fh_data_t *fish;
981 gchar *shell_commands = NULL;
982 struct vfs_s_super *super = FH_SUPER;
983 char *name;
984 char *quoted_name;
985
986 if (fh->data == NULL)
987 fh->data = g_new0 (fish_fh_data_t, 1);
988
989 fish = (fish_fh_data_t *) fh->data;
990
991 name = vfs_s_fullpath (me, fh->ino);
992 if (name == NULL)
993 return 0;
994 quoted_name = strutils_shell_escape (name);
995 g_free (name);
996 fish->append = FALSE;
997
998 /*
999 * Check whether the remote file is readable by using `dd' to copy
1000 * a single byte from the remote file to /dev/null. If `dd' completes
1001 * with exit status of 0 use `cat' to send the file contents to the
1002 * standard output (i.e. over the network).
1003 */
1004
1005 shell_commands =
1006 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_START_OFFSET=%" PRIuMAX ";\n",
1007 SUP->scr_get, (char *) NULL);
1008 offset = fish_command (me, super, WANT_STRING, shell_commands, quoted_name, (uintmax_t) offset);
1009 g_free (shell_commands);
1010 g_free (quoted_name);
1011 if (offset != PRELIM)
1012 ERRNOR (E_REMOTE, 0);
1013 fh->linear = LS_LINEAR_OPEN;
1014 fish->got = 0;
1015 errno = 0;
1016 #if SIZEOF_OFF_T == SIZEOF_LONG
1017 fish->total = (off_t) strtol (reply_str, NULL, 10);
1018 #else
1019 fish->total = (off_t) strtoll (reply_str, NULL, 10);
1020 #endif
1021 if (errno != 0)
1022 ERRNOR (E_REMOTE, 0);
1023 return 1;
1024 }
1025
1026 /* --------------------------------------------------------------------------------------------- */
1027
1028 static void
1029 fish_linear_abort (struct vfs_class *me, vfs_file_handler_t * fh)
1030 {
1031 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
1032 struct vfs_s_super *super = FH_SUPER;
1033 char buffer[BUF_8K];
1034 ssize_t n;
1035
1036 vfs_print_message (_("Aborting transfer..."));
1037
1038 do
1039 {
1040 n = MIN ((off_t) sizeof (buffer), (fish->total - fish->got));
1041 if (n != 0)
1042 {
1043 n = read (SUP->sockr, buffer, n);
1044 if (n < 0)
1045 return;
1046 fish->got += n;
1047 }
1048 }
1049 while (n != 0);
1050
1051 if (fish_get_reply (me, SUP->sockr, NULL, 0) != COMPLETE)
1052 vfs_print_message (_("Error reported after abort."));
1053 else
1054 vfs_print_message (_("Aborted transfer would be successful."));
1055 }
1056
1057 /* --------------------------------------------------------------------------------------------- */
1058
1059 static int
1060 fish_linear_read (struct vfs_class *me, vfs_file_handler_t * fh, void *buf, size_t len)
1061 {
1062 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
1063 struct vfs_s_super *super = FH_SUPER;
1064 ssize_t n = 0;
1065
1066
1067 len = MIN ((size_t) (fish->total - fish->got), len);
1068 tty_disable_interrupt_key ();
1069 while (len != 0 && ((n = read (SUP->sockr, buf, len)) < 0))
1070 {
1071 if ((errno == EINTR) && !tty_got_interrupt ())
1072 continue;
1073 break;
1074 }
1075 tty_enable_interrupt_key ();
1076
1077 if (n > 0)
1078 fish->got += n;
1079 else if (n < 0)
1080 fish_linear_abort (me, fh);
1081 else if (fish_get_reply (me, SUP->sockr, NULL, 0) != COMPLETE)
1082 ERRNOR (E_REMOTE, -1);
1083 ERRNOR (errno, n);
1084 }
1085
1086 /* --------------------------------------------------------------------------------------------- */
1087
1088 static void
1089 fish_linear_close (struct vfs_class *me, vfs_file_handler_t * fh)
1090 {
1091 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
1092
1093 if (fish->total != fish->got)
1094 fish_linear_abort (me, fh);
1095 }
1096
1097 /* --------------------------------------------------------------------------------------------- */
1098
1099 static int
1100 fish_ctl (void *fh, int ctlop, void *arg)
1101 {
1102 (void) arg;
1103 (void) fh;
1104 (void) ctlop;
1105 return 0;
1106 #if 0
1107 switch (ctlop)
1108 {
1109 case VFS_CTL_IS_NOTREADY:
1110 {
1111 int v;
1112
1113 if (!FH->linear)
1114 vfs_die ("You may not do this");
1115 if (FH->linear == LS_LINEAR_CLOSED || FH->linear == LS_LINEAR_PREOPEN)
1116 return 0;
1117
1118 v = vfs_s_select_on_two (FH_SUPER->u.fish.sockr, 0);
1119 if (((v < 0) && (errno == EINTR)) || v == 0)
1120 return 1;
1121 return 0;
1122 }
1123 default:
1124 return 0;
1125 }
1126 #endif
1127 }
1128
1129 /* --------------------------------------------------------------------------------------------- */
1130
1131 static int
1132 fish_send_command (struct vfs_class *me, struct vfs_s_super *super, const char *cmd, int flags)
1133 {
1134 int r;
1135
1136 r = fish_command (me, super, WAIT_REPLY, "%s", cmd);
1137 vfs_stamp_create (&vfs_fish_ops, super);
1138 if (r != COMPLETE)
1139 ERRNOR (E_REMOTE, -1);
1140 if (flags & OPT_FLUSH)
1141 vfs_s_invalidate (me, super);
1142 return 0;
1143 }
1144
1145 /* --------------------------------------------------------------------------------------------- */
1146
1147 static int
1148 fish_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1149 {
1150 gchar *shell_commands = NULL;
1151 char buf[BUF_LARGE];
1152 const char *crpath1, *crpath2;
1153 char *rpath1, *rpath2;
1154 struct vfs_s_super *super, *super2;
1155 const vfs_path_element_t *path_element;
1156
1157 path_element = vfs_path_get_by_index (vpath1, -1);
1158
1159 crpath1 = vfs_s_get_path (vpath1, &super, 0);
1160 if (crpath1 == NULL)
1161 return -1;
1162
1163 crpath2 = vfs_s_get_path (vpath2, &super2, 0);
1164 if (crpath2 == NULL)
1165 return -1;
1166
1167 rpath1 = strutils_shell_escape (crpath1);
1168 rpath2 = strutils_shell_escape (crpath2);
1169 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1170 SUP->scr_mv, (char *) NULL);
1171 g_snprintf (buf, sizeof (buf), shell_commands, rpath1, rpath2);
1172 g_free (shell_commands);
1173 g_free (rpath1);
1174 g_free (rpath2);
1175 return fish_send_command (path_element->class, super2, buf, OPT_FLUSH);
1176 }
1177
1178 /* --------------------------------------------------------------------------------------------- */
1179
1180 static int
1181 fish_link (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1182 {
1183 gchar *shell_commands = NULL;
1184 char buf[BUF_LARGE];
1185 const char *crpath1, *crpath2;
1186 char *rpath1, *rpath2;
1187 struct vfs_s_super *super, *super2;
1188 const vfs_path_element_t *path_element;
1189
1190 path_element = vfs_path_get_by_index (vpath1, -1);
1191
1192 crpath1 = vfs_s_get_path (vpath1, &super, 0);
1193 if (crpath1 == NULL)
1194 return -1;
1195
1196 crpath2 = vfs_s_get_path (vpath2, &super2, 0);
1197 if (crpath2 == NULL)
1198 return -1;
1199
1200 rpath1 = strutils_shell_escape (crpath1);
1201 rpath2 = strutils_shell_escape (crpath2);
1202 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1203 SUP->scr_hardlink, (char *) NULL);
1204 g_snprintf (buf, sizeof (buf), shell_commands, rpath1, rpath2);
1205 g_free (shell_commands);
1206 g_free (rpath1);
1207 g_free (rpath2);
1208 return fish_send_command (path_element->class, super2, buf, OPT_FLUSH);
1209 }
1210
1211
1212 /* --------------------------------------------------------------------------------------------- */
1213
1214 static int
1215 fish_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1216 {
1217 char *qsetto;
1218 gchar *shell_commands = NULL;
1219 char buf[BUF_LARGE];
1220 const char *crpath;
1221 char *rpath;
1222 struct vfs_s_super *super;
1223 const vfs_path_element_t *path_element;
1224
1225 path_element = vfs_path_get_by_index (vpath2, -1);
1226
1227 crpath = vfs_s_get_path (vpath2, &super, 0);
1228 if (crpath == NULL)
1229 return -1;
1230
1231 rpath = strutils_shell_escape (crpath);
1232 qsetto = strutils_shell_escape (vfs_path_get_by_index (vpath1, -1)->path);
1233
1234 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1235 SUP->scr_ln, (char *) NULL);
1236 g_snprintf (buf, sizeof (buf), shell_commands, qsetto, rpath);
1237 g_free (shell_commands);
1238 g_free (qsetto);
1239 g_free (rpath);
1240 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1241 }
1242
1243 /* --------------------------------------------------------------------------------------------- */
1244
1245 static int
1246 fish_chmod (const vfs_path_t * vpath, mode_t mode)
1247 {
1248 gchar *shell_commands = NULL;
1249 char buf[BUF_LARGE];
1250 const char *crpath;
1251 char *rpath;
1252 struct vfs_s_super *super;
1253 const vfs_path_element_t *path_element;
1254
1255 path_element = vfs_path_get_by_index (vpath, -1);
1256
1257 crpath = vfs_s_get_path (vpath, &super, 0);
1258 if (crpath == NULL)
1259 return -1;
1260 rpath = strutils_shell_escape (crpath);
1261
1262 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILEMODE=%4.4o;\n",
1263 SUP->scr_chmod, (char *) NULL);
1264 g_snprintf (buf, sizeof (buf), shell_commands, rpath, (int) (mode & 07777));
1265 g_free (shell_commands);
1266 g_free (rpath);
1267 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1268 }
1269
1270 /* --------------------------------------------------------------------------------------------- */
1271
1272 static int
1273 fish_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
1274 {
1275 char *sowner, *sgroup;
1276 struct passwd *pw;
1277 struct group *gr;
1278
1279 pw = getpwuid (owner);
1280 if (pw == NULL)
1281 return 0;
1282
1283 gr = getgrgid (group);
1284 if (gr == NULL)
1285 return 0;
1286
1287 sowner = pw->pw_name;
1288 sgroup = gr->gr_name;
1289
1290 {
1291 gchar *shell_commands = NULL;
1292 char buf[BUF_LARGE];
1293 const char *crpath;
1294 char *rpath;
1295 struct vfs_s_super *super;
1296 const vfs_path_element_t *path_element;
1297
1298 path_element = vfs_path_get_by_index (vpath, -1);
1299
1300 crpath = vfs_s_get_path (vpath, &super, 0);
1301 if (crpath == NULL)
1302 return -1;
1303 rpath = strutils_shell_escape (crpath);
1304
1305 shell_commands = g_strconcat (SUP->scr_env,
1306 "FISH_FILENAME=%s FISH_FILEOWNER=%s FISH_FILEGROUP=%s;\n",
1307 SUP->scr_chown, (char *) NULL);
1308 g_snprintf (buf, sizeof (buf), shell_commands, rpath, sowner, sgroup);
1309 g_free (shell_commands);
1310 fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1311 /* FIXME: what should we report if chgrp succeeds but chown fails? */
1312 /* fish_send_command(me, super, buf, OPT_FLUSH); */
1313 g_free (rpath);
1314 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1315 }
1316 }
1317
1318 /* --------------------------------------------------------------------------------------------- */
1319
1320 static int
1321 fish_utime (const vfs_path_t * vpath, struct utimbuf *times)
1322 {
1323 gchar *shell_commands = NULL;
1324 char utcmtime[16], utcatime[16];
1325 struct tm *gmt;
1326
1327 char buf[BUF_LARGE];
1328 const char *crpath;
1329 char *rpath;
1330 struct vfs_s_super *super;
1331 const vfs_path_element_t *path_element;
1332
1333 path_element = vfs_path_get_by_index (vpath, -1);
1334
1335 crpath = vfs_s_get_path (vpath, &super, 0);
1336 if (crpath == NULL)
1337 return -1;
1338 rpath = strutils_shell_escape (crpath);
1339
1340 gmt = gmtime (&times->modtime);
1341 g_snprintf (utcmtime, sizeof (utcmtime), "%04d%02d%02d%02d%02d.%02d",
1342 gmt->tm_year + 1900, gmt->tm_mon + 1, gmt->tm_mday,
1343 gmt->tm_hour, gmt->tm_min, gmt->tm_sec);
1344
1345 gmt = gmtime (&times->actime);
1346 g_snprintf (utcatime, sizeof (utcatime), "%04d%02d%02d%02d%02d.%02d",
1347 gmt->tm_year + 1900, gmt->tm_mon + 1, gmt->tm_mday,
1348 gmt->tm_hour, gmt->tm_min, gmt->tm_sec);
1349
1350 shell_commands =
1351 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILEATIME=%ld FISH_FILEMTIME=%ld ",
1352 "FISH_TOUCHATIME=%s FISH_TOUCHMTIME=%s;\n", SUP->scr_utime, (char *) NULL);
1353 g_snprintf (buf, sizeof (buf), shell_commands, rpath, (long) times->actime,
1354 (long) times->modtime, utcatime, utcmtime);
1355 g_free (shell_commands);
1356 g_free (rpath);
1357 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1358 }
1359
1360 /* --------------------------------------------------------------------------------------------- */
1361
1362 static int
1363 fish_unlink (const vfs_path_t * vpath)
1364 {
1365 gchar *shell_commands = NULL;
1366
1367 char buf[BUF_LARGE];
1368 const char *crpath;
1369 char *rpath;
1370 struct vfs_s_super *super;
1371 const vfs_path_element_t *path_element;
1372
1373 path_element = vfs_path_get_by_index (vpath, -1);
1374
1375 crpath = vfs_s_get_path (vpath, &super, 0);
1376 if (crpath == NULL)
1377 return -1;
1378 rpath = strutils_shell_escape (crpath);
1379
1380 shell_commands =
1381 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_unlink, (char *) NULL);
1382 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1383 g_free (shell_commands);
1384 g_free (rpath);
1385 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1386 }
1387
1388 /* --------------------------------------------------------------------------------------------- */
1389
1390 static int
1391 fish_exists (const vfs_path_t * vpath)
1392 {
1393 gchar *shell_commands = NULL;
1394
1395 char buf[BUF_LARGE];
1396 const char *crpath;
1397 char *rpath;
1398 struct vfs_s_super *super;
1399 const vfs_path_element_t *path_element;
1400
1401 path_element = vfs_path_get_by_index (vpath, -1);
1402
1403 crpath = vfs_s_get_path (vpath, &super, 0);
1404 if (crpath == NULL)
1405 return -1;
1406 rpath = strutils_shell_escape (crpath);
1407
1408 shell_commands =
1409 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_exists, (char *) NULL);
1410 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1411 g_free (shell_commands);
1412 g_free (rpath);
1413
1414 return (fish_send_command (path_element->class, super, buf, OPT_FLUSH) == 0) ? 1 : 0;
1415 }
1416
1417 /* --------------------------------------------------------------------------------------------- */
1418
1419 static int
1420 fish_mkdir (const vfs_path_t * vpath, mode_t mode)
1421 {
1422 gchar *shell_commands = NULL;
1423 int ret_code;
1424 char buf[BUF_LARGE];
1425 const char *crpath;
1426 char *rpath;
1427 struct vfs_s_super *super;
1428 const vfs_path_element_t *path_element;
1429
1430 (void) mode;
1431
1432 path_element = vfs_path_get_by_index (vpath, -1);
1433
1434 crpath = vfs_s_get_path (vpath, &super, 0);
1435 if (crpath == NULL)
1436 return -1;
1437 rpath = strutils_shell_escape (crpath);
1438
1439 shell_commands =
1440 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_mkdir, (char *) NULL);
1441 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1442 g_free (shell_commands);
1443
1444 g_free (rpath);
1445 ret_code = fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1446
1447 if (ret_code != 0)
1448 return ret_code;
1449
1450 if (!fish_exists (vpath))
1451 {
1452 path_element->class->verrno = EACCES;
1453 return -1;
1454 }
1455 return 0;
1456 }
1457
1458 /* --------------------------------------------------------------------------------------------- */
1459
1460 static int
1461 fish_rmdir (const vfs_path_t * vpath)
1462 {
1463 gchar *shell_commands = NULL;
1464 char buf[BUF_LARGE];
1465 const char *crpath;
1466 char *rpath;
1467 struct vfs_s_super *super;
1468 const vfs_path_element_t *path_element;
1469
1470 path_element = vfs_path_get_by_index (vpath, -1);
1471
1472 crpath = vfs_s_get_path (vpath, &super, 0);
1473 if (crpath == NULL)
1474 return -1;
1475 rpath = strutils_shell_escape (crpath);
1476
1477 shell_commands =
1478 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_rmdir, (char *) NULL);
1479 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1480 g_free (shell_commands);
1481 g_free (rpath);
1482 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1483 }
1484
1485 /* --------------------------------------------------------------------------------------------- */
1486
1487 static void
1488 fish_fh_free_data (vfs_file_handler_t * fh)
1489 {
1490 if (fh != NULL)
1491 {
1492 g_free (fh->data);
1493 fh->data = NULL;
1494 }
1495 }
1496
1497 /* --------------------------------------------------------------------------------------------- */
1498
1499 static int
1500 fish_fh_open (struct vfs_class *me, vfs_file_handler_t * fh, int flags, mode_t mode)
1501 {
1502 fish_fh_data_t *fish;
1503
1504 (void) mode;
1505
1506 fh->data = g_new0 (fish_fh_data_t, 1);
1507 fish = (fish_fh_data_t *) fh->data;
1508
1509 /* File will be written only, so no need to retrieve it */
1510 if (((flags & O_WRONLY) == O_WRONLY) && ((flags & (O_RDONLY | O_RDWR)) == 0))
1511 {
1512 /* user pressed the button [ Append ] in the "Copy" dialog */
1513 if ((flags & O_APPEND) != 0)
1514 fish->append = TRUE;
1515
1516 if (!fh->ino->localname)
1517 {
1518 vfs_path_t *vpath;
1519 int tmp_handle;
1520
1521 tmp_handle = vfs_mkstemps (&vpath, me->name, fh->ino->ent->name);
1522 if (tmp_handle == -1)
1523 {
1524 vfs_path_free (vpath);
1525 goto fail;
1526 }
1527 fh->ino->localname = vfs_path_to_str (vpath);
1528 vfs_path_free (vpath);
1529 close (tmp_handle);
1530 }
1531 return 0;
1532 }
1533 if (!fh->ino->localname && vfs_s_retrieve_file (me, fh->ino) == -1)
1534 goto fail;
1535 if (!fh->ino->localname)
1536 vfs_die ("retrieve_file failed to fill in localname");
1537 return 0;
1538
1539 fail:
1540 fish_fh_free_data (fh);
1541 return -1;
1542 }
1543
1544 /* --------------------------------------------------------------------------------------------- */
1545
1546 static void
1547 fish_fill_names (struct vfs_class *me, fill_names_f func)
1548 {
1549 GList *iter;
1550
1551 for (iter = MEDATA->supers; iter != NULL; iter = g_list_next (iter))
1552 {
1553 const struct vfs_s_super *super = (const struct vfs_s_super *) iter->data;
1554
1555 char *name;
1556 char gbuf[10];
1557 const char *flags = "";
1558
1559 switch (super->path_element->port)
1560 {
1561 case FISH_FLAG_RSH:
1562 flags = ":r";
1563 break;
1564 case FISH_FLAG_COMPRESSED:
1565 flags = ":C";
1566 break;
1567 default:
1568 if (super->path_element->port > FISH_FLAG_RSH)
1569 {
1570 g_snprintf (gbuf, sizeof (gbuf), ":%d", super->path_element->port);
1571 flags = gbuf;
1572 }
1573 break;
1574 }
1575
1576 name =
1577 g_strconcat (vfs_fish_ops.prefix, VFS_PATH_URL_DELIMITER,
1578 super->path_element->user, "@", super->path_element->host, flags, "/",
1579 super->path_element->path, (char *) NULL);
1580 func (name);
1581 g_free (name);
1582 }
1583 }
1584
1585 /* --------------------------------------------------------------------------------------------- */
1586
1587 static void *
1588 fish_open (const vfs_path_t * vpath, int flags, mode_t mode)
1589 {
1590 /*
1591 sorry, i've places hack here
1592 cause fish don't able to open files with O_EXCL flag
1593 */
1594 flags &= ~O_EXCL;
1595 return vfs_s_open (vpath, flags, mode);
1596 }
1597
1598 /* --------------------------------------------------------------------------------------------- */
1599 /*** public functions ****************************************************************************/
1600 /* --------------------------------------------------------------------------------------------- */
1601
1602 void
1603 init_fish (void)
1604 {
1605 static struct vfs_s_subclass fish_subclass;
1606
1607 tcp_init ();
1608
1609 fish_subclass.flags = VFS_S_REMOTE | VFS_S_USETMP;
1610 fish_subclass.archive_same = fish_archive_same;
1611 fish_subclass.open_archive = fish_open_archive;
1612 fish_subclass.free_archive = fish_free_archive;
1613 fish_subclass.fh_open = fish_fh_open;
1614 fish_subclass.fh_free_data = fish_fh_free_data;
1615 fish_subclass.dir_load = fish_dir_load;
1616 fish_subclass.file_store = fish_file_store;
1617 fish_subclass.linear_start = fish_linear_start;
1618 fish_subclass.linear_read = fish_linear_read;
1619 fish_subclass.linear_close = fish_linear_close;
1620
1621 vfs_s_init_class (&vfs_fish_ops, &fish_subclass);
1622 vfs_fish_ops.name = "fish";
1623 vfs_fish_ops.prefix = "sh";
1624 vfs_fish_ops.fill_names = fish_fill_names;
1625 vfs_fish_ops.chmod = fish_chmod;
1626 vfs_fish_ops.chown = fish_chown;
1627 vfs_fish_ops.utime = fish_utime;
1628 vfs_fish_ops.open = fish_open;
1629 vfs_fish_ops.symlink = fish_symlink;
1630 vfs_fish_ops.link = fish_link;
1631 vfs_fish_ops.unlink = fish_unlink;
1632 vfs_fish_ops.rename = fish_rename;
1633 vfs_fish_ops.mkdir = fish_mkdir;
1634 vfs_fish_ops.rmdir = fish_rmdir;
1635 vfs_fish_ops.ctl = fish_ctl;
1636 vfs_register_class (&vfs_fish_ops);
1637 }
1638
1639 /* --------------------------------------------------------------------------------------------- */
Midnight Commander