vfs/ftpfs.c

   1 /* Virtual File System: FTP file system.
   2    Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2006, 2007 Free Software Foundation, Inc.
   4
   5    Written by: 1995 Ching Hui
   6                1995 Jakub Jelinek
   7                1995, 1996, 1997 Miguel de Icaza
   8                1997 Norbert Warmuth
   9                1998 Pavel Machek
  10
  11    This program is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU Library General Public License
  13    as published by the Free Software Foundation; either version 2 of
  14    the License, or (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU Library General Public License for more details.
  20
  21    You should have received a copy of the GNU Library General Public
  22    License along with this program; if not, write to the Free Software
  23    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  24
  25 /**
  26  * \file
  27  * \brief Source: Virtual File System: FTP file system
  28  * \author Ching Hui
  29  * \author Jakub Jelinek
  30  * \author Miguel de Icaza
  31  * \author Norbert Warmuth
  32  * \author Pavel Machek
  33  * \date 1995, 1997, 1998
  34  *
  35  * \todo
  36 - make it more robust - all the connects etc. should handle EADDRINUSE and
  37   ERETRY (have I spelled these names correctly?)
  38 - make the user able to flush a connection - all the caches will get empty
  39   etc., (tarfs as well), we should give there a user selectable timeout
  40   and assign a key sequence.
  41 - use hash table instead of linklist to cache ftpfs directory.
  42
  43 What to do with this?
  44
  45
  46      * NOTE: Usage of tildes is deprecated, consider:
  47      * cd /#ftp:pavel@hobit
  48      * cd ~
  49      * And now: what do I want to do? Do I want to go to /home/pavel or to
  50      * /#ftp:hobit/home/pavel? I think first has better sense...
  51      *
  52     {
  53         int f = !strcmp( remote_path, "/~" );
  54         if (f || !strncmp( remote_path, "/~/", 3 )) {
  55             char *s;
  56             s = concat_dir_and_file( qhome (*bucket), remote_path +3-f );
  57             g_free (remote_path);
  58             remote_path = s;
  59         }
  60     }
  61
  62
  63  */
  64
  65 /* \todo Fix: Namespace pollution: horrible */
  66
  67 #include <config.h>
  68 #include <stdlib.h>             /* atoi() */
  69 #include <sys/types.h>          /* POSIX-required by sys/socket.h and netdb.h */
  70 #include <netdb.h>              /* struct hostent */
  71 #include <sys/socket.h>         /* AF_INET */
  72 #include <netinet/in.h>         /* struct in_addr */
  73 #ifdef HAVE_ARPA_INET_H
  74 #include <arpa/inet.h>
  75 #endif
  76 #include <arpa/ftp.h>
  77 #include <arpa/telnet.h>
  78 #include <sys/param.h>
  79 #include <errno.h>
  80 #include <ctype.h>
  81 #include <fcntl.h>
  82 #include <sys/time.h>           /* gettimeofday() */
  83
  84 #include "../src/global.h"
  85
  86 #include "../src/tty/tty.h"     /* enable/disable interrupt key */
  87
  88 #include "../src/wtools.h"      /* message() */
  89 #include "../src/main.h"        /* print_vfs_message */
  90 #include "../src/history.h"
  91 #include "../src/setup.h"       /* for load_anon_passwd */
  92
  93 #include "utilvfs.h"
  94 #include "xdirentry.h"
  95 #include "vfs.h"
  96 #include "vfs-impl.h"
  97 #include "gc.h"         /* vfs_stamp_create */
  98 #include "tcputil.h"
  99 #include "ftpfs.h"
 100 #ifndef MAXHOSTNAMELEN
 101 #    define MAXHOSTNAMELEN 64
 102 #endif
 103
 104 #define UPLOAD_ZERO_LENGTH_FILE
 105 #define SUP super->u.ftp
 106 #define FH_SOCK fh->u.ftp.sock
 107
 108 #ifndef INADDR_NONE
 109 #define INADDR_NONE 0xffffffff
 110 #endif
 111
 112 #define RFC_AUTODETECT 0
 113 #define RFC_DARING 1
 114 #define RFC_STRICT 2
 115
 116 #ifndef HAVE_SOCKLEN_T
 117 typedef int socklen_t;
 118 #endif
 119
 120 static int ftpfs_errno;
 121 static int code;
 122
 123 /* Delay to retry a connection */
 124 int ftpfs_retry_seconds = 30;
 125
 126 /* Method to use to connect to ftp sites */
 127 int ftpfs_use_passive_connections = 1;
 128 int ftpfs_use_passive_connections_over_proxy = 0;
 129
 130 /* Method used to get directory listings:
 131  * 1: try 'LIST -la <path>', if it fails
 132  *    fall back to CWD <path>; LIST
 133  * 0: always use CWD <path>; LIST
 134  */
 135 int ftpfs_use_unix_list_options = 1;
 136
 137 /* First "CWD <path>", then "LIST -la ." */
 138 int ftpfs_first_cd_then_ls = 1;
 139
 140 /* Use the ~/.netrc */
 141 int use_netrc = 1;
 142
 143 /* Anonymous setup */
 144 char *ftpfs_anonymous_passwd = NULL;
 145 int ftpfs_directory_timeout = 900;
 146
 147 /* Proxy host */
 148 char *ftpfs_proxy_host = NULL;
 149
 150 /* wether we have to use proxy by default? */
 151 int ftpfs_always_use_proxy;
 152
 153 #ifdef FIXME_LATER_ALIGATOR
 154 static struct linklist *connections_list;
 155 #endif
 156
 157 /* ftpfs_command wait_flag: */
 158 #define NONE        0x00
 159 #define WAIT_REPLY  0x01
 160 #define WANT_STRING 0x02
 161 static char reply_str [80];
 162
 163 static struct vfs_class vfs_ftpfs_ops;
 164
 165 /* char *ftpfs_translate_path (struct ftpfs_connection *bucket, char *remote_path)
 166    Translate a Unix path, i.e. MC's internal path representation (e.g.
 167    /somedir/somefile) to a path valid for the remote server. Every path
 168    transfered to the remote server has to be mangled by this function
 169    right prior to sending it.
 170    Currently only Amiga ftp servers are handled in a special manner.
 171
 172    When the remote server is an amiga:
 173    a) strip leading slash if necesarry
 174    b) replace first occurance of ":/" with ":"
 175    c) strip trailing "/."
 176  */
 177
 178 static char *ftpfs_get_current_directory (struct vfs_class *me, struct vfs_s_super *super);
 179 static int ftpfs_chdir_internal (struct vfs_class *me, struct vfs_s_super *super, const char *remote_path);
 180 static int ftpfs_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, const char *fmt, ...)
 181     __attribute__ ((format (__printf__, 4, 5)));
 182 static int ftpfs_open_socket (struct vfs_class *me, struct vfs_s_super *super);
 183 static int ftpfs_login_server (struct vfs_class *me, struct vfs_s_super *super, const char *netrcpass);
 184 static int ftpfs_netrc_lookup (const char *host, char **login, char **pass);
 185
 186 static char *
 187 ftpfs_translate_path (struct vfs_class *me, struct vfs_s_super *super, const char *remote_path)
 188 {
 189     if (!SUP.remote_is_amiga)
 190         return g_strdup (remote_path);
 191     else {
 192         char *ret, *p;
 193
 194         if (MEDATA->logfile) {
 195             fprintf (MEDATA->logfile, "MC -- ftpfs_translate_path: %s\n", remote_path);
 196             fflush (MEDATA->logfile);
 197         }
 198
 199         /* strip leading slash(es) */
 200         while (*remote_path == '/')
 201             remote_path++;
 202
 203         /*
 204          * Don't change "/" into "", e.g. "CWD " would be
 205          * invalid.
 206          */
 207         if (*remote_path == '\0')
 208             return g_strdup (".");
 209
 210         ret = g_strdup (remote_path);
 211
 212         /* replace first occurance of ":/" with ":" */
 213         if ((p = strchr (ret, ':')) && *(p + 1) == '/')
 214             strcpy (p + 1, p + 2);
 215
 216         /* strip trailing "/." */
 217         if ((p = strrchr (ret, '/')) && *(p + 1) == '.' && *(p + 2) == '\0')
 218             *p = '\0';
 219         return ret;
 220     }
 221 }
 222
 223 /* Extract the hostname and username from the path */
 224
 225 /*
 226  * path is in the form: [user@]hostname:port/remote-dir, e.g.:
 227  * ftp://sunsite.unc.edu/pub/linux
 228  * ftp://miguel@sphinx.nuclecu.unam.mx/c/nc
 229  * ftp://tsx-11.mit.edu:8192/
 230  * ftp://joe@foo.edu:11321/private
 231  * If the user is empty, e.g. ftp://@roxanne/private, then your login name
 232  * is supplied.
 233  *
 234  */
 235
 236 #define FTP_COMMAND_PORT   21
 237
 238 static void
 239 ftpfs_split_url(char *path, char **host, char **user, int *port, char **pass)
 240 {
 241     char *p;
 242
 243     p = vfs_split_url (path, host, user, port, pass, FTP_COMMAND_PORT,
 244                        URL_ALLOW_ANON);
 245
 246     if (!*user) {
 247         /* Look up user and password in netrc */
 248         if (use_netrc)
 249             ftpfs_netrc_lookup (*host, user, pass);
 250         if (!*user)
 251             *user = g_strdup ("anonymous");
 252     }
 253
 254     /* Look up password in netrc for known user */
 255     if (use_netrc && *user && pass && !*pass) {
 256         char *new_user;
 257
 258         ftpfs_netrc_lookup (*host, &new_user, pass);
 259
 260         /* If user is different, remove password */
 261         if (new_user && strcmp (*user, new_user)) {
 262             g_free (*pass);
 263             *pass = NULL;
 264         }
 265
 266         g_free (new_user);
 267     }
 268
 269     g_free (p);
 270 }
 271
 272 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
 273 static int
 274 ftpfs_get_reply (struct vfs_class *me, int sock, char *string_buf, int string_len)
 275 {
 276     char answer[BUF_1K];
 277     int i;
 278
 279     for (;;) {
 280         if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n')){
 281             if (string_buf)
 282                 *string_buf = 0;
 283             code = 421;
 284             return 4;
 285         }
 286         switch (sscanf(answer, "%d", &code)){
 287             case 0:
 288                 if (string_buf)
 289                     g_strlcpy (string_buf, answer, string_len);
 290                 code = 500;
 291                 return 5;
 292             case 1:
 293                 if (answer[3] == '-') {
 294                     while (1) {
 295                         if (!vfs_s_get_line (me, sock, answer, sizeof(answer), '\n')){
 296                             if (string_buf)
 297                                 *string_buf = 0;
 298                             code = 421;
 299                             return 4;
 300                         }
 301                         if ((sscanf (answer, "%d", &i) > 0) &&
 302                             (code == i) && (answer[3] == ' '))
 303                             break;
 304                     }
 305                 }
 306                 if (string_buf)
 307                     g_strlcpy (string_buf, answer, string_len);
 308                 return code / 100;
 309         }
 310     }
 311 }
 312
 313 static int
 314 ftpfs_reconnect (struct vfs_class *me, struct vfs_s_super *super)
 315 {
 316     int sock = ftpfs_open_socket (me, super);
 317     if (sock != -1){
 318         char *cwdir = SUP.cwdir;
 319         close (SUP.sock);
 320         SUP.sock = sock;
 321         SUP.cwdir = NULL;
 322         if (ftpfs_login_server (me, super, SUP.password)){
 323             if (!cwdir)
 324                 return 1;
 325             sock = ftpfs_chdir_internal (me, super, cwdir);
 326             g_free (cwdir);
 327             return sock == COMPLETE;
 328         }
 329         SUP.cwdir = cwdir;
 330     }
 331     return 0;
 332 }
 333
 334 static int
 335 ftpfs_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, const char *fmt, ...)
 336 {
 337     va_list ap;
 338     char *cmdstr;
 339     int status, cmdlen;
 340     static int retry = 0;
 341     static int level = 0;       /* ftpfs_login_server() use ftpfs_command() */
 342
 343     va_start (ap, fmt);
 344     cmdstr = g_strdup_vprintf (fmt, ap);
 345     va_end (ap);
 346
 347     cmdlen = strlen (cmdstr);
 348     cmdstr = g_realloc (cmdstr, cmdlen + 3);
 349     strcpy (cmdstr + cmdlen, "\r\n");
 350     cmdlen += 2;
 351
 352     if (MEDATA->logfile) {
 353         if (strncmp (cmdstr, "PASS ", 5) == 0) {
 354             fputs ("PASS <Password not logged>\r\n", MEDATA->logfile);
 355         } else
 356             fwrite (cmdstr, cmdlen, 1, MEDATA->logfile);
 357
 358         fflush (MEDATA->logfile);
 359     }
 360
 361     got_sigpipe = 0;
 362     tty_enable_interrupt_key ();
 363     status = write (SUP.sock, cmdstr, cmdlen);
 364
 365     if (status < 0) {
 366         code = 421;
 367
 368         if (errno == EPIPE) {   /* Remote server has closed connection */
 369             if (level == 0) {
 370                 level = 1;
 371                 status = ftpfs_reconnect (me, super);
 372                 level = 0;
 373                 if (status && (write (SUP.sock, cmdstr, cmdlen) > 0)) {
 374                     goto ok;
 375                 }
 376
 377             }
 378             got_sigpipe = 1;
 379         }
 380         g_free (cmdstr);
 381         tty_disable_interrupt_key ();
 382         return TRANSIENT;
 383     }
 384     retry = 0;
 385   ok:
 386     tty_disable_interrupt_key ();
 387
 388     if (wait_reply)
 389     {
 390         status = ftpfs_get_reply (me, SUP.sock,
 391                           (wait_reply & WANT_STRING) ? reply_str : NULL,
 392                           sizeof (reply_str) - 1);
 393         if ((wait_reply & WANT_STRING) && !retry && !level && code == 421)
 394         {
 395             retry = 1;
 396             level = 1;
 397             status = ftpfs_reconnect (me, super);
 398             level = 0;
 399             if (status && (write (SUP.sock, cmdstr, cmdlen) > 0)) {
 400                 goto ok;
 401             }
 402         }
 403         retry = 0;
 404         g_free (cmdstr);
 405         return status;
 406     }
 407     g_free (cmdstr);
 408     return COMPLETE;
 409 }
 410
 411 static void
 412 ftpfs_free_archive (struct vfs_class *me, struct vfs_s_super *super)
 413 {
 414     if (SUP.sock != -1){
 415         print_vfs_message (_("ftpfs: Disconnecting from %s"), SUP.host);
 416         ftpfs_command(me, super, NONE, "QUIT");
 417         close(SUP.sock);
 418     }
 419     g_free (SUP.host);
 420     g_free (SUP.user);
 421     g_free (SUP.cwdir);
 422     g_free (SUP.password);
 423 }
 424
 425 /* some defines only used by ftpfs_changetype */
 426 /* These two are valid values for the second parameter */
 427 #define TYPE_ASCII    0
 428 #define TYPE_BINARY   1
 429
 430 /* This one is only used to initialize bucket->isbinary, don't use it as
 431    second parameter to ftpfs_changetype. */
 432 #define TYPE_UNKNOWN -1
 433
 434 static int
 435 ftpfs_changetype (struct vfs_class *me, struct vfs_s_super *super, int binary)
 436 {
 437     if (binary != SUP.isbinary) {
 438         if (ftpfs_command (me, super, WAIT_REPLY, "TYPE %c", binary ? 'I' : 'A') != COMPLETE)
 439                 ERRNOR (EIO, -1);
 440         SUP.isbinary = binary;
 441     }
 442     return binary;
 443 }
 444
 445 /* This routine logs the user in */
 446 static int
 447 ftpfs_login_server (struct vfs_class *me, struct vfs_s_super *super,
 448                     const char *netrcpass)
 449 {
 450     char *pass;
 451     char *op;
 452     char *name;                 /* login user name */
 453     int anon = 0;
 454     char reply_string[BUF_MEDIUM];
 455
 456     SUP.isbinary = TYPE_UNKNOWN;
 457
 458     if (SUP.password)           /* explicit password */
 459         op = g_strdup (SUP.password);
 460     else if (netrcpass)         /* password from netrc */
 461         op = g_strdup (netrcpass);
 462     else if (!strcmp (SUP.user, "anonymous") || !strcmp (SUP.user, "ftp")) {
 463         if (!ftpfs_anonymous_passwd)    /* default anonymous password */
 464             ftpfs_init_passwd ();
 465         op = g_strdup (ftpfs_anonymous_passwd);
 466         anon = 1;
 467     } else {                    /* ask user */
 468         char *p;
 469
 470         p = g_strconcat (_(" FTP: Password required for "), SUP.user, " ",
 471                          NULL);
 472         op = vfs_get_password (p);
 473         g_free (p);
 474         if (op == NULL)
 475             ERRNOR (EPERM, 0);
 476         SUP.password = g_strdup (op);
 477     }
 478
 479     if (!anon || MEDATA->logfile)
 480         pass = op;
 481     else {
 482         pass = g_strconcat ("-", op, (char *) NULL);
 483         wipe_password (op);
 484     }
 485
 486     /* Proxy server accepts: username@host-we-want-to-connect */
 487     if (SUP.proxy) {
 488         name =
 489             g_strconcat (SUP.user, "@",
 490                          SUP.host[0] == '!' ? SUP.host + 1 : SUP.host,
 491                          NULL);
 492     } else
 493         name = g_strdup (SUP.user);
 494
 495     if (ftpfs_get_reply
 496         (me, SUP.sock, reply_string,
 497          sizeof (reply_string) - 1) == COMPLETE) {
 498         g_strup (reply_string);
 499         SUP.remote_is_amiga = strstr (reply_string, "AMIGA") != 0;
 500         if (MEDATA->logfile) {
 501             fprintf (MEDATA->logfile, "MC -- remote_is_amiga =  %d\n",
 502                      SUP.remote_is_amiga);
 503             fflush (MEDATA->logfile);
 504         }
 505
 506         print_vfs_message (_("ftpfs: sending login name"));
 507
 508         switch (ftpfs_command (me, super, WAIT_REPLY, "USER %s", name)) {
 509         case CONTINUE:
 510             print_vfs_message (_("ftpfs: sending user password"));
 511             code = ftpfs_command (me, super, WAIT_REPLY, "PASS %s", pass);
 512             if (code == CONTINUE) {
 513                 char *p;
 514
 515                 p = g_strdup_printf (_
 516                                      ("FTP: Account required for user %s"),
 517                                      SUP.user);
 518                 op = input_dialog (p, _("Account:"), MC_HISTORY_FTPFS_ACCOUNT, "");
 519                 g_free (p);
 520                 if (op == NULL)
 521                     ERRNOR (EPERM, 0);
 522                 print_vfs_message (_("ftpfs: sending user account"));
 523                 code =
 524                     ftpfs_command (me, super, WAIT_REPLY, "ACCT %s", op);
 525                 g_free (op);
 526             }
 527             if (code != COMPLETE)
 528                 break;
 529             /* fall through */
 530
 531         case COMPLETE:
 532             print_vfs_message (_("ftpfs: logged in"));
 533             wipe_password (pass);
 534             g_free (name);
 535             return 1;
 536
 537         default:
 538             SUP.failed_on_login = 1;
 539             if (SUP.password)
 540                 wipe_password (SUP.password);
 541             SUP.password = 0;
 542
 543             goto login_fail;
 544         }
 545     }
 546     message (D_ERROR, MSG_ERROR, _("ftpfs: Login incorrect for user %s "),
 547              SUP.user);
 548   login_fail:
 549     wipe_password (pass);
 550     g_free (name);
 551     ERRNOR (EPERM, 0);
 552 }
 553
 554 static struct no_proxy_entry {
 555     char  *domain;
 556     void  *next;
 557 } *no_proxy;
 558
 559 static void
 560 ftpfs_load_no_proxy_list (void)
 561 {
 562     /* FixMe: shouldn't be hardcoded!!! */
 563     char        s[BUF_LARGE]; /* provide for BUF_LARGE characters */
 564     struct no_proxy_entry *np, *current = 0;
 565     FILE        *npf;
 566     int         c;
 567     char        *p;
 568     static char *mc_file;
 569
 570     if (mc_file)
 571         return;
 572
 573     mc_file = concat_dir_and_file (mc_home, "mc.no_proxy");
 574     if (exist_file (mc_file) &&
 575         (npf = fopen (mc_file, "r"))) {
 576         while (fgets (s, sizeof (s), npf)) {
 577             if (!(p = strchr (s, '\n'))) {      /* skip bogus entries */
 578                 while ((c = fgetc (npf)) != EOF && c != '\n')
 579                     ;
 580                 continue;
 581             }
 582
 583             if (p == s)
 584                 continue;
 585
 586             *p = '\0';
 587
 588             np = g_new (struct no_proxy_entry, 1);
 589             np->domain = g_strdup (s);
 590             np->next   = NULL;
 591             if (no_proxy)
 592                 current->next = np;
 593             else
 594                 no_proxy = np;
 595             current = np;
 596         }
 597
 598         fclose (npf);
 599     }
 600     g_free (mc_file);
 601 }
 602
 603 /* Return 1 if FTP proxy should be used for this host, 0 otherwise */
 604 static int
 605 ftpfs_check_proxy (const char *host)
 606 {
 607     struct no_proxy_entry       *npe;
 608
 609     if (!ftpfs_proxy_host || !*ftpfs_proxy_host || !host || !*host)
 610         return 0;               /* sanity check */
 611
 612     if (*host == '!')
 613         return 1;
 614
 615     if (!ftpfs_always_use_proxy)
 616         return 0;
 617
 618     if (!strchr (host, '.'))
 619         return 0;
 620
 621     ftpfs_load_no_proxy_list ();
 622     for (npe = no_proxy; npe; npe=npe->next) {
 623         char    *domain = npe->domain;
 624
 625         if (domain[0] == '.') {
 626             int         ld = strlen (domain);
 627             int         lh = strlen (host);
 628
 629             while (ld && lh && host[lh - 1] == domain[ld - 1]) {
 630                 ld--;
 631                 lh--;
 632             }
 633
 634             if (!ld)
 635                 return 0;
 636         } else
 637             if (!g_strcasecmp (host, domain))
 638                 return 0;
 639     }
 640
 641     return 1;
 642 }
 643
 644 static void
 645 ftpfs_get_proxy_host_and_port (const char *proxy, char **host, int *port)
 646 {
 647     char *user, *dir;
 648
 649     dir =
 650         vfs_split_url (proxy, host, &user, port, 0, FTP_COMMAND_PORT,
 651                        URL_ALLOW_ANON);
 652     g_free (user);
 653     g_free (dir);
 654 }
 655
 656 static int
 657 ftpfs_open_socket (struct vfs_class *me, struct vfs_s_super *super)
 658 {
 659     struct addrinfo hints, *res, *curr_res;
 660     int      my_socket = 0;
 661     char     *host = NULL;
 662     char     *port = NULL;
 663     int      tmp_port;
 664     int      e;
 665
 666     (void) me;
 667
 668     /* Use a proxy host? */
 669     host = g_strdup(SUP.host);
 670
 671     if (!host || !*host){
 672         print_vfs_message (_("ftpfs: Invalid host name."));
 673         ftpfs_errno = EINVAL;
 674         return -1;
 675     }
 676
 677     /* Hosts to connect to that start with a ! should use proxy */
 678     tmp_port = SUP.port;
 679
 680     if (SUP.proxy){
 681         ftpfs_get_proxy_host_and_port (ftpfs_proxy_host, &host, &tmp_port);
 682     }
 683
 684     port = g_strdup_printf("%hu", (unsigned short) tmp_port);
 685     if (port == NULL) {
 686         g_free (host);
 687         ftpfs_errno = errno;
 688         return -1;
 689     }
 690
 691     tty_enable_interrupt_key(); /* clear the interrupt flag */
 692
 693     memset (&hints, 0, sizeof (struct addrinfo));
 694     hints.ai_socktype = SOCK_STREAM;
 695     hints.ai_flags = AI_ADDRCONFIG;
 696
 697
 698     e = getaddrinfo (host, port, &hints, &res);
 699     g_free (port);
 700     port = NULL;
 701
 702     if ( e != 0 ) {
 703         tty_disable_interrupt_key ();
 704         print_vfs_message (_("ftpfs: %s"), gai_strerror (e));
 705         g_free (host);
 706         ftpfs_errno = EINVAL;
 707         return -1;
 708     }
 709
 710     for (curr_res = res; curr_res != NULL; curr_res = curr_res->ai_next) {
 711
 712         my_socket = socket (curr_res->ai_family, curr_res->ai_socktype, curr_res->ai_protocol);
 713
 714         if (my_socket < 0) {
 715
 716             if (curr_res->ai_next != NULL)
 717                 continue;
 718
 719             tty_disable_interrupt_key();
 720             print_vfs_message (_("ftpfs: %s"), unix_error_string (errno));
 721             g_free (host);
 722             freeaddrinfo (res);
 723             ftpfs_errno = errno;
 724             return -1;
 725         }
 726
 727         print_vfs_message (_("ftpfs: making connection to %s"), host);
 728         g_free (host);
 729         host = NULL;
 730
 731         if ( connect (my_socket, curr_res->ai_addr, curr_res->ai_addrlen) >= 0 )
 732             break;
 733
 734         ftpfs_errno = errno;
 735         close (my_socket);
 736
 737         if (errno == EINTR && tty_got_interrupt ()) {
 738             print_vfs_message (_("ftpfs: connection interrupted by user"));
 739         } else if (res->ai_next == NULL) {
 740             print_vfs_message (_("ftpfs: connection to server failed: %s"),
 741                                 unix_error_string (errno));
 742         } else {
 743             continue;
 744         }
 745
 746         freeaddrinfo (res);
 747         tty_disable_interrupt_key ();
 748         return -1;
 749     }
 750
 751     freeaddrinfo (res);
 752     tty_disable_interrupt_key ();
 753     return my_socket;
 754 }
 755
 756 static int
 757 ftpfs_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
 758 {
 759     int retry_seconds, count_down;
 760
 761     /* We do not want to use the passive if we are using proxies */
 762     if (SUP.proxy)
 763         SUP.use_passive_connection = ftpfs_use_passive_connections_over_proxy;
 764
 765     retry_seconds = 0;
 766     do {
 767         SUP.failed_on_login = 0;
 768
 769         SUP.sock = ftpfs_open_socket (me, super);
 770         if (SUP.sock == -1)
 771             return -1;
 772
 773         if (ftpfs_login_server (me, super, NULL)) {
 774             /* Logged in, no need to retry the connection */
 775             break;
 776         } else {
 777             if (SUP.failed_on_login){
 778                 /* Close only the socket descriptor */
 779                 close (SUP.sock);
 780             } else {
 781                 return -1;
 782             }
 783             if (ftpfs_retry_seconds){
 784                 retry_seconds = ftpfs_retry_seconds;
 785                 tty_enable_interrupt_key ();
 786                 for (count_down = retry_seconds; count_down; count_down--){
 787                     print_vfs_message (_("Waiting to retry... %d (Control-C to cancel)"), count_down);
 788                     sleep (1);
 789                     if (tty_got_interrupt ()) {
 790                         /* ftpfs_errno = E; */
 791                         tty_disable_interrupt_key ();
 792                         return 0;
 793                     }
 794                 }
 795                 tty_disable_interrupt_key ();
 796             }
 797         }
 798     } while (retry_seconds);
 799
 800     SUP.cwdir = ftpfs_get_current_directory (me, super);
 801     if (!SUP.cwdir)
 802         SUP.cwdir = g_strdup (PATH_SEP_STR);
 803     return 0;
 804 }
 805
 806 static int
 807 ftpfs_open_archive (struct vfs_class *me, struct vfs_s_super *super,
 808                     const char *archive_name, char *op)
 809 {
 810     char *host, *user, *password;
 811     int port;
 812
 813     (void) archive_name;
 814
 815     ftpfs_split_url (strchr (op, ':') + 1, &host, &user, &port, &password);
 816
 817     SUP.host = host;
 818     SUP.user = user;
 819     SUP.port = port;
 820     SUP.cwdir = NULL;
 821     SUP.proxy = 0;
 822     if (ftpfs_check_proxy (host))
 823         SUP.proxy = ftpfs_proxy_host;
 824     SUP.password = password;
 825     SUP.use_passive_connection = ftpfs_use_passive_connections;
 826     SUP.strict = ftpfs_use_unix_list_options ? RFC_AUTODETECT : RFC_STRICT;
 827     SUP.isbinary = TYPE_UNKNOWN;
 828     SUP.remote_is_amiga = 0;
 829     super->name = g_strdup ("/");
 830     super->root =
 831         vfs_s_new_inode (me, super,
 832                          vfs_s_default_stat (me, S_IFDIR | 0755));
 833
 834     return ftpfs_open_archive_int (me, super);
 835 }
 836
 837 static int
 838 ftpfs_archive_same (struct vfs_class *me, struct vfs_s_super *super,
 839                     const char *archive_name, char *op, void *cookie)
 840 {
 841     char *host, *user;
 842     int port;
 843
 844     (void) me;
 845     (void) archive_name;
 846     (void) cookie;
 847
 848     ftpfs_split_url (strchr (op, ':') + 1, &host, &user, &port, 0);
 849
 850     port = ((strcmp (host, SUP.host) == 0)
 851             && (strcmp (user, SUP.user) == 0) && (port == SUP.port));
 852
 853     g_free (host);
 854     g_free (user);
 855
 856     return port;
 857 }
 858
 859 /* The returned directory should always contain a trailing slash */
 860 static char *
 861 ftpfs_get_current_directory (struct vfs_class *me, struct vfs_s_super *super)
 862 {
 863     char buf[BUF_8K], *bufp, *bufq;
 864
 865     if (ftpfs_command (me, super, NONE, "PWD") == COMPLETE &&
 866         ftpfs_get_reply(me, SUP.sock, buf, sizeof(buf)) == COMPLETE) {
 867         bufp = NULL;
 868         for (bufq = buf; *bufq; bufq++)
 869             if (*bufq == '"') {
 870                 if (!bufp) {
 871                     bufp = bufq + 1;
 872                 } else {
 873                     *bufq = 0;
 874                     if (*bufp) {
 875                         if (*(bufq - 1) != '/') {
 876                             *bufq++ = '/';
 877                             *bufq = 0;
 878                         }
 879                         if (*bufp == '/')
 880                             return g_strdup (bufp);
 881                         else {
 882                             /* If the remote server is an Amiga a leading slash
 883                                might be missing. MC needs it because it is used
 884                                as separator between hostname and path internally. */
 885                             return g_strconcat( "/", bufp, NULL);
 886                         }
 887                     } else {
 888                         ftpfs_errno = EIO;
 889                         return NULL;
 890                     }
 891                 }
 892             }
 893     }
 894     ftpfs_errno = EIO;
 895     return NULL;
 896 }
 897
 898
 899 /* Setup Passive ftp connection, we use it for source routed connections */
 900 static int
 901 ftpfs_setup_passive (struct vfs_class *me, struct vfs_s_super *super,
 902         int my_socket, struct sockaddr_storage *sa, socklen_t *salen)
 903 {
 904     char *c;
 905
 906     if (ftpfs_command (me, super, WAIT_REPLY | WANT_STRING, "EPSV") == COMPLETE) {
 907         int port;
 908         /* (|||<port>|) */
 909         c = strchr (reply_str, '|');
 910         if (c == NULL)
 911             return 0;
 912         if(strlen(c) > 3)
 913             c+=3;
 914         else
 915             return 0;
 916
 917         port = atoi (c);
 918         if (port < 0 || port > 65535)
 919             return 0;
 920         port = htons (port);
 921
 922         switch (sa->ss_family) {
 923         case AF_INET:
 924             ((struct sockaddr_in *)sa)->sin_port = port;
 925         break;
 926         case AF_INET6:
 927             ((struct sockaddr_in6 *)sa)->sin6_port = port;
 928         break;
 929         default:
 930             print_vfs_message (_("ftpfs: invalid address family"));
 931             ERRNOR (EINVAL, -1);
 932         }
 933     } else if (sa->ss_family == AF_INET) {
 934         int xa, xb, xc, xd, xe, xf;
 935         char n [6];
 936
 937         if (ftpfs_command (me, super, WAIT_REPLY | WANT_STRING, "PASV") != COMPLETE)
 938             return 0;
 939
 940         /* Parse remote parameters */
 941         for (c = reply_str + 4; (*c) && (!isdigit ((unsigned char) *c)); c++);
 942
 943         if (!*c)
 944             return 0;
 945         if (!isdigit ((unsigned char) *c))
 946             return 0;
 947         if (sscanf (c, "%d,%d,%d,%d,%d,%d", &xa, &xb, &xc, &xd, &xe, &xf) != 6)
 948             return 0;
 949
 950         n [0] = (unsigned char) xa;
 951         n [1] = (unsigned char) xb;
 952         n [2] = (unsigned char) xc;
 953         n [3] = (unsigned char) xd;
 954         n [4] = (unsigned char) xe;
 955         n [5] = (unsigned char) xf;
 956
 957         memcpy (&(((struct sockaddr_in *)sa)->sin_addr.s_addr), (void *)n, 4);
 958         memcpy (&(((struct sockaddr_in *)sa)->sin_port), (void *)&n[4], 2);
 959     } else
 960         return 0;
 961
 962     if (connect (my_socket, (struct sockaddr *) sa, *salen ) < 0)
 963         return 0;
 964
 965     return 1;
 966 }
 967
 968 static int
 969 ftpfs_initconn (struct vfs_class *me, struct vfs_s_super *super)
 970 {
 971     struct sockaddr_storage data_addr;
 972     socklen_t data_addrlen;
 973     int data_sock;
 974
 975 again:
 976     memset (&data_addr, 0, sizeof (struct sockaddr_storage));
 977     data_addrlen = sizeof (struct sockaddr_storage);
 978
 979     if (getpeername (SUP.sock, (struct sockaddr *) &data_addr, &data_addrlen) == -1)
 980         return -1;
 981
 982     switch (data_addr.ss_family) {
 983     case AF_INET:
 984         ((struct sockaddr_in *)&data_addr)->sin_port = 0;
 985     break;
 986     case AF_INET6:
 987         ((struct sockaddr_in6 *)&data_addr)->sin6_port = 0;
 988     break;
 989     default:
 990         print_vfs_message (_("ftpfs: invalid address family"));
 991         ERRNOR(EINVAL, -1);
 992     }
 993
 994     data_sock = socket (data_addr.ss_family, SOCK_STREAM, IPPROTO_TCP);
 995     if (data_sock < 0) {
 996         if (SUP.use_passive_connection) {
 997             print_vfs_message (_("ftpfs: could not setup passive mode: %s"), unix_error_string (errno));
 998             SUP.use_passive_connection = 0;
 999             goto again;
1000         }
1001
1002         print_vfs_message (_("ftpfs: could not create socket: %s"), unix_error_string (errno));
1003         return -1;
1004     }
1005
1006     if (SUP.use_passive_connection) {
1007
1008         if (ftpfs_setup_passive (me, super, data_sock, &data_addr, &data_addrlen))
1009             return data_sock;
1010
1011         SUP.use_passive_connection = 0;
1012         print_vfs_message (_("ftpfs: could not setup passive mode"));
1013
1014         close (data_sock);
1015         goto again;
1016     }
1017
1018     /* If passive setup fails, fallback to active connections */
1019     /* Active FTP connection */
1020     if ((bind (data_sock, (struct sockaddr *)&data_addr, data_addrlen) == 0) &&
1021       (getsockname (data_sock, (struct sockaddr *)&data_addr, &data_addrlen) == 0) &&
1022       (listen (data_sock, 1) == 0)) {
1023         unsigned short int port;
1024         char *addr;
1025         unsigned int af;
1026
1027         switch (data_addr.ss_family) {
1028         case AF_INET:
1029             af = FTP_INET;
1030             port = ((struct sockaddr_in *)&data_addr)->sin_port;
1031         break;
1032         case AF_INET6:
1033             af = FTP_INET6;
1034             port = ((struct sockaddr_in6 *)&data_addr)->sin6_port;
1035         break;
1036         default:
1037             print_vfs_message (_("ftpfs: invalid address family"));
1038             ERRNOR (EINVAL, -1);
1039         }
1040
1041         port = ntohs (port);
1042
1043         addr = g_malloc (NI_MAXHOST);
1044         if (addr == NULL)
1045             ERRNOR (ENOMEM, -1);
1046
1047         if (getnameinfo ((struct sockaddr *)&data_addr, data_addrlen, addr, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0) {
1048             g_free (addr);
1049             ERRNOR (EIO, -1);
1050         }
1051
1052         if (ftpfs_command (me, super, WAIT_REPLY, "EPRT |%u|%s|%hu|", af, addr, port) == COMPLETE) {
1053             g_free (addr);
1054             return data_sock;
1055         }
1056         g_free (addr);
1057
1058         if (FTP_INET == af) {
1059             unsigned char *a = (unsigned char *)&((struct sockaddr_in *)&data_addr)->sin_addr;
1060             unsigned char *p = (unsigned char *)&port;
1061
1062         if (ftpfs_command (me, super, WAIT_REPLY,
1063                             "PORT %u,%u,%u,%u,%u,%u", a[0], a[1], a[2], a[3],
1064                             p[0], p[1]) == COMPLETE)
1065           return data_sock;
1066         }
1067     }
1068     close (data_sock);
1069     ftpfs_errno = EIO;
1070     return -1;
1071 }
1072
1073 static int
1074 ftpfs_open_data_connection (struct vfs_class *me, struct vfs_s_super *super, const char *cmd,
1075                       const char *remote, int isbinary, int reget)
1076 {
1077     struct sockaddr_storage from;
1078     int s, j, data;
1079     socklen_t fromlen = sizeof(from);
1080
1081     if ((s = ftpfs_initconn (me, super)) == -1)
1082         return -1;
1083     if (ftpfs_changetype (me, super, isbinary) == -1)
1084         return -1;
1085     if (reget > 0){
1086         j = ftpfs_command (me, super, WAIT_REPLY, "REST %d", reget);
1087         if (j != CONTINUE)
1088             return -1;
1089     }
1090     if (remote) {
1091         char *remote_path = ftpfs_translate_path (me, super, remote);
1092         j = ftpfs_command (me, super, WAIT_REPLY, "%s /%s", cmd,
1093             /* WarFtpD can't STORE //filename */
1094             (*remote_path == '/') ? remote_path + 1 : remote_path);
1095         g_free (remote_path);
1096     } else
1097         j = ftpfs_command (me, super, WAIT_REPLY, "%s", cmd);
1098     if (j != PRELIM)
1099         ERRNOR (EPERM, -1);
1100     tty_enable_interrupt_key ();
1101     if (SUP.use_passive_connection)
1102         data = s;
1103     else {
1104         data = accept (s, (struct sockaddr *)&from, &fromlen);
1105         if (data < 0) {
1106             ftpfs_errno = errno;
1107             close (s);
1108             return -1;
1109         }
1110         close (s);
1111     }
1112     tty_disable_interrupt_key ();
1113     return data;
1114 }
1115
1116 #define ABORT_TIMEOUT 5
1117 static void
1118 ftpfs_linear_abort (struct vfs_class *me, struct vfs_s_fh *fh)
1119 {
1120     struct vfs_s_super *super = FH_SUPER;
1121     static unsigned char const ipbuf[3] = { IAC, IP, IAC };
1122     fd_set mask;
1123     char buf[1024];
1124     int dsock = FH_SOCK;
1125     FH_SOCK = -1;
1126     SUP.ctl_connection_busy = 0;
1127
1128     print_vfs_message (_("ftpfs: aborting transfer."));
1129     if (send (SUP.sock, ipbuf, sizeof (ipbuf), MSG_OOB) != sizeof (ipbuf)) {
1130         print_vfs_message (_("ftpfs: abort error: %s"),
1131                            unix_error_string (errno));
1132         if (dsock != -1)
1133             close (dsock);
1134         return;
1135     }
1136
1137     if (ftpfs_command (me, super, NONE, "%cABOR", DM) != COMPLETE) {
1138         print_vfs_message (_("ftpfs: abort failed"));
1139         if (dsock != -1)
1140             close (dsock);
1141         return;
1142     }
1143     if (dsock != -1) {
1144         FD_ZERO (&mask);
1145         FD_SET (dsock, &mask);
1146         if (select (dsock + 1, &mask, NULL, NULL, NULL) > 0) {
1147             struct timeval start_tim, tim;
1148             gettimeofday (&start_tim, NULL);
1149             /* flush the remaining data */
1150             while (read (dsock, buf, sizeof (buf)) > 0) {
1151                 gettimeofday (&tim, NULL);
1152                 if (tim.tv_sec > start_tim.tv_sec + ABORT_TIMEOUT) {
1153                     /* server keeps sending, drop the connection and ftpfs_reconnect */
1154                     close (dsock);
1155                     ftpfs_reconnect (me, super);
1156                     return;
1157                 }
1158             }
1159         }
1160         close (dsock);
1161     }
1162     if ((ftpfs_get_reply (me, SUP.sock, NULL, 0) == TRANSIENT) && (code == 426))
1163         ftpfs_get_reply (me, SUP.sock, NULL, 0);
1164 }
1165
1166 #if 0
1167 static void
1168 resolve_symlink_without_ls_options(struct vfs_class *me, struct vfs_s_super *super, struct vfs_s_inode *dir)
1169 {
1170     struct linklist *flist;
1171     struct direntry *fe, *fel;
1172     char tmp[MC_MAXPATHLEN];
1173     int depth;
1174
1175     dir->symlink_status = FTPFS_RESOLVING_SYMLINKS;
1176     for (flist = dir->file_list->next; flist != dir->file_list; flist = flist->next) {
1177         /* flist->data->l_stat is alread initialized with 0 */
1178         fel = flist->data;
1179         if (S_ISLNK(fel->s.st_mode) && fel->linkname) {
1180             if (fel->linkname[0] == '/') {
1181                 if (strlen (fel->linkname) >= MC_MAXPATHLEN)
1182                     continue;
1183                 strcpy (tmp, fel->linkname);
1184             } else {
1185                 if ((strlen (dir->remote_path) + strlen (fel->linkname)) >= MC_MAXPATHLEN)
1186                     continue;
1187                 strcpy (tmp, dir->remote_path);
1188                 if (tmp[1] != '\0')
1189                    strcat (tmp, "/");
1190                 strcat (tmp + 1, fel->linkname);
1191             }
1192             for ( depth = 0; depth < 100; depth++) { /* depth protects against recursive symbolic links */
1193                 canonicalize_pathname (tmp);
1194                 fe = _get_file_entry(bucket, tmp, 0, 0);
1195                 if (fe) {
1196                     if (S_ISLNK (fe->s.st_mode) && fe->l_stat == 0) {
1197                         /* Symlink points to link which isn't resolved, yet. */
1198                         if (fe->linkname[0] == '/') {
1199                             if (strlen (fe->linkname) >= MC_MAXPATHLEN)
1200                                 break;
1201                             strcpy (tmp, fe->linkname);
1202                         } else {
1203                             /* at this point tmp looks always like this
1204                                /directory/filename, i.e. no need to check
1205                                 strrchr's return value */
1206                             *(strrchr (tmp, '/') + 1) = '\0'; /* dirname */
1207                             if ((strlen (tmp) + strlen (fe->linkname)) >= MC_MAXPATHLEN)
1208                                 break;
1209                             strcat (tmp, fe->linkname);
1210                         }
1211                         continue;
1212                     } else {
1213                         fel->l_stat = g_new (struct stat, 1);
1214                         if ( S_ISLNK (fe->s.st_mode))
1215                             *fel->l_stat = *fe->l_stat;
1216                         else
1217                             *fel->l_stat = fe->s;
1218                         (*fel->l_stat).st_ino = bucket->__inode_counter++;
1219                     }
1220                 }
1221                 break;
1222             }
1223         }
1224     }
1225     dir->symlink_status = FTPFS_RESOLVED_SYMLINKS;
1226 }
1227
1228 static void
1229 resolve_symlink_with_ls_options(struct vfs_class *me, struct vfs_s_super *super, struct vfs_s_inode *dir)
1230 {
1231     char  buffer[2048] = "", *filename;
1232     int sock;
1233     FILE *fp;
1234     struct stat s;
1235     struct linklist *flist;
1236     struct direntry *fe;
1237     int switch_method = 0;
1238
1239     dir->symlink_status = FTPFS_RESOLVED_SYMLINKS;
1240     if (strchr (dir->remote_path, ' ')) {
1241         if (ftpfs_chdir_internal (bucket, dir->remote_path) != COMPLETE) {
1242             print_vfs_message(_("ftpfs: CWD failed."));
1243             return;
1244         }
1245         sock = ftpfs_open_data_connection (bucket, "LIST -lLa", ".", TYPE_ASCII, 0);
1246     }
1247     else
1248         sock = ftpfs_open_data_connection (bucket, "LIST -lLa",
1249                                      dir->remote_path, TYPE_ASCII, 0);
1250
1251     if (sock == -1) {
1252         print_vfs_message(_("ftpfs: couldn't resolve symlink"));
1253         return;
1254     }
1255
1256     fp = fdopen(sock, "r");
1257     if (fp == NULL) {
1258         close(sock);
1259         print_vfs_message(_("ftpfs: couldn't resolve symlink"));
1260         return;
1261     }
1262     tty_enable_interrupt_key ();
1263     flist = dir->file_list->next;
1264     while (1) {
1265         do {
1266             if (flist == dir->file_list)
1267                 goto done;
1268             fe = flist->data;
1269             flist = flist->next;
1270         } while (!S_ISLNK(fe->s.st_mode));
1271         while (1) {
1272             if (fgets (buffer, sizeof (buffer), fp) == NULL)
1273                 goto done;
1274             if (MEDATA->logfile){
1275                 fputs (buffer, MEDATA->logfile);
1276                 fflush (MEDATA->logfile);
1277             }
1278             vfs_die("This code should be commented out\n");
1279             if (vfs_parse_ls_lga (buffer, &s, &filename, NULL)) {
1280                 int r = strcmp(fe->name, filename);
1281                 g_free(filename);
1282                 if (r == 0) {
1283                     if (S_ISLNK (s.st_mode)) {
1284                         /* This server doesn't understand LIST -lLa */
1285                         switch_method = 1;
1286                         goto done;
1287                     }
1288                     fe->l_stat = g_new (struct stat, 1);
1289                     if (fe->l_stat == NULL)
1290                         goto done;
1291                     *fe->l_stat = s;
1292                     (*fe->l_stat).st_ino = bucket->__inode_counter++;
1293                     break;
1294                 }
1295                 if (r < 0)
1296                     break;
1297             }
1298         }
1299     }
1300 done:
1301     while (fgets(buffer, sizeof(buffer), fp) != NULL);
1302     tty_disable_interrupt_key ();
1303     fclose(fp);
1304     ftpfs_get_reply(me, SUP.sock, NULL, 0);
1305 }
1306
1307 static void
1308 resolve_symlink(struct vfs_class *me, struct vfs_s_super *super, struct vfs_s_inode *dir)
1309 {
1310     print_vfs_message(_("Resolving symlink..."));
1311
1312     if (SUP.strict_rfc959_list_cmd)
1313         resolve_symlink_without_ls_options(me, super, dir);
1314     else
1315         resolve_symlink_with_ls_options(me, super, dir);
1316 }
1317 #endif
1318
1319 static int
1320 ftpfs_dir_load (struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
1321 {
1322     struct vfs_s_entry *ent;
1323     struct vfs_s_super *super = dir->super;
1324     int sock, num_entries = 0;
1325     char buffer[BUF_8K];
1326     int cd_first;
1327
1328     cd_first = ftpfs_first_cd_then_ls || (SUP.strict == RFC_STRICT)
1329         || (strchr (remote_path, ' ') != NULL);
1330
1331   again:
1332     print_vfs_message (_("ftpfs: Reading FTP directory %s... %s%s"),
1333                        remote_path,
1334                        SUP.strict ==
1335                        RFC_STRICT ? _("(strict rfc959)") : "",
1336                        cd_first ? _("(chdir first)") : "");
1337
1338     if (cd_first) {
1339         if (ftpfs_chdir_internal (me, super, remote_path) != COMPLETE) {
1340             ftpfs_errno = ENOENT;
1341             print_vfs_message (_("ftpfs: CWD failed."));
1342             return -1;
1343         }
1344     }
1345
1346     gettimeofday (&dir->timestamp, NULL);
1347     dir->timestamp.tv_sec += ftpfs_directory_timeout;
1348
1349     if (SUP.strict == RFC_STRICT)
1350         sock = ftpfs_open_data_connection (me, super, "LIST", 0, TYPE_ASCII, 0);
1351     else if (cd_first)
1352         /* Dirty hack to avoid autoprepending / to . */
1353         /* Wu-ftpd produces strange output for '/' if 'LIST -la .' used */
1354         sock =
1355             ftpfs_open_data_connection (me, super, "LIST -la", 0, TYPE_ASCII, 0);
1356     else {
1357         /* Trailing "/." is necessary if remote_path is a symlink */
1358         char *path = concat_dir_and_file (remote_path, ".");
1359         sock =
1360             ftpfs_open_data_connection (me, super, "LIST -la", path, TYPE_ASCII,
1361                                   0);
1362         g_free (path);
1363     }
1364
1365     if (sock == -1)
1366         goto fallback;
1367
1368     /* Clear the interrupt flag */
1369     tty_enable_interrupt_key ();
1370
1371     while (1) {
1372         int i;
1373         int res =
1374             vfs_s_get_line_interruptible (me, buffer, sizeof (buffer),
1375                                           sock);
1376         if (!res)
1377             break;
1378
1379         if (res == EINTR) {
1380             me->verrno = ECONNRESET;
1381             close (sock);
1382             tty_disable_interrupt_key ();
1383             ftpfs_get_reply (me, SUP.sock, NULL, 0);
1384             print_vfs_message (_("%s: failure"), me->name);
1385             return -1;
1386         }
1387
1388         if (MEDATA->logfile) {
1389             fputs (buffer, MEDATA->logfile);
1390             fputs ("\n", MEDATA->logfile);
1391             fflush (MEDATA->logfile);
1392         }
1393
1394         ent = vfs_s_generate_entry (me, NULL, dir, 0);
1395         i = ent->ino->st.st_nlink;
1396         if (!vfs_parse_ls_lga
1397             (buffer, &ent->ino->st, &ent->name, &ent->ino->linkname)) {
1398             vfs_s_free_entry (me, ent);
1399             continue;
1400         }
1401         ent->ino->st.st_nlink = i;      /* Ouch, we need to preserve our counts :-( */
1402         num_entries++;
1403         vfs_s_insert_entry (me, dir, ent);
1404     }
1405
1406     close (sock);
1407     me->verrno = E_REMOTE;
1408     if ((ftpfs_get_reply (me, SUP.sock, NULL, 0) != COMPLETE))
1409         goto fallback;
1410
1411     if (num_entries == 0 && cd_first == 0) {
1412         /* The LIST command may produce an empty output. In such scenario
1413            it is not clear whether this is caused by  `remote_path' being
1414            a non-existent path or for some other reason (listing emtpy
1415            directory without the -a option, non-readable directory, etc.).
1416
1417            Since `dir_load' is a crucial method, when it comes to determine
1418            whether a given path is a _directory_, the code must try its best
1419            to determine the type of `remote_path'. The only reliable way to
1420            achieve this is trough issuing a CWD command. */
1421
1422         cd_first = 1;
1423         goto again;
1424     }
1425
1426     if (SUP.strict == RFC_AUTODETECT)
1427         SUP.strict = RFC_DARING;
1428
1429     print_vfs_message (_("%s: done."), me->name);
1430     return 0;
1431
1432   fallback:
1433     if (SUP.strict == RFC_AUTODETECT) {
1434         /* It's our first attempt to get a directory listing from this
1435            server (UNIX style LIST command) */
1436         SUP.strict = RFC_STRICT;
1437         /* I hate goto, but recursive call needs another 8K on stack */
1438         /* return ftpfs_dir_load (me, dir, remote_path); */
1439         cd_first = 1;
1440         goto again;
1441     }
1442     print_vfs_message (_("ftpfs: failed; nowhere to fallback to"));
1443     ERRNOR (EACCES, -1);
1444 }
1445
1446 static int
1447 ftpfs_file_store (struct vfs_class *me, struct vfs_s_fh *fh, char *name,
1448                   char *localname)
1449 {
1450     int h, sock, n_read, n_written;
1451     off_t n_stored;
1452 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1453     struct linger li;
1454 #else
1455     int flag_one = 1;
1456 #endif
1457     char buffer[8192];
1458     struct stat s;
1459     char  *w_buf;
1460     struct vfs_s_super *super = FH_SUPER;
1461
1462     h = open (localname, O_RDONLY);
1463     if (h == -1)
1464         ERRNOR (EIO, -1);
1465     sock =
1466         ftpfs_open_data_connection (me, super,
1467                                     fh->u.ftp.append ? "APPE" : "STOR", name,
1468                                     TYPE_BINARY, 0);
1469     if (sock < 0 || fstat (h, &s) == -1) {
1470         close (h);
1471         return -1;
1472     }
1473 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1474     li.l_onoff = 1;
1475     li.l_linger = 120;
1476     setsockopt (sock, SOL_SOCKET, SO_LINGER, (char *) &li, sizeof (li));
1477 #else
1478     setsockopt (sock, SOL_SOCKET, SO_LINGER, &flag_one, sizeof (flag_one));
1479 #endif
1480     n_stored = 0;
1481
1482     tty_enable_interrupt_key ();
1483     while (1) {
1484         while ((n_read = read (h, buffer, sizeof (buffer))) == -1) {
1485             if (errno == EINTR) {
1486                 if (tty_got_interrupt ()) {
1487                     ftpfs_errno = EINTR;
1488                     goto error_return;
1489                 } else
1490                     continue;
1491             }
1492             ftpfs_errno = errno;
1493             goto error_return;
1494         }
1495         if (n_read == 0)
1496             break;
1497         n_stored += n_read;
1498         w_buf = buffer;
1499         while ((n_written = write (sock, w_buf, n_read)) != n_read) {
1500             if (n_written == -1) {
1501                 if (errno == EINTR && !tty_got_interrupt ()) {
1502                     continue;
1503                 }
1504                 ftpfs_errno = errno;
1505                 goto error_return;
1506             }
1507             w_buf += n_written;
1508             n_read -= n_written;
1509         }
1510         print_vfs_message (_("ftpfs: storing file %lu (%lu)"),
1511                            (unsigned long) n_stored, (unsigned long) s.st_size);
1512     }
1513     tty_disable_interrupt_key ();
1514     close (sock);
1515     close (h);
1516     if (ftpfs_get_reply (me, SUP.sock, NULL, 0) != COMPLETE)
1517         ERRNOR (EIO, -1);
1518     return 0;
1519   error_return:
1520     tty_disable_interrupt_key ();
1521     close (sock);
1522     close (h);
1523     ftpfs_get_reply (me, SUP.sock, NULL, 0);
1524     return -1;
1525 }
1526
1527 static int
1528 ftpfs_linear_start (struct vfs_class *me, struct vfs_s_fh *fh, off_t offset)
1529 {
1530     char *name = vfs_s_fullpath (me, fh->ino);
1531
1532     if (!name)
1533         return 0;
1534     FH_SOCK = ftpfs_open_data_connection(me, FH_SUPER, "RETR", name, TYPE_BINARY, offset);
1535     g_free (name);
1536     if (FH_SOCK == -1)
1537         ERRNOR (EACCES, 0);
1538     fh->linear = LS_LINEAR_OPEN;
1539     FH_SUPER->u.ftp.ctl_connection_busy = 1;
1540     fh->u.ftp.append = 0;
1541     return 1;
1542 }
1543
1544 static int
1545 ftpfs_linear_read (struct vfs_class *me, struct vfs_s_fh *fh, void *buf, int len)
1546 {
1547     int n;
1548     struct vfs_s_super *super = FH_SUPER;
1549
1550     while ((n = read (FH_SOCK, buf, len))<0) {
1551         if ((errno == EINTR) && !tty_got_interrupt ())
1552             continue;
1553         break;
1554     }
1555
1556     if (n<0)
1557         ftpfs_linear_abort(me, fh);
1558
1559     if (!n) {
1560         SUP.ctl_connection_busy = 0;
1561         close (FH_SOCK);
1562         FH_SOCK = -1;
1563         if ((ftpfs_get_reply (me, SUP.sock, NULL, 0) != COMPLETE))
1564             ERRNOR (E_REMOTE, -1);
1565         return 0;
1566     }
1567     ERRNOR (errno, n);
1568 }
1569
1570 static void
1571 ftpfs_linear_close (struct vfs_class *me, struct vfs_s_fh *fh)
1572 {
1573     if (FH_SOCK != -1)
1574         ftpfs_linear_abort(me, fh);
1575 }
1576
1577 static int ftpfs_ctl (void *fh, int ctlop, void *arg)
1578 {
1579     (void) arg;
1580
1581     switch (ctlop) {
1582         case VFS_CTL_IS_NOTREADY:
1583             {
1584                 int v;
1585
1586                 if (!FH->linear)
1587                     vfs_die ("You may not do this");
1588                 if (FH->linear == LS_LINEAR_CLOSED || FH->linear == LS_LINEAR_PREOPEN)
1589                     return 0;
1590
1591                 v = vfs_s_select_on_two (FH->u.ftp.sock, 0);
1592                 if (((v < 0) && (errno == EINTR)) || v == 0)
1593                     return 1;
1594                 return 0;
1595             }
1596         default:
1597             return 0;
1598     }
1599 }
1600
1601 static int
1602 ftpfs_send_command(struct vfs_class *me, const char *filename, const char *cmd, int flags)
1603 {
1604     const char *rpath;
1605     char *p, *mpath = g_strdup(filename);
1606     struct vfs_s_super *super;
1607     int r;
1608     int flush_directory_cache = (flags & OPT_FLUSH);
1609
1610     if (!(rpath = vfs_s_get_path_mangle(me, mpath, &super, 0))) {
1611         g_free(mpath);
1612         return -1;
1613     }
1614     p = ftpfs_translate_path (me, super, rpath);
1615     r = ftpfs_command (me, super, WAIT_REPLY, cmd, p);
1616     g_free (p);
1617     vfs_stamp_create (&vfs_ftpfs_ops, super);
1618     if (flags & OPT_IGNORE_ERROR)
1619         r = COMPLETE;
1620     if (r != COMPLETE) {
1621         me->verrno = EPERM;
1622         g_free (mpath);
1623         return -1;
1624     }
1625     if (flush_directory_cache)
1626         vfs_s_invalidate(me, super);
1627     g_free(mpath);
1628     return 0;
1629 }
1630
1631 /* This routine is called as the last step in load_setup */
1632 void
1633 ftpfs_init_passwd(void)
1634 {
1635     ftpfs_anonymous_passwd = load_anon_passwd ();
1636     if (ftpfs_anonymous_passwd)
1637         return;
1638
1639     /* If there is no anonymous ftp password specified
1640      * then we'll just use anonymous@
1641      * We don't send any other thing because:
1642      * - We want to remain anonymous
1643      * - We want to stop SPAM
1644      * - We don't want to let ftp sites to discriminate by the user,
1645      *   host or country.
1646      */
1647     ftpfs_anonymous_passwd = g_strdup ("anonymous@");
1648 }
1649
1650 static int ftpfs_chmod (struct vfs_class *me, const char *path, int mode)
1651 {
1652     char buf[BUF_SMALL];
1653
1654     g_snprintf(buf, sizeof(buf), "SITE CHMOD %4.4o /%%s", mode & 07777);
1655     return ftpfs_send_command(me, path, buf, OPT_FLUSH);
1656 }
1657
1658 static int ftpfs_chown (struct vfs_class *me, const char *path, int owner, int group)
1659 {
1660 #if 0
1661     ftpfs_errno = EPERM;
1662     return -1;
1663 #else
1664 /* Everyone knows it is not possible to chown remotely, so why bother them.
1665    If someone's root, then copy/move will always try to chown it... */
1666     (void) me;
1667     (void) path;
1668     (void) owner;
1669     (void) group;
1670     return 0;
1671 #endif
1672 }
1673
1674 static int ftpfs_unlink (struct vfs_class *me, const char *path)
1675 {
1676     return ftpfs_send_command(me, path, "DELE /%s", OPT_FLUSH);
1677 }
1678
1679 /* Return 1 if path is the same directory as the one we are in now */
1680 static int
1681 ftpfs_is_same_dir (struct vfs_class *me, struct vfs_s_super *super, const char *path)
1682 {
1683     (void) me;
1684
1685     if (!SUP.cwdir)
1686         return 0;
1687     if (strcmp (path, SUP.cwdir) == 0)
1688         return 1;
1689     return 0;
1690 }
1691
1692 static int
1693 ftpfs_chdir_internal (struct vfs_class *me, struct vfs_s_super *super, const char *remote_path)
1694 {
1695     int r;
1696     char *p;
1697
1698     if (!SUP.cwd_deferred && ftpfs_is_same_dir (me, super, remote_path))
1699         return COMPLETE;
1700
1701     p = ftpfs_translate_path (me, super, remote_path);
1702     r = ftpfs_command (me, super, WAIT_REPLY, "CWD /%s", p);
1703     g_free (p);
1704
1705     if (r != COMPLETE) {
1706         ftpfs_errno = EIO;
1707     } else {
1708         g_free(SUP.cwdir);
1709         SUP.cwdir = g_strdup (remote_path);
1710         SUP.cwd_deferred = 0;
1711     }
1712     return r;
1713 }
1714
1715 static int ftpfs_rename (struct vfs_class *me, const char *path1, const char *path2)
1716 {
1717     ftpfs_send_command(me, path1, "RNFR /%s", OPT_FLUSH);
1718     return ftpfs_send_command(me, path2, "RNTO /%s", OPT_FLUSH);
1719 }
1720
1721 static int ftpfs_mkdir (struct vfs_class *me, const char *path, mode_t mode)
1722 {
1723     (void) mode; /* FIXME: should be used */
1724
1725     return ftpfs_send_command(me, path, "MKD /%s", OPT_FLUSH);
1726 }
1727
1728 static int ftpfs_rmdir (struct vfs_class *me, const char *path)
1729 {
1730     return ftpfs_send_command(me, path, "RMD /%s", OPT_FLUSH);
1731 }
1732
1733 static int
1734 ftpfs_fh_open (struct vfs_class *me, struct vfs_s_fh *fh, int flags,
1735                int mode)
1736 {
1737     (void) mode;
1738
1739     fh->u.ftp.append = 0;
1740     /* File will be written only, so no need to retrieve it from ftp server */
1741     if (((flags & O_WRONLY) == O_WRONLY) && !(flags & (O_RDONLY | O_RDWR))) {
1742 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1743         struct linger li;
1744 #else
1745         int li = 1;
1746 #endif
1747         char *name;
1748
1749         /* ftpfs_linear_start() called, so data will be written
1750          * to local temporary file and stored to ftp server
1751          * by vfs_s_close later
1752          */
1753         if (FH_SUPER->u.ftp.ctl_connection_busy) {
1754             if (!fh->ino->localname) {
1755                 int handle = vfs_mkstemps (&fh->ino->localname, me->name,
1756                                            fh->ino->ent->name);
1757                 if (handle == -1)
1758                     return -1;
1759                 close (handle);
1760                 fh->u.ftp.append = flags & O_APPEND;
1761             }
1762             return 0;
1763         }
1764         name = vfs_s_fullpath (me, fh->ino);
1765         if (!name)
1766             return -1;
1767         fh->handle =
1768             ftpfs_open_data_connection (me, fh->ino->super,
1769                                         (flags & O_APPEND) ? "APPE" :
1770                                         "STOR", name, TYPE_BINARY, 0);
1771         g_free (name);
1772
1773         if (fh->handle < 0)
1774             return -1;
1775 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1776         li.l_onoff = 1;
1777         li.l_linger = 120;
1778 #endif
1779         setsockopt (fh->handle, SOL_SOCKET, SO_LINGER, &li, sizeof (li));
1780
1781         if (fh->ino->localname) {
1782             unlink (fh->ino->localname);
1783             g_free (fh->ino->localname);
1784             fh->ino->localname = NULL;
1785         }
1786         return 0;
1787     }
1788
1789     if (!fh->ino->localname)
1790         if (vfs_s_retrieve_file (me, fh->ino) == -1)
1791             return -1;
1792     if (!fh->ino->localname)
1793         vfs_die ("retrieve_file failed to fill in localname");
1794     return 0;
1795 }
1796
1797 static int ftpfs_fh_close (struct vfs_class *me, struct vfs_s_fh *fh)
1798 {
1799     if (fh->handle != -1 && !fh->ino->localname){
1800         close (fh->handle);
1801         fh->handle = -1;
1802         /* File is stored to destination already, so
1803          * we prevent MEDATA->ftpfs_file_store() call from vfs_s_close ()
1804          */
1805         fh->changed = 0;
1806         if (ftpfs_get_reply (me, fh->ino->SUP.sock, NULL, 0) != COMPLETE)
1807             ERRNOR (EIO, -1);
1808         vfs_s_invalidate (me, FH_SUPER);
1809     }
1810     return 0;
1811 }
1812
1813 static void
1814 ftpfs_done (struct vfs_class *me)
1815 {
1816     struct no_proxy_entry *np;
1817
1818     (void) me;
1819
1820     while (no_proxy) {
1821         np = no_proxy->next;
1822         g_free (no_proxy->domain);
1823         g_free (no_proxy);
1824         no_proxy = np;
1825     }
1826     g_free (ftpfs_anonymous_passwd);
1827     g_free (ftpfs_proxy_host);
1828 }
1829
1830 static void
1831 ftpfs_fill_names (struct vfs_class *me, fill_names_f func)
1832 {
1833     struct vfs_s_super *super = MEDATA->supers;
1834     char *name;
1835
1836     while (super){
1837         name = g_strconcat ("/#ftp:", SUP.user, "@", SUP.host, "/", SUP.cwdir, (char *) NULL);
1838         (*func)(name);
1839         g_free (name);
1840         super = super->next;
1841     }
1842 }
1843
1844 static char buffer[BUF_MEDIUM];
1845 static char *netrc;
1846 static const char *netrcp;
1847
1848 /* This should match the keywords[] array below */
1849 typedef enum {
1850     NETRC_NONE = 0,
1851     NETRC_DEFAULT,
1852     NETRC_MACHINE,
1853     NETRC_LOGIN,
1854     NETRC_PASSWORD,
1855     NETRC_PASSWD,
1856     NETRC_ACCOUNT,
1857     NETRC_MACDEF,
1858     NETRC_UNKNOWN
1859 } keyword_t;
1860
1861 static keyword_t ftpfs_netrc_next (void)
1862 {
1863     char *p;
1864     keyword_t i;
1865     static const char *const keywords[] = { "default", "machine",
1866         "login", "password", "passwd", "account", "macdef", NULL
1867     };
1868
1869
1870     while (1) {
1871         netrcp = skip_separators (netrcp);
1872         if (*netrcp != '\n')
1873             break;
1874         netrcp++;
1875     }
1876     if (!*netrcp)
1877         return NETRC_NONE;
1878     p = buffer;
1879     if (*netrcp == '"') {
1880         for (netrcp++; *netrcp != '"' && *netrcp; netrcp++) {
1881             if (*netrcp == '\\')
1882                 netrcp++;
1883             *p++ = *netrcp;
1884         }
1885     } else {
1886         for (; *netrcp != '\n' && *netrcp != '\t' && *netrcp != ' ' &&
1887              *netrcp != ',' && *netrcp; netrcp++) {
1888             if (*netrcp == '\\')
1889                 netrcp++;
1890             *p++ = *netrcp;
1891         }
1892     }
1893     *p = 0;
1894     if (!*buffer)
1895         return NETRC_NONE;
1896
1897     i = NETRC_DEFAULT;
1898     while (keywords[i - 1]) {
1899         if (!strcmp (keywords[i - 1], buffer))
1900             return i;
1901
1902         i++;
1903     }
1904
1905     return NETRC_UNKNOWN;
1906 }
1907
1908 static int ftpfs_netrc_bad_mode (const char *netrcname)
1909 {
1910     static int be_angry = 1;
1911     struct stat mystat;
1912
1913     if (stat (netrcname, &mystat) >= 0 && (mystat.st_mode & 077)) {
1914         if (be_angry) {
1915             message (D_ERROR, MSG_ERROR,
1916                         _("~/.netrc file has incorrect mode.\n"
1917                           "Remove password or correct mode."));
1918             be_angry = 0;
1919         }
1920         return 1;
1921     }
1922     return 0;
1923 }
1924
1925 /* Scan .netrc until we find matching "machine" or "default"
1926  * domain is used for additional matching
1927  * No search is done after "default" in compliance with "man netrc"
1928  * Return 0 if found, -1 otherwise */
1929 static int ftpfs_find_machine (const char *host, const char *domain)
1930 {
1931     keyword_t keyword;
1932
1933     while ((keyword = ftpfs_netrc_next ()) != NETRC_NONE) {
1934         if (keyword == NETRC_DEFAULT)
1935             return 0;
1936
1937         if (keyword == NETRC_MACDEF) {
1938             /* Scan for an empty line, which concludes "macdef" */
1939             do {
1940                 while (*netrcp && *netrcp != '\n')
1941                     netrcp++;
1942                 if (*netrcp != '\n')
1943                     break;
1944                 netrcp++;
1945             } while (*netrcp && *netrcp != '\n');
1946             continue;
1947         }
1948
1949         if (keyword != NETRC_MACHINE)
1950             continue;
1951
1952         /* Take machine name */
1953         if (ftpfs_netrc_next () == NETRC_NONE)
1954             break;
1955
1956         if (g_strcasecmp (host, buffer)) {
1957             /* Try adding our domain to short names in .netrc */
1958             const char *host_domain = strchr (host, '.');
1959             if (!host_domain)
1960                 continue;
1961
1962             /* Compare domain part */
1963             if (g_strcasecmp (host_domain, domain))
1964                 continue;
1965
1966             /* Compare local part */
1967             if (g_strncasecmp (host, buffer, host_domain - host))
1968                 continue;
1969         }
1970
1971         return 0;
1972     }
1973
1974     /* end of .netrc */
1975     return -1;
1976 }
1977
1978 /* Extract login and password from .netrc for the host.
1979  * pass may be NULL.
1980  * Returns 0 for success, -1 for error */
1981 static int ftpfs_netrc_lookup (const char *host, char **login, char **pass)
1982 {
1983     char *netrcname;
1984     char *tmp_pass = NULL;
1985     char hostname[MAXHOSTNAMELEN];
1986     const char *domain;
1987     keyword_t keyword;
1988     static struct rupcache {
1989         struct rupcache *next;
1990         char *host;
1991         char *login;
1992         char *pass;
1993     } *rup_cache = NULL, *rupp;
1994
1995     /* Initialize *login and *pass */
1996     if (!login)
1997         return 0;
1998     *login = NULL;
1999     if (pass)
2000         *pass = NULL;
2001
2002     /* Look up in the cache first */
2003     for (rupp = rup_cache; rupp != NULL; rupp = rupp->next) {
2004         if (!strcmp (host, rupp->host)) {
2005             if (rupp->login)
2006                 *login = g_strdup (rupp->login);
2007             if (pass && rupp->pass)
2008                 *pass = g_strdup (rupp->pass);
2009             return 0;
2010         }
2011     }
2012
2013     /* Load current .netrc */
2014     netrcname = concat_dir_and_file (home_dir, ".netrc");
2015     netrcp = netrc = load_file (netrcname);
2016     if (netrc == NULL) {
2017         g_free (netrcname);
2018         return 0;
2019     }
2020
2021     /* Find our own domain name */
2022     if (gethostname (hostname, sizeof (hostname)) < 0)
2023         *hostname = 0;
2024     if (!(domain = strchr (hostname, '.')))
2025         domain = "";
2026
2027     /* Scan for "default" and matching "machine" keywords */
2028     ftpfs_find_machine (host, domain);
2029
2030     /* Scan for keywords following "default" and "machine" */
2031     while (1) {
2032         int need_break = 0;
2033         keyword = ftpfs_netrc_next ();
2034
2035         switch (keyword) {
2036         case NETRC_LOGIN:
2037             if (ftpfs_netrc_next () == NETRC_NONE) {
2038                 need_break = 1;
2039                 break;
2040             }
2041
2042             /* We have another name already - should not happen */
2043             if (*login) {
2044                 need_break = 1;
2045                 break;
2046             }
2047
2048             /* We have login name now */
2049             *login = g_strdup (buffer);
2050             break;
2051
2052         case NETRC_PASSWORD:
2053         case NETRC_PASSWD:
2054             if (ftpfs_netrc_next () == NETRC_NONE) {
2055                 need_break = 1;
2056                 break;
2057             }
2058
2059             /* Ignore unsafe passwords */
2060             if (strcmp (*login, "anonymous") && strcmp (*login, "ftp")
2061                 && ftpfs_netrc_bad_mode (netrcname)) {
2062                 need_break = 1;
2063                 break;
2064             }
2065
2066             /* Remember password.  pass may be NULL, so use tmp_pass */
2067             if (tmp_pass == NULL)
2068                 tmp_pass = g_strdup (buffer);
2069             break;
2070
2071         case NETRC_ACCOUNT:
2072             /* "account" is followed by a token which we ignore */
2073             if (ftpfs_netrc_next () == NETRC_NONE) {
2074                 need_break = 1;
2075                 break;
2076             }
2077
2078             /* Ignore account, but warn user anyways */
2079             ftpfs_netrc_bad_mode (netrcname);
2080             break;
2081
2082         default:
2083             /* Unexpected keyword or end of file */
2084             need_break = 1;
2085             break;
2086         }
2087
2088         if (need_break)
2089             break;
2090     }
2091
2092     g_free (netrc);
2093     g_free (netrcname);
2094
2095     rupp = g_new (struct rupcache, 1);
2096     rupp->host = g_strdup (host);
2097     rupp->login = rupp->pass = 0;
2098
2099     if (*login != NULL) {
2100         rupp->login = g_strdup (*login);
2101     }
2102     if (tmp_pass != NULL)
2103         rupp->pass = g_strdup (tmp_pass);
2104     rupp->next = rup_cache;
2105     rup_cache = rupp;
2106
2107     if (pass)
2108         *pass = tmp_pass;
2109
2110     return 0;
2111 }
2112
2113 void
2114 init_ftpfs (void)
2115 {
2116     static struct vfs_s_subclass ftpfs_subclass;
2117
2118     ftpfs_subclass.flags = VFS_S_REMOTE;
2119     ftpfs_subclass.archive_same = ftpfs_archive_same;
2120     ftpfs_subclass.open_archive = ftpfs_open_archive;
2121     ftpfs_subclass.free_archive = ftpfs_free_archive;
2122     ftpfs_subclass.fh_open = ftpfs_fh_open;
2123     ftpfs_subclass.fh_close = ftpfs_fh_close;
2124     ftpfs_subclass.dir_load = ftpfs_dir_load;
2125     ftpfs_subclass.file_store = ftpfs_file_store;
2126     ftpfs_subclass.linear_start = ftpfs_linear_start;
2127     ftpfs_subclass.linear_read = ftpfs_linear_read;
2128     ftpfs_subclass.linear_close = ftpfs_linear_close;
2129
2130     vfs_s_init_class (&vfs_ftpfs_ops, &ftpfs_subclass);
2131     vfs_ftpfs_ops.name = "ftpfs";
2132     vfs_ftpfs_ops.flags = VFSF_NOLINKS;
2133     vfs_ftpfs_ops.prefix = "ftp:";
2134     vfs_ftpfs_ops.done = &ftpfs_done;
2135     vfs_ftpfs_ops.fill_names = ftpfs_fill_names;
2136     vfs_ftpfs_ops.chmod = ftpfs_chmod;
2137     vfs_ftpfs_ops.chown = ftpfs_chown;
2138     vfs_ftpfs_ops.unlink = ftpfs_unlink;
2139     vfs_ftpfs_ops.rename = ftpfs_rename;
2140     vfs_ftpfs_ops.mkdir = ftpfs_mkdir;
2141     vfs_ftpfs_ops.rmdir = ftpfs_rmdir;
2142     vfs_ftpfs_ops.ctl = ftpfs_ctl;
2143     vfs_register_class (&vfs_ftpfs_ops);
2144 }