2 Virtual File System: FTP file system.
4 Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
5 2006, 2007, 2008, 2009, 2010, 2011
6 The Free Software Foundation, Inc.
11 Miguel de Icaza, 1995, 1996, 1997
15 Slava Zanko <slavazanko@gmail.com>, 2010
16 Andrew Borodin <aborodin@vmail.ru>, 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: FTP file system
38 * \author Jakub Jelinek
39 * \author Miguel de Icaza
40 * \author Norbert Warmuth
41 * \author Pavel Machek
42 * \date 1995, 1997, 1998
45 - make it more robust - all the connects etc. should handle EADDRINUSE and
46 ERETRY (have I spelled these names correctly?)
47 - make the user able to flush a connection - all the caches will get empty
48 etc., (tarfs as well), we should give there a user selectable timeout
49 and assign a key sequence.
50 - use hash table instead of linklist to cache ftpfs directory.
55 * NOTE: Usage of tildes is deprecated, consider:
60 * And now: what do I want to do? Do I want to go to /home/pavel or to
61 * ftp://hobit/home/pavel? I think first has better sense...
65 int f = !strcmp( remote_path, "/~" );
66 if (f || !strncmp( remote_path, "/~/", 3 )) {
68 s = mc_build_filename ( qhome (*bucket), remote_path +3-f, NULL );
76 /* \todo Fix: Namespace pollution: horrible */
79 #include <stdio.h> /* sscanf() */
80 #include <stdlib.h> /* atoi() */
81 #include <sys/types.h> /* POSIX-required by sys/socket.h and netdb.h */
82 #include <netdb.h> /* struct hostent */
83 #include <sys/socket.h> /* AF_INET */
84 #include <netinet/in.h> /* struct in_addr */
85 #ifdef HAVE_ARPA_INET_H
86 #include <arpa/inet.h>
89 #include <arpa/telnet.h>
90 #ifdef HAVE_SYS_PARAM_H
91 #include <sys/param.h>
96 #include <sys/time.h> /* gettimeofday() */
97 #include <inttypes.h> /* uintmax_t */
99 #include "lib/global.h"
100 #include "lib/util.h"
101 #include "lib/mcconfig.h"
103 #include "lib/tty/tty.h" /* enable/disable interrupt key */
104 #include "lib/widget.h" /* message() */
106 #include "src/history.h"
107 #include "src/setup.h" /* for load_anon_passwd */
109 #include "lib/vfs/vfs.h"
110 #include "lib/vfs/utilvfs.h"
111 #include "lib/vfs/netutil.h"
112 #include "lib/vfs/xdirentry.h"
113 #include "lib/vfs/gc.h" /* vfs_stamp_create */
117 /*** global variables ****************************************************************************/
119 /* Delay to retry a connection */
120 int ftpfs_retry_seconds
= 30;
122 /* Method to use to connect to ftp sites */
123 int ftpfs_use_passive_connections
= 1;
124 int ftpfs_use_passive_connections_over_proxy
= 0;
126 /* Method used to get directory listings:
127 * 1: try 'LIST -la <path>', if it fails
128 * fall back to CWD <path>; LIST
129 * 0: always use CWD <path>; LIST
131 int ftpfs_use_unix_list_options
= 1;
133 /* First "CWD <path>", then "LIST -la ." */
134 int ftpfs_first_cd_then_ls
= 1;
136 /* Use the ~/.netrc */
137 int ftpfs_use_netrc
= 1;
139 /* Anonymous setup */
140 char *ftpfs_anonymous_passwd
= NULL
;
141 int ftpfs_directory_timeout
= 900;
144 char *ftpfs_proxy_host
= NULL
;
146 /* wether we have to use proxy by default? */
147 int ftpfs_always_use_proxy
= 0;
149 int ftpfs_ignore_chattr_errors
= 1;
151 /*** file scope macro definitions ****************************************************************/
153 #ifndef MAXHOSTNAMELEN
154 #define MAXHOSTNAMELEN 64
157 #define UPLOAD_ZERO_LENGTH_FILE
158 #define SUP ((ftp_super_data_t *) super->data)
159 #define FH_SOCK ((ftp_fh_data_t *) fh->data)->sock
162 #define INADDR_NONE 0xffffffff
165 #define RFC_AUTODETECT 0
169 /* ftpfs_command wait_flag: */
171 #define WAIT_REPLY 0x01
172 #define WANT_STRING 0x02
174 #define FTP_COMMAND_PORT 21
176 /* some defines only used by ftpfs_changetype */
177 /* These two are valid values for the second parameter */
179 #define TYPE_BINARY 1
181 /* This one is only used to initialize bucket->isbinary, don't use it as
182 second parameter to ftpfs_changetype. */
183 #define TYPE_UNKNOWN -1
185 #define ABORT_TIMEOUT 5
186 /*** file scope type declarations ****************************************************************/
188 #ifndef HAVE_SOCKLEN_T
189 typedef int socklen_t
;
192 /* This should match the keywords[] array below */
210 char *proxy
; /* proxy server, NULL if no proxy */
211 int failed_on_login
; /* used to pass the failure reason to upper levels */
212 int use_passive_connection
;
213 int remote_is_amiga
; /* No leading slash allowed for AmiTCP (Amiga) */
215 int cwd_deferred
; /* current_directory was changed but CWD command hasn't
217 int strict
; /* ftp server doesn't understand
218 * "LIST -la <path>"; use "CWD <path>"/
221 int ctl_connection_busy
;
231 /*** file scope variables ************************************************************************/
233 static int ftpfs_errno
;
236 #ifdef FIXME_LATER_ALIGATOR
237 static struct linklist
*connections_list
;
240 static char reply_str
[80];
242 static struct vfs_class vfs_ftpfs_ops
;
244 static GSList
*no_proxy
;
246 static char buffer
[BUF_MEDIUM
];
248 static const char *netrcp
;
250 /*** file scope functions ************************************************************************/
251 /* --------------------------------------------------------------------------------------------- */
253 /* char *ftpfs_translate_path (struct ftpfs_connection *bucket, char *remote_path)
254 Translate a Unix path, i.e. MC's internal path representation (e.g.
255 /somedir/somefile) to a path valid for the remote server. Every path
256 transfered to the remote server has to be mangled by this function
257 right prior to sending it.
258 Currently only Amiga ftp servers are handled in a special manner.
260 When the remote server is an amiga:
261 a) strip leading slash if necesarry
262 b) replace first occurance of ":/" with ":"
263 c) strip trailing "/."
266 static char *ftpfs_get_current_directory (struct vfs_class
*me
, struct vfs_s_super
*super
);
267 static int ftpfs_chdir_internal (struct vfs_class
*me
, struct vfs_s_super
*super
,
268 const char *remote_path
);
269 static int ftpfs_command (struct vfs_class
*me
, struct vfs_s_super
*super
, int wait_reply
,
270 const char *fmt
, ...) __attribute__ ((format (__printf__
, 4, 5)));
271 static int ftpfs_open_socket (struct vfs_class
*me
, struct vfs_s_super
*super
);
272 static int ftpfs_login_server (struct vfs_class
*me
, struct vfs_s_super
*super
,
273 const char *netrcpass
);
274 static int ftpfs_netrc_lookup (const char *host
, char **login
, char **pass
);
276 /* --------------------------------------------------------------------------------------------- */
279 ftpfs_translate_path (struct vfs_class
*me
, struct vfs_s_super
*super
, const char *remote_path
)
281 if (!SUP
->remote_is_amiga
)
282 return g_strdup (remote_path
);
289 fprintf (MEDATA
->logfile
, "MC -- ftpfs_translate_path: %s\n", remote_path
);
290 fflush (MEDATA
->logfile
);
293 /* strip leading slash(es) */
294 while (*remote_path
== '/')
298 * Don't change "/" into "", e.g. "CWD " would be
301 if (*remote_path
== '\0')
302 return g_strdup (".");
304 ret
= g_strdup (remote_path
);
306 /* replace first occurance of ":/" with ":" */
307 p
= strchr (ret
, ':');
308 if ((p
!= NULL
) && (*(p
+ 1) == '/'))
309 memmove (p
+ 1, p
+ 2, strlen (p
+ 2) + 1);
311 /* strip trailing "/." */
312 p
= strrchr (ret
, '/');
313 if ((p
!= NULL
) && (*(p
+ 1) == '.') && (*(p
+ 2) == '\0'))
320 /* --------------------------------------------------------------------------------------------- */
321 /** Extract the hostname and username from the path */
323 * path is in the form: [user@]hostname:port/remote-dir, e.g.:
324 * ftp://sunsite.unc.edu/pub/linux
325 * ftp://miguel@sphinx.nuclecu.unam.mx/c/nc
326 * ftp://tsx-11.mit.edu:8192/
327 * ftp://joe@foo.edu:11321/private
328 * If the user is empty, e.g. ftp://@roxanne/private, then your login name
332 static vfs_path_element_t
*
333 ftpfs_correct_url_parameters (const vfs_path_element_t
* velement
)
335 vfs_path_element_t
*path_element
= vfs_path_element_clone (velement
);
337 if (path_element
->port
== 0)
338 path_element
->port
= FTP_COMMAND_PORT
;
340 if (path_element
->user
== NULL
)
342 /* Look up user and password in netrc */
344 ftpfs_netrc_lookup (path_element
->host
, &path_element
->user
, &path_element
->password
);
346 if (path_element
->user
== NULL
)
347 path_element
->user
= g_strdup ("anonymous");
349 /* Look up password in netrc for known user */
350 if (ftpfs_use_netrc
&& path_element
->user
!= NULL
&& path_element
->password
!= NULL
)
352 char *new_user
= NULL
;
353 char *new_passwd
= NULL
;
355 ftpfs_netrc_lookup (path_element
->host
, &new_user
, &new_passwd
);
357 /* If user is different, remove password */
358 if (new_user
!= NULL
&& strcmp (path_element
->user
, new_user
) != 0)
360 g_free (path_element
->password
);
361 path_element
->password
= NULL
;
371 /* --------------------------------------------------------------------------------------------- */
372 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
375 ftpfs_get_reply (struct vfs_class
*me
, int sock
, char *string_buf
, int string_len
)
382 if (!vfs_s_get_line (me
, sock
, answer
, sizeof (answer
), '\n'))
384 if (string_buf
!= NULL
)
389 switch (sscanf (answer
, "%d", &code
))
392 if (string_buf
!= NULL
)
393 g_strlcpy (string_buf
, answer
, string_len
);
397 if (answer
[3] == '-')
401 if (!vfs_s_get_line (me
, sock
, answer
, sizeof (answer
), '\n'))
403 if (string_buf
!= NULL
)
408 if ((sscanf (answer
, "%d", &i
) > 0) && (code
== i
) && (answer
[3] == ' '))
412 if (string_buf
!= NULL
)
413 g_strlcpy (string_buf
, answer
, string_len
);
419 /* --------------------------------------------------------------------------------------------- */
422 ftpfs_reconnect (struct vfs_class
*me
, struct vfs_s_super
*super
)
426 sock
= ftpfs_open_socket (me
, super
);
429 char *cwdir
= SUP
->current_dir
;
433 SUP
->current_dir
= NULL
;
435 if (ftpfs_login_server (me
, super
, super
->path_element
->password
) != 0)
439 sock
= ftpfs_chdir_internal (me
, super
, cwdir
);
441 return sock
== COMPLETE
? 1 : 0;
444 SUP
->current_dir
= cwdir
;
450 /* --------------------------------------------------------------------------------------------- */
453 ftpfs_command (struct vfs_class
*me
, struct vfs_s_super
*super
, int wait_reply
, const char *fmt
,
459 static int retry
= 0;
460 static int level
= 0; /* ftpfs_login_server() use ftpfs_command() */
463 cmdstr
= g_strdup_vprintf (fmt
, ap
);
466 cmdlen
= strlen (cmdstr
);
467 cmdstr
= g_realloc (cmdstr
, cmdlen
+ 3);
468 strcpy (cmdstr
+ cmdlen
, "\r\n");
473 if (strncmp (cmdstr
, "PASS ", 5) == 0)
475 fputs ("PASS <Password not logged>\r\n", MEDATA
->logfile
);
480 ret
= fwrite (cmdstr
, cmdlen
, 1, MEDATA
->logfile
);
484 fflush (MEDATA
->logfile
);
488 tty_enable_interrupt_key ();
489 status
= write (SUP
->sock
, cmdstr
, cmdlen
);
496 { /* Remote server has closed connection */
500 status
= ftpfs_reconnect (me
, super
);
502 if (status
&& (write (SUP
->sock
, cmdstr
, cmdlen
) > 0))
511 tty_disable_interrupt_key ();
516 tty_disable_interrupt_key ();
520 status
= ftpfs_get_reply (me
, SUP
->sock
,
521 (wait_reply
& WANT_STRING
) ? reply_str
: NULL
,
522 sizeof (reply_str
) - 1);
523 if ((wait_reply
& WANT_STRING
) && !retry
&& !level
&& code
== 421)
527 status
= ftpfs_reconnect (me
, super
);
529 if (status
&& (write (SUP
->sock
, cmdstr
, cmdlen
) > 0))
542 /* --------------------------------------------------------------------------------------------- */
545 ftpfs_free_archive (struct vfs_class
*me
, struct vfs_s_super
*super
)
549 vfs_print_message (_("ftpfs: Disconnecting from %s"), super
->path_element
->host
);
550 ftpfs_command (me
, super
, NONE
, "QUIT");
553 g_free (SUP
->current_dir
);
554 g_free (super
->data
);
558 /* --------------------------------------------------------------------------------------------- */
561 ftpfs_changetype (struct vfs_class
*me
, struct vfs_s_super
*super
, int binary
)
563 if (binary
!= SUP
->isbinary
)
565 if (ftpfs_command (me
, super
, WAIT_REPLY
, "TYPE %c", binary
? 'I' : 'A') != COMPLETE
)
567 SUP
->isbinary
= binary
;
572 /* --------------------------------------------------------------------------------------------- */
573 /* This routine logs the user in */
576 ftpfs_login_server (struct vfs_class
*me
, struct vfs_s_super
*super
, const char *netrcpass
)
580 char *name
; /* login user name */
582 char reply_string
[BUF_MEDIUM
];
584 SUP
->isbinary
= TYPE_UNKNOWN
;
586 if (super
->path_element
->password
!= NULL
) /* explicit password */
587 op
= g_strdup (super
->path_element
->password
);
588 else if (netrcpass
!= NULL
) /* password from netrc */
589 op
= g_strdup (netrcpass
);
590 else if (strcmp (super
->path_element
->user
, "anonymous") == 0
591 || strcmp (super
->path_element
->user
, "ftp") == 0)
593 if (ftpfs_anonymous_passwd
== NULL
) /* default anonymous password */
594 ftpfs_init_passwd ();
595 op
= g_strdup (ftpfs_anonymous_passwd
);
602 p
= g_strdup_printf (_("FTP: Password required for %s"), super
->path_element
->user
);
603 op
= vfs_get_password (p
);
607 super
->path_element
->password
= g_strdup (op
);
610 if (!anon
|| MEDATA
->logfile
)
614 pass
= g_strconcat ("-", op
, (char *) NULL
);
618 /* Proxy server accepts: username@host-we-want-to-connect */
621 g_strconcat (super
->path_element
->user
, "@",
622 super
->path_element
->host
[0] ==
623 '!' ? super
->path_element
->host
+ 1 : super
->path_element
->host
,
626 name
= g_strdup (super
->path_element
->user
);
628 if (ftpfs_get_reply (me
, SUP
->sock
, reply_string
, sizeof (reply_string
) - 1) == COMPLETE
)
632 reply_up
= g_ascii_strup (reply_string
, -1);
633 SUP
->remote_is_amiga
= strstr (reply_up
, "AMIGA") != 0;
634 if (strstr (reply_up
, " SPFTP/1.0.0000 SERVER ")) /* handles `LIST -la` in a weird way */
635 SUP
->strict
= RFC_STRICT
;
640 fprintf (MEDATA
->logfile
, "MC -- remote_is_amiga = %d\n", SUP
->remote_is_amiga
);
641 fflush (MEDATA
->logfile
);
644 vfs_print_message (_("ftpfs: sending login name"));
646 switch (ftpfs_command (me
, super
, WAIT_REPLY
, "USER %s", name
))
649 vfs_print_message (_("ftpfs: sending user password"));
650 code
= ftpfs_command (me
, super
, WAIT_REPLY
, "PASS %s", pass
);
651 if (code
== CONTINUE
)
655 p
= g_strdup_printf (_("FTP: Account required for user %s"),
656 super
->path_element
->user
);
657 op
= input_dialog (p
, _("Account:"), MC_HISTORY_FTPFS_ACCOUNT
, "",
658 INPUT_COMPLETE_DEFAULT
);
662 vfs_print_message (_("ftpfs: sending user account"));
663 code
= ftpfs_command (me
, super
, WAIT_REPLY
, "ACCT %s", op
);
666 if (code
!= COMPLETE
)
671 vfs_print_message (_("ftpfs: logged in"));
672 wipe_password (pass
);
677 SUP
->failed_on_login
= 1;
678 wipe_password (super
->path_element
->password
);
679 super
->path_element
->password
= NULL
;
685 message (D_ERROR
, MSG_ERROR
, _("ftpfs: Login incorrect for user %s "),
686 super
->path_element
->user
);
689 wipe_password (pass
);
694 /* --------------------------------------------------------------------------------------------- */
697 ftpfs_load_no_proxy_list (void)
699 /* FixMe: shouldn't be hardcoded!!! */
700 char s
[BUF_LARGE
]; /* provide for BUF_LARGE characters */
704 static char *mc_file
= NULL
;
706 mc_file
= g_build_filename (mc_global
.sysconfig_dir
, "mc.no_proxy", (char *) NULL
);
707 if (exist_file (mc_file
))
709 npf
= fopen (mc_file
, "r");
712 while (fgets (s
, sizeof (s
), npf
) != NULL
)
714 p
= strchr (s
, '\n');
715 if (p
== NULL
) /* skip bogus entries */
717 while ((c
= fgetc (npf
)) != EOF
&& c
!= '\n')
725 no_proxy
= g_slist_prepend (no_proxy
, g_strdup (s
));
734 /* --------------------------------------------------------------------------------------------- */
735 /* Return 1 if FTP proxy should be used for this host, 0 otherwise */
738 ftpfs_check_proxy (const char *host
)
742 if (ftpfs_proxy_host
== NULL
|| *ftpfs_proxy_host
== '\0' || host
== NULL
|| *host
== '\0')
743 return 0; /* sanity check */
748 if (!ftpfs_always_use_proxy
)
751 if (strchr (host
, '.') == NULL
)
754 ftpfs_load_no_proxy_list ();
755 for (npe
= no_proxy
; npe
!= NULL
; npe
= g_slist_next (npe
))
757 const char *domain
= (const char *) npe
->data
;
759 if (domain
[0] == '.')
761 size_t ld
= strlen (domain
);
762 size_t lh
= strlen (host
);
764 while (ld
!= 0 && lh
!= 0 && host
[lh
- 1] == domain
[ld
- 1])
773 else if (g_ascii_strcasecmp (host
, domain
) == 0)
780 /* --------------------------------------------------------------------------------------------- */
783 ftpfs_get_proxy_host_and_port (const char *proxy
, char **host
, int *port
)
785 vfs_path_element_t
*path_element
;
787 path_element
= vfs_url_split (proxy
, FTP_COMMAND_PORT
, URL_USE_ANONYMOUS
);
788 *host
= g_strdup (path_element
->host
);
789 *port
= path_element
->port
;
790 vfs_path_element_free (path_element
);
793 /* --------------------------------------------------------------------------------------------- */
796 ftpfs_open_socket (struct vfs_class
*me
, struct vfs_s_super
*super
)
798 struct addrinfo hints
, *res
, *curr_res
;
807 /* Use a proxy host? */
808 host
= g_strdup (super
->path_element
->host
);
810 if (host
== NULL
|| *host
== '\0')
812 vfs_print_message (_("ftpfs: Invalid host name."));
813 ftpfs_errno
= EINVAL
;
818 /* Hosts to connect to that start with a ! should use proxy */
819 tmp_port
= super
->path_element
->port
;
821 if (SUP
->proxy
!= NULL
)
822 ftpfs_get_proxy_host_and_port (ftpfs_proxy_host
, &host
, &tmp_port
);
824 g_snprintf (port
, sizeof (port
), "%hu", (unsigned short) tmp_port
);
832 tty_enable_interrupt_key (); /* clear the interrupt flag */
834 memset (&hints
, 0, sizeof (struct addrinfo
));
835 hints
.ai_family
= AF_UNSPEC
;
836 hints
.ai_socktype
= SOCK_STREAM
;
839 /* By default, only look up addresses using address types for
840 * which a local interface is configured (i.e. no IPv6 if no IPv6
841 * interfaces, likewise for IPv4 (see RFC 3493 for details). */
842 hints
.ai_flags
= AI_ADDRCONFIG
;
845 e
= getaddrinfo (host
, port
, &hints
, &res
);
848 if (e
== EAI_BADFLAGS
)
850 /* Retry with no flags if AI_ADDRCONFIG was rejected. */
852 e
= getaddrinfo (host
, port
, &hints
, &res
);
860 tty_disable_interrupt_key ();
861 vfs_print_message (_("ftpfs: %s"), gai_strerror (e
));
863 ftpfs_errno
= EINVAL
;
867 for (curr_res
= res
; curr_res
!= NULL
; curr_res
= curr_res
->ai_next
)
869 my_socket
= socket (curr_res
->ai_family
, curr_res
->ai_socktype
, curr_res
->ai_protocol
);
873 if (curr_res
->ai_next
!= NULL
)
876 tty_disable_interrupt_key ();
877 vfs_print_message (_("ftpfs: %s"), unix_error_string (errno
));
884 vfs_print_message (_("ftpfs: making connection to %s"), host
);
888 if (connect (my_socket
, curr_res
->ai_addr
, curr_res
->ai_addrlen
) >= 0)
894 if (errno
== EINTR
&& tty_got_interrupt ())
895 vfs_print_message (_("ftpfs: connection interrupted by user"));
896 else if (res
->ai_next
== NULL
)
897 vfs_print_message (_("ftpfs: connection to server failed: %s"),
898 unix_error_string (errno
));
903 tty_disable_interrupt_key ();
908 tty_disable_interrupt_key ();
912 /* --------------------------------------------------------------------------------------------- */
915 ftpfs_open_archive_int (struct vfs_class
*me
, struct vfs_s_super
*super
)
917 int retry_seconds
= 0;
920 /* We do not want to use the passive if we are using proxies */
922 SUP
->use_passive_connection
= ftpfs_use_passive_connections_over_proxy
;
926 SUP
->failed_on_login
= 0;
928 SUP
->sock
= ftpfs_open_socket (me
, super
);
932 if (ftpfs_login_server (me
, super
, NULL
) != 0)
934 /* Logged in, no need to retry the connection */
939 if (!SUP
->failed_on_login
)
942 /* Close only the socket descriptor */
945 if (ftpfs_retry_seconds
!= 0)
947 retry_seconds
= ftpfs_retry_seconds
;
948 tty_enable_interrupt_key ();
949 for (count_down
= retry_seconds
; count_down
; count_down
--)
951 vfs_print_message (_("Waiting to retry... %d (Control-G to cancel)"),
954 if (tty_got_interrupt ())
956 /* ftpfs_errno = E; */
957 tty_disable_interrupt_key ();
961 tty_disable_interrupt_key ();
965 while (retry_seconds
!= 0);
967 SUP
->current_dir
= ftpfs_get_current_directory (me
, super
);
968 if (SUP
->current_dir
== NULL
)
969 SUP
->current_dir
= g_strdup (PATH_SEP_STR
);
974 /* --------------------------------------------------------------------------------------------- */
977 ftpfs_open_archive (struct vfs_s_super
*super
,
978 const vfs_path_t
* vpath
, const vfs_path_element_t
* vpath_element
)
982 super
->data
= g_new0 (ftp_super_data_t
, 1);
984 super
->path_element
= ftpfs_correct_url_parameters (vpath_element
);
986 if (ftpfs_check_proxy (super
->path_element
->host
))
987 SUP
->proxy
= ftpfs_proxy_host
;
988 SUP
->use_passive_connection
= ftpfs_use_passive_connections
;
989 SUP
->strict
= ftpfs_use_unix_list_options
? RFC_AUTODETECT
: RFC_STRICT
;
990 SUP
->isbinary
= TYPE_UNKNOWN
;
991 SUP
->remote_is_amiga
= 0;
992 super
->name
= g_strdup ("/");
994 vfs_s_new_inode (vpath_element
->class, super
,
995 vfs_s_default_stat (vpath_element
->class, S_IFDIR
| 0755));
997 return ftpfs_open_archive_int (vpath_element
->class, super
);
1000 /* --------------------------------------------------------------------------------------------- */
1003 ftpfs_archive_same (const vfs_path_element_t
* vpath_element
, struct vfs_s_super
*super
,
1004 const vfs_path_t
* vpath
, void *cookie
)
1006 vfs_path_element_t
*path_element
;
1012 path_element
= ftpfs_correct_url_parameters (vpath_element
);
1014 result
= ((strcmp (path_element
->host
, super
->path_element
->host
) == 0)
1015 && (strcmp (path_element
->user
, super
->path_element
->user
) == 0)
1016 && (path_element
->port
== super
->path_element
->port
)) ? 1 : 0;
1018 vfs_path_element_free (path_element
);
1022 /* --------------------------------------------------------------------------------------------- */
1023 /* The returned directory should always contain a trailing slash */
1026 ftpfs_get_current_directory (struct vfs_class
*me
, struct vfs_s_super
*super
)
1028 char buf
[MC_MAXPATHLEN
+ 1];
1030 if (ftpfs_command (me
, super
, NONE
, "PWD") == COMPLETE
&&
1031 ftpfs_get_reply (me
, SUP
->sock
, buf
, sizeof (buf
)) == COMPLETE
)
1036 for (bufq
= buf
; *bufq
!= '\0'; bufq
++)
1047 if (*(bufq
- 1) != '/')
1054 return g_strdup (bufp
);
1056 /* If the remote server is an Amiga a leading slash
1057 might be missing. MC needs it because it is used
1058 as separator between hostname and path internally. */
1059 return g_strconcat ("/", bufp
, (char *) NULL
);
1071 /* --------------------------------------------------------------------------------------------- */
1072 /* Setup Passive PASV FTP connection */
1075 ftpfs_setup_passive_pasv (struct vfs_class
*me
, struct vfs_s_super
*super
,
1076 int my_socket
, struct sockaddr_storage
*sa
, socklen_t
* salen
)
1080 int xa
, xb
, xc
, xd
, xe
, xf
;
1082 if (ftpfs_command (me
, super
, WAIT_REPLY
| WANT_STRING
, "PASV") != COMPLETE
)
1085 /* Parse remote parameters */
1086 for (c
= reply_str
+ 4; (*c
) && (!isdigit ((unsigned char) *c
)); c
++);
1090 if (!isdigit ((unsigned char) *c
))
1092 if (sscanf (c
, "%d,%d,%d,%d,%d,%d", &xa
, &xb
, &xc
, &xd
, &xe
, &xf
) != 6)
1095 n
[0] = (unsigned char) xa
;
1096 n
[1] = (unsigned char) xb
;
1097 n
[2] = (unsigned char) xc
;
1098 n
[3] = (unsigned char) xd
;
1099 n
[4] = (unsigned char) xe
;
1100 n
[5] = (unsigned char) xf
;
1102 memcpy (&(((struct sockaddr_in
*) sa
)->sin_addr
.s_addr
), (void *) n
, 4);
1103 memcpy (&(((struct sockaddr_in
*) sa
)->sin_port
), (void *) &n
[4], 2);
1105 if (connect (my_socket
, (struct sockaddr
*) sa
, *salen
) < 0)
1111 /* --------------------------------------------------------------------------------------------- */
1112 /* Setup Passive EPSV FTP connection */
1115 ftpfs_setup_passive_epsv (struct vfs_class
*me
, struct vfs_s_super
*super
,
1116 int my_socket
, struct sockaddr_storage
*sa
, socklen_t
* salen
)
1121 if (ftpfs_command (me
, super
, WAIT_REPLY
| WANT_STRING
, "EPSV") != COMPLETE
)
1125 c
= strchr (reply_str
, '|');
1134 if (port
< 0 || port
> 65535)
1136 port
= htons (port
);
1138 switch (sa
->ss_family
)
1141 ((struct sockaddr_in
*) sa
)->sin_port
= port
;
1144 ((struct sockaddr_in6
*) sa
)->sin6_port
= port
;
1148 return (connect (my_socket
, (struct sockaddr
*) sa
, *salen
) < 0) ? 0 : 1;
1151 /* --------------------------------------------------------------------------------------------- */
1152 /* Setup Passive ftp connection, we use it for source routed connections */
1155 ftpfs_setup_passive (struct vfs_class
*me
, struct vfs_s_super
*super
,
1156 int my_socket
, struct sockaddr_storage
*sa
, socklen_t
* salen
)
1158 /* It's IPV4, so try PASV first, some servers and ALGs get confused by EPSV */
1159 if (sa
->ss_family
== AF_INET
)
1161 if (!ftpfs_setup_passive_pasv (me
, super
, my_socket
, sa
, salen
))
1162 /* An IPV4 FTP server might support EPSV, so if PASV fails we can try EPSV anyway */
1163 if (!ftpfs_setup_passive_epsv (me
, super
, my_socket
, sa
, salen
))
1166 /* It's IPV6, so EPSV is our only hope */
1169 if (!ftpfs_setup_passive_epsv (me
, super
, my_socket
, sa
, salen
))
1176 /* --------------------------------------------------------------------------------------------- */
1177 /* Setup Active PORT or EPRT FTP connection */
1180 ftpfs_setup_active (struct vfs_class
*me
, struct vfs_s_super
*super
,
1181 struct sockaddr_storage data_addr
, socklen_t data_addrlen
)
1183 unsigned short int port
;
1187 switch (data_addr
.ss_family
)
1191 port
= ((struct sockaddr_in
*) &data_addr
)->sin_port
;
1195 port
= ((struct sockaddr_in6
*) &data_addr
)->sin6_port
;
1197 /* Not implemented */
1202 addr
= g_try_malloc (NI_MAXHOST
);
1204 ERRNOR (ENOMEM
, -1);
1207 ((struct sockaddr
*) &data_addr
, data_addrlen
, addr
, NI_MAXHOST
, NULL
, 0,
1208 NI_NUMERICHOST
) != 0)
1214 /* If we are talking to an IPV4 server, try PORT, and, only if it fails, go for EPRT */
1217 unsigned char *a
= (unsigned char *) &((struct sockaddr_in
*) &data_addr
)->sin_addr
;
1218 unsigned char *p
= (unsigned char *) &port
;
1220 if (ftpfs_command (me
, super
, WAIT_REPLY
,
1221 "PORT %u,%u,%u,%u,%u,%u", a
[0], a
[1], a
[2], a
[3],
1222 p
[0], p
[1]) == COMPLETE
)
1230 * Converts network MSB first order to host byte order (LSB
1231 * first on i386). If we do it earlier, we will run into an
1232 * endianness issue, because the server actually expects to see
1233 * "PORT A,D,D,R,MSB,LSB" in the PORT command.
1235 port
= ntohs (port
);
1237 /* We are talking to an IPV6 server or PORT failed, so we can try EPRT anyway */
1238 if (ftpfs_command (me
, super
, WAIT_REPLY
, "EPRT |%u|%s|%hu|", af
, addr
, port
) == COMPLETE
)
1248 /* --------------------------------------------------------------------------------------------- */
1249 /* Initialize a socket for FTP DATA connection */
1252 ftpfs_init_data_socket (struct vfs_class
*me
, struct vfs_s_super
*super
,
1253 struct sockaddr_storage
*data_addr
, socklen_t
* data_addrlen
)
1257 memset (data_addr
, 0, sizeof (struct sockaddr_storage
));
1258 *data_addrlen
= sizeof (struct sockaddr_storage
);
1260 if (SUP
->use_passive_connection
)
1261 result
= getpeername (SUP
->sock
, (struct sockaddr
*) data_addr
, data_addrlen
);
1263 result
= getsockname (SUP
->sock
, (struct sockaddr
*) data_addr
, data_addrlen
);
1268 switch (data_addr
->ss_family
)
1271 ((struct sockaddr_in
*) data_addr
)->sin_port
= 0;
1274 ((struct sockaddr_in6
*) data_addr
)->sin6_port
= 0;
1277 vfs_print_message (_("ftpfs: invalid address family"));
1278 ERRNOR (EINVAL
, -1);
1281 result
= socket (data_addr
->ss_family
, SOCK_STREAM
, IPPROTO_TCP
);
1285 vfs_print_message (_("ftpfs: could not create socket: %s"), unix_error_string (errno
));
1292 /* --------------------------------------------------------------------------------------------- */
1293 /* Initialize FTP DATA connection */
1296 ftpfs_initconn (struct vfs_class
*me
, struct vfs_s_super
*super
)
1298 struct sockaddr_storage data_addr
;
1299 socklen_t data_addrlen
;
1302 * Don't factor socket initialization out of these conditionals,
1303 * because ftpfs_init_data_socket initializes it in different way
1304 * depending on use_passive_connection flag.
1307 /* Try to establish a passive connection first (if requested) */
1308 if (SUP
->use_passive_connection
)
1312 data_sock
= ftpfs_init_data_socket (me
, super
, &data_addr
, &data_addrlen
);
1316 if (ftpfs_setup_passive (me
, super
, data_sock
, &data_addr
, &data_addrlen
))
1319 vfs_print_message (_("ftpfs: could not setup passive mode"));
1320 SUP
->use_passive_connection
= 0;
1325 /* If passive setup is diabled or failed, fallback to active connections */
1326 if (!SUP
->use_passive_connection
)
1330 data_sock
= ftpfs_init_data_socket (me
, super
, &data_addr
, &data_addrlen
);
1334 if ((bind (data_sock
, (struct sockaddr
*) &data_addr
, data_addrlen
) == 0) &&
1335 (getsockname (data_sock
, (struct sockaddr
*) &data_addr
, &data_addrlen
) == 0) &&
1336 (listen (data_sock
, 1) == 0) &&
1337 (ftpfs_setup_active (me
, super
, data_addr
, data_addrlen
) != 0))
1343 /* Restore the initial value of use_passive_connection (for subsequent retries) */
1344 SUP
->use_passive_connection
= SUP
->proxy
!= NULL
? ftpfs_use_passive_connections_over_proxy
:
1345 ftpfs_use_passive_connections
;
1351 /* --------------------------------------------------------------------------------------------- */
1354 ftpfs_open_data_connection (struct vfs_class
*me
, struct vfs_s_super
*super
, const char *cmd
,
1355 const char *remote
, int isbinary
, int reget
)
1357 struct sockaddr_storage from
;
1359 socklen_t fromlen
= sizeof (from
);
1361 s
= ftpfs_initconn (me
, super
);
1365 if (ftpfs_changetype (me
, super
, isbinary
) == -1)
1369 j
= ftpfs_command (me
, super
, WAIT_REPLY
, "REST %d", reget
);
1375 char *remote_path
= ftpfs_translate_path (me
, super
, remote
);
1376 j
= ftpfs_command (me
, super
, WAIT_REPLY
, "%s /%s", cmd
,
1377 /* WarFtpD can't STORE //filename */
1378 (*remote_path
== '/') ? remote_path
+ 1 : remote_path
);
1379 g_free (remote_path
);
1382 j
= ftpfs_command (me
, super
, WAIT_REPLY
, "%s", cmd
);
1386 tty_enable_interrupt_key ();
1387 if (SUP
->use_passive_connection
)
1391 data
= accept (s
, (struct sockaddr
*) &from
, &fromlen
);
1394 ftpfs_errno
= errno
;
1400 tty_disable_interrupt_key ();
1404 /* --------------------------------------------------------------------------------------------- */
1407 ftpfs_linear_abort (struct vfs_class
*me
, vfs_file_handler_t
* fh
)
1409 struct vfs_s_super
*super
= FH_SUPER
;
1410 static unsigned char const ipbuf
[3] = { IAC
, IP
, IAC
};
1413 int dsock
= FH_SOCK
;
1415 SUP
->ctl_connection_busy
= 0;
1417 vfs_print_message (_("ftpfs: aborting transfer."));
1418 if (send (SUP
->sock
, ipbuf
, sizeof (ipbuf
), MSG_OOB
) != sizeof (ipbuf
))
1420 vfs_print_message (_("ftpfs: abort error: %s"), unix_error_string (errno
));
1426 if (ftpfs_command (me
, super
, NONE
, "%cABOR", DM
) != COMPLETE
)
1428 vfs_print_message (_("ftpfs: abort failed"));
1436 FD_SET (dsock
, &mask
);
1437 if (select (dsock
+ 1, &mask
, NULL
, NULL
, NULL
) > 0)
1439 struct timeval start_tim
, tim
;
1440 gettimeofday (&start_tim
, NULL
);
1441 /* flush the remaining data */
1442 while (read (dsock
, buf
, sizeof (buf
)) > 0)
1444 gettimeofday (&tim
, NULL
);
1445 if (tim
.tv_sec
> start_tim
.tv_sec
+ ABORT_TIMEOUT
)
1447 /* server keeps sending, drop the connection and ftpfs_reconnect */
1449 ftpfs_reconnect (me
, super
);
1456 if ((ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0) == TRANSIENT
) && (code
== 426))
1457 ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0);
1460 /* --------------------------------------------------------------------------------------------- */
1464 resolve_symlink_without_ls_options (struct vfs_class
*me
, struct vfs_s_super
*super
,
1465 struct vfs_s_inode
*dir
)
1467 struct linklist
*flist
;
1468 struct direntry
*fe
, *fel
;
1469 char tmp
[MC_MAXPATHLEN
];
1472 dir
->symlink_status
= FTPFS_RESOLVING_SYMLINKS
;
1473 for (flist
= dir
->file_list
->next
; flist
!= dir
->file_list
; flist
= flist
->next
)
1475 /* flist->data->l_stat is alread initialized with 0 */
1477 if (S_ISLNK (fel
->s
.st_mode
) && fel
->linkname
)
1479 if (fel
->linkname
[0] == '/')
1481 if (strlen (fel
->linkname
) >= MC_MAXPATHLEN
)
1483 strcpy (tmp
, fel
->linkname
);
1487 if ((strlen (dir
->remote_path
) + strlen (fel
->linkname
)) >= MC_MAXPATHLEN
)
1489 strcpy (tmp
, dir
->remote_path
);
1492 strcat (tmp
+ 1, fel
->linkname
);
1494 for (depth
= 0; depth
< 100; depth
++)
1495 { /* depth protects against recursive symbolic links */
1496 canonicalize_pathname (tmp
);
1497 fe
= _get_file_entry (bucket
, tmp
, 0, 0);
1500 if (S_ISLNK (fe
->s
.st_mode
) && fe
->l_stat
== 0)
1502 /* Symlink points to link which isn't resolved, yet. */
1503 if (fe
->linkname
[0] == '/')
1505 if (strlen (fe
->linkname
) >= MC_MAXPATHLEN
)
1507 strcpy (tmp
, fe
->linkname
);
1511 /* at this point tmp looks always like this
1512 /directory/filename, i.e. no need to check
1513 strrchr's return value */
1514 *(strrchr (tmp
, '/') + 1) = '\0'; /* dirname */
1515 if ((strlen (tmp
) + strlen (fe
->linkname
)) >= MC_MAXPATHLEN
)
1517 strcat (tmp
, fe
->linkname
);
1523 fel
->l_stat
= g_new (struct stat
, 1);
1524 if (S_ISLNK (fe
->s
.st_mode
))
1525 *fel
->l_stat
= *fe
->l_stat
;
1527 *fel
->l_stat
= fe
->s
;
1528 (*fel
->l_stat
).st_ino
= bucket
->__inode_counter
++;
1535 dir
->symlink_status
= FTPFS_RESOLVED_SYMLINKS
;
1538 /* --------------------------------------------------------------------------------------------- */
1541 resolve_symlink_with_ls_options (struct vfs_class
*me
, struct vfs_s_super
*super
,
1542 struct vfs_s_inode
*dir
)
1544 char buffer
[2048] = "", *filename
;
1548 struct linklist
*flist
;
1549 struct direntry
*fe
;
1550 int switch_method
= 0;
1552 dir
->symlink_status
= FTPFS_RESOLVED_SYMLINKS
;
1553 if (strchr (dir
->remote_path
, ' '))
1555 if (ftpfs_chdir_internal (bucket
, dir
->remote_path
) != COMPLETE
)
1557 vfs_print_message (_("ftpfs: CWD failed."));
1560 sock
= ftpfs_open_data_connection (bucket
, "LIST -lLa", ".", TYPE_ASCII
, 0);
1563 sock
= ftpfs_open_data_connection (bucket
, "LIST -lLa", dir
->remote_path
, TYPE_ASCII
, 0);
1567 vfs_print_message (_("ftpfs: couldn't resolve symlink"));
1571 fp
= fdopen (sock
, "r");
1575 vfs_print_message (_("ftpfs: couldn't resolve symlink"));
1578 tty_enable_interrupt_key ();
1579 flist
= dir
->file_list
->next
;
1584 if (flist
== dir
->file_list
)
1587 flist
= flist
->next
;
1589 while (!S_ISLNK (fe
->s
.st_mode
));
1592 if (fgets (buffer
, sizeof (buffer
), fp
) == NULL
)
1594 if (MEDATA
->logfile
)
1596 fputs (buffer
, MEDATA
->logfile
);
1597 fflush (MEDATA
->logfile
);
1599 vfs_die ("This code should be commented out\n");
1600 if (vfs_parse_ls_lga (buffer
, &s
, &filename
, NULL
))
1602 int r
= strcmp (fe
->name
, filename
);
1606 if (S_ISLNK (s
.st_mode
))
1608 /* This server doesn't understand LIST -lLa */
1612 fe
->l_stat
= g_new (struct stat
, 1);
1613 if (fe
->l_stat
== NULL
)
1616 (*fe
->l_stat
).st_ino
= bucket
->__inode_counter
++;
1625 while (fgets (buffer
, sizeof (buffer
), fp
) != NULL
);
1626 tty_disable_interrupt_key ();
1628 ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0);
1631 /* --------------------------------------------------------------------------------------------- */
1634 resolve_symlink (struct vfs_class
*me
, struct vfs_s_super
*super
, struct vfs_s_inode
*dir
)
1636 vfs_print_message (_("Resolving symlink..."));
1638 if (SUP
->strict_rfc959_list_cmd
)
1639 resolve_symlink_without_ls_options (me
, super
, dir
);
1641 resolve_symlink_with_ls_options (me
, super
, dir
);
1645 /* --------------------------------------------------------------------------------------------- */
1648 ftpfs_dir_load (struct vfs_class
*me
, struct vfs_s_inode
*dir
, char *remote_path
)
1650 struct vfs_s_entry
*ent
;
1651 struct vfs_s_super
*super
= dir
->super
;
1652 int sock
, num_entries
= 0;
1653 char lc_buffer
[BUF_8K
];
1656 cd_first
= ftpfs_first_cd_then_ls
|| (SUP
->strict
== RFC_STRICT
)
1657 || (strchr (remote_path
, ' ') != NULL
);
1660 vfs_print_message (_("ftpfs: Reading FTP directory %s... %s%s"),
1663 RFC_STRICT
? _("(strict rfc959)") : "", cd_first
? _("(chdir first)") : "");
1667 if (ftpfs_chdir_internal (me
, super
, remote_path
) != COMPLETE
)
1669 ftpfs_errno
= ENOENT
;
1670 vfs_print_message (_("ftpfs: CWD failed."));
1675 gettimeofday (&dir
->timestamp
, NULL
);
1676 dir
->timestamp
.tv_sec
+= ftpfs_directory_timeout
;
1678 if (SUP
->strict
== RFC_STRICT
)
1679 sock
= ftpfs_open_data_connection (me
, super
, "LIST", 0, TYPE_ASCII
, 0);
1681 /* Dirty hack to avoid autoprepending / to . */
1682 /* Wu-ftpd produces strange output for '/' if 'LIST -la .' used */
1683 sock
= ftpfs_open_data_connection (me
, super
, "LIST -la", 0, TYPE_ASCII
, 0);
1688 /* Trailing "/." is necessary if remote_path is a symlink */
1689 path
= mc_build_filename (remote_path
, ".", NULL
);
1690 sock
= ftpfs_open_data_connection (me
, super
, "LIST -la", path
, TYPE_ASCII
, 0);
1697 /* Clear the interrupt flag */
1698 tty_enable_interrupt_key ();
1700 vfs_parse_ls_lga_init ();
1704 size_t count_spaces
= 0;
1705 int res
= vfs_s_get_line_interruptible (me
, lc_buffer
, sizeof (lc_buffer
),
1712 me
->verrno
= ECONNRESET
;
1714 tty_disable_interrupt_key ();
1715 ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0);
1716 vfs_print_message (_("%s: failure"), me
->name
);
1720 if (MEDATA
->logfile
)
1722 fputs (lc_buffer
, MEDATA
->logfile
);
1723 fputs ("\n", MEDATA
->logfile
);
1724 fflush (MEDATA
->logfile
);
1727 ent
= vfs_s_generate_entry (me
, NULL
, dir
, 0);
1728 i
= ent
->ino
->st
.st_nlink
;
1729 if (!vfs_parse_ls_lga
1730 (lc_buffer
, &ent
->ino
->st
, &ent
->name
, &ent
->ino
->linkname
, &count_spaces
))
1732 vfs_s_free_entry (me
, ent
);
1735 ent
->ino
->st
.st_nlink
= i
; /* Ouch, we need to preserve our counts :-( */
1737 vfs_s_store_filename_leading_spaces (ent
, count_spaces
);
1738 vfs_s_insert_entry (me
, dir
, ent
);
1742 me
->verrno
= E_REMOTE
;
1743 if ((ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0) != COMPLETE
))
1746 if (num_entries
== 0 && cd_first
== 0)
1748 /* The LIST command may produce an empty output. In such scenario
1749 it is not clear whether this is caused by `remote_path' being
1750 a non-existent path or for some other reason (listing emtpy
1751 directory without the -a option, non-readable directory, etc.).
1753 Since `dir_load' is a crucial method, when it comes to determine
1754 whether a given path is a _directory_, the code must try its best
1755 to determine the type of `remote_path'. The only reliable way to
1756 achieve this is trough issuing a CWD command. */
1762 vfs_s_normalize_filename_leading_spaces (dir
, vfs_parse_ls_lga_get_final_spaces ());
1764 if (SUP
->strict
== RFC_AUTODETECT
)
1765 SUP
->strict
= RFC_DARING
;
1767 vfs_print_message (_("%s: done."), me
->name
);
1771 if (SUP
->strict
== RFC_AUTODETECT
)
1773 /* It's our first attempt to get a directory listing from this
1774 server (UNIX style LIST command) */
1775 SUP
->strict
= RFC_STRICT
;
1776 /* I hate goto, but recursive call needs another 8K on stack */
1777 /* return ftpfs_dir_load (me, dir, remote_path); */
1781 vfs_print_message (_("ftpfs: failed; nowhere to fallback to"));
1782 ERRNOR (EACCES
, -1);
1785 /* --------------------------------------------------------------------------------------------- */
1788 ftpfs_file_store (struct vfs_class
*me
, vfs_file_handler_t
* fh
, char *name
, char *localname
)
1792 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1797 char lc_buffer
[BUF_8K
];
1800 struct vfs_s_super
*super
= FH_SUPER
;
1801 ftp_fh_data_t
*ftp
= (ftp_fh_data_t
*) fh
->data
;
1803 h
= open (localname
, O_RDONLY
);
1808 ftpfs_open_data_connection (me
, super
, ftp
->append
? "APPE" : "STOR", name
, TYPE_BINARY
, 0);
1809 if (sock
< 0 || fstat (h
, &s
) == -1)
1814 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1817 setsockopt (sock
, SOL_SOCKET
, SO_LINGER
, (char *) &li
, sizeof (li
));
1819 setsockopt (sock
, SOL_SOCKET
, SO_LINGER
, &flag_one
, sizeof (flag_one
));
1823 tty_enable_interrupt_key ();
1826 ssize_t n_read
, n_written
;
1828 while ((n_read
= read (h
, lc_buffer
, sizeof (lc_buffer
))) == -1)
1832 ftpfs_errno
= errno
;
1835 if (tty_got_interrupt ())
1837 ftpfs_errno
= EINTR
;
1845 while ((n_written
= write (sock
, w_buf
, n_read
)) != n_read
)
1847 if (n_written
== -1)
1849 if (errno
== EINTR
&& !tty_got_interrupt ())
1852 ftpfs_errno
= errno
;
1856 n_read
-= n_written
;
1858 vfs_print_message ("%s: %" PRIuMAX
"/%" PRIuMAX
,
1859 _("ftpfs: storing file"), (uintmax_t) n_stored
, (uintmax_t) s
.st_size
);
1861 tty_disable_interrupt_key ();
1864 if (ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0) != COMPLETE
)
1868 tty_disable_interrupt_key ();
1871 ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0);
1875 /* --------------------------------------------------------------------------------------------- */
1878 ftpfs_linear_start (struct vfs_class
*me
, vfs_file_handler_t
* fh
, off_t offset
)
1882 if (fh
->data
== NULL
)
1883 fh
->data
= g_new0 (ftp_fh_data_t
, 1);
1885 name
= vfs_s_fullpath (me
, fh
->ino
);
1888 FH_SOCK
= ftpfs_open_data_connection (me
, FH_SUPER
, "RETR", name
, TYPE_BINARY
, offset
);
1892 fh
->linear
= LS_LINEAR_OPEN
;
1893 ((ftp_super_data_t
*) (FH_SUPER
->data
))->ctl_connection_busy
= 1;
1894 ((ftp_fh_data_t
*) fh
->data
)->append
= 0;
1898 /* --------------------------------------------------------------------------------------------- */
1901 ftpfs_linear_read (struct vfs_class
*me
, vfs_file_handler_t
* fh
, void *buf
, size_t len
)
1904 struct vfs_s_super
*super
= FH_SUPER
;
1906 while ((n
= read (FH_SOCK
, buf
, len
)) < 0)
1908 if ((errno
== EINTR
) && !tty_got_interrupt ())
1914 ftpfs_linear_abort (me
, fh
);
1918 SUP
->ctl_connection_busy
= 0;
1921 if ((ftpfs_get_reply (me
, SUP
->sock
, NULL
, 0) != COMPLETE
))
1922 ERRNOR (E_REMOTE
, -1);
1928 /* --------------------------------------------------------------------------------------------- */
1931 ftpfs_linear_close (struct vfs_class
*me
, vfs_file_handler_t
* fh
)
1934 ftpfs_linear_abort (me
, fh
);
1937 /* --------------------------------------------------------------------------------------------- */
1940 ftpfs_ctl (void *fh
, int ctlop
, void *arg
)
1946 case VFS_CTL_IS_NOTREADY
:
1951 vfs_die ("You may not do this");
1952 if (FH
->linear
== LS_LINEAR_CLOSED
|| FH
->linear
== LS_LINEAR_PREOPEN
)
1955 v
= vfs_s_select_on_two (((ftp_fh_data_t
*) (FH
->data
))->sock
, 0);
1956 return (((v
< 0) && (errno
== EINTR
)) || v
== 0) ? 1 : 0;
1963 /* --------------------------------------------------------------------------------------------- */
1966 ftpfs_send_command (const vfs_path_t
* vpath
, const char *cmd
, int flags
)
1970 struct vfs_s_super
*super
;
1972 const vfs_path_element_t
*path_element
;
1973 int flush_directory_cache
= (flags
& OPT_FLUSH
);
1975 path_element
= vfs_path_get_by_index (vpath
, -1);
1977 rpath
= vfs_s_get_path (vpath
, &super
, 0);
1981 p
= ftpfs_translate_path (path_element
->class, super
, rpath
);
1982 r
= ftpfs_command (path_element
->class, super
, WAIT_REPLY
, cmd
, p
);
1984 vfs_stamp_create (&vfs_ftpfs_ops
, super
);
1985 if (flags
& OPT_IGNORE_ERROR
)
1989 path_element
->class->verrno
= EPERM
;
1992 if (flush_directory_cache
)
1993 vfs_s_invalidate (path_element
->class, super
);
1997 /* --------------------------------------------------------------------------------------------- */
2000 ftpfs_chmod (const vfs_path_t
* vpath
, mode_t mode
)
2002 char buf
[BUF_SMALL
];
2005 g_snprintf (buf
, sizeof (buf
), "SITE CHMOD %4.4o /%%s", (int) (mode
& 07777));
2007 ret
= ftpfs_send_command (vpath
, buf
, OPT_FLUSH
);
2009 return ftpfs_ignore_chattr_errors
? 0 : ret
;
2012 /* --------------------------------------------------------------------------------------------- */
2015 ftpfs_chown (const vfs_path_t
* vpath
, uid_t owner
, gid_t group
)
2022 ftpfs_errno
= EPERM
;
2025 /* Everyone knows it is not possible to chown remotely, so why bother them.
2026 If someone's root, then copy/move will always try to chown it... */
2034 /* --------------------------------------------------------------------------------------------- */
2037 ftpfs_unlink (const vfs_path_t
* vpath
)
2039 return ftpfs_send_command (vpath
, "DELE /%s", OPT_FLUSH
);
2042 /* --------------------------------------------------------------------------------------------- */
2044 /* Return 1 if path is the same directory as the one we are in now */
2046 ftpfs_is_same_dir (struct vfs_class
*me
, struct vfs_s_super
*super
, const char *path
)
2050 if (SUP
->current_dir
== NULL
)
2052 return (strcmp (path
, SUP
->current_dir
) == 0);
2055 /* --------------------------------------------------------------------------------------------- */
2058 ftpfs_chdir_internal (struct vfs_class
*me
, struct vfs_s_super
*super
, const char *remote_path
)
2063 if (!SUP
->cwd_deferred
&& ftpfs_is_same_dir (me
, super
, remote_path
))
2066 p
= ftpfs_translate_path (me
, super
, remote_path
);
2067 r
= ftpfs_command (me
, super
, WAIT_REPLY
, "CWD /%s", p
);
2074 g_free (SUP
->current_dir
);
2075 SUP
->current_dir
= g_strdup (remote_path
);
2076 SUP
->cwd_deferred
= 0;
2081 /* --------------------------------------------------------------------------------------------- */
2084 ftpfs_rename (const vfs_path_t
* vpath1
, const vfs_path_t
* vpath2
)
2086 ftpfs_send_command (vpath1
, "RNFR /%s", OPT_FLUSH
);
2087 return ftpfs_send_command (vpath2
, "RNTO /%s", OPT_FLUSH
);
2090 /* --------------------------------------------------------------------------------------------- */
2093 ftpfs_mkdir (const vfs_path_t
* vpath
, mode_t mode
)
2095 (void) mode
; /* FIXME: should be used */
2097 return ftpfs_send_command (vpath
, "MKD /%s", OPT_FLUSH
);
2100 /* --------------------------------------------------------------------------------------------- */
2103 ftpfs_rmdir (const vfs_path_t
* vpath
)
2105 return ftpfs_send_command (vpath
, "RMD /%s", OPT_FLUSH
);
2108 /* --------------------------------------------------------------------------------------------- */
2111 ftpfs_fh_free_data (vfs_file_handler_t
* fh
)
2120 /* --------------------------------------------------------------------------------------------- */
2123 ftpfs_fh_open (struct vfs_class
*me
, vfs_file_handler_t
* fh
, int flags
, mode_t mode
)
2129 fh
->data
= g_new0 (ftp_fh_data_t
, 1);
2130 ftp
= (ftp_fh_data_t
*) fh
->data
;
2131 /* File will be written only, so no need to retrieve it from ftp server */
2132 if (((flags
& O_WRONLY
) == O_WRONLY
) && ((flags
& (O_RDONLY
| O_RDWR
)) == 0))
2134 #ifdef HAVE_STRUCT_LINGER_L_LINGER
2141 /* ftpfs_linear_start() called, so data will be written
2142 * to local temporary file and stored to ftp server
2143 * by vfs_s_close later
2145 if (((ftp_super_data_t
*) (FH_SUPER
->data
))->ctl_connection_busy
)
2147 if (!fh
->ino
->localname
)
2152 handle
= vfs_mkstemps (&vpath
, me
->name
, fh
->ino
->ent
->name
);
2155 vfs_path_free (vpath
);
2159 fh
->ino
->localname
= vfs_path_to_str (vpath
);
2160 vfs_path_free (vpath
);
2161 ftp
->append
= flags
& O_APPEND
;
2165 name
= vfs_s_fullpath (me
, fh
->ino
);
2169 ftpfs_open_data_connection (me
, fh
->ino
->super
,
2170 (flags
& O_APPEND
) ? "APPE" : "STOR", name
, TYPE_BINARY
, 0);
2175 #ifdef HAVE_STRUCT_LINGER_L_LINGER
2179 setsockopt (fh
->handle
, SOL_SOCKET
, SO_LINGER
, &li
, sizeof (li
));
2181 if (fh
->ino
->localname
)
2183 unlink (fh
->ino
->localname
);
2184 g_free (fh
->ino
->localname
);
2185 fh
->ino
->localname
= NULL
;
2190 if (!fh
->ino
->localname
&& vfs_s_retrieve_file (me
, fh
->ino
) == -1)
2192 if (!fh
->ino
->localname
)
2193 vfs_die ("retrieve_file failed to fill in localname");
2197 ftpfs_fh_free_data (fh
);
2201 /* --------------------------------------------------------------------------------------------- */
2204 ftpfs_fh_close (struct vfs_class
*me
, vfs_file_handler_t
* fh
)
2206 if (fh
->handle
!= -1 && !fh
->ino
->localname
)
2208 ftp_super_data_t
*ftp
= (ftp_super_data_t
*) fh
->ino
->super
->data
;
2212 /* File is stored to destination already, so
2213 * we prevent MEDATA->ftpfs_file_store() call from vfs_s_close ()
2216 if (ftpfs_get_reply (me
, ftp
->sock
, NULL
, 0) != COMPLETE
)
2218 vfs_s_invalidate (me
, FH_SUPER
);
2224 /* --------------------------------------------------------------------------------------------- */
2227 ftpfs_done (struct vfs_class
*me
)
2231 g_slist_foreach (no_proxy
, (GFunc
) g_free
, NULL
);
2232 g_slist_free (no_proxy
);
2234 g_free (ftpfs_anonymous_passwd
);
2235 g_free (ftpfs_proxy_host
);
2238 /* --------------------------------------------------------------------------------------------- */
2241 ftpfs_fill_names (struct vfs_class
*me
, fill_names_f func
)
2245 for (iter
= MEDATA
->supers
; iter
!= NULL
; iter
= g_list_next (iter
))
2247 const struct vfs_s_super
*super
= (const struct vfs_s_super
*) iter
->data
;
2250 name
= vfs_path_element_build_pretty_path_str (super
->path_element
);
2257 /* --------------------------------------------------------------------------------------------- */
2260 ftpfs_netrc_next (void)
2264 static const char *const keywords
[] = { "default", "machine",
2265 "login", "password", "passwd", "account", "macdef", NULL
2270 netrcp
= skip_separators (netrcp
);
2271 if (*netrcp
!= '\n')
2280 for (netrcp
++; *netrcp
!= '"' && *netrcp
; netrcp
++)
2282 if (*netrcp
== '\\')
2289 for (; *netrcp
!= '\n' && *netrcp
!= '\t' && *netrcp
!= ' ' &&
2290 *netrcp
!= ',' && *netrcp
; netrcp
++)
2292 if (*netrcp
== '\\')
2301 for (i
= NETRC_DEFAULT
; keywords
[i
- 1] != NULL
; i
++)
2302 if (strcmp (keywords
[i
- 1], buffer
) == 0)
2305 return NETRC_UNKNOWN
;
2308 /* --------------------------------------------------------------------------------------------- */
2311 ftpfs_netrc_bad_mode (const char *netrcname
)
2313 static int be_angry
= 1;
2316 if (stat (netrcname
, &mystat
) >= 0 && (mystat
.st_mode
& 077))
2320 message (D_ERROR
, MSG_ERROR
,
2321 _("~/.netrc file has incorrect mode\nRemove password or correct mode"));
2329 /* --------------------------------------------------------------------------------------------- */
2330 /* Scan .netrc until we find matching "machine" or "default"
2331 * domain is used for additional matching
2332 * No search is done after "default" in compliance with "man netrc"
2333 * Return 0 if found, -1 otherwise */
2336 ftpfs_find_machine (const char *host
, const char *domain
)
2345 while ((keyword
= ftpfs_netrc_next ()) != NETRC_NONE
)
2347 if (keyword
== NETRC_DEFAULT
)
2350 if (keyword
== NETRC_MACDEF
)
2352 /* Scan for an empty line, which concludes "macdef" */
2355 while (*netrcp
&& *netrcp
!= '\n')
2357 if (*netrcp
!= '\n')
2361 while (*netrcp
&& *netrcp
!= '\n');
2365 if (keyword
!= NETRC_MACHINE
)
2368 /* Take machine name */
2369 if (ftpfs_netrc_next () == NETRC_NONE
)
2372 if (g_ascii_strcasecmp (host
, buffer
) != 0)
2374 /* Try adding our domain to short names in .netrc */
2375 const char *host_domain
= strchr (host
, '.');
2379 /* Compare domain part */
2380 if (g_ascii_strcasecmp (host_domain
, domain
) != 0)
2383 /* Compare local part */
2384 if (g_ascii_strncasecmp (host
, buffer
, host_domain
- host
) != 0)
2395 /* --------------------------------------------------------------------------------------------- */
2396 /* Extract login and password from .netrc for the host.
2398 * Returns 0 for success, -1 for error */
2401 ftpfs_netrc_lookup (const char *host
, char **login
, char **pass
)
2404 char *tmp_pass
= NULL
;
2405 char hostname
[MAXHOSTNAMELEN
];
2408 static struct rupcache
2410 struct rupcache
*next
;
2414 } *rup_cache
= NULL
, *rupp
;
2416 /* Initialize *login and *pass */
2422 /* Look up in the cache first */
2423 for (rupp
= rup_cache
; rupp
!= NULL
; rupp
= rupp
->next
)
2425 if (!strcmp (host
, rupp
->host
))
2428 *login
= g_strdup (rupp
->login
);
2429 if (pass
&& rupp
->pass
)
2430 *pass
= g_strdup (rupp
->pass
);
2435 /* Load current .netrc */
2436 netrcname
= g_build_filename (mc_config_get_home_dir (), ".netrc", (char *) NULL
);
2437 if (!g_file_get_contents (netrcname
, &netrc
, NULL
, NULL
))
2445 /* Find our own domain name */
2446 if (gethostname (hostname
, sizeof (hostname
)) < 0)
2449 domain
= strchr (hostname
, '.');
2453 /* Scan for "default" and matching "machine" keywords */
2454 ftpfs_find_machine (host
, domain
);
2456 /* Scan for keywords following "default" and "machine" */
2460 keyword
= ftpfs_netrc_next ();
2465 if (ftpfs_netrc_next () == NETRC_NONE
)
2471 /* We have another name already - should not happen */
2478 /* We have login name now */
2479 *login
= g_strdup (buffer
);
2482 case NETRC_PASSWORD
:
2484 if (ftpfs_netrc_next () == NETRC_NONE
)
2490 /* Ignore unsafe passwords */
2491 if (*login
!= NULL
&&
2492 strcmp (*login
, "anonymous") != 0 && strcmp (*login
, "ftp") != 0
2493 && ftpfs_netrc_bad_mode (netrcname
))
2499 /* Remember password. pass may be NULL, so use tmp_pass */
2500 if (tmp_pass
== NULL
)
2501 tmp_pass
= g_strdup (buffer
);
2505 /* "account" is followed by a token which we ignore */
2506 if (ftpfs_netrc_next () == NETRC_NONE
)
2512 /* Ignore account, but warn user anyways */
2513 ftpfs_netrc_bad_mode (netrcname
);
2517 /* Unexpected keyword or end of file */
2529 rupp
= g_new (struct rupcache
, 1);
2530 rupp
->host
= g_strdup (host
);
2531 rupp
->login
= g_strdup (*login
);
2532 rupp
->pass
= g_strdup (tmp_pass
);
2534 rupp
->next
= rup_cache
;
2542 /* --------------------------------------------------------------------------------------------- */
2543 /*** public functions ****************************************************************************/
2544 /* --------------------------------------------------------------------------------------------- */
2546 /** This routine is called as the last step in load_setup */
2548 ftpfs_init_passwd (void)
2550 ftpfs_anonymous_passwd
= load_anon_passwd ();
2551 if (ftpfs_anonymous_passwd
)
2554 /* If there is no anonymous ftp password specified
2555 * then we'll just use anonymous@
2556 * We don't send any other thing because:
2557 * - We want to remain anonymous
2558 * - We want to stop SPAM
2559 * - We don't want to let ftp sites to discriminate by the user,
2562 ftpfs_anonymous_passwd
= g_strdup ("anonymous@");
2565 /* --------------------------------------------------------------------------------------------- */
2570 static struct vfs_s_subclass ftpfs_subclass
;
2574 ftpfs_subclass
.flags
= VFS_S_REMOTE
| VFS_S_USETMP
;
2575 ftpfs_subclass
.archive_same
= ftpfs_archive_same
;
2576 ftpfs_subclass
.open_archive
= ftpfs_open_archive
;
2577 ftpfs_subclass
.free_archive
= ftpfs_free_archive
;
2578 ftpfs_subclass
.fh_open
= ftpfs_fh_open
;
2579 ftpfs_subclass
.fh_close
= ftpfs_fh_close
;
2580 ftpfs_subclass
.fh_free_data
= ftpfs_fh_free_data
;
2581 ftpfs_subclass
.dir_load
= ftpfs_dir_load
;
2582 ftpfs_subclass
.file_store
= ftpfs_file_store
;
2583 ftpfs_subclass
.linear_start
= ftpfs_linear_start
;
2584 ftpfs_subclass
.linear_read
= ftpfs_linear_read
;
2585 ftpfs_subclass
.linear_close
= ftpfs_linear_close
;
2587 vfs_s_init_class (&vfs_ftpfs_ops
, &ftpfs_subclass
);
2588 vfs_ftpfs_ops
.name
= "ftpfs";
2589 vfs_ftpfs_ops
.flags
= VFSF_NOLINKS
;
2590 vfs_ftpfs_ops
.prefix
= "ftp";
2591 vfs_ftpfs_ops
.done
= &ftpfs_done
;
2592 vfs_ftpfs_ops
.fill_names
= ftpfs_fill_names
;
2593 vfs_ftpfs_ops
.chmod
= ftpfs_chmod
;
2594 vfs_ftpfs_ops
.chown
= ftpfs_chown
;
2595 vfs_ftpfs_ops
.unlink
= ftpfs_unlink
;
2596 vfs_ftpfs_ops
.rename
= ftpfs_rename
;
2597 vfs_ftpfs_ops
.mkdir
= ftpfs_mkdir
;
2598 vfs_ftpfs_ops
.rmdir
= ftpfs_rmdir
;
2599 vfs_ftpfs_ops
.ctl
= ftpfs_ctl
;
2600 vfs_register_class (&vfs_ftpfs_ops
);
2603 /* --------------------------------------------------------------------------------------------- */