src/vfs/ftpfs/ftpfs.c

   1 /*
   2    Virtual File System: FTP file system.
   3
   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.
   7
   8    Written by:
   9    Ching Hui, 1995
  10    Jakub Jelinek, 1995
  11    Miguel de Icaza, 1995, 1996, 1997
  12    Norbert Warmuth, 1997
  13    Pavel Machek, 1998
  14    Yury V. Zaytsev, 2010
  15    Slava Zanko <slavazanko@gmail.com>, 2010
  16    Andrew Borodin <aborodin@vmail.ru>, 2010
  17
  18    This file is part of the Midnight Commander.
  19
  20    The Midnight Commander is free software: you can redistribute it
  21    and/or modify it under the terms of the GNU General Public License as
  22    published by the Free Software Foundation, either version 3 of the License,
  23    or (at your option) any later version.
  24
  25    The Midnight Commander is distributed in the hope that it will be useful,
  26    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28    GNU General Public License for more details.
  29
  30    You should have received a copy of the GNU General Public License
  31    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  32  */
  33
  34 /**
  35  * \file
  36  * \brief Source: Virtual File System: FTP file system
  37  * \author Ching Hui
  38  * \author Jakub Jelinek
  39  * \author Miguel de Icaza
  40  * \author Norbert Warmuth
  41  * \author Pavel Machek
  42  * \date 1995, 1997, 1998
  43  *
  44  * \todo
  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.
  51
  52 What to do with this?
  53
  54
  55      * NOTE: Usage of tildes is deprecated, consider:
  56      * \verbatim
  57          cd ftp//:pavel@hobit
  58          cd ~
  59        \endverbatim
  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...
  62      *
  63     \verbatim
  64     {
  65         int f = !strcmp( remote_path, "/~" );
  66         if (f || !strncmp( remote_path, "/~/", 3 )) {
  67             char *s;
  68             s = mc_build_filename ( qhome (*bucket), remote_path +3-f, NULL );
  69             g_free (remote_path);
  70             remote_path = s;
  71         }
  72     }
  73     \endverbatim
  74  */
  75
  76 /* \todo Fix: Namespace pollution: horrible */
  77
  78 #include <config.h>
  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>
  87 #endif
  88 #include <arpa/ftp.h>
  89 #include <arpa/telnet.h>
  90 #ifdef HAVE_SYS_PARAM_H
  91 #include <sys/param.h>
  92 #endif
  93 #include <errno.h>
  94 #include <ctype.h>
  95 #include <fcntl.h>
  96 #include <sys/time.h>           /* gettimeofday() */
  97 #include <inttypes.h>           /* uintmax_t */
  98
  99 #include "lib/global.h"
 100 #include "lib/util.h"
 101 #include "lib/mcconfig.h"
 102
 103 #include "lib/tty/tty.h"        /* enable/disable interrupt key */
 104 #include "lib/widget.h"         /* message() */
 105
 106 #include "src/history.h"
 107 #include "src/setup.h"          /* for load_anon_passwd */
 108
 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 */
 114
 115 #include "ftpfs.h"
 116
 117 /*** global variables ****************************************************************************/
 118
 119 /* Delay to retry a connection */
 120 int ftpfs_retry_seconds = 30;
 121
 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;
 125
 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
 130  */
 131 int ftpfs_use_unix_list_options = 1;
 132
 133 /* First "CWD <path>", then "LIST -la ." */
 134 int ftpfs_first_cd_then_ls = 1;
 135
 136 /* Use the ~/.netrc */
 137 int ftpfs_use_netrc = 1;
 138
 139 /* Anonymous setup */
 140 char *ftpfs_anonymous_passwd = NULL;
 141 int ftpfs_directory_timeout = 900;
 142
 143 /* Proxy host */
 144 char *ftpfs_proxy_host = NULL;
 145
 146 /* wether we have to use proxy by default? */
 147 int ftpfs_always_use_proxy = 0;
 148
 149 int ftpfs_ignore_chattr_errors = 1;
 150
 151 /*** file scope macro definitions ****************************************************************/
 152
 153 #ifndef MAXHOSTNAMELEN
 154 #define MAXHOSTNAMELEN 64
 155 #endif
 156
 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
 160
 161 #ifndef INADDR_NONE
 162 #define INADDR_NONE 0xffffffff
 163 #endif
 164
 165 #define RFC_AUTODETECT 0
 166 #define RFC_DARING 1
 167 #define RFC_STRICT 2
 168
 169 /* ftpfs_command wait_flag: */
 170 #define NONE        0x00
 171 #define WAIT_REPLY  0x01
 172 #define WANT_STRING 0x02
 173
 174 #define FTP_COMMAND_PORT   21
 175
 176 /* some defines only used by ftpfs_changetype */
 177 /* These two are valid values for the second parameter */
 178 #define TYPE_ASCII    0
 179 #define TYPE_BINARY   1
 180
 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
 184
 185 #define ABORT_TIMEOUT 5
 186 /*** file scope type declarations ****************************************************************/
 187
 188 #ifndef HAVE_SOCKLEN_T
 189 typedef int socklen_t;
 190 #endif
 191
 192 /* This should match the keywords[] array below */
 193 typedef enum
 194 {
 195     NETRC_NONE = 0,
 196     NETRC_DEFAULT,
 197     NETRC_MACHINE,
 198     NETRC_LOGIN,
 199     NETRC_PASSWORD,
 200     NETRC_PASSWD,
 201     NETRC_ACCOUNT,
 202     NETRC_MACDEF,
 203     NETRC_UNKNOWN
 204 } keyword_t;
 205
 206 typedef struct
 207 {
 208     int sock;
 209
 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) */
 214     int isbinary;
 215     int cwd_deferred;           /* current_directory was changed but CWD command hasn't
 216                                    been sent yet */
 217     int strict;                 /* ftp server doesn't understand
 218                                  * "LIST -la <path>"; use "CWD <path>"/
 219                                  * "LIST" instead
 220                                  */
 221     int ctl_connection_busy;
 222     char *current_dir;
 223 } ftp_super_data_t;
 224
 225 typedef struct
 226 {
 227     int sock;
 228     int append;
 229 } ftp_fh_data_t;
 230
 231 /*** file scope variables ************************************************************************/
 232
 233 static int ftpfs_errno;
 234 static int code;
 235
 236 #ifdef FIXME_LATER_ALIGATOR
 237 static struct linklist *connections_list;
 238 #endif
 239
 240 static char reply_str[80];
 241
 242 static struct vfs_class vfs_ftpfs_ops;
 243
 244 static GSList *no_proxy;
 245
 246 static char buffer[BUF_MEDIUM];
 247 static char *netrc;
 248 static const char *netrcp;
 249
 250 /*** file scope functions ************************************************************************/
 251 /* --------------------------------------------------------------------------------------------- */
 252
 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.
 259
 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 "/."
 264  */
 265
 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);
 275
 276 /* --------------------------------------------------------------------------------------------- */
 277
 278 static char *
 279 ftpfs_translate_path (struct vfs_class *me, struct vfs_s_super *super, const char *remote_path)
 280 {
 281     if (!SUP->remote_is_amiga)
 282         return g_strdup (remote_path);
 283     else
 284     {
 285         char *ret, *p;
 286
 287         if (MEDATA->logfile)
 288         {
 289             fprintf (MEDATA->logfile, "MC -- ftpfs_translate_path: %s\n", remote_path);
 290             fflush (MEDATA->logfile);
 291         }
 292
 293         /* strip leading slash(es) */
 294         while (*remote_path == '/')
 295             remote_path++;
 296
 297         /*
 298          * Don't change "/" into "", e.g. "CWD " would be
 299          * invalid.
 300          */
 301         if (*remote_path == '\0')
 302             return g_strdup (".");
 303
 304         ret = g_strdup (remote_path);
 305
 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);
 310
 311         /* strip trailing "/." */
 312         p = strrchr (ret, '/');
 313         if ((p != NULL) && (*(p + 1) == '.') && (*(p + 2) == '\0'))
 314             *p = '\0';
 315
 316         return ret;
 317     }
 318 }
 319
 320 /* --------------------------------------------------------------------------------------------- */
 321 /** Extract the hostname and username from the path */
 322 /*
 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
 329  * is supplied.
 330  */
 331
 332 static vfs_path_element_t *
 333 ftpfs_correct_url_parameters (const vfs_path_element_t * velement)
 334 {
 335     vfs_path_element_t *path_element = vfs_path_element_clone (velement);
 336
 337     if (path_element->port == 0)
 338         path_element->port = FTP_COMMAND_PORT;
 339
 340     if (path_element->user == NULL)
 341     {
 342         /* Look up user and password in netrc */
 343         if (ftpfs_use_netrc)
 344             ftpfs_netrc_lookup (path_element->host, &path_element->user, &path_element->password);
 345     }
 346     if (path_element->user == NULL)
 347         path_element->user = g_strdup ("anonymous");
 348
 349     /* Look up password in netrc for known user */
 350     if (ftpfs_use_netrc && path_element->user != NULL && path_element->password != NULL)
 351     {
 352         char *new_user = NULL;
 353         char *new_passwd = NULL;
 354
 355         ftpfs_netrc_lookup (path_element->host, &new_user, &new_passwd);
 356
 357         /* If user is different, remove password */
 358         if (new_user != NULL && strcmp (path_element->user, new_user) != 0)
 359         {
 360             g_free (path_element->password);
 361             path_element->password = NULL;
 362         }
 363
 364         g_free (new_user);
 365         g_free (new_passwd);
 366     }
 367
 368     return path_element;
 369 }
 370
 371 /* --------------------------------------------------------------------------------------------- */
 372 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
 373
 374 static int
 375 ftpfs_get_reply (struct vfs_class *me, int sock, char *string_buf, int string_len)
 376 {
 377     char answer[BUF_1K];
 378     int i;
 379
 380     for (;;)
 381     {
 382         if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n'))
 383         {
 384             if (string_buf)
 385                 *string_buf = 0;
 386             code = 421;
 387             return 4;
 388         }
 389         switch (sscanf (answer, "%d", &code))
 390         {
 391         case 0:
 392             if (string_buf)
 393                 g_strlcpy (string_buf, answer, string_len);
 394             code = 500;
 395             return 5;
 396         case 1:
 397             if (answer[3] == '-')
 398             {
 399                 while (1)
 400                 {
 401                     if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n'))
 402                     {
 403                         if (string_buf)
 404                             *string_buf = 0;
 405                         code = 421;
 406                         return 4;
 407                     }
 408                     if ((sscanf (answer, "%d", &i) > 0) && (code == i) && (answer[3] == ' '))
 409                         break;
 410                 }
 411             }
 412             if (string_buf)
 413                 g_strlcpy (string_buf, answer, string_len);
 414             return code / 100;
 415         }
 416     }
 417 }
 418
 419 /* --------------------------------------------------------------------------------------------- */
 420
 421 static int
 422 ftpfs_reconnect (struct vfs_class *me, struct vfs_s_super *super)
 423 {
 424     int sock;
 425
 426     sock = ftpfs_open_socket (me, super);
 427     if (sock != -1)
 428     {
 429         char *cwdir = SUP->current_dir;
 430
 431         close (SUP->sock);
 432         SUP->sock = sock;
 433         SUP->current_dir = NULL;
 434
 435
 436         if (ftpfs_login_server (me, super, super->path_element->password) != 0)
 437         {
 438             if (cwdir == NULL)
 439                 return 1;
 440             sock = ftpfs_chdir_internal (me, super, cwdir);
 441             g_free (cwdir);
 442             return sock == COMPLETE ? 1 : 0;
 443         }
 444
 445         SUP->current_dir = cwdir;
 446     }
 447
 448     return 0;
 449 }
 450
 451 /* --------------------------------------------------------------------------------------------- */
 452
 453 static int
 454 ftpfs_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, const char *fmt,
 455                ...)
 456 {
 457     va_list ap;
 458     char *cmdstr;
 459     int status, cmdlen;
 460     static int retry = 0;
 461     static int level = 0;       /* ftpfs_login_server() use ftpfs_command() */
 462
 463     va_start (ap, fmt);
 464     cmdstr = g_strdup_vprintf (fmt, ap);
 465     va_end (ap);
 466
 467     cmdlen = strlen (cmdstr);
 468     cmdstr = g_realloc (cmdstr, cmdlen + 3);
 469     strcpy (cmdstr + cmdlen, "\r\n");
 470     cmdlen += 2;
 471
 472     if (MEDATA->logfile)
 473     {
 474         if (strncmp (cmdstr, "PASS ", 5) == 0)
 475         {
 476             fputs ("PASS <Password not logged>\r\n", MEDATA->logfile);
 477         }
 478         else
 479         {
 480             size_t ret;
 481             ret = fwrite (cmdstr, cmdlen, 1, MEDATA->logfile);
 482         }
 483
 484         fflush (MEDATA->logfile);
 485     }
 486
 487     got_sigpipe = 0;
 488     tty_enable_interrupt_key ();
 489     status = write (SUP->sock, cmdstr, cmdlen);
 490
 491     if (status < 0)
 492     {
 493         code = 421;
 494
 495         if (errno == EPIPE)
 496         {                       /* Remote server has closed connection */
 497             if (level == 0)
 498             {
 499                 level = 1;
 500                 status = ftpfs_reconnect (me, super);
 501                 level = 0;
 502                 if (status && (write (SUP->sock, cmdstr, cmdlen) > 0))
 503                 {
 504                     goto ok;
 505                 }
 506
 507             }
 508             got_sigpipe = 1;
 509         }
 510         g_free (cmdstr);
 511         tty_disable_interrupt_key ();
 512         return TRANSIENT;
 513     }
 514     retry = 0;
 515   ok:
 516     tty_disable_interrupt_key ();
 517
 518     if (wait_reply)
 519     {
 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)
 524         {
 525             retry = 1;
 526             level = 1;
 527             status = ftpfs_reconnect (me, super);
 528             level = 0;
 529             if (status && (write (SUP->sock, cmdstr, cmdlen) > 0))
 530             {
 531                 goto ok;
 532             }
 533         }
 534         retry = 0;
 535         g_free (cmdstr);
 536         return status;
 537     }
 538     g_free (cmdstr);
 539     return COMPLETE;
 540 }
 541
 542 /* --------------------------------------------------------------------------------------------- */
 543
 544 static void
 545 ftpfs_free_archive (struct vfs_class *me, struct vfs_s_super *super)
 546 {
 547     if (SUP->sock != -1)
 548     {
 549         vfs_print_message (_("ftpfs: Disconnecting from %s"), super->path_element->host);
 550         ftpfs_command (me, super, NONE, "QUIT");
 551         close (SUP->sock);
 552     }
 553     g_free (SUP->current_dir);
 554     g_free (super->data);
 555     super->data = NULL;
 556 }
 557
 558 /* --------------------------------------------------------------------------------------------- */
 559
 560 static int
 561 ftpfs_changetype (struct vfs_class *me, struct vfs_s_super *super, int binary)
 562 {
 563     if (binary != SUP->isbinary)
 564     {
 565         if (ftpfs_command (me, super, WAIT_REPLY, "TYPE %c", binary ? 'I' : 'A') != COMPLETE)
 566             ERRNOR (EIO, -1);
 567         SUP->isbinary = binary;
 568     }
 569     return binary;
 570 }
 571
 572 /* --------------------------------------------------------------------------------------------- */
 573 /* This routine logs the user in */
 574
 575 static int
 576 ftpfs_login_server (struct vfs_class *me, struct vfs_s_super *super, const char *netrcpass)
 577 {
 578     char *pass;
 579     char *op;
 580     char *name;                 /* login user name */
 581     int anon = 0;
 582     char reply_string[BUF_MEDIUM];
 583
 584     SUP->isbinary = TYPE_UNKNOWN;
 585
 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)
 592     {
 593         if (ftpfs_anonymous_passwd == NULL)     /* default anonymous password */
 594             ftpfs_init_passwd ();
 595         op = g_strdup (ftpfs_anonymous_passwd);
 596         anon = 1;
 597     }
 598     else
 599     {                           /* ask user */
 600         char *p;
 601
 602         p = g_strdup_printf (_("FTP: Password required for %s"), super->path_element->user);
 603         op = vfs_get_password (p);
 604         g_free (p);
 605         if (op == NULL)
 606             ERRNOR (EPERM, 0);
 607         super->path_element->password = g_strdup (op);
 608     }
 609
 610     if (!anon || MEDATA->logfile)
 611         pass = op;
 612     else
 613     {
 614         pass = g_strconcat ("-", op, (char *) NULL);
 615         wipe_password (op);
 616     }
 617
 618     /* Proxy server accepts: username@host-we-want-to-connect */
 619     if (SUP->proxy)
 620         name =
 621             g_strconcat (super->path_element->user, "@",
 622                          super->path_element->host[0] ==
 623                          '!' ? super->path_element->host + 1 : super->path_element->host,
 624                          (char *) NULL);
 625     else
 626         name = g_strdup (super->path_element->user);
 627
 628     if (ftpfs_get_reply (me, SUP->sock, reply_string, sizeof (reply_string) - 1) == COMPLETE)
 629     {
 630         char *reply_up;
 631
 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;
 636         g_free (reply_up);
 637
 638         if (MEDATA->logfile)
 639         {
 640             fprintf (MEDATA->logfile, "MC -- remote_is_amiga =  %d\n", SUP->remote_is_amiga);
 641             fflush (MEDATA->logfile);
 642         }
 643
 644         vfs_print_message (_("ftpfs: sending login name"));
 645
 646         switch (ftpfs_command (me, super, WAIT_REPLY, "USER %s", name))
 647         {
 648         case CONTINUE:
 649             vfs_print_message (_("ftpfs: sending user password"));
 650             code = ftpfs_command (me, super, WAIT_REPLY, "PASS %s", pass);
 651             if (code == CONTINUE)
 652             {
 653                 char *p;
 654
 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                 g_free (p);
 659                 if (op == NULL)
 660                     ERRNOR (EPERM, 0);
 661                 vfs_print_message (_("ftpfs: sending user account"));
 662                 code = ftpfs_command (me, super, WAIT_REPLY, "ACCT %s", op);
 663                 g_free (op);
 664             }
 665             if (code != COMPLETE)
 666                 break;
 667             /* fall through */
 668
 669         case COMPLETE:
 670             vfs_print_message (_("ftpfs: logged in"));
 671             wipe_password (pass);
 672             g_free (name);
 673             return 1;
 674
 675         default:
 676             SUP->failed_on_login = 1;
 677             wipe_password (super->path_element->password);
 678             super->path_element->password = NULL;
 679
 680             goto login_fail;
 681         }
 682     }
 683
 684     message (D_ERROR, MSG_ERROR, _("ftpfs: Login incorrect for user %s "),
 685              super->path_element->user);
 686
 687   login_fail:
 688     wipe_password (pass);
 689     g_free (name);
 690     ERRNOR (EPERM, 0);
 691 }
 692
 693 /* --------------------------------------------------------------------------------------------- */
 694
 695 static void
 696 ftpfs_load_no_proxy_list (void)
 697 {
 698     /* FixMe: shouldn't be hardcoded!!! */
 699     char s[BUF_LARGE];          /* provide for BUF_LARGE characters */
 700     FILE *npf;
 701     int c;
 702     char *p;
 703     static char *mc_file = NULL;
 704
 705     mc_file = g_build_filename (mc_global.sysconfig_dir, "mc.no_proxy", (char *) NULL);
 706     if (exist_file (mc_file))
 707     {
 708         npf = fopen (mc_file, "r");
 709         if (npf != NULL)
 710         {
 711             while (fgets (s, sizeof (s), npf) != NULL)
 712             {
 713                 p = strchr (s, '\n');
 714                 if (p == NULL)  /* skip bogus entries */
 715                 {
 716                     while ((c = fgetc (npf)) != EOF && c != '\n')
 717                         ;
 718                     continue;
 719                 }
 720
 721                 if (p != s)
 722                 {
 723                     *p = '\0';
 724                     no_proxy = g_slist_prepend (no_proxy, g_strdup (s));
 725                 }
 726             }
 727             fclose (npf);
 728         }
 729     }
 730     g_free (mc_file);
 731 }
 732
 733 /* --------------------------------------------------------------------------------------------- */
 734 /* Return 1 if FTP proxy should be used for this host, 0 otherwise */
 735
 736 static int
 737 ftpfs_check_proxy (const char *host)
 738 {
 739     GSList *npe;
 740
 741     if (ftpfs_proxy_host == NULL || *ftpfs_proxy_host == '\0' || host == NULL || *host == '\0')
 742         return 0;               /* sanity check */
 743
 744     if (*host == '!')
 745         return 1;
 746
 747     if (!ftpfs_always_use_proxy)
 748         return 0;
 749
 750     if (strchr (host, '.') == NULL)
 751         return 0;
 752
 753     ftpfs_load_no_proxy_list ();
 754     for (npe = no_proxy; npe != NULL; npe = g_slist_next (npe))
 755     {
 756         const char *domain = (const char *) npe->data;
 757
 758         if (domain[0] == '.')
 759         {
 760             size_t ld = strlen (domain);
 761             size_t lh = strlen (host);
 762
 763             while (ld != 0 && lh != 0 && host[lh - 1] == domain[ld - 1])
 764             {
 765                 ld--;
 766                 lh--;
 767             }
 768
 769             if (ld == 0)
 770                 return 0;
 771         }
 772         else if (g_ascii_strcasecmp (host, domain) == 0)
 773             return 0;
 774     }
 775
 776     return 1;
 777 }
 778
 779 /* --------------------------------------------------------------------------------------------- */
 780
 781 static void
 782 ftpfs_get_proxy_host_and_port (const char *proxy, char **host, int *port)
 783 {
 784     vfs_path_element_t *path_element;
 785
 786     path_element = vfs_url_split (proxy, FTP_COMMAND_PORT, URL_USE_ANONYMOUS);
 787     *host = g_strdup (path_element->host);
 788     *port = path_element->port;
 789     vfs_path_element_free (path_element);
 790 }
 791
 792 /* --------------------------------------------------------------------------------------------- */
 793
 794 static int
 795 ftpfs_open_socket (struct vfs_class *me, struct vfs_s_super *super)
 796 {
 797     struct addrinfo hints, *res, *curr_res;
 798     int my_socket = 0;
 799     char *host = NULL;
 800     char port[8];
 801     int tmp_port;
 802     int e;
 803
 804     (void) me;
 805
 806     /* Use a proxy host? */
 807     host = g_strdup (super->path_element->host);
 808
 809     if (host == NULL || *host == '\0')
 810     {
 811         vfs_print_message (_("ftpfs: Invalid host name."));
 812         ftpfs_errno = EINVAL;
 813         g_free (host);
 814         return -1;
 815     }
 816
 817     /* Hosts to connect to that start with a ! should use proxy */
 818     tmp_port = super->path_element->port;
 819
 820     if (SUP->proxy != NULL)
 821         ftpfs_get_proxy_host_and_port (ftpfs_proxy_host, &host, &tmp_port);
 822
 823     g_snprintf (port, sizeof (port), "%hu", (unsigned short) tmp_port);
 824     if (port[0] == '\0')
 825     {
 826         g_free (host);
 827         ftpfs_errno = errno;
 828         return -1;
 829     }
 830
 831     tty_enable_interrupt_key ();        /* clear the interrupt flag */
 832
 833     memset (&hints, 0, sizeof (struct addrinfo));
 834     hints.ai_family = AF_UNSPEC;
 835     hints.ai_socktype = SOCK_STREAM;
 836
 837 #ifdef AI_ADDRCONFIG
 838     /* By default, only look up addresses using address types for
 839      * which a local interface is configured (i.e. no IPv6 if no IPv6
 840      * interfaces, likewise for IPv4 (see RFC 3493 for details). */
 841     hints.ai_flags = AI_ADDRCONFIG;
 842 #endif
 843
 844     e = getaddrinfo (host, port, &hints, &res);
 845
 846 #ifdef AI_ADDRCONFIG
 847     if (e == EAI_BADFLAGS)
 848     {
 849         /* Retry with no flags if AI_ADDRCONFIG was rejected. */
 850         hints.ai_flags = 0;
 851         e = getaddrinfo (host, port, &hints, &res);
 852     }
 853 #endif
 854
 855     *port = '\0';
 856
 857     if (e != 0)
 858     {
 859         tty_disable_interrupt_key ();
 860         vfs_print_message (_("ftpfs: %s"), gai_strerror (e));
 861         g_free (host);
 862         ftpfs_errno = EINVAL;
 863         return -1;
 864     }
 865
 866     for (curr_res = res; curr_res != NULL; curr_res = curr_res->ai_next)
 867     {
 868         my_socket = socket (curr_res->ai_family, curr_res->ai_socktype, curr_res->ai_protocol);
 869
 870         if (my_socket < 0)
 871         {
 872             if (curr_res->ai_next != NULL)
 873                 continue;
 874
 875             tty_disable_interrupt_key ();
 876             vfs_print_message (_("ftpfs: %s"), unix_error_string (errno));
 877             g_free (host);
 878             freeaddrinfo (res);
 879             ftpfs_errno = errno;
 880             return -1;
 881         }
 882
 883         vfs_print_message (_("ftpfs: making connection to %s"), host);
 884         g_free (host);
 885         host = NULL;
 886
 887         if (connect (my_socket, curr_res->ai_addr, curr_res->ai_addrlen) >= 0)
 888             break;
 889
 890         ftpfs_errno = errno;
 891         close (my_socket);
 892
 893         if (errno == EINTR && tty_got_interrupt ())
 894             vfs_print_message (_("ftpfs: connection interrupted by user"));
 895         else if (res->ai_next == NULL)
 896             vfs_print_message (_("ftpfs: connection to server failed: %s"),
 897                                unix_error_string (errno));
 898         else
 899             continue;
 900
 901         freeaddrinfo (res);
 902         tty_disable_interrupt_key ();
 903         return -1;
 904     }
 905
 906     freeaddrinfo (res);
 907     tty_disable_interrupt_key ();
 908     return my_socket;
 909 }
 910
 911 /* --------------------------------------------------------------------------------------------- */
 912
 913 static int
 914 ftpfs_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
 915 {
 916     int retry_seconds = 0;
 917     int count_down;
 918
 919     /* We do not want to use the passive if we are using proxies */
 920     if (SUP->proxy)
 921         SUP->use_passive_connection = ftpfs_use_passive_connections_over_proxy;
 922
 923     do
 924     {
 925         SUP->failed_on_login = 0;
 926
 927         SUP->sock = ftpfs_open_socket (me, super);
 928         if (SUP->sock == -1)
 929             return -1;
 930
 931         if (ftpfs_login_server (me, super, NULL) != 0)
 932         {
 933             /* Logged in, no need to retry the connection */
 934             break;
 935         }
 936         else
 937         {
 938             if (!SUP->failed_on_login)
 939                 return -1;
 940
 941             /* Close only the socket descriptor */
 942             close (SUP->sock);
 943
 944             if (ftpfs_retry_seconds != 0)
 945             {
 946                 retry_seconds = ftpfs_retry_seconds;
 947                 tty_enable_interrupt_key ();
 948                 for (count_down = retry_seconds; count_down; count_down--)
 949                 {
 950                     vfs_print_message (_("Waiting to retry... %d (Control-G to cancel)"),
 951                                        count_down);
 952                     sleep (1);
 953                     if (tty_got_interrupt ())
 954                     {
 955                         /* ftpfs_errno = E; */
 956                         tty_disable_interrupt_key ();
 957                         return 0;
 958                     }
 959                 }
 960                 tty_disable_interrupt_key ();
 961             }
 962         }
 963     }
 964     while (retry_seconds != 0);
 965
 966     SUP->current_dir = ftpfs_get_current_directory (me, super);
 967     if (SUP->current_dir == NULL)
 968         SUP->current_dir = g_strdup (PATH_SEP_STR);
 969
 970     return 0;
 971 }
 972
 973 /* --------------------------------------------------------------------------------------------- */
 974
 975 static int
 976 ftpfs_open_archive (struct vfs_s_super *super,
 977                     const vfs_path_t * vpath, const vfs_path_element_t * vpath_element)
 978 {
 979     (void) vpath;
 980
 981     super->data = g_new0 (ftp_super_data_t, 1);
 982
 983     super->path_element = ftpfs_correct_url_parameters (vpath_element);
 984     SUP->proxy = NULL;
 985     if (ftpfs_check_proxy (super->path_element->host))
 986         SUP->proxy = ftpfs_proxy_host;
 987     SUP->use_passive_connection = ftpfs_use_passive_connections;
 988     SUP->strict = ftpfs_use_unix_list_options ? RFC_AUTODETECT : RFC_STRICT;
 989     SUP->isbinary = TYPE_UNKNOWN;
 990     SUP->remote_is_amiga = 0;
 991     super->name = g_strdup ("/");
 992     super->root =
 993         vfs_s_new_inode (vpath_element->class, super,
 994                          vfs_s_default_stat (vpath_element->class, S_IFDIR | 0755));
 995
 996     return ftpfs_open_archive_int (vpath_element->class, super);
 997 }
 998
 999 /* --------------------------------------------------------------------------------------------- */
1000
1001 static int
1002 ftpfs_archive_same (const vfs_path_element_t * vpath_element, struct vfs_s_super *super,
1003                     const vfs_path_t * vpath, void *cookie)
1004 {
1005     vfs_path_element_t *path_element;
1006     int result;
1007
1008     (void) vpath;
1009     (void) cookie;
1010
1011     path_element = ftpfs_correct_url_parameters (vpath_element);
1012
1013     result = ((strcmp (path_element->host, super->path_element->host) == 0)
1014               && (strcmp (path_element->user, super->path_element->user) == 0)
1015               && (path_element->port == super->path_element->port)) ? 1 : 0;
1016
1017     vfs_path_element_free (path_element);
1018     return result;
1019 }
1020
1021 /* --------------------------------------------------------------------------------------------- */
1022 /* The returned directory should always contain a trailing slash */
1023
1024 static char *
1025 ftpfs_get_current_directory (struct vfs_class *me, struct vfs_s_super *super)
1026 {
1027     char buf[MC_MAXPATHLEN + 1];
1028
1029     if (ftpfs_command (me, super, NONE, "PWD") == COMPLETE &&
1030         ftpfs_get_reply (me, SUP->sock, buf, sizeof (buf)) == COMPLETE)
1031     {
1032         char *bufp = NULL;
1033         char *bufq;
1034
1035         for (bufq = buf; *bufq != '\0'; bufq++)
1036             if (*bufq == '"')
1037             {
1038                 if (bufp == NULL)
1039                     bufp = bufq + 1;
1040                 else
1041                 {
1042                     *bufq = '\0';
1043
1044                     if (*bufp != '\0')
1045                     {
1046                         if (*(bufq - 1) != '/')
1047                         {
1048                             *bufq++ = '/';
1049                             *bufq = '\0';
1050                         }
1051
1052                         if (*bufp == '/')
1053                             return g_strdup (bufp);
1054
1055                         /* If the remote server is an Amiga a leading slash
1056                            might be missing. MC needs it because it is used
1057                            as separator between hostname and path internally. */
1058                         return g_strconcat ("/", bufp, (char *) NULL);
1059                     }
1060
1061                     break;
1062                 }
1063             }
1064     }
1065
1066     ftpfs_errno = EIO;
1067     return NULL;
1068 }
1069
1070 /* --------------------------------------------------------------------------------------------- */
1071 /* Setup Passive PASV FTP connection */
1072
1073 static int
1074 ftpfs_setup_passive_pasv (struct vfs_class *me, struct vfs_s_super *super,
1075                           int my_socket, struct sockaddr_storage *sa, socklen_t * salen)
1076 {
1077     char *c;
1078     char n[6];
1079     int xa, xb, xc, xd, xe, xf;
1080
1081     if (ftpfs_command (me, super, WAIT_REPLY | WANT_STRING, "PASV") != COMPLETE)
1082         return 0;
1083
1084     /* Parse remote parameters */
1085     for (c = reply_str + 4; (*c) && (!isdigit ((unsigned char) *c)); c++);
1086
1087     if (!*c)
1088         return 0;
1089     if (!isdigit ((unsigned char) *c))
1090         return 0;
1091     if (sscanf (c, "%d,%d,%d,%d,%d,%d", &xa, &xb, &xc, &xd, &xe, &xf) != 6)
1092         return 0;
1093
1094     n[0] = (unsigned char) xa;
1095     n[1] = (unsigned char) xb;
1096     n[2] = (unsigned char) xc;
1097     n[3] = (unsigned char) xd;
1098     n[4] = (unsigned char) xe;
1099     n[5] = (unsigned char) xf;
1100
1101     memcpy (&(((struct sockaddr_in *) sa)->sin_addr.s_addr), (void *) n, 4);
1102     memcpy (&(((struct sockaddr_in *) sa)->sin_port), (void *) &n[4], 2);
1103
1104     if (connect (my_socket, (struct sockaddr *) sa, *salen) < 0)
1105         return 0;
1106
1107     return 1;
1108 }
1109
1110 /* --------------------------------------------------------------------------------------------- */
1111 /* Setup Passive EPSV FTP connection */
1112
1113 static int
1114 ftpfs_setup_passive_epsv (struct vfs_class *me, struct vfs_s_super *super,
1115                           int my_socket, struct sockaddr_storage *sa, socklen_t * salen)
1116 {
1117     char *c;
1118     int port;
1119
1120     if (ftpfs_command (me, super, WAIT_REPLY | WANT_STRING, "EPSV") != COMPLETE)
1121         return 0;
1122
1123     /* (|||<port>|) */
1124     c = strchr (reply_str, '|');
1125     if (c == NULL)
1126         return 0;
1127     if (strlen (c) > 3)
1128         c += 3;
1129     else
1130         return 0;
1131
1132     port = atoi (c);
1133     if (port < 0 || port > 65535)
1134         return 0;
1135     port = htons (port);
1136
1137     switch (sa->ss_family)
1138     {
1139     case AF_INET:
1140         ((struct sockaddr_in *) sa)->sin_port = port;
1141         break;
1142     case AF_INET6:
1143         ((struct sockaddr_in6 *) sa)->sin6_port = port;
1144         break;
1145     }
1146
1147     return (connect (my_socket, (struct sockaddr *) sa, *salen) < 0) ? 0 : 1;
1148 }
1149
1150 /* --------------------------------------------------------------------------------------------- */
1151 /* Setup Passive ftp connection, we use it for source routed connections */
1152
1153 static int
1154 ftpfs_setup_passive (struct vfs_class *me, struct vfs_s_super *super,
1155                      int my_socket, struct sockaddr_storage *sa, socklen_t * salen)
1156 {
1157     /* It's IPV4, so try PASV first, some servers and ALGs get confused by EPSV */
1158     if (sa->ss_family == AF_INET)
1159     {
1160         if (!ftpfs_setup_passive_pasv (me, super, my_socket, sa, salen))
1161             /* An IPV4 FTP server might support EPSV, so if PASV fails we can try EPSV anyway */
1162             if (!ftpfs_setup_passive_epsv (me, super, my_socket, sa, salen))
1163                 return 0;
1164     }
1165     /* It's IPV6, so EPSV is our only hope */
1166     else
1167     {
1168         if (!ftpfs_setup_passive_epsv (me, super, my_socket, sa, salen))
1169             return 0;
1170     }
1171
1172     return 1;
1173 }
1174
1175 /* --------------------------------------------------------------------------------------------- */
1176 /* Setup Active PORT or EPRT FTP connection */
1177
1178 static int
1179 ftpfs_setup_active (struct vfs_class *me, struct vfs_s_super *super,
1180                     struct sockaddr_storage data_addr, socklen_t data_addrlen)
1181 {
1182     unsigned short int port;
1183     char *addr;
1184     unsigned int af;
1185
1186     switch (data_addr.ss_family)
1187     {
1188     case AF_INET:
1189         af = FTP_INET;
1190         port = ((struct sockaddr_in *) &data_addr)->sin_port;
1191         break;
1192     case AF_INET6:
1193         af = FTP_INET6;
1194         port = ((struct sockaddr_in6 *) &data_addr)->sin6_port;
1195         break;
1196         /* Not implemented */
1197     default:
1198         return 0;
1199     }
1200
1201     addr = g_try_malloc (NI_MAXHOST);
1202     if (addr == NULL)
1203         ERRNOR (ENOMEM, -1);
1204
1205     if (getnameinfo
1206         ((struct sockaddr *) &data_addr, data_addrlen, addr, NI_MAXHOST, NULL, 0,
1207          NI_NUMERICHOST) != 0)
1208     {
1209         g_free (addr);
1210         ERRNOR (EIO, -1);
1211     }
1212
1213     /* If we are talking to an IPV4 server, try PORT, and, only if it fails, go for EPRT */
1214     if (af == FTP_INET)
1215     {
1216         unsigned char *a = (unsigned char *) &((struct sockaddr_in *) &data_addr)->sin_addr;
1217         unsigned char *p = (unsigned char *) &port;
1218
1219         if (ftpfs_command (me, super, WAIT_REPLY,
1220                            "PORT %u,%u,%u,%u,%u,%u", a[0], a[1], a[2], a[3],
1221                            p[0], p[1]) == COMPLETE)
1222         {
1223             g_free (addr);
1224             return 1;
1225         }
1226     }
1227
1228     /*
1229      * Converts network MSB first order to host byte order (LSB
1230      * first on i386). If we do it earlier, we will run into an
1231      * endianness issue, because the server actually expects to see
1232      * "PORT A,D,D,R,MSB,LSB" in the PORT command.
1233      */
1234     port = ntohs (port);
1235
1236     /* We are talking to an IPV6 server or PORT failed, so we can try EPRT anyway */
1237     if (ftpfs_command (me, super, WAIT_REPLY, "EPRT |%u|%s|%hu|", af, addr, port) == COMPLETE)
1238     {
1239         g_free (addr);
1240         return 1;
1241     }
1242
1243     g_free (addr);
1244     return 0;
1245 }
1246
1247 /* --------------------------------------------------------------------------------------------- */
1248 /* Initialize a socket for FTP DATA connection */
1249
1250 static int
1251 ftpfs_init_data_socket (struct vfs_class *me, struct vfs_s_super *super,
1252                         struct sockaddr_storage *data_addr, socklen_t * data_addrlen)
1253 {
1254     int result;
1255
1256     memset (data_addr, 0, sizeof (struct sockaddr_storage));
1257     *data_addrlen = sizeof (struct sockaddr_storage);
1258
1259     if (SUP->use_passive_connection)
1260         result = getpeername (SUP->sock, (struct sockaddr *) data_addr, data_addrlen);
1261     else
1262         result = getsockname (SUP->sock, (struct sockaddr *) data_addr, data_addrlen);
1263
1264     if (result == -1)
1265         return -1;
1266
1267     switch (data_addr->ss_family)
1268     {
1269     case AF_INET:
1270         ((struct sockaddr_in *) data_addr)->sin_port = 0;
1271         break;
1272     case AF_INET6:
1273         ((struct sockaddr_in6 *) data_addr)->sin6_port = 0;
1274         break;
1275     default:
1276         vfs_print_message (_("ftpfs: invalid address family"));
1277         ERRNOR (EINVAL, -1);
1278     }
1279
1280     result = socket (data_addr->ss_family, SOCK_STREAM, IPPROTO_TCP);
1281
1282     if (result < 0)
1283     {
1284         vfs_print_message (_("ftpfs: could not create socket: %s"), unix_error_string (errno));
1285         return -1;
1286     }
1287
1288     return result;
1289 }
1290
1291 /* --------------------------------------------------------------------------------------------- */
1292 /* Initialize FTP DATA connection */
1293
1294 static int
1295 ftpfs_initconn (struct vfs_class *me, struct vfs_s_super *super)
1296 {
1297     struct sockaddr_storage data_addr;
1298     socklen_t data_addrlen;
1299
1300     /*
1301      * Don't factor socket initialization out of these conditionals,
1302      * because ftpfs_init_data_socket initializes it in different way
1303      * depending on use_passive_connection flag.
1304      */
1305
1306     /* Try to establish a passive connection first (if requested) */
1307     if (SUP->use_passive_connection)
1308     {
1309         int data_sock;
1310
1311         data_sock = ftpfs_init_data_socket (me, super, &data_addr, &data_addrlen);
1312         if (data_sock < 0)
1313             return -1;
1314
1315         if (ftpfs_setup_passive (me, super, data_sock, &data_addr, &data_addrlen))
1316             return data_sock;
1317
1318         vfs_print_message (_("ftpfs: could not setup passive mode"));
1319         SUP->use_passive_connection = 0;
1320
1321         close (data_sock);
1322     }
1323
1324     /* If passive setup is diabled or failed, fallback to active connections */
1325     if (!SUP->use_passive_connection)
1326     {
1327         int data_sock;
1328
1329         data_sock = ftpfs_init_data_socket (me, super, &data_addr, &data_addrlen);
1330         if (data_sock < 0)
1331             return -1;
1332
1333         if ((bind (data_sock, (struct sockaddr *) &data_addr, data_addrlen) == 0) &&
1334             (getsockname (data_sock, (struct sockaddr *) &data_addr, &data_addrlen) == 0) &&
1335             (listen (data_sock, 1) == 0) &&
1336             (ftpfs_setup_active (me, super, data_addr, data_addrlen) != 0))
1337             return data_sock;
1338
1339         close (data_sock);
1340     }
1341
1342     /* Restore the initial value of use_passive_connection (for subsequent retries) */
1343     SUP->use_passive_connection = SUP->proxy != NULL ? ftpfs_use_passive_connections_over_proxy :
1344         ftpfs_use_passive_connections;
1345
1346     ftpfs_errno = EIO;
1347     return -1;
1348 }
1349
1350 /* --------------------------------------------------------------------------------------------- */
1351
1352 static int
1353 ftpfs_open_data_connection (struct vfs_class *me, struct vfs_s_super *super, const char *cmd,
1354                             const char *remote, int isbinary, int reget)
1355 {
1356     struct sockaddr_storage from;
1357     int s, j, data;
1358     socklen_t fromlen = sizeof (from);
1359
1360     s = ftpfs_initconn (me, super);
1361     if (s == -1)
1362         return -1;
1363
1364     if (ftpfs_changetype (me, super, isbinary) == -1)
1365         return -1;
1366     if (reget > 0)
1367     {
1368         j = ftpfs_command (me, super, WAIT_REPLY, "REST %d", reget);
1369         if (j != CONTINUE)
1370             return -1;
1371     }
1372     if (remote)
1373     {
1374         char *remote_path = ftpfs_translate_path (me, super, remote);
1375         j = ftpfs_command (me, super, WAIT_REPLY, "%s /%s", cmd,
1376                            /* WarFtpD can't STORE //filename */
1377                            (*remote_path == '/') ? remote_path + 1 : remote_path);
1378         g_free (remote_path);
1379     }
1380     else
1381         j = ftpfs_command (me, super, WAIT_REPLY, "%s", cmd);
1382
1383     if (j != PRELIM)
1384         ERRNOR (EPERM, -1);
1385     tty_enable_interrupt_key ();
1386     if (SUP->use_passive_connection)
1387         data = s;
1388     else
1389     {
1390         data = accept (s, (struct sockaddr *) &from, &fromlen);
1391         if (data < 0)
1392         {
1393             ftpfs_errno = errno;
1394             close (s);
1395             return -1;
1396         }
1397         close (s);
1398     }
1399     tty_disable_interrupt_key ();
1400     return data;
1401 }
1402
1403 /* --------------------------------------------------------------------------------------------- */
1404
1405 static void
1406 ftpfs_linear_abort (struct vfs_class *me, vfs_file_handler_t * fh)
1407 {
1408     struct vfs_s_super *super = FH_SUPER;
1409     static unsigned char const ipbuf[3] = { IAC, IP, IAC };
1410     fd_set mask;
1411     char buf[BUF_8K];
1412     int dsock = FH_SOCK;
1413     FH_SOCK = -1;
1414     SUP->ctl_connection_busy = 0;
1415
1416     vfs_print_message (_("ftpfs: aborting transfer."));
1417     if (send (SUP->sock, ipbuf, sizeof (ipbuf), MSG_OOB) != sizeof (ipbuf))
1418     {
1419         vfs_print_message (_("ftpfs: abort error: %s"), unix_error_string (errno));
1420         if (dsock != -1)
1421             close (dsock);
1422         return;
1423     }
1424
1425     if (ftpfs_command (me, super, NONE, "%cABOR", DM) != COMPLETE)
1426     {
1427         vfs_print_message (_("ftpfs: abort failed"));
1428         if (dsock != -1)
1429             close (dsock);
1430         return;
1431     }
1432     if (dsock != -1)
1433     {
1434         FD_ZERO (&mask);
1435         FD_SET (dsock, &mask);
1436         if (select (dsock + 1, &mask, NULL, NULL, NULL) > 0)
1437         {
1438             struct timeval start_tim, tim;
1439             gettimeofday (&start_tim, NULL);
1440             /* flush the remaining data */
1441             while (read (dsock, buf, sizeof (buf)) > 0)
1442             {
1443                 gettimeofday (&tim, NULL);
1444                 if (tim.tv_sec > start_tim.tv_sec + ABORT_TIMEOUT)
1445                 {
1446                     /* server keeps sending, drop the connection and ftpfs_reconnect */
1447                     close (dsock);
1448                     ftpfs_reconnect (me, super);
1449                     return;
1450                 }
1451             }
1452         }
1453         close (dsock);
1454     }
1455     if ((ftpfs_get_reply (me, SUP->sock, NULL, 0) == TRANSIENT) && (code == 426))
1456         ftpfs_get_reply (me, SUP->sock, NULL, 0);
1457 }
1458
1459 /* --------------------------------------------------------------------------------------------- */
1460
1461 #if 0
1462 static void
1463 resolve_symlink_without_ls_options (struct vfs_class *me, struct vfs_s_super *super,
1464                                     struct vfs_s_inode *dir)
1465 {
1466     struct linklist *flist;
1467     struct direntry *fe, *fel;
1468     char tmp[MC_MAXPATHLEN];
1469     int depth;
1470
1471     dir->symlink_status = FTPFS_RESOLVING_SYMLINKS;
1472     for (flist = dir->file_list->next; flist != dir->file_list; flist = flist->next)
1473     {
1474         /* flist->data->l_stat is alread initialized with 0 */
1475         fel = flist->data;
1476         if (S_ISLNK (fel->s.st_mode) && fel->linkname)
1477         {
1478             if (fel->linkname[0] == '/')
1479             {
1480                 if (strlen (fel->linkname) >= MC_MAXPATHLEN)
1481                     continue;
1482                 strcpy (tmp, fel->linkname);
1483             }
1484             else
1485             {
1486                 if ((strlen (dir->remote_path) + strlen (fel->linkname)) >= MC_MAXPATHLEN)
1487                     continue;
1488                 strcpy (tmp, dir->remote_path);
1489                 if (tmp[1] != '\0')
1490                     strcat (tmp, "/");
1491                 strcat (tmp + 1, fel->linkname);
1492             }
1493             for (depth = 0; depth < 100; depth++)
1494             {                   /* depth protects against recursive symbolic links */
1495                 canonicalize_pathname (tmp);
1496                 fe = _get_file_entry (bucket, tmp, 0, 0);
1497                 if (fe)
1498                 {
1499                     if (S_ISLNK (fe->s.st_mode) && fe->l_stat == 0)
1500                     {
1501                         /* Symlink points to link which isn't resolved, yet. */
1502                         if (fe->linkname[0] == '/')
1503                         {
1504                             if (strlen (fe->linkname) >= MC_MAXPATHLEN)
1505                                 break;
1506                             strcpy (tmp, fe->linkname);
1507                         }
1508                         else
1509                         {
1510                             /* at this point tmp looks always like this
1511                                /directory/filename, i.e. no need to check
1512                                strrchr's return value */
1513                             *(strrchr (tmp, '/') + 1) = '\0';   /* dirname */
1514                             if ((strlen (tmp) + strlen (fe->linkname)) >= MC_MAXPATHLEN)
1515                                 break;
1516                             strcat (tmp, fe->linkname);
1517                         }
1518                         continue;
1519                     }
1520                     else
1521                     {
1522                         fel->l_stat = g_new (struct stat, 1);
1523                         if (S_ISLNK (fe->s.st_mode))
1524                             *fel->l_stat = *fe->l_stat;
1525                         else
1526                             *fel->l_stat = fe->s;
1527                         (*fel->l_stat).st_ino = bucket->__inode_counter++;
1528                     }
1529                 }
1530                 break;
1531             }
1532         }
1533     }
1534     dir->symlink_status = FTPFS_RESOLVED_SYMLINKS;
1535 }
1536
1537 /* --------------------------------------------------------------------------------------------- */
1538
1539 static void
1540 resolve_symlink_with_ls_options (struct vfs_class *me, struct vfs_s_super *super,
1541                                  struct vfs_s_inode *dir)
1542 {
1543     char buffer[2048] = "", *filename;
1544     int sock;
1545     FILE *fp;
1546     struct stat s;
1547     struct linklist *flist;
1548     struct direntry *fe;
1549     int switch_method = 0;
1550
1551     dir->symlink_status = FTPFS_RESOLVED_SYMLINKS;
1552     if (strchr (dir->remote_path, ' '))
1553     {
1554         if (ftpfs_chdir_internal (bucket, dir->remote_path) != COMPLETE)
1555         {
1556             vfs_print_message (_("ftpfs: CWD failed."));
1557             return;
1558         }
1559         sock = ftpfs_open_data_connection (bucket, "LIST -lLa", ".", TYPE_ASCII, 0);
1560     }
1561     else
1562         sock = ftpfs_open_data_connection (bucket, "LIST -lLa", dir->remote_path, TYPE_ASCII, 0);
1563
1564     if (sock == -1)
1565     {
1566         vfs_print_message (_("ftpfs: couldn't resolve symlink"));
1567         return;
1568     }
1569
1570     fp = fdopen (sock, "r");
1571     if (fp == NULL)
1572     {
1573         close (sock);
1574         vfs_print_message (_("ftpfs: couldn't resolve symlink"));
1575         return;
1576     }
1577     tty_enable_interrupt_key ();
1578     flist = dir->file_list->next;
1579     while (1)
1580     {
1581         do
1582         {
1583             if (flist == dir->file_list)
1584                 goto done;
1585             fe = flist->data;
1586             flist = flist->next;
1587         }
1588         while (!S_ISLNK (fe->s.st_mode));
1589         while (1)
1590         {
1591             if (fgets (buffer, sizeof (buffer), fp) == NULL)
1592                 goto done;
1593             if (MEDATA->logfile)
1594             {
1595                 fputs (buffer, MEDATA->logfile);
1596                 fflush (MEDATA->logfile);
1597             }
1598             vfs_die ("This code should be commented out\n");
1599             if (vfs_parse_ls_lga (buffer, &s, &filename, NULL))
1600             {
1601                 int r = strcmp (fe->name, filename);
1602                 g_free (filename);
1603                 if (r == 0)
1604                 {
1605                     if (S_ISLNK (s.st_mode))
1606                     {
1607                         /* This server doesn't understand LIST -lLa */
1608                         switch_method = 1;
1609                         goto done;
1610                     }
1611                     fe->l_stat = g_new (struct stat, 1);
1612                     if (fe->l_stat == NULL)
1613                         goto done;
1614                     *fe->l_stat = s;
1615                     (*fe->l_stat).st_ino = bucket->__inode_counter++;
1616                     break;
1617                 }
1618                 if (r < 0)
1619                     break;
1620             }
1621         }
1622     }
1623   done:
1624     while (fgets (buffer, sizeof (buffer), fp) != NULL);
1625     tty_disable_interrupt_key ();
1626     fclose (fp);
1627     ftpfs_get_reply (me, SUP->sock, NULL, 0);
1628 }
1629
1630 /* --------------------------------------------------------------------------------------------- */
1631
1632 static void
1633 resolve_symlink (struct vfs_class *me, struct vfs_s_super *super, struct vfs_s_inode *dir)
1634 {
1635     vfs_print_message (_("Resolving symlink..."));
1636
1637     if (SUP->strict_rfc959_list_cmd)
1638         resolve_symlink_without_ls_options (me, super, dir);
1639     else
1640         resolve_symlink_with_ls_options (me, super, dir);
1641 }
1642 #endif
1643
1644 /* --------------------------------------------------------------------------------------------- */
1645
1646 static int
1647 ftpfs_dir_load (struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
1648 {
1649     struct vfs_s_entry *ent;
1650     struct vfs_s_super *super = dir->super;
1651     int sock, num_entries = 0;
1652     char lc_buffer[BUF_8K];
1653     int cd_first;
1654
1655     cd_first = ftpfs_first_cd_then_ls || (SUP->strict == RFC_STRICT)
1656         || (strchr (remote_path, ' ') != NULL);
1657
1658   again:
1659     vfs_print_message (_("ftpfs: Reading FTP directory %s... %s%s"),
1660                        remote_path,
1661                        SUP->strict ==
1662                        RFC_STRICT ? _("(strict rfc959)") : "", cd_first ? _("(chdir first)") : "");
1663
1664     if (cd_first)
1665     {
1666         if (ftpfs_chdir_internal (me, super, remote_path) != COMPLETE)
1667         {
1668             ftpfs_errno = ENOENT;
1669             vfs_print_message (_("ftpfs: CWD failed."));
1670             return -1;
1671         }
1672     }
1673
1674     gettimeofday (&dir->timestamp, NULL);
1675     dir->timestamp.tv_sec += ftpfs_directory_timeout;
1676
1677     if (SUP->strict == RFC_STRICT)
1678         sock = ftpfs_open_data_connection (me, super, "LIST", 0, TYPE_ASCII, 0);
1679     else if (cd_first)
1680         /* Dirty hack to avoid autoprepending / to . */
1681         /* Wu-ftpd produces strange output for '/' if 'LIST -la .' used */
1682         sock = ftpfs_open_data_connection (me, super, "LIST -la", 0, TYPE_ASCII, 0);
1683     else
1684     {
1685         char *path;
1686
1687         /* Trailing "/." is necessary if remote_path is a symlink */
1688         path = mc_build_filename (remote_path, ".", NULL);
1689         sock = ftpfs_open_data_connection (me, super, "LIST -la", path, TYPE_ASCII, 0);
1690         g_free (path);
1691     }
1692
1693     if (sock == -1)
1694         goto fallback;
1695
1696     /* Clear the interrupt flag */
1697     tty_enable_interrupt_key ();
1698
1699     vfs_parse_ls_lga_init ();
1700     while (1)
1701     {
1702         int i;
1703         size_t count_spaces = 0;
1704         int res = vfs_s_get_line_interruptible (me, lc_buffer, sizeof (lc_buffer),
1705                                                 sock);
1706         if (!res)
1707             break;
1708
1709         if (res == EINTR)
1710         {
1711             me->verrno = ECONNRESET;
1712             close (sock);
1713             tty_disable_interrupt_key ();
1714             ftpfs_get_reply (me, SUP->sock, NULL, 0);
1715             vfs_print_message (_("%s: failure"), me->name);
1716             return -1;
1717         }
1718
1719         if (MEDATA->logfile)
1720         {
1721             fputs (lc_buffer, MEDATA->logfile);
1722             fputs ("\n", MEDATA->logfile);
1723             fflush (MEDATA->logfile);
1724         }
1725
1726         ent = vfs_s_generate_entry (me, NULL, dir, 0);
1727         i = ent->ino->st.st_nlink;
1728         if (!vfs_parse_ls_lga
1729             (lc_buffer, &ent->ino->st, &ent->name, &ent->ino->linkname, &count_spaces))
1730         {
1731             vfs_s_free_entry (me, ent);
1732             continue;
1733         }
1734         ent->ino->st.st_nlink = i;      /* Ouch, we need to preserve our counts :-( */
1735         num_entries++;
1736         vfs_s_store_filename_leading_spaces (ent, count_spaces);
1737         vfs_s_insert_entry (me, dir, ent);
1738     }
1739
1740     close (sock);
1741     me->verrno = E_REMOTE;
1742     if ((ftpfs_get_reply (me, SUP->sock, NULL, 0) != COMPLETE))
1743         goto fallback;
1744
1745     if (num_entries == 0 && cd_first == 0)
1746     {
1747         /* The LIST command may produce an empty output. In such scenario
1748            it is not clear whether this is caused by  `remote_path' being
1749            a non-existent path or for some other reason (listing emtpy
1750            directory without the -a option, non-readable directory, etc.).
1751
1752            Since `dir_load' is a crucial method, when it comes to determine
1753            whether a given path is a _directory_, the code must try its best
1754            to determine the type of `remote_path'. The only reliable way to
1755            achieve this is trough issuing a CWD command. */
1756
1757         cd_first = 1;
1758         goto again;
1759     }
1760
1761     vfs_s_normalize_filename_leading_spaces (dir, vfs_parse_ls_lga_get_final_spaces ());
1762
1763     if (SUP->strict == RFC_AUTODETECT)
1764         SUP->strict = RFC_DARING;
1765
1766     vfs_print_message (_("%s: done."), me->name);
1767     return 0;
1768
1769   fallback:
1770     if (SUP->strict == RFC_AUTODETECT)
1771     {
1772         /* It's our first attempt to get a directory listing from this
1773            server (UNIX style LIST command) */
1774         SUP->strict = RFC_STRICT;
1775         /* I hate goto, but recursive call needs another 8K on stack */
1776         /* return ftpfs_dir_load (me, dir, remote_path); */
1777         cd_first = 1;
1778         goto again;
1779     }
1780     vfs_print_message (_("ftpfs: failed; nowhere to fallback to"));
1781     ERRNOR (EACCES, -1);
1782 }
1783
1784 /* --------------------------------------------------------------------------------------------- */
1785
1786 static int
1787 ftpfs_file_store (struct vfs_class *me, vfs_file_handler_t * fh, char *name, char *localname)
1788 {
1789     int h, sock, n_read, n_written;
1790     off_t n_stored;
1791 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1792     struct linger li;
1793 #else
1794     int flag_one = 1;
1795 #endif
1796     char lc_buffer[BUF_8K];
1797     struct stat s;
1798     char *w_buf;
1799     struct vfs_s_super *super = FH_SUPER;
1800     ftp_fh_data_t *ftp = (ftp_fh_data_t *) fh->data;
1801
1802     h = open (localname, O_RDONLY);
1803     if (h == -1)
1804         ERRNOR (EIO, -1);
1805
1806     sock =
1807         ftpfs_open_data_connection (me, super, ftp->append ? "APPE" : "STOR", name, TYPE_BINARY, 0);
1808     if (sock < 0 || fstat (h, &s) == -1)
1809     {
1810         close (h);
1811         return -1;
1812     }
1813 #ifdef HAVE_STRUCT_LINGER_L_LINGER
1814     li.l_onoff = 1;
1815     li.l_linger = 120;
1816     setsockopt (sock, SOL_SOCKET, SO_LINGER, (char *) &li, sizeof (li));
1817 #else
1818     setsockopt (sock, SOL_SOCKET, SO_LINGER, &flag_one, sizeof (flag_one));
1819 #endif
1820     n_stored = 0;
1821
1822     tty_enable_interrupt_key ();
1823     while (TRUE)
1824     {
1825         while ((n_read = read (h, lc_buffer, sizeof (lc_buffer))) == -1)
1826         {
1827             if (errno == EINTR)
1828             {
1829                 if (tty_got_interrupt ())
1830                 {
1831                     ftpfs_errno = EINTR;
1832                     goto error_return;
1833                 }
1834                 else
1835                     continue;
1836             }
1837             ftpfs_errno = errno;
1838             goto error_return;
1839         }
1840         if (n_read == 0)
1841             break;
1842         n_stored += n_read;
1843         w_buf = lc_buffer;
1844         while ((n_written = write (sock, w_buf, n_read)) != n_read)
1845         {
1846             if (n_written == -1)
1847             {
1848                 if (errno == EINTR && !tty_got_interrupt ())
1849                 {
1850                     continue;
1851                 }
1852                 ftpfs_errno = errno;
1853                 goto error_return;
1854             }
1855             w_buf += n_written;
1856             n_read -= n_written;
1857         }
1858         vfs_print_message ("%s: %" PRIuMAX "/%" PRIuMAX,
1859                            _("ftpfs: storing file"), (uintmax_t) n_stored, (uintmax_t) s.st_size);
1860     }
1861     tty_disable_interrupt_key ();
1862     close (sock);
1863     close (h);
1864     if (ftpfs_get_reply (me, SUP->sock, NULL, 0) != COMPLETE)
1865         ERRNOR (EIO, -1);
1866     return 0;
1867   error_return:
1868     tty_disable_interrupt_key ();
1869     close (sock);
1870     close (h);
1871     ftpfs_get_reply (me, SUP->sock, NULL, 0);
1872     return -1;
1873 }
1874
1875 /* --------------------------------------------------------------------------------------------- */
1876
1877 static int
1878 ftpfs_linear_start (struct vfs_class *me, vfs_file_handler_t * fh, off_t offset)
1879 {
1880     char *name;
1881
1882     if (fh->data == NULL)
1883         fh->data = g_new0 (ftp_fh_data_t, 1);
1884
1885     name = vfs_s_fullpath (me, fh->ino);
1886     if (name == NULL)
1887         return 0;
1888     FH_SOCK = ftpfs_open_data_connection (me, FH_SUPER, "RETR", name, TYPE_BINARY, offset);
1889     g_free (name);
1890     if (FH_SOCK == -1)
1891         ERRNOR (EACCES, 0);
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;
1895     return 1;
1896 }
1897
1898 /* --------------------------------------------------------------------------------------------- */
1899
1900 static int
1901 ftpfs_linear_read (struct vfs_class *me, vfs_file_handler_t * fh, void *buf, size_t len)
1902 {
1903     ssize_t n;
1904     struct vfs_s_super *super = FH_SUPER;
1905
1906     while ((n = read (FH_SOCK, buf, len)) < 0)
1907     {
1908         if ((errno == EINTR) && !tty_got_interrupt ())
1909             continue;
1910         break;
1911     }
1912
1913     if (n < 0)
1914         ftpfs_linear_abort (me, fh);
1915
1916     if (n == 0)
1917     {
1918         SUP->ctl_connection_busy = 0;
1919         close (FH_SOCK);
1920         FH_SOCK = -1;
1921         if ((ftpfs_get_reply (me, SUP->sock, NULL, 0) != COMPLETE))
1922             ERRNOR (E_REMOTE, -1);
1923         return 0;
1924     }
1925     ERRNOR (errno, n);
1926 }
1927
1928 /* --------------------------------------------------------------------------------------------- */
1929
1930 static void
1931 ftpfs_linear_close (struct vfs_class *me, vfs_file_handler_t * fh)
1932 {
1933     if (FH_SOCK != -1)
1934         ftpfs_linear_abort (me, fh);
1935 }
1936
1937 /* --------------------------------------------------------------------------------------------- */
1938
1939 static int
1940 ftpfs_ctl (void *fh, int ctlop, void *arg)
1941 {
1942     (void) arg;
1943
1944     switch (ctlop)
1945     {
1946     case VFS_CTL_IS_NOTREADY:
1947         {
1948             int v;
1949
1950             if (!FH->linear)
1951                 vfs_die ("You may not do this");
1952             if (FH->linear == LS_LINEAR_CLOSED || FH->linear == LS_LINEAR_PREOPEN)
1953                 return 0;
1954
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;
1957         }
1958     default:
1959         return 0;
1960     }
1961 }
1962
1963 /* --------------------------------------------------------------------------------------------- */
1964
1965 static int
1966 ftpfs_send_command (const vfs_path_t * vpath, const char *cmd, int flags)
1967 {
1968     const char *rpath;
1969     char *p;
1970     struct vfs_s_super *super;
1971     int r;
1972     const vfs_path_element_t *path_element;
1973     int flush_directory_cache = (flags & OPT_FLUSH);
1974
1975     path_element = vfs_path_get_by_index (vpath, -1);
1976
1977     rpath = vfs_s_get_path (vpath, &super, 0);
1978     if (rpath == NULL)
1979         return -1;
1980
1981     p = ftpfs_translate_path (path_element->class, super, rpath);
1982     r = ftpfs_command (path_element->class, super, WAIT_REPLY, cmd, p);
1983     g_free (p);
1984     vfs_stamp_create (&vfs_ftpfs_ops, super);
1985     if (flags & OPT_IGNORE_ERROR)
1986         r = COMPLETE;
1987     if (r != COMPLETE)
1988     {
1989         path_element->class->verrno = EPERM;
1990         return -1;
1991     }
1992     if (flush_directory_cache)
1993         vfs_s_invalidate (path_element->class, super);
1994     return 0;
1995 }
1996
1997 /* --------------------------------------------------------------------------------------------- */
1998
1999 static int
2000 ftpfs_chmod (const vfs_path_t * vpath, mode_t mode)
2001 {
2002     char buf[BUF_SMALL];
2003     int ret;
2004
2005     g_snprintf (buf, sizeof (buf), "SITE CHMOD %4.4o /%%s", (int) (mode & 07777));
2006
2007     ret = ftpfs_send_command (vpath, buf, OPT_FLUSH);
2008
2009     return ftpfs_ignore_chattr_errors ? 0 : ret;
2010 }
2011
2012 /* --------------------------------------------------------------------------------------------- */
2013
2014 static int
2015 ftpfs_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
2016 {
2017 #if 0
2018     (void) vpath;
2019     (void) owner;
2020     (void) group;
2021
2022     ftpfs_errno = EPERM;
2023     return -1;
2024 #else
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... */
2027     (void) vpath;
2028     (void) owner;
2029     (void) group;
2030     return 0;
2031 #endif
2032 }
2033
2034 /* --------------------------------------------------------------------------------------------- */
2035
2036 static int
2037 ftpfs_unlink (const vfs_path_t * vpath)
2038 {
2039     return ftpfs_send_command (vpath, "DELE /%s", OPT_FLUSH);
2040 }
2041
2042 /* --------------------------------------------------------------------------------------------- */
2043
2044 /* Return 1 if path is the same directory as the one we are in now */
2045 static int
2046 ftpfs_is_same_dir (struct vfs_class *me, struct vfs_s_super *super, const char *path)
2047 {
2048     (void) me;
2049
2050     if (SUP->current_dir == NULL)
2051         return FALSE;
2052     return (strcmp (path, SUP->current_dir) == 0);
2053 }
2054
2055 /* --------------------------------------------------------------------------------------------- */
2056
2057 static int
2058 ftpfs_chdir_internal (struct vfs_class *me, struct vfs_s_super *super, const char *remote_path)
2059 {
2060     int r;
2061     char *p;
2062
2063     if (!SUP->cwd_deferred && ftpfs_is_same_dir (me, super, remote_path))
2064         return COMPLETE;
2065
2066     p = ftpfs_translate_path (me, super, remote_path);
2067     r = ftpfs_command (me, super, WAIT_REPLY, "CWD /%s", p);
2068     g_free (p);
2069
2070     if (r != COMPLETE)
2071         ftpfs_errno = EIO;
2072     else
2073     {
2074         g_free (SUP->current_dir);
2075         SUP->current_dir = g_strdup (remote_path);
2076         SUP->cwd_deferred = 0;
2077     }
2078     return r;
2079 }
2080
2081 /* --------------------------------------------------------------------------------------------- */
2082
2083 static int
2084 ftpfs_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
2085 {
2086     ftpfs_send_command (vpath1, "RNFR /%s", OPT_FLUSH);
2087     return ftpfs_send_command (vpath2, "RNTO /%s", OPT_FLUSH);
2088 }
2089
2090 /* --------------------------------------------------------------------------------------------- */
2091
2092 static int
2093 ftpfs_mkdir (const vfs_path_t * vpath, mode_t mode)
2094 {
2095     (void) mode;                /* FIXME: should be used */
2096
2097     return ftpfs_send_command (vpath, "MKD /%s", OPT_FLUSH);
2098 }
2099
2100 /* --------------------------------------------------------------------------------------------- */
2101
2102 static int
2103 ftpfs_rmdir (const vfs_path_t * vpath)
2104 {
2105     return ftpfs_send_command (vpath, "RMD /%s", OPT_FLUSH);
2106 }
2107
2108 /* --------------------------------------------------------------------------------------------- */
2109
2110 static void
2111 ftpfs_fh_free_data (vfs_file_handler_t * fh)
2112 {
2113     if (fh != NULL)
2114     {
2115         g_free (fh->data);
2116         fh->data = NULL;
2117     }
2118 }
2119
2120 /* --------------------------------------------------------------------------------------------- */
2121
2122 static int
2123 ftpfs_fh_open (struct vfs_class *me, vfs_file_handler_t * fh, int flags, mode_t mode)
2124 {
2125     ftp_fh_data_t *ftp;
2126
2127     (void) mode;
2128
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))
2133     {
2134 #ifdef HAVE_STRUCT_LINGER_L_LINGER
2135         struct linger li;
2136 #else
2137         int li = 1;
2138 #endif
2139         char *name;
2140
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
2144          */
2145         if (((ftp_super_data_t *) (FH_SUPER->data))->ctl_connection_busy)
2146         {
2147             if (!fh->ino->localname)
2148             {
2149                 vfs_path_t *vpath;
2150                 int handle;
2151
2152                 handle = vfs_mkstemps (&vpath, me->name, fh->ino->ent->name);
2153                 if (handle == -1)
2154                 {
2155                     vfs_path_free (vpath);
2156                     goto fail;
2157                 }
2158                 close (handle);
2159                 fh->ino->localname = vfs_path_to_str (vpath);
2160                 vfs_path_free (vpath);
2161                 ftp->append = flags & O_APPEND;
2162             }
2163             return 0;
2164         }
2165         name = vfs_s_fullpath (me, fh->ino);
2166         if (name == NULL)
2167             goto fail;
2168         fh->handle =
2169             ftpfs_open_data_connection (me, fh->ino->super,
2170                                         (flags & O_APPEND) ? "APPE" : "STOR", name, TYPE_BINARY, 0);
2171         g_free (name);
2172
2173         if (fh->handle < 0)
2174             goto fail;
2175 #ifdef HAVE_STRUCT_LINGER_L_LINGER
2176         li.l_onoff = 1;
2177         li.l_linger = 120;
2178 #endif
2179         setsockopt (fh->handle, SOL_SOCKET, SO_LINGER, &li, sizeof (li));
2180
2181         if (fh->ino->localname)
2182         {
2183             unlink (fh->ino->localname);
2184             g_free (fh->ino->localname);
2185             fh->ino->localname = NULL;
2186         }
2187         return 0;
2188     }
2189
2190     if (!fh->ino->localname && vfs_s_retrieve_file (me, fh->ino) == -1)
2191         goto fail;
2192     if (!fh->ino->localname)
2193         vfs_die ("retrieve_file failed to fill in localname");
2194     return 0;
2195
2196   fail:
2197     ftpfs_fh_free_data (fh);
2198     return -1;
2199 }
2200
2201 /* --------------------------------------------------------------------------------------------- */
2202
2203 static int
2204 ftpfs_fh_close (struct vfs_class *me, vfs_file_handler_t * fh)
2205 {
2206     if (fh->handle != -1 && !fh->ino->localname)
2207     {
2208         ftp_super_data_t *ftp = (ftp_super_data_t *) fh->ino->super->data;
2209
2210         close (fh->handle);
2211         fh->handle = -1;
2212         /* File is stored to destination already, so
2213          * we prevent MEDATA->ftpfs_file_store() call from vfs_s_close ()
2214          */
2215         fh->changed = 0;
2216         if (ftpfs_get_reply (me, ftp->sock, NULL, 0) != COMPLETE)
2217             ERRNOR (EIO, -1);
2218         vfs_s_invalidate (me, FH_SUPER);
2219     }
2220
2221     return 0;
2222 }
2223
2224 /* --------------------------------------------------------------------------------------------- */
2225
2226 static void
2227 ftpfs_done (struct vfs_class *me)
2228 {
2229     (void) me;
2230
2231     g_slist_foreach (no_proxy, (GFunc) g_free, NULL);
2232     g_slist_free (no_proxy);
2233
2234     g_free (ftpfs_anonymous_passwd);
2235     g_free (ftpfs_proxy_host);
2236 }
2237
2238 /* --------------------------------------------------------------------------------------------- */
2239
2240 static void
2241 ftpfs_fill_names (struct vfs_class *me, fill_names_f func)
2242 {
2243     GList *iter;
2244
2245     for (iter = MEDATA->supers; iter != NULL; iter = g_list_next (iter))
2246     {
2247         const struct vfs_s_super *super = (const struct vfs_s_super *) iter->data;
2248         char *name;
2249
2250         name = vfs_path_element_build_pretty_path_str (super->path_element);
2251
2252         func (name);
2253         g_free (name);
2254     }
2255 }
2256
2257 /* --------------------------------------------------------------------------------------------- */
2258
2259 static keyword_t
2260 ftpfs_netrc_next (void)
2261 {
2262     char *p;
2263     keyword_t i;
2264     static const char *const keywords[] = { "default", "machine",
2265         "login", "password", "passwd", "account", "macdef", NULL
2266     };
2267
2268     while (1)
2269     {
2270         netrcp = skip_separators (netrcp);
2271         if (*netrcp != '\n')
2272             break;
2273         netrcp++;
2274     }
2275     if (!*netrcp)
2276         return NETRC_NONE;
2277     p = buffer;
2278     if (*netrcp == '"')
2279     {
2280         for (netrcp++; *netrcp != '"' && *netrcp; netrcp++)
2281         {
2282             if (*netrcp == '\\')
2283                 netrcp++;
2284             *p++ = *netrcp;
2285         }
2286     }
2287     else
2288     {
2289         for (; *netrcp != '\n' && *netrcp != '\t' && *netrcp != ' ' &&
2290              *netrcp != ',' && *netrcp; netrcp++)
2291         {
2292             if (*netrcp == '\\')
2293                 netrcp++;
2294             *p++ = *netrcp;
2295         }
2296     }
2297     *p = 0;
2298     if (!*buffer)
2299         return NETRC_NONE;
2300
2301     for (i = NETRC_DEFAULT; keywords[i - 1] != NULL; i++)
2302         if (strcmp (keywords[i - 1], buffer) == 0)
2303             return i;
2304
2305     return NETRC_UNKNOWN;
2306 }
2307
2308 /* --------------------------------------------------------------------------------------------- */
2309
2310 static int
2311 ftpfs_netrc_bad_mode (const char *netrcname)
2312 {
2313     static int be_angry = 1;
2314     struct stat mystat;
2315
2316     if (stat (netrcname, &mystat) >= 0 && (mystat.st_mode & 077))
2317     {
2318         if (be_angry)
2319         {
2320             message (D_ERROR, MSG_ERROR,
2321                      _("~/.netrc file has incorrect mode\nRemove password or correct mode"));
2322             be_angry = 0;
2323         }
2324         return 1;
2325     }
2326     return 0;
2327 }
2328
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 */
2334
2335 static int
2336 ftpfs_find_machine (const char *host, const char *domain)
2337 {
2338     keyword_t keyword;
2339
2340     if (!host)
2341         host = "";
2342     if (!domain)
2343         domain = "";
2344
2345     while ((keyword = ftpfs_netrc_next ()) != NETRC_NONE)
2346     {
2347         if (keyword == NETRC_DEFAULT)
2348             return 0;
2349
2350         if (keyword == NETRC_MACDEF)
2351         {
2352             /* Scan for an empty line, which concludes "macdef" */
2353             do
2354             {
2355                 while (*netrcp && *netrcp != '\n')
2356                     netrcp++;
2357                 if (*netrcp != '\n')
2358                     break;
2359                 netrcp++;
2360             }
2361             while (*netrcp && *netrcp != '\n');
2362             continue;
2363         }
2364
2365         if (keyword != NETRC_MACHINE)
2366             continue;
2367
2368         /* Take machine name */
2369         if (ftpfs_netrc_next () == NETRC_NONE)
2370             break;
2371
2372         if (g_ascii_strcasecmp (host, buffer) != 0)
2373         {
2374             /* Try adding our domain to short names in .netrc */
2375             const char *host_domain = strchr (host, '.');
2376             if (!host_domain)
2377                 continue;
2378
2379             /* Compare domain part */
2380             if (g_ascii_strcasecmp (host_domain, domain) != 0)
2381                 continue;
2382
2383             /* Compare local part */
2384             if (g_ascii_strncasecmp (host, buffer, host_domain - host) != 0)
2385                 continue;
2386         }
2387
2388         return 0;
2389     }
2390
2391     /* end of .netrc */
2392     return -1;
2393 }
2394
2395 /* --------------------------------------------------------------------------------------------- */
2396 /* Extract login and password from .netrc for the host.
2397  * pass may be NULL.
2398  * Returns 0 for success, -1 for error */
2399
2400 static int
2401 ftpfs_netrc_lookup (const char *host, char **login, char **pass)
2402 {
2403     char *netrcname;
2404     char *tmp_pass = NULL;
2405     char hostname[MAXHOSTNAMELEN];
2406     const char *domain;
2407     keyword_t keyword;
2408     static struct rupcache
2409     {
2410         struct rupcache *next;
2411         char *host;
2412         char *login;
2413         char *pass;
2414     } *rup_cache = NULL, *rupp;
2415
2416     /* Initialize *login and *pass */
2417     g_free (*login);
2418     *login = NULL;
2419     g_free (*pass);
2420     *pass = NULL;
2421
2422     /* Look up in the cache first */
2423     for (rupp = rup_cache; rupp != NULL; rupp = rupp->next)
2424     {
2425         if (!strcmp (host, rupp->host))
2426         {
2427             if (rupp->login)
2428                 *login = g_strdup (rupp->login);
2429             if (pass && rupp->pass)
2430                 *pass = g_strdup (rupp->pass);
2431             return 0;
2432         }
2433     }
2434
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))
2438     {
2439         g_free (netrcname);
2440         return 0;
2441     }
2442
2443     netrcp = netrc;
2444
2445     /* Find our own domain name */
2446     if (gethostname (hostname, sizeof (hostname)) < 0)
2447         *hostname = '\0';
2448
2449     domain = strchr (hostname, '.');
2450     if (domain == NULL)
2451         domain = "";
2452
2453     /* Scan for "default" and matching "machine" keywords */
2454     ftpfs_find_machine (host, domain);
2455
2456     /* Scan for keywords following "default" and "machine" */
2457     while (1)
2458     {
2459         int need_break = 0;
2460         keyword = ftpfs_netrc_next ();
2461
2462         switch (keyword)
2463         {
2464         case NETRC_LOGIN:
2465             if (ftpfs_netrc_next () == NETRC_NONE)
2466             {
2467                 need_break = 1;
2468                 break;
2469             }
2470
2471             /* We have another name already - should not happen */
2472             if (*login)
2473             {
2474                 need_break = 1;
2475                 break;
2476             }
2477
2478             /* We have login name now */
2479             *login = g_strdup (buffer);
2480             break;
2481
2482         case NETRC_PASSWORD:
2483         case NETRC_PASSWD:
2484             if (ftpfs_netrc_next () == NETRC_NONE)
2485             {
2486                 need_break = 1;
2487                 break;
2488             }
2489
2490             /* Ignore unsafe passwords */
2491             if (*login != NULL &&
2492                 strcmp (*login, "anonymous") != 0 && strcmp (*login, "ftp") != 0
2493                 && ftpfs_netrc_bad_mode (netrcname))
2494             {
2495                 need_break = 1;
2496                 break;
2497             }
2498
2499             /* Remember password.  pass may be NULL, so use tmp_pass */
2500             if (tmp_pass == NULL)
2501                 tmp_pass = g_strdup (buffer);
2502             break;
2503
2504         case NETRC_ACCOUNT:
2505             /* "account" is followed by a token which we ignore */
2506             if (ftpfs_netrc_next () == NETRC_NONE)
2507             {
2508                 need_break = 1;
2509                 break;
2510             }
2511
2512             /* Ignore account, but warn user anyways */
2513             ftpfs_netrc_bad_mode (netrcname);
2514             break;
2515
2516         default:
2517             /* Unexpected keyword or end of file */
2518             need_break = 1;
2519             break;
2520         }
2521
2522         if (need_break)
2523             break;
2524     }
2525
2526     g_free (netrc);
2527     g_free (netrcname);
2528
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);
2533
2534     rupp->next = rup_cache;
2535     rup_cache = rupp;
2536
2537     *pass = tmp_pass;
2538
2539     return 0;
2540 }
2541
2542 /* --------------------------------------------------------------------------------------------- */
2543 /*** public functions ****************************************************************************/
2544 /* --------------------------------------------------------------------------------------------- */
2545
2546 /** This routine is called as the last step in load_setup */
2547 void
2548 ftpfs_init_passwd (void)
2549 {
2550     ftpfs_anonymous_passwd = load_anon_passwd ();
2551     if (ftpfs_anonymous_passwd)
2552         return;
2553
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,
2560      *   host or country.
2561      */
2562     ftpfs_anonymous_passwd = g_strdup ("anonymous@");
2563 }
2564
2565 /* --------------------------------------------------------------------------------------------- */
2566
2567 void
2568 init_ftpfs (void)
2569 {
2570     static struct vfs_s_subclass ftpfs_subclass;
2571
2572     tcp_init ();
2573
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;
2586
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);
2601 }
2602
2603 /* --------------------------------------------------------------------------------------------- */