2 Virtual File System: FISH implementation for transfering files over
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2007, 2008, 2009, 2010, 2011
7 The Free Software Foundation, Inc.
12 Andrew Borodin <aborodin@vmail.ru>, 2010
13 Slava Zanko <slavazanko@gmail.com>, 2010
14 Ilia Maslakov <il.smind@gmail.com>, 2010
18 This file is part of the Midnight Commander.
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.
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.
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/>.
36 * \brief Source: Virtual File System: FISH implementation for transfering files over
38 * \author Pavel Machek
42 * Derived from ftpfs.c
43 * Read README.fish for protocol specification.
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
49 * Namespace: fish_vfs_ops exported.
52 /* Define this if your ssh can take -I option */
59 #include <sys/time.h> /* gettimeofday() */
62 #include <inttypes.h> /* uintmax_t */
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"
71 #include "src/execute.h" /* pre_exec, post_exec */
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 */
82 /*** global variables ****************************************************************************/
84 int fish_directory_timeout
= 900;
86 /*** file scope macro definitions ****************************************************************/
88 #define DO_RESOLVE_SYMLINK 1
90 #define DO_FREE_RESOURCE 4
92 #define FISH_FLAG_COMPRESSED 1
93 #define FISH_FLAG_RSH 2
96 #define OPT_IGNORE_ERROR 2
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 */
107 /* command wait_flag: */
109 #define WAIT_REPLY 0x01
110 #define WANT_STRING 0x02
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
121 #define SUP ((fish_super_data_t *) super->data)
123 /*** file scope type declarations ****************************************************************/
155 /*** file scope variables ************************************************************************/
157 static char reply_str
[80];
159 static struct vfs_class vfs_fish_ops
;
161 /*** file scope functions ************************************************************************/
162 /* --------------------------------------------------------------------------------------------- */
165 fish_load_script_from_file (const char *hostname
, const char *script_name
, const char *def_content
)
167 char *scr_filename
= NULL
;
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
)
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
);
186 if (scr_content
!= NULL
)
189 return g_strdup (def_content
);
192 /* --------------------------------------------------------------------------------------------- */
195 fish_decode_reply (char *s
, int was_garbage
)
198 if (!sscanf (s
, "%d", &code
))
204 return was_garbage
? ERROR
: (!code
? COMPLETE
: PRELIM
);
208 /* --------------------------------------------------------------------------------------------- */
209 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
212 fish_get_reply (struct vfs_class
*me
, int sock
, char *string_buf
, int string_len
)
219 if (!vfs_s_get_line (me
, sock
, answer
, sizeof (answer
), '\n'))
226 if (strncmp (answer
, "### ", 4))
230 g_strlcpy (string_buf
, answer
, string_len
);
233 return fish_decode_reply (answer
+ 4, was_garbage
);
237 /* --------------------------------------------------------------------------------------------- */
240 fish_command (struct vfs_class
*me
, struct vfs_s_super
*super
, int wait_reply
, const char *fmt
, ...)
245 FILE *logfile
= MEDATA
->logfile
;
249 str
= g_strdup_vprintf (fmt
, ap
);
255 ret
= fwrite (str
, strlen (str
), 1, logfile
);
256 ret
= fflush (logfile
);
259 tty_enable_interrupt_key ();
261 status
= write (SUP
->sockw
, str
, strlen (str
));
264 tty_disable_interrupt_key ();
269 return fish_get_reply (me
, SUP
->sockr
,
270 (wait_reply
& WANT_STRING
) ? reply_str
:
271 NULL
, sizeof (reply_str
) - 1);
275 /* --------------------------------------------------------------------------------------------- */
278 fish_free_archive (struct vfs_class
*me
, struct vfs_s_super
*super
)
280 if ((SUP
->sockw
!= -1) || (SUP
->sockr
!= -1))
282 vfs_print_message (_("fish: Disconnecting from %s"), super
->name
? super
->name
: "???");
283 fish_command (me
, super
, NONE
, "#BYE\nexit\n");
286 SUP
->sockw
= SUP
->sockr
= -1;
288 g_free (SUP
->scr_ls
);
289 g_free (SUP
->scr_exists
);
290 g_free (SUP
->scr_mkdir
);
291 g_free (SUP
->scr_unlink
);
292 g_free (SUP
->scr_chown
);
293 g_free (SUP
->scr_chmod
);
294 g_free (SUP
->scr_utime
);
295 g_free (SUP
->scr_rmdir
);
296 g_free (SUP
->scr_ln
);
297 g_free (SUP
->scr_mv
);
298 g_free (SUP
->scr_hardlink
);
299 g_free (SUP
->scr_get
);
300 g_free (SUP
->scr_send
);
301 g_free (SUP
->scr_append
);
302 g_free (SUP
->scr_info
);
303 g_free (SUP
->scr_env
);
308 /* --------------------------------------------------------------------------------------------- */
311 fish_pipeopen (struct vfs_s_super
*super
, const char *path
, const char *argv
[])
313 int fileset1
[2], fileset2
[2];
316 if ((pipe (fileset1
) < 0) || (pipe (fileset2
) < 0))
317 vfs_die ("Cannot pipe(): %m.");
324 vfs_die ("Cannot fork(): %m.");
325 /* We are the parent */
327 SUP
->sockw
= fileset1
[1];
329 SUP
->sockr
= fileset2
[0];
333 res
= dup2 (fileset1
[0], 0);
336 res
= dup2 (fileset2
[1], 1);
338 /* stderr to /dev/null */
339 res
= open ("/dev/null", O_WRONLY
);
342 execvp (path
, const_cast (char **, argv
));
347 /* --------------------------------------------------------------------------------------------- */
350 fish_set_env (int flags
)
354 tmp
= g_string_sized_new (250);
355 g_string_assign (tmp
, "");
357 if ((flags
& FISH_HAVE_HEAD
) != 0)
358 g_string_append (tmp
, "FISH_HAVE_HEAD=1 export FISH_HAVE_HEAD; ");
360 if ((flags
& FISH_HAVE_SED
) != 0)
361 g_string_append (tmp
, "FISH_HAVE_SED=1 export FISH_HAVE_SED; ");
363 if ((flags
& FISH_HAVE_AWK
) != 0)
364 g_string_append (tmp
, "FISH_HAVE_AWK=1 export FISH_HAVE_AWK; ");
366 if ((flags
& FISH_HAVE_PERL
) != 0)
367 g_string_append (tmp
, "FISH_HAVE_PERL=1 export FISH_HAVE_PERL; ");
369 if ((flags
& FISH_HAVE_LSQ
) != 0)
370 g_string_append (tmp
, "FISH_HAVE_LSQ=1 export FISH_HAVE_LSQ; ");
372 if ((flags
& FISH_HAVE_DATE_MDYT
) != 0)
373 g_string_append (tmp
, "FISH_HAVE_DATE_MDYT=1 export FISH_HAVE_DATE_MDYT; ");
375 if ((flags
& FISH_HAVE_TAIL
) != 0)
376 g_string_append (tmp
, "FISH_HAVE_TAIL=1 export FISH_HAVE_TAIL; ");
378 return g_string_free (tmp
, FALSE
);
381 /* --------------------------------------------------------------------------------------------- */
384 fish_info (struct vfs_class
*me
, struct vfs_s_super
*super
)
387 if (fish_command (me
, super
, NONE
, SUP
->scr_info
) == COMPLETE
)
393 res
= vfs_s_get_line_interruptible (me
, buffer
, sizeof (buffer
), SUP
->sockr
);
394 if ((res
== 0) || (res
== EINTR
))
395 ERRNOR (ECONNRESET
, FALSE
);
396 if (strncmp (buffer
, "### ", 4) == 0)
398 SUP
->host_flags
= atol (buffer
);
402 ERRNOR (E_PROTO
, FALSE
);
406 /* --------------------------------------------------------------------------------------------- */
409 fish_open_archive_pipeopen (struct vfs_s_super
*super
)
412 const char *argv
[10]; /* All of 10 is used now */
413 const char *xsh
= (super
->path_element
->port
== FISH_FLAG_RSH
? "rsh" : "ssh");
417 if (super
->path_element
->port
== FISH_FLAG_COMPRESSED
)
420 if (super
->path_element
->port
> FISH_FLAG_RSH
)
423 g_snprintf (gbuf
, sizeof (gbuf
), "%d", super
->path_element
->port
);
428 * Add the user name to the ssh command line only if it was explicitly
429 * set in vfs URL. rsh/ssh will get current user by default
430 * plus we can set convenient overrides in ~/.ssh/config (explicit -l
431 * option breaks it for some)
434 if (super
->path_element
->user
!= NULL
)
437 argv
[i
++] = super
->path_element
->user
;
441 /* The rest of the code assumes it to be a valid username */
442 super
->path_element
->user
= vfs_get_local_username ();
445 argv
[i
++] = super
->path_element
->host
;
446 argv
[i
++] = "echo FISH:; /bin/sh";
449 fish_pipeopen (super
, xsh
, argv
);
452 /* --------------------------------------------------------------------------------------------- */
455 fish_open_archive_talk (struct vfs_class
*me
, struct vfs_s_super
*super
)
459 printf ("\n%s\n", _("fish: Waiting for initial line..."));
461 if (!vfs_s_get_line (me
, SUP
->sockr
, answer
, sizeof (answer
), ':'))
464 if (strstr (answer
, "assword") != NULL
)
466 /* Currently, this does not work. ssh reads passwords from
467 /dev/tty, not from stdin :-(. */
469 printf ("\n%s\n", _("Sorry, we cannot do password authenticated connections for now."));
473 if (super
->path_element
->password
== NULL
)
476 p
= g_strdup_printf (_("fish: Password is required for %s"), super
->path_element
->user
);
477 op
= vfs_get_password (p
);
481 super
->path_element
->password
= op
;
485 printf ("\n%s\n", _("fish: Sending password..."));
490 str_len
= strlen (super
->path_element
->password
);
491 if ((write (SUP
.sockw
, super
->path_element
->password
, str_len
) != (ssize_t
) str_len
)
492 || (write (SUP
->sockw
, "\n", 1) != 1))
500 /* --------------------------------------------------------------------------------------------- */
503 fish_open_archive_int (struct vfs_class
*me
, struct vfs_s_super
*super
)
510 fish_open_archive_pipeopen (super
);
512 /* Start talk with ssh-server (password prompt, etc ) */
513 ftalk
= fish_open_archive_talk (me
, super
);
519 ERRNOR (E_PROTO
, -1);
521 vfs_print_message (_("fish: Sending initial line..."));
523 * Run `start_fish_server'. If it doesn't exist - no problem,
524 * we'll talk directly to the shell.
528 (me
, super
, WAIT_REPLY
,
529 "#FISH\necho; start_fish_server 2>&1; echo '### 200'\n") != COMPLETE
)
530 ERRNOR (E_PROTO
, -1);
532 vfs_print_message (_("fish: Handshaking version..."));
533 if (fish_command (me
, super
, WAIT_REPLY
, "#VER 0.0.3\necho '### 000'\n") != COMPLETE
)
534 ERRNOR (E_PROTO
, -1);
536 /* Set up remote locale to C, otherwise dates cannot be recognized */
538 (me
, super
, WAIT_REPLY
,
539 "LANG=C LC_ALL=C LC_TIME=C; export LANG LC_ALL LC_TIME;\n" "echo '### 200'\n") != COMPLETE
)
540 ERRNOR (E_PROTO
, -1);
542 vfs_print_message (_("fish: Getting host info..."));
543 if (fish_info (me
, super
))
544 SUP
->scr_env
= fish_set_env (SUP
->host_flags
);
548 g_strconcat ("sh://", super
->path_element
->user
, "@", super
->path_element
->host
, "/",
551 super
->name
= g_strdup (PATH_SEP_STR
);
554 super
->root
= vfs_s_new_inode (me
, super
, vfs_s_default_stat (me
, S_IFDIR
| 0755));
558 /* --------------------------------------------------------------------------------------------- */
561 fish_open_archive (struct vfs_s_super
*super
,
562 const vfs_path_t
* vpath
, const vfs_path_element_t
* vpath_element
)
566 super
->data
= g_new0 (fish_super_data_t
, 1);
567 super
->path_element
= vfs_path_element_clone (vpath_element
);
569 if (strncmp (vpath_element
->vfs_prefix
, "rsh", 3) == 0)
570 super
->path_element
->port
= FISH_FLAG_RSH
;
573 fish_load_script_from_file (super
->path_element
->host
, FISH_LS_FILE
, FISH_LS_DEF_CONTENT
);
575 fish_load_script_from_file (super
->path_element
->host
, FISH_EXISTS_FILE
,
576 FISH_EXISTS_DEF_CONTENT
);
578 fish_load_script_from_file (super
->path_element
->host
, FISH_MKDIR_FILE
,
579 FISH_MKDIR_DEF_CONTENT
);
581 fish_load_script_from_file (super
->path_element
->host
, FISH_UNLINK_FILE
,
582 FISH_UNLINK_DEF_CONTENT
);
584 fish_load_script_from_file (super
->path_element
->host
, FISH_CHOWN_FILE
,
585 FISH_CHOWN_DEF_CONTENT
);
587 fish_load_script_from_file (super
->path_element
->host
, FISH_CHMOD_FILE
,
588 FISH_CHMOD_DEF_CONTENT
);
590 fish_load_script_from_file (super
->path_element
->host
, FISH_UTIME_FILE
,
591 FISH_UTIME_DEF_CONTENT
);
593 fish_load_script_from_file (super
->path_element
->host
, FISH_RMDIR_FILE
,
594 FISH_RMDIR_DEF_CONTENT
);
596 fish_load_script_from_file (super
->path_element
->host
, FISH_LN_FILE
, FISH_LN_DEF_CONTENT
);
598 fish_load_script_from_file (super
->path_element
->host
, FISH_MV_FILE
, FISH_MV_DEF_CONTENT
);
600 fish_load_script_from_file (super
->path_element
->host
, FISH_HARDLINK_FILE
,
601 FISH_HARDLINK_DEF_CONTENT
);
603 fish_load_script_from_file (super
->path_element
->host
, FISH_GET_FILE
, FISH_GET_DEF_CONTENT
);
605 fish_load_script_from_file (super
->path_element
->host
, FISH_SEND_FILE
,
606 FISH_SEND_DEF_CONTENT
);
608 fish_load_script_from_file (super
->path_element
->host
, FISH_APPEND_FILE
,
609 FISH_APPEND_DEF_CONTENT
);
611 fish_load_script_from_file (super
->path_element
->host
, FISH_INFO_FILE
,
612 FISH_INFO_DEF_CONTENT
);
614 return fish_open_archive_int (vpath_element
->class, super
);
617 /* --------------------------------------------------------------------------------------------- */
620 fish_archive_same (const vfs_path_element_t
* vpath_element
, struct vfs_s_super
*super
,
621 const vfs_path_t
* vpath
, void *cookie
)
623 vfs_path_element_t
*path_element
;
629 path_element
= vfs_path_element_clone (vpath_element
);
631 if (path_element
->user
== NULL
)
632 path_element
->user
= vfs_get_local_username ();
634 result
= ((strcmp (path_element
->host
, super
->path_element
->host
) == 0)
635 && (strcmp (path_element
->user
, super
->path_element
->user
) == 0)
636 && (path_element
->port
== super
->path_element
->port
)) ? 1 : 0;
638 vfs_path_element_free (path_element
);
643 /* --------------------------------------------------------------------------------------------- */
646 fish_dir_load (struct vfs_class
*me
, struct vfs_s_inode
*dir
, char *remote_path
)
648 struct vfs_s_super
*super
= dir
->super
;
650 struct vfs_s_entry
*ent
= NULL
;
654 gchar
*shell_commands
;
657 * Simple FISH debug interface :]
660 if (!(MEDATA
->logfile
))
662 MEDATA
->logfile
= fopen ("/tmp/mc-FISH.sh", "w");
665 logfile
= MEDATA
->logfile
;
667 vfs_print_message (_("fish: Reading directory %s..."), remote_path
);
669 gettimeofday (&dir
->timestamp
, NULL
);
670 dir
->timestamp
.tv_sec
+= fish_directory_timeout
;
671 quoted_path
= strutils_shell_escape (remote_path
);
672 shell_commands
= g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s;\n", SUP
->scr_ls
, (char *) NULL
);
673 fish_command (me
, super
, NONE
, shell_commands
, quoted_path
);
674 g_free (shell_commands
);
675 g_free (quoted_path
);
676 ent
= vfs_s_generate_entry (me
, NULL
, dir
, 0);
679 int res
= vfs_s_get_line_interruptible (me
, buffer
, sizeof (buffer
), SUP
->sockr
);
680 if ((!res
) || (res
== EINTR
))
682 vfs_s_free_entry (me
, ent
);
683 me
->verrno
= ECONNRESET
;
688 fputs (buffer
, logfile
);
689 fputs ("\n", logfile
);
692 if (!strncmp (buffer
, "### ", 4))
698 vfs_s_insert_entry (me
, dir
, ent
);
699 ent
= vfs_s_generate_entry (me
, NULL
, dir
, 0);
704 #define ST ent->ino->st
711 char *data_start
= buffer
+ 1;
712 char *filename
= data_start
;
713 char *filename_bound
;
715 filename_bound
= filename
+ strlen (filename
);
717 if (!strcmp (data_start
, "\".\"") || !strcmp (data_start
, "\"..\""))
718 break; /* We'll do "." and ".." ourselves */
720 if (S_ISLNK (ST
.st_mode
))
723 char *linkname_bound
;
724 /* we expect: "escaped-name" -> "escaped-name"
725 // -> cannot occur in filenames,
726 // because it will be escaped to -\> */
729 linkname_bound
= filename_bound
;
731 if (*filename
== '"')
734 linkname
= strstr (filename
, "\" -> \"");
737 /* broken client, or smth goes wrong */
738 linkname
= filename_bound
;
739 if (filename_bound
> filename
&& *(filename_bound
- 1) == '"')
740 --filename_bound
; /* skip trailing " */
744 filename_bound
= linkname
;
745 linkname
+= 6; /* strlen ("\" -> \"") */
746 if (*(linkname_bound
- 1) == '"')
747 --linkname_bound
; /* skip trailing " */
750 ent
->name
= g_strndup (filename
, filename_bound
- filename
);
752 ent
->name
= strutils_shell_unescape (ent
->name
);
755 ent
->ino
->linkname
= g_strndup (linkname
, linkname_bound
- linkname
);
756 temp
= ent
->ino
->linkname
;
757 ent
->ino
->linkname
= strutils_shell_unescape (ent
->ino
->linkname
);
762 /* we expect: "escaped-name" */
763 if (filename_bound
- filename
> 2)
766 there is at least 2 "
769 if (*filename
== '"')
771 if (*(filename_bound
- 1) == '"')
774 ent
->name
= g_strndup (filename
, filename_bound
- filename
);
776 ent
->name
= strutils_shell_unescape (ent
->name
);
783 ST
.st_size
= (off_t
) atoll (buffer
+ 1);
785 ST
.st_size
= (off_t
) atof (buffer
+ 1);
791 vfs_parse_filemode (buffer
+ 1, &skipped
, &ST
.st_mode
);
798 we expect: Roctal-filemode octal-filetype uid.gid
801 vfs_parse_raw_filemode (buffer
+ 1, &skipped
, &ST
.st_mode
);
806 vfs_split_text (buffer
+ 1);
807 if (!vfs_parse_filedate (0, &ST
.st_ctime
))
809 ST
.st_atime
= ST
.st_mtime
= ST
.st_ctime
;
815 if (sscanf (buffer
+ 1, "%d %d %d %d %d %d", &tim
.tm_year
, &tim
.tm_mon
,
816 &tim
.tm_mday
, &tim
.tm_hour
, &tim
.tm_min
, &tim
.tm_sec
) != 6)
818 ST
.st_atime
= ST
.st_mtime
= ST
.st_ctime
= mktime (&tim
);
824 if (sscanf (buffer
+ 1, "%d,%d", &maj
, &min
) != 2)
826 #ifdef HAVE_STRUCT_STAT_ST_RDEV
827 ST
.st_rdev
= makedev (maj
, min
);
833 vfs_s_free_entry (me
, ent
);
834 reply_code
= fish_decode_reply (buffer
+ 4, 0);
835 if (reply_code
== COMPLETE
)
837 vfs_print_message (_("%s: done."), me
->name
);
841 me
->verrno
= reply_code
== ERROR
? EACCES
: E_REMOTE
;
844 vfs_print_message (_("%s: failure"), me
->name
);
848 /* --------------------------------------------------------------------------------------------- */
851 fish_file_store (struct vfs_class
*me
, vfs_file_handler_t
* fh
, char *name
, char *localname
)
853 fish_fh_data_t
*fish
= (fish_fh_data_t
*) fh
->data
;
854 gchar
*shell_commands
= NULL
;
855 struct vfs_s_super
*super
= FH_SUPER
;
860 gboolean was_error
= FALSE
;
864 h
= open (localname
, O_RDONLY
);
867 if (fstat (h
, &s
) < 0)
873 /* First, try this as stor:
875 * ( head -c number ) | ( cat > file; cat >/dev/null )
877 * If `head' is not present on the remote system, `dd' will be used.
878 * Unfortunately, we cannot trust most non-GNU `head' implementations
879 * even if `-c' options is supported. Therefore, we separate GNU head
880 * (and other modern heads?) using `-q' and `-' . This causes another
881 * implementations to fail (because of "incorrect options").
886 * while [ $rest -gt 0 ]
888 * cnt=`expr \( $rest + 255 \) / 256`
889 * n=`dd bs=256 count=$cnt | tee -a <target_file> | wc -c`
890 * rest=`expr $rest - $n`
893 * `dd' was not designed for full filling of input buffers,
894 * and does not report exact number of bytes (not blocks).
895 * Therefore a more complex shell script is needed.
897 * On some systems non-GNU head writes "Usage:" error report to stdout
898 * instead of stderr. It makes impossible the use of "head || dd"
899 * algorithm for file appending case, therefore just "dd" is used for it.
902 quoted_name
= strutils_shell_escape (name
);
903 vfs_print_message (_("fish: store %s: sending command..."), quoted_name
);
905 /* FIXME: File size is limited to ULONG_MAX */
909 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s FISH_FILESIZE=%" PRIuMAX
";\n",
910 SUP
->scr_append
, (char *) NULL
);
912 code
= fish_command (me
, super
, WAIT_REPLY
, shell_commands
, quoted_name
,
913 (uintmax_t) s
.st_size
);
914 g_free (shell_commands
);
919 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s FISH_FILESIZE=%" PRIuMAX
";\n",
920 SUP
->scr_send
, (char *) NULL
);
921 code
= fish_command (me
, super
, WAIT_REPLY
, shell_commands
, quoted_name
,
922 (uintmax_t) s
.st_size
);
923 g_free (shell_commands
);
928 ERRNOR (E_REMOTE
, -1);
937 while ((n
= read (h
, buffer
, sizeof (buffer
))) < 0)
939 if ((errno
== EINTR
) && tty_got_interrupt ())
941 vfs_print_message (_("fish: Local read failed, sending zeros"));
943 h
= open ("/dev/zero", O_RDONLY
);
949 t
= write (SUP
->sockw
, buffer
, n
);
958 tty_disable_interrupt_key ();
960 vfs_print_message ("%s: %" PRIuMAX
"/%" PRIuMAX
,
961 was_error
? _("fish: storing zeros") : _("fish: storing file"),
962 (uintmax_t) total
, (uintmax_t) s
.st_size
);
965 g_free (quoted_name
);
967 if ((fish_get_reply (me
, SUP
->sockr
, NULL
, 0) != COMPLETE
) || was_error
)
968 ERRNOR (E_REMOTE
, -1);
973 fish_get_reply (me
, SUP
->sockr
, NULL
, 0);
974 g_free (quoted_name
);
978 /* --------------------------------------------------------------------------------------------- */
981 fish_linear_start (struct vfs_class
*me
, vfs_file_handler_t
* fh
, off_t offset
)
983 fish_fh_data_t
*fish
;
984 gchar
*shell_commands
= NULL
;
985 struct vfs_s_super
*super
= FH_SUPER
;
989 if (fh
->data
== NULL
)
990 fh
->data
= g_new0 (fish_fh_data_t
, 1);
992 fish
= (fish_fh_data_t
*) fh
->data
;
994 name
= vfs_s_fullpath (me
, fh
->ino
);
997 quoted_name
= strutils_shell_escape (name
);
999 fish
->append
= FALSE
;
1002 * Check whether the remote file is readable by using `dd' to copy
1003 * a single byte from the remote file to /dev/null. If `dd' completes
1004 * with exit status of 0 use `cat' to send the file contents to the
1005 * standard output (i.e. over the network).
1009 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s FISH_START_OFFSET=%" PRIuMAX
";\n",
1010 SUP
->scr_get
, (char *) NULL
);
1011 offset
= fish_command (me
, super
, WANT_STRING
, shell_commands
, quoted_name
, (uintmax_t) offset
);
1012 g_free (shell_commands
);
1013 g_free (quoted_name
);
1014 if (offset
!= PRELIM
)
1015 ERRNOR (E_REMOTE
, 0);
1016 fh
->linear
= LS_LINEAR_OPEN
;
1019 #if SIZEOF_OFF_T == SIZEOF_LONG
1020 fish
->total
= (off_t
) strtol (reply_str
, NULL
, 10);
1022 fish
->total
= (off_t
) strtoll (reply_str
, NULL
, 10);
1025 ERRNOR (E_REMOTE
, 0);
1029 /* --------------------------------------------------------------------------------------------- */
1032 fish_linear_abort (struct vfs_class
*me
, vfs_file_handler_t
* fh
)
1034 fish_fh_data_t
*fish
= (fish_fh_data_t
*) fh
->data
;
1035 struct vfs_s_super
*super
= FH_SUPER
;
1036 char buffer
[BUF_8K
];
1039 vfs_print_message (_("Aborting transfer..."));
1043 n
= MIN (sizeof (buffer
), (size_t) (fish
->total
- fish
->got
));
1046 n
= read (SUP
->sockr
, buffer
, n
);
1054 if (fish_get_reply (me
, SUP
->sockr
, NULL
, 0) != COMPLETE
)
1055 vfs_print_message (_("Error reported after abort."));
1057 vfs_print_message (_("Aborted transfer would be successful."));
1060 /* --------------------------------------------------------------------------------------------- */
1063 fish_linear_read (struct vfs_class
*me
, vfs_file_handler_t
* fh
, void *buf
, size_t len
)
1065 fish_fh_data_t
*fish
= (fish_fh_data_t
*) fh
->data
;
1066 struct vfs_s_super
*super
= FH_SUPER
;
1070 len
= MIN ((size_t) (fish
->total
- fish
->got
), len
);
1071 tty_disable_interrupt_key ();
1072 while (len
!= 0 && ((n
= read (SUP
->sockr
, buf
, len
)) < 0))
1074 if ((errno
== EINTR
) && !tty_got_interrupt ())
1078 tty_enable_interrupt_key ();
1083 fish_linear_abort (me
, fh
);
1084 else if (fish_get_reply (me
, SUP
->sockr
, NULL
, 0) != COMPLETE
)
1085 ERRNOR (E_REMOTE
, -1);
1089 /* --------------------------------------------------------------------------------------------- */
1092 fish_linear_close (struct vfs_class
*me
, vfs_file_handler_t
* fh
)
1094 fish_fh_data_t
*fish
= (fish_fh_data_t
*) fh
->data
;
1096 if (fish
->total
!= fish
->got
)
1097 fish_linear_abort (me
, fh
);
1100 /* --------------------------------------------------------------------------------------------- */
1103 fish_ctl (void *fh
, int ctlop
, void *arg
)
1112 case VFS_CTL_IS_NOTREADY
:
1117 vfs_die ("You may not do this");
1118 if (FH
->linear
== LS_LINEAR_CLOSED
|| FH
->linear
== LS_LINEAR_PREOPEN
)
1121 v
= vfs_s_select_on_two (FH_SUPER
->u
.fish
.sockr
, 0);
1122 if (((v
< 0) && (errno
== EINTR
)) || v
== 0)
1132 /* --------------------------------------------------------------------------------------------- */
1135 fish_send_command (struct vfs_class
*me
, struct vfs_s_super
*super
, const char *cmd
, int flags
)
1139 r
= fish_command (me
, super
, WAIT_REPLY
, "%s", cmd
);
1140 vfs_stamp_create (&vfs_fish_ops
, super
);
1142 ERRNOR (E_REMOTE
, -1);
1143 if (flags
& OPT_FLUSH
)
1144 vfs_s_invalidate (me
, super
);
1148 /* --------------------------------------------------------------------------------------------- */
1151 fish_rename (const vfs_path_t
* vpath1
, const vfs_path_t
* vpath2
)
1153 gchar
*shell_commands
= NULL
;
1154 char buf
[BUF_LARGE
];
1155 const char *crpath1
, *crpath2
;
1156 char *rpath1
, *rpath2
;
1157 struct vfs_s_super
*super
, *super2
;
1158 const vfs_path_element_t
*path_element
;
1160 path_element
= vfs_path_get_by_index (vpath1
, -1);
1162 crpath1
= vfs_s_get_path (vpath1
, &super
, 0);
1163 if (crpath1
== NULL
)
1166 crpath2
= vfs_s_get_path (vpath2
, &super2
, 0);
1167 if (crpath2
== NULL
)
1170 rpath1
= strutils_shell_escape (crpath1
);
1171 rpath2
= strutils_shell_escape (crpath2
);
1172 shell_commands
= g_strconcat (SUP
->scr_env
, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1173 SUP
->scr_mv
, (char *) NULL
);
1174 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath1
, rpath2
);
1175 g_free (shell_commands
);
1178 return fish_send_command (path_element
->class, super2
, buf
, OPT_FLUSH
);
1181 /* --------------------------------------------------------------------------------------------- */
1184 fish_link (const vfs_path_t
* vpath1
, const vfs_path_t
* vpath2
)
1186 gchar
*shell_commands
= NULL
;
1187 char buf
[BUF_LARGE
];
1188 const char *crpath1
, *crpath2
;
1189 char *rpath1
, *rpath2
;
1190 struct vfs_s_super
*super
, *super2
;
1191 const vfs_path_element_t
*path_element
;
1193 path_element
= vfs_path_get_by_index (vpath1
, -1);
1195 crpath1
= vfs_s_get_path (vpath1
, &super
, 0);
1196 if (crpath1
== NULL
)
1199 crpath2
= vfs_s_get_path (vpath2
, &super2
, 0);
1200 if (crpath2
== NULL
)
1203 rpath1
= strutils_shell_escape (crpath1
);
1204 rpath2
= strutils_shell_escape (crpath2
);
1205 shell_commands
= g_strconcat (SUP
->scr_env
, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1206 SUP
->scr_hardlink
, (char *) NULL
);
1207 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath1
, rpath2
);
1208 g_free (shell_commands
);
1211 return fish_send_command (path_element
->class, super2
, buf
, OPT_FLUSH
);
1215 /* --------------------------------------------------------------------------------------------- */
1218 fish_symlink (const vfs_path_t
* vpath1
, const vfs_path_t
* vpath2
)
1221 gchar
*shell_commands
= NULL
;
1222 char buf
[BUF_LARGE
];
1225 struct vfs_s_super
*super
;
1226 const vfs_path_element_t
*path_element
;
1228 path_element
= vfs_path_get_by_index (vpath2
, -1);
1230 crpath
= vfs_s_get_path (vpath2
, &super
, 0);
1234 rpath
= strutils_shell_escape (crpath
);
1235 qsetto
= strutils_shell_escape (vfs_path_get_by_index (vpath1
, -1)->path
);
1237 shell_commands
= g_strconcat (SUP
->scr_env
, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1238 SUP
->scr_ln
, (char *) NULL
);
1239 g_snprintf (buf
, sizeof (buf
), shell_commands
, qsetto
, rpath
);
1240 g_free (shell_commands
);
1243 return fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1246 /* --------------------------------------------------------------------------------------------- */
1249 fish_chmod (const vfs_path_t
* vpath
, mode_t mode
)
1251 gchar
*shell_commands
= NULL
;
1252 char buf
[BUF_LARGE
];
1255 struct vfs_s_super
*super
;
1256 const vfs_path_element_t
*path_element
;
1258 path_element
= vfs_path_get_by_index (vpath
, -1);
1260 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1263 rpath
= strutils_shell_escape (crpath
);
1265 shell_commands
= g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s FISH_FILEMODE=%4.4o;\n",
1266 SUP
->scr_chmod
, (char *) NULL
);
1267 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
, (int) (mode
& 07777));
1268 g_free (shell_commands
);
1270 return fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1273 /* --------------------------------------------------------------------------------------------- */
1276 fish_chown (const vfs_path_t
* vpath
, uid_t owner
, gid_t group
)
1278 char *sowner
, *sgroup
;
1282 pw
= getpwuid (owner
);
1286 gr
= getgrgid (group
);
1290 sowner
= pw
->pw_name
;
1291 sgroup
= gr
->gr_name
;
1294 gchar
*shell_commands
= NULL
;
1295 char buf
[BUF_LARGE
];
1298 struct vfs_s_super
*super
;
1299 const vfs_path_element_t
*path_element
;
1301 path_element
= vfs_path_get_by_index (vpath
, -1);
1303 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1306 rpath
= strutils_shell_escape (crpath
);
1308 shell_commands
= g_strconcat (SUP
->scr_env
,
1309 "FISH_FILENAME=%s FISH_FILEOWNER=%s FISH_FILEGROUP=%s;\n",
1310 SUP
->scr_chown
, (char *) NULL
);
1311 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
, sowner
, sgroup
);
1312 g_free (shell_commands
);
1313 fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1314 /* FIXME: what should we report if chgrp succeeds but chown fails? */
1315 /* fish_send_command(me, super, buf, OPT_FLUSH); */
1317 return fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1321 /* --------------------------------------------------------------------------------------------- */
1324 fish_utime (const vfs_path_t
* vpath
, struct utimbuf
*times
)
1326 gchar
*shell_commands
= NULL
;
1327 char utcmtime
[16], utcatime
[16];
1330 char buf
[BUF_LARGE
];
1333 struct vfs_s_super
*super
;
1334 const vfs_path_element_t
*path_element
;
1336 path_element
= vfs_path_get_by_index (vpath
, -1);
1338 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1341 rpath
= strutils_shell_escape (crpath
);
1343 gmt
= gmtime (×
->modtime
);
1344 g_snprintf (utcmtime
, sizeof (utcmtime
), "%04d%02d%02d%02d%02d.%02d",
1345 gmt
->tm_year
+ 1900, gmt
->tm_mon
+ 1, gmt
->tm_mday
,
1346 gmt
->tm_hour
, gmt
->tm_min
, gmt
->tm_sec
);
1348 gmt
= gmtime (×
->actime
);
1349 g_snprintf (utcatime
, sizeof (utcatime
), "%04d%02d%02d%02d%02d.%02d",
1350 gmt
->tm_year
+ 1900, gmt
->tm_mon
+ 1, gmt
->tm_mday
,
1351 gmt
->tm_hour
, gmt
->tm_min
, gmt
->tm_sec
);
1354 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s FISH_FILEATIME=%ld FISH_FILEMTIME=%ld ",
1355 "FISH_TOUCHATIME=%s FISH_TOUCHMTIME=%s;\n", SUP
->scr_utime
, (char *) NULL
);
1356 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
, (long) times
->actime
,
1357 (long) times
->modtime
, utcatime
, utcmtime
);
1358 g_free (shell_commands
);
1360 return fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1363 /* --------------------------------------------------------------------------------------------- */
1366 fish_unlink (const vfs_path_t
* vpath
)
1368 gchar
*shell_commands
= NULL
;
1370 char buf
[BUF_LARGE
];
1373 struct vfs_s_super
*super
;
1374 const vfs_path_element_t
*path_element
;
1376 path_element
= vfs_path_get_by_index (vpath
, -1);
1378 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1381 rpath
= strutils_shell_escape (crpath
);
1384 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s;\n", SUP
->scr_unlink
, (char *) NULL
);
1385 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
);
1386 g_free (shell_commands
);
1388 return fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1391 /* --------------------------------------------------------------------------------------------- */
1394 fish_exists (const vfs_path_t
* vpath
)
1396 gchar
*shell_commands
= NULL
;
1398 char buf
[BUF_LARGE
];
1401 struct vfs_s_super
*super
;
1402 const vfs_path_element_t
*path_element
;
1404 path_element
= vfs_path_get_by_index (vpath
, -1);
1406 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1409 rpath
= strutils_shell_escape (crpath
);
1412 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s;\n", SUP
->scr_exists
, (char *) NULL
);
1413 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
);
1414 g_free (shell_commands
);
1417 return (fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
) == 0) ? 1 : 0;
1420 /* --------------------------------------------------------------------------------------------- */
1423 fish_mkdir (const vfs_path_t
* vpath
, mode_t mode
)
1425 gchar
*shell_commands
= NULL
;
1427 char buf
[BUF_LARGE
];
1430 struct vfs_s_super
*super
;
1431 const vfs_path_element_t
*path_element
;
1435 path_element
= vfs_path_get_by_index (vpath
, -1);
1437 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1440 rpath
= strutils_shell_escape (crpath
);
1443 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s;\n", SUP
->scr_mkdir
, (char *) NULL
);
1444 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
);
1445 g_free (shell_commands
);
1448 ret_code
= fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1453 if (!fish_exists (vpath
))
1455 path_element
->class->verrno
= EACCES
;
1461 /* --------------------------------------------------------------------------------------------- */
1464 fish_rmdir (const vfs_path_t
* vpath
)
1466 gchar
*shell_commands
= NULL
;
1467 char buf
[BUF_LARGE
];
1470 struct vfs_s_super
*super
;
1471 const vfs_path_element_t
*path_element
;
1473 path_element
= vfs_path_get_by_index (vpath
, -1);
1475 crpath
= vfs_s_get_path (vpath
, &super
, 0);
1478 rpath
= strutils_shell_escape (crpath
);
1481 g_strconcat (SUP
->scr_env
, "FISH_FILENAME=%s;\n", SUP
->scr_rmdir
, (char *) NULL
);
1482 g_snprintf (buf
, sizeof (buf
), shell_commands
, rpath
);
1483 g_free (shell_commands
);
1485 return fish_send_command (path_element
->class, super
, buf
, OPT_FLUSH
);
1488 /* --------------------------------------------------------------------------------------------- */
1491 fish_fh_free_data (vfs_file_handler_t
* fh
)
1500 /* --------------------------------------------------------------------------------------------- */
1503 fish_fh_open (struct vfs_class
*me
, vfs_file_handler_t
* fh
, int flags
, mode_t mode
)
1505 fish_fh_data_t
*fish
;
1509 fh
->data
= g_new0 (fish_fh_data_t
, 1);
1510 fish
= (fish_fh_data_t
*) fh
->data
;
1512 /* File will be written only, so no need to retrieve it */
1513 if (((flags
& O_WRONLY
) == O_WRONLY
) && ((flags
& (O_RDONLY
| O_RDWR
)) == 0))
1515 /* user pressed the button [ Append ] in the "Copy" dialog */
1516 if ((flags
& O_APPEND
) != 0)
1517 fish
->append
= TRUE
;
1519 if (!fh
->ino
->localname
)
1524 tmp_handle
= vfs_mkstemps (&vpath
, me
->name
, fh
->ino
->ent
->name
);
1525 if (tmp_handle
== -1)
1527 vfs_path_free (vpath
);
1530 fh
->ino
->localname
= vfs_path_to_str (vpath
);
1531 vfs_path_free (vpath
);
1536 if (!fh
->ino
->localname
&& vfs_s_retrieve_file (me
, fh
->ino
) == -1)
1538 if (!fh
->ino
->localname
)
1539 vfs_die ("retrieve_file failed to fill in localname");
1543 fish_fh_free_data (fh
);
1547 /* --------------------------------------------------------------------------------------------- */
1550 fish_fill_names (struct vfs_class
*me
, fill_names_f func
)
1554 for (iter
= MEDATA
->supers
; iter
!= NULL
; iter
= g_list_next (iter
))
1556 const struct vfs_s_super
*super
= (const struct vfs_s_super
*) iter
->data
;
1560 const char *flags
= "";
1562 switch (super
->path_element
->port
)
1567 case FISH_FLAG_COMPRESSED
:
1571 if (super
->path_element
->port
> FISH_FLAG_RSH
)
1573 g_snprintf (gbuf
, sizeof (gbuf
), ":%d", super
->path_element
->port
);
1580 g_strconcat (vfs_fish_ops
.prefix
, VFS_PATH_URL_DELIMITER
,
1581 super
->path_element
->user
, "@", super
->path_element
->host
, flags
, "/",
1582 super
->path_element
->path
, (char *) NULL
);
1588 /* --------------------------------------------------------------------------------------------- */
1591 fish_open (const vfs_path_t
* vpath
, int flags
, mode_t mode
)
1594 sorry, i've places hack here
1595 cause fish don't able to open files with O_EXCL flag
1598 return vfs_s_open (vpath
, flags
, mode
);
1601 /* --------------------------------------------------------------------------------------------- */
1602 /*** public functions ****************************************************************************/
1603 /* --------------------------------------------------------------------------------------------- */
1608 static struct vfs_s_subclass fish_subclass
;
1612 fish_subclass
.flags
= VFS_S_REMOTE
| VFS_S_USETMP
;
1613 fish_subclass
.archive_same
= fish_archive_same
;
1614 fish_subclass
.open_archive
= fish_open_archive
;
1615 fish_subclass
.free_archive
= fish_free_archive
;
1616 fish_subclass
.fh_open
= fish_fh_open
;
1617 fish_subclass
.fh_free_data
= fish_fh_free_data
;
1618 fish_subclass
.dir_load
= fish_dir_load
;
1619 fish_subclass
.file_store
= fish_file_store
;
1620 fish_subclass
.linear_start
= fish_linear_start
;
1621 fish_subclass
.linear_read
= fish_linear_read
;
1622 fish_subclass
.linear_close
= fish_linear_close
;
1624 vfs_s_init_class (&vfs_fish_ops
, &fish_subclass
);
1625 vfs_fish_ops
.name
= "fish";
1626 vfs_fish_ops
.prefix
= "sh";
1627 vfs_fish_ops
.fill_names
= fish_fill_names
;
1628 vfs_fish_ops
.chmod
= fish_chmod
;
1629 vfs_fish_ops
.chown
= fish_chown
;
1630 vfs_fish_ops
.utime
= fish_utime
;
1631 vfs_fish_ops
.open
= fish_open
;
1632 vfs_fish_ops
.symlink
= fish_symlink
;
1633 vfs_fish_ops
.link
= fish_link
;
1634 vfs_fish_ops
.unlink
= fish_unlink
;
1635 vfs_fish_ops
.rename
= fish_rename
;
1636 vfs_fish_ops
.mkdir
= fish_mkdir
;
1637 vfs_fish_ops
.rmdir
= fish_rmdir
;
1638 vfs_fish_ops
.ctl
= fish_ctl
;
1639 vfs_register_class (&vfs_fish_ops
);
1642 /* --------------------------------------------------------------------------------------------- */