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     while (TRUE)
 381     {
 382         if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n'))
 383         {
 384             if (string_buf != NULL)
 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 != NULL)
 393                 g_strlcpy (string_buf, answer, string_len);
 394             code = 500;
 395             return 5;
 396         case 1:
 397             if (answer[3] == '-')
 398             {
 399                 while (TRUE)
 400                 {
 401                     if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n'))
 402                     {
 403                         if (string_buf != NULL)
 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 != NULL)
 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         if (ftpfs_login_server (me, super, super->path_element->password) != 0)
 436         {
 437             if (cwdir == NULL)
 438                 return 1;
 439             sock = ftpfs_chdir_internal (me, super, cwdir);
 440             g_free (cwdir);
 441             return sock == COMPLETE ? 1 : 0;
 442         }
 443
 444         SUP->current_dir = cwdir;
 445     }
 446
 447     return 0;
 448 }
 449
 450 /* --------------------------------------------------------------------------------------------- */
 451
 452 static int
 453 ftpfs_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, const char *fmt,
 454                ...)
 455 {
 456     va_list ap;
 457     char *cmdstr;
 458     int status, cmdlen;
 459     static int retry = 0;
 460     static int level = 0;       /* ftpfs_login_server() use ftpfs_command() */
 461
 462     va_start (ap, fmt);
 463     cmdstr = g_strdup_vprintf (fmt, ap);
 464     va_end (ap);
 465
 466     cmdlen = strlen (cmdstr);
 467     cmdstr = g_realloc (cmdstr, cmdlen + 3);
 468     strcpy (cmdstr + cmdlen, "\r\n");
 469     cmdlen += 2;
 470
 471     if (MEDATA->logfile)
 472     {
 473         if (strncmp (cmdstr, "PASS ", 5) == 0)
 474         {
 475             fputs ("PASS <Password not logged>\r\n", MEDATA->logfile);
 476         }
 477         else
 478         {
 479             size_t ret;
 480             ret = fwrite (cmdstr, cmdlen, 1, MEDATA->logfile);
 481             (void) ret;
 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;
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         ssize_t n_read, n_written;
1826
1827         while ((n_read = read (h, lc_buffer, sizeof (lc_buffer))) == -1)
1828         {
1829             if (errno != EINTR)
1830             {
1831                 ftpfs_errno = errno;
1832                 goto error_return;
1833             }
1834             if (tty_got_interrupt ())
1835             {
1836                 ftpfs_errno = EINTR;
1837                 goto error_return;
1838             }
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                     continue;
1850
1851                 ftpfs_errno = errno;
1852                 goto error_return;
1853             }
1854             w_buf += n_written;
1855             n_read -= n_written;
1856         }
1857         vfs_print_message ("%s: %" PRIuMAX "/%" PRIuMAX,
1858                            _("ftpfs: storing file"), (uintmax_t) n_stored, (uintmax_t) s.st_size);
1859     }
1860     tty_disable_interrupt_key ();
1861     close (sock);
1862     close (h);
1863     if (ftpfs_get_reply (me, SUP->sock, NULL, 0) != COMPLETE)
1864         ERRNOR (EIO, -1);
1865     return 0;
1866   error_return:
1867     tty_disable_interrupt_key ();
1868     close (sock);
1869     close (h);
1870     ftpfs_get_reply (me, SUP->sock, NULL, 0);
1871     return -1;
1872 }
1873
1874 /* --------------------------------------------------------------------------------------------- */
1875
1876 static int
1877 ftpfs_linear_start (struct vfs_class *me, vfs_file_handler_t * fh, off_t offset)
1878 {
1879     char *name;
1880
1881     if (fh->data == NULL)
1882         fh->data = g_new0 (ftp_fh_data_t, 1);
1883
1884     name = vfs_s_fullpath (me, fh->ino);
1885     if (name == NULL)
1886         return 0;
1887     FH_SOCK = ftpfs_open_data_connection (me, FH_SUPER, "RETR", name, TYPE_BINARY, offset);
1888     g_free (name);
1889     if (FH_SOCK == -1)
1890         ERRNOR (EACCES, 0);
1891     fh->linear = LS_LINEAR_OPEN;
1892     ((ftp_super_data_t *) (FH_SUPER->data))->ctl_connection_busy = 1;
1893     ((ftp_fh_data_t *) fh->data)->append = 0;
1894     return 1;
1895 }
1896
1897 /* --------------------------------------------------------------------------------------------- */
1898
1899 static ssize_t
1900 ftpfs_linear_read (struct vfs_class *me, vfs_file_handler_t * fh, void *buf, size_t len)
1901 {
1902     ssize_t n;
1903     struct vfs_s_super *super = FH_SUPER;
1904
1905     while ((n = read (FH_SOCK, buf, len)) < 0)
1906     {
1907         if ((errno == EINTR) && !tty_got_interrupt ())
1908             continue;
1909         break;
1910     }
1911
1912     if (n < 0)
1913         ftpfs_linear_abort (me, fh);
1914
1915     if (n == 0)
1916     {
1917         SUP->ctl_connection_busy = 0;
1918         close (FH_SOCK);
1919         FH_SOCK = -1;
1920         if ((ftpfs_get_reply (me, SUP->sock, NULL, 0) != COMPLETE))
1921             ERRNOR (E_REMOTE, -1);
1922         return 0;
1923     }
1924     ERRNOR (errno, n);
1925 }
1926
1927 /* --------------------------------------------------------------------------------------------- */
1928
1929 static void
1930 ftpfs_linear_close (struct vfs_class *me, vfs_file_handler_t * fh)
1931 {
1932     if (FH_SOCK != -1)
1933         ftpfs_linear_abort (me, fh);
1934 }
1935
1936 /* --------------------------------------------------------------------------------------------- */
1937
1938 static int
1939 ftpfs_ctl (void *fh, int ctlop, void *arg)
1940 {
1941     (void) arg;
1942
1943     switch (ctlop)
1944     {
1945     case VFS_CTL_IS_NOTREADY:
1946         {
1947             int v;
1948
1949             if (!FH->linear)
1950                 vfs_die ("You may not do this");
1951             if (FH->linear == LS_LINEAR_CLOSED || FH->linear == LS_LINEAR_PREOPEN)
1952                 return 0;
1953
1954             v = vfs_s_select_on_two (((ftp_fh_data_t *) (FH->data))->sock, 0);
1955             return (((v < 0) && (errno == EINTR)) || v == 0) ? 1 : 0;
1956         }
1957     default:
1958         return 0;
1959     }
1960 }
1961
1962 /* --------------------------------------------------------------------------------------------- */
1963
1964 static int
1965 ftpfs_send_command (const vfs_path_t * vpath, const char *cmd, int flags)
1966 {
1967     const char *rpath;
1968     char *p;
1969     struct vfs_s_super *super;
1970     int r;
1971     const vfs_path_element_t *path_element;
1972     int flush_directory_cache = (flags & OPT_FLUSH);
1973
1974     path_element = vfs_path_get_by_index (vpath, -1);
1975
1976     rpath = vfs_s_get_path (vpath, &super, 0);
1977     if (rpath == NULL)
1978         return -1;
1979
1980     p = ftpfs_translate_path (path_element->class, super, rpath);
1981     r = ftpfs_command (path_element->class, super, WAIT_REPLY, cmd, p);
1982     g_free (p);
1983     vfs_stamp_create (&vfs_ftpfs_ops, super);
1984     if (flags & OPT_IGNORE_ERROR)
1985         r = COMPLETE;
1986     if (r != COMPLETE)
1987     {
1988         path_element->class->verrno = EPERM;
1989         return -1;
1990     }
1991     if (flush_directory_cache)
1992         vfs_s_invalidate (path_element->class, super);
1993     return 0;
1994 }
1995
1996 /* --------------------------------------------------------------------------------------------- */
1997
1998 static int
1999 ftpfs_chmod (const vfs_path_t * vpath, mode_t mode)
2000 {
2001     char buf[BUF_SMALL];
2002     int ret;
2003
2004     g_snprintf (buf, sizeof (buf), "SITE CHMOD %4.4o /%%s", (int) (mode & 07777));
2005
2006     ret = ftpfs_send_command (vpath, buf, OPT_FLUSH);
2007
2008     return ftpfs_ignore_chattr_errors ? 0 : ret;
2009 }
2010
2011 /* --------------------------------------------------------------------------------------------- */
2012
2013 static int
2014 ftpfs_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
2015 {
2016 #if 0
2017     (void) vpath;
2018     (void) owner;
2019     (void) group;
2020
2021     ftpfs_errno = EPERM;
2022     return -1;
2023 #else
2024     /* Everyone knows it is not possible to chown remotely, so why bother them.
2025        If someone's root, then copy/move will always try to chown it... */
2026     (void) vpath;
2027     (void) owner;
2028     (void) group;
2029     return 0;
2030 #endif
2031 }
2032
2033 /* --------------------------------------------------------------------------------------------- */
2034
2035 static int
2036 ftpfs_unlink (const vfs_path_t * vpath)
2037 {
2038     return ftpfs_send_command (vpath, "DELE /%s", OPT_FLUSH);
2039 }
2040
2041 /* --------------------------------------------------------------------------------------------- */
2042
2043 /* Return 1 if path is the same directory as the one we are in now */
2044 static int
2045 ftpfs_is_same_dir (struct vfs_class *me, struct vfs_s_super *super, const char *path)
2046 {
2047     (void) me;
2048
2049     if (SUP->current_dir == NULL)
2050         return FALSE;
2051     return (strcmp (path, SUP->current_dir) == 0);
2052 }
2053
2054 /* --------------------------------------------------------------------------------------------- */
2055
2056 static int
2057 ftpfs_chdir_internal (struct vfs_class *me, struct vfs_s_super *super, const char *remote_path)
2058 {
2059     int r;
2060     char *p;
2061
2062     if (!SUP->cwd_deferred && ftpfs_is_same_dir (me, super, remote_path))
2063         return COMPLETE;
2064
2065     p = ftpfs_translate_path (me, super, remote_path);
2066     r = ftpfs_command (me, super, WAIT_REPLY, "CWD /%s", p);
2067     g_free (p);
2068
2069     if (r != COMPLETE)
2070         ftpfs_errno = EIO;
2071     else
2072     {
2073         g_free (SUP->current_dir);
2074         SUP->current_dir = g_strdup (remote_path);
2075         SUP->cwd_deferred = 0;
2076     }
2077     return r;
2078 }
2079
2080 /* --------------------------------------------------------------------------------------------- */
2081
2082 static int
2083 ftpfs_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
2084 {
2085     ftpfs_send_command (vpath1, "RNFR /%s", OPT_FLUSH);
2086     return ftpfs_send_command (vpath2, "RNTO /%s", OPT_FLUSH);
2087 }
2088
2089 /* --------------------------------------------------------------------------------------------- */
2090
2091 static int
2092 ftpfs_mkdir (const vfs_path_t * vpath, mode_t mode)
2093 {
2094     (void) mode;                /* FIXME: should be used */
2095
2096     return ftpfs_send_command (vpath, "MKD /%s", OPT_FLUSH);
2097 }
2098
2099 /* --------------------------------------------------------------------------------------------- */
2100
2101 static int
2102 ftpfs_rmdir (const vfs_path_t * vpath)
2103 {
2104     return ftpfs_send_command (vpath, "RMD /%s", OPT_FLUSH);
2105 }
2106
2107 /* --------------------------------------------------------------------------------------------- */
2108
2109 static void
2110 ftpfs_fh_free_data (vfs_file_handler_t * fh)
2111 {
2112     if (fh != NULL)
2113     {
2114         g_free (fh->data);
2115         fh->data = NULL;
2116     }
2117 }
2118
2119 /* --------------------------------------------------------------------------------------------- */
2120
2121 static int
2122 ftpfs_fh_open (struct vfs_class *me, vfs_file_handler_t * fh, int flags, mode_t mode)
2123 {
2124     ftp_fh_data_t *ftp;
2125
2126     (void) mode;
2127
2128     fh->data = g_new0 (ftp_fh_data_t, 1);
2129     ftp = (ftp_fh_data_t *) fh->data;
2130     /* File will be written only, so no need to retrieve it from ftp server */
2131     if (((flags & O_WRONLY) == O_WRONLY) && ((flags & (O_RDONLY | O_RDWR)) == 0))
2132     {
2133 #ifdef HAVE_STRUCT_LINGER_L_LINGER
2134         struct linger li;
2135 #else
2136         int li = 1;
2137 #endif
2138         char *name;
2139
2140         /* ftpfs_linear_start() called, so data will be written
2141          * to local temporary file and stored to ftp server
2142          * by vfs_s_close later
2143          */
2144         if (((ftp_super_data_t *) (FH_SUPER->data))->ctl_connection_busy)
2145         {
2146             if (!fh->ino->localname)
2147             {
2148                 vfs_path_t *vpath;
2149                 int handle;
2150
2151                 handle = vfs_mkstemps (&vpath, me->name, fh->ino->ent->name);
2152                 if (handle == -1)
2153                 {
2154                     vfs_path_free (vpath);
2155                     goto fail;
2156                 }
2157                 close (handle);
2158                 fh->ino->localname = vfs_path_to_str (vpath);
2159                 vfs_path_free (vpath);
2160                 ftp->append = flags & O_APPEND;
2161             }
2162             return 0;
2163         }
2164         name = vfs_s_fullpath (me, fh->ino);
2165         if (name == NULL)
2166             goto fail;
2167         fh->handle =
2168             ftpfs_open_data_connection (me, fh->ino->super,
2169                                         (flags & O_APPEND) ? "APPE" : "STOR", name, TYPE_BINARY, 0);
2170         g_free (name);
2171
2172         if (fh->handle < 0)
2173             goto fail;
2174 #ifdef HAVE_STRUCT_LINGER_L_LINGER
2175         li.l_onoff = 1;
2176         li.l_linger = 120;
2177 #endif
2178         setsockopt (fh->handle, SOL_SOCKET, SO_LINGER, &li, sizeof (li));
2179
2180         if (fh->ino->localname)
2181         {
2182             unlink (fh->ino->localname);
2183             g_free (fh->ino->localname);
2184             fh->ino->localname = NULL;
2185         }
2186         return 0;
2187     }
2188
2189     if (!fh->ino->localname && vfs_s_retrieve_file (me, fh->ino) == -1)
2190         goto fail;
2191     if (!fh->ino->localname)
2192         vfs_die ("retrieve_file failed to fill in localname");
2193     return 0;
2194
2195   fail:
2196     ftpfs_fh_free_data (fh);
2197     return -1;
2198 }
2199
2200 /* --------------------------------------------------------------------------------------------- */
2201
2202 static int
2203 ftpfs_fh_close (struct vfs_class *me, vfs_file_handler_t * fh)
2204 {
2205     if (fh->handle != -1 && !fh->ino->localname)
2206     {
2207         ftp_super_data_t *ftp = (ftp_super_data_t *) fh->ino->super->data;
2208
2209         close (fh->handle);
2210         fh->handle = -1;
2211         /* File is stored to destination already, so
2212          * we prevent MEDATA->ftpfs_file_store() call from vfs_s_close ()
2213          */
2214         fh->changed = 0;
2215         if (ftpfs_get_reply (me, ftp->sock, NULL, 0) != COMPLETE)
2216             ERRNOR (EIO, -1);
2217         vfs_s_invalidate (me, FH_SUPER);
2218     }
2219
2220     return 0;
2221 }
2222
2223 /* --------------------------------------------------------------------------------------------- */
2224
2225 static void
2226 ftpfs_done (struct vfs_class *me)
2227 {
2228     (void) me;
2229
2230     g_slist_foreach (no_proxy, (GFunc) g_free, NULL);
2231     g_slist_free (no_proxy);
2232
2233     g_free (ftpfs_anonymous_passwd);
2234     g_free (ftpfs_proxy_host);
2235 }
2236
2237 /* --------------------------------------------------------------------------------------------- */
2238
2239 static void
2240 ftpfs_fill_names (struct vfs_class *me, fill_names_f func)
2241 {
2242     GList *iter;
2243
2244     for (iter = MEDATA->supers; iter != NULL; iter = g_list_next (iter))
2245     {
2246         const struct vfs_s_super *super = (const struct vfs_s_super *) iter->data;
2247         char *name;
2248
2249         name = vfs_path_element_build_pretty_path_str (super->path_element);
2250
2251         func (name);
2252         g_free (name);
2253     }
2254 }
2255
2256 /* --------------------------------------------------------------------------------------------- */
2257
2258 static keyword_t
2259 ftpfs_netrc_next (void)
2260 {
2261     char *p;
2262     keyword_t i;
2263     static const char *const keywords[] = { "default", "machine",
2264         "login", "password", "passwd", "account", "macdef", NULL
2265     };
2266
2267     while (1)
2268     {
2269         netrcp = skip_separators (netrcp);
2270         if (*netrcp != '\n')
2271             break;
2272         netrcp++;
2273     }
2274     if (!*netrcp)
2275         return NETRC_NONE;
2276     p = buffer;
2277     if (*netrcp == '"')
2278     {
2279         for (netrcp++; *netrcp != '"' && *netrcp; netrcp++)
2280         {
2281             if (*netrcp == '\\')
2282                 netrcp++;
2283             *p++ = *netrcp;
2284         }
2285     }
2286     else
2287     {
2288         for (; *netrcp != '\n' && *netrcp != '\t' && *netrcp != ' ' &&
2289              *netrcp != ',' && *netrcp; netrcp++)
2290         {
2291             if (*netrcp == '\\')
2292                 netrcp++;
2293             *p++ = *netrcp;
2294         }
2295     }
2296     *p = 0;
2297     if (!*buffer)
2298         return NETRC_NONE;
2299
2300     for (i = NETRC_DEFAULT; keywords[i - 1] != NULL; i++)
2301         if (strcmp (keywords[i - 1], buffer) == 0)
2302             return i;
2303
2304     return NETRC_UNKNOWN;
2305 }
2306
2307 /* --------------------------------------------------------------------------------------------- */
2308
2309 static int
2310 ftpfs_netrc_bad_mode (const char *netrcname)
2311 {
2312     static int be_angry = 1;
2313     struct stat mystat;
2314
2315     if (stat (netrcname, &mystat) >= 0 && (mystat.st_mode & 077))
2316     {
2317         if (be_angry)
2318         {
2319             message (D_ERROR, MSG_ERROR,
2320                      _("~/.netrc file has incorrect mode\nRemove password or correct mode"));
2321             be_angry = 0;
2322         }
2323         return 1;
2324     }
2325     return 0;
2326 }
2327
2328 /* --------------------------------------------------------------------------------------------- */
2329 /* Scan .netrc until we find matching "machine" or "default"
2330  * domain is used for additional matching
2331  * No search is done after "default" in compliance with "man netrc"
2332  * Return 0 if found, -1 otherwise */
2333
2334 static int
2335 ftpfs_find_machine (const char *host, const char *domain)
2336 {
2337     keyword_t keyword;
2338
2339     if (!host)
2340         host = "";
2341     if (!domain)
2342         domain = "";
2343
2344     while ((keyword = ftpfs_netrc_next ()) != NETRC_NONE)
2345     {
2346         if (keyword == NETRC_DEFAULT)
2347             return 0;
2348
2349         if (keyword == NETRC_MACDEF)
2350         {
2351             /* Scan for an empty line, which concludes "macdef" */
2352             do
2353             {
2354                 while (*netrcp && *netrcp != '\n')
2355                     netrcp++;
2356                 if (*netrcp != '\n')
2357                     break;
2358                 netrcp++;
2359             }
2360             while (*netrcp && *netrcp != '\n');
2361             continue;
2362         }
2363
2364         if (keyword != NETRC_MACHINE)
2365             continue;
2366
2367         /* Take machine name */
2368         if (ftpfs_netrc_next () == NETRC_NONE)
2369             break;
2370
2371         if (g_ascii_strcasecmp (host, buffer) != 0)
2372         {
2373             /* Try adding our domain to short names in .netrc */
2374             const char *host_domain = strchr (host, '.');
2375             if (!host_domain)
2376                 continue;
2377
2378             /* Compare domain part */
2379             if (g_ascii_strcasecmp (host_domain, domain) != 0)
2380                 continue;
2381
2382             /* Compare local part */
2383             if (g_ascii_strncasecmp (host, buffer, host_domain - host) != 0)
2384                 continue;
2385         }
2386
2387         return 0;
2388     }
2389
2390     /* end of .netrc */
2391     return -1;
2392 }
2393
2394 /* --------------------------------------------------------------------------------------------- */
2395 /* Extract login and password from .netrc for the host.
2396  * pass may be NULL.
2397  * Returns 0 for success, -1 for error */
2398
2399 static int
2400 ftpfs_netrc_lookup (const char *host, char **login, char **pass)
2401 {
2402     char *netrcname;
2403     char *tmp_pass = NULL;
2404     char hostname[MAXHOSTNAMELEN];
2405     const char *domain;
2406     keyword_t keyword;
2407     static struct rupcache
2408     {
2409         struct rupcache *next;
2410         char *host;
2411         char *login;
2412         char *pass;
2413     } *rup_cache = NULL, *rupp;
2414
2415     /* Initialize *login and *pass */
2416     g_free (*login);
2417     *login = NULL;
2418     g_free (*pass);
2419     *pass = NULL;
2420
2421     /* Look up in the cache first */
2422     for (rupp = rup_cache; rupp != NULL; rupp = rupp->next)
2423     {
2424         if (!strcmp (host, rupp->host))
2425         {
2426             if (rupp->login)
2427                 *login = g_strdup (rupp->login);
2428             if (pass && rupp->pass)
2429                 *pass = g_strdup (rupp->pass);
2430             return 0;
2431         }
2432     }
2433
2434     /* Load current .netrc */
2435     netrcname = g_build_filename (mc_config_get_home_dir (), ".netrc", (char *) NULL);
2436     if (!g_file_get_contents (netrcname, &netrc, NULL, NULL))
2437     {
2438         g_free (netrcname);
2439         return 0;
2440     }
2441
2442     netrcp = netrc;
2443
2444     /* Find our own domain name */
2445     if (gethostname (hostname, sizeof (hostname)) < 0)
2446         *hostname = '\0';
2447
2448     domain = strchr (hostname, '.');
2449     if (domain == NULL)
2450         domain = "";
2451
2452     /* Scan for "default" and matching "machine" keywords */
2453     ftpfs_find_machine (host, domain);
2454
2455     /* Scan for keywords following "default" and "machine" */
2456     while (1)
2457     {
2458         int need_break = 0;
2459         keyword = ftpfs_netrc_next ();
2460
2461         switch (keyword)
2462         {
2463         case NETRC_LOGIN:
2464             if (ftpfs_netrc_next () == NETRC_NONE)
2465             {
2466                 need_break = 1;
2467                 break;
2468             }
2469
2470             /* We have another name already - should not happen */
2471             if (*login)
2472             {
2473                 need_break = 1;
2474                 break;
2475             }
2476
2477             /* We have login name now */
2478             *login = g_strdup (buffer);
2479             break;
2480
2481         case NETRC_PASSWORD:
2482         case NETRC_PASSWD:
2483             if (ftpfs_netrc_next () == NETRC_NONE)
2484             {
2485                 need_break = 1;
2486                 break;
2487             }
2488
2489             /* Ignore unsafe passwords */
2490             if (*login != NULL &&
2491                 strcmp (*login, "anonymous") != 0 && strcmp (*login, "ftp") != 0
2492                 && ftpfs_netrc_bad_mode (netrcname))
2493             {
2494                 need_break = 1;
2495                 break;
2496             }
2497
2498             /* Remember password.  pass may be NULL, so use tmp_pass */
2499             if (tmp_pass == NULL)
2500                 tmp_pass = g_strdup (buffer);
2501             break;
2502
2503         case NETRC_ACCOUNT:
2504             /* "account" is followed by a token which we ignore */
2505             if (ftpfs_netrc_next () == NETRC_NONE)
2506             {
2507                 need_break = 1;
2508                 break;
2509             }
2510
2511             /* Ignore account, but warn user anyways */
2512             ftpfs_netrc_bad_mode (netrcname);
2513             break;
2514
2515         default:
2516             /* Unexpected keyword or end of file */
2517             need_break = 1;
2518             break;
2519         }
2520
2521         if (need_break)
2522             break;
2523     }
2524
2525     g_free (netrc);
2526     g_free (netrcname);
2527
2528     rupp = g_new (struct rupcache, 1);
2529     rupp->host = g_strdup (host);
2530     rupp->login = g_strdup (*login);
2531     rupp->pass = g_strdup (tmp_pass);
2532
2533     rupp->next = rup_cache;
2534     rup_cache = rupp;
2535
2536     *pass = tmp_pass;
2537
2538     return 0;
2539 }
2540
2541 /* --------------------------------------------------------------------------------------------- */
2542 /*** public functions ****************************************************************************/
2543 /* --------------------------------------------------------------------------------------------- */
2544
2545 /** This routine is called as the last step in load_setup */
2546 void
2547 ftpfs_init_passwd (void)
2548 {
2549     ftpfs_anonymous_passwd = load_anon_passwd ();
2550     if (ftpfs_anonymous_passwd)
2551         return;
2552
2553     /* If there is no anonymous ftp password specified
2554      * then we'll just use anonymous@
2555      * We don't send any other thing because:
2556      * - We want to remain anonymous
2557      * - We want to stop SPAM
2558      * - We don't want to let ftp sites to discriminate by the user,
2559      *   host or country.
2560      */
2561     ftpfs_anonymous_passwd = g_strdup ("anonymous@");
2562 }
2563
2564 /* --------------------------------------------------------------------------------------------- */
2565
2566 void
2567 init_ftpfs (void)
2568 {
2569     static struct vfs_s_subclass ftpfs_subclass;
2570
2571     tcp_init ();
2572
2573     ftpfs_subclass.flags = VFS_S_REMOTE | VFS_S_USETMP;
2574     ftpfs_subclass.archive_same = ftpfs_archive_same;
2575     ftpfs_subclass.open_archive = ftpfs_open_archive;
2576     ftpfs_subclass.free_archive = ftpfs_free_archive;
2577     ftpfs_subclass.fh_open = ftpfs_fh_open;
2578     ftpfs_subclass.fh_close = ftpfs_fh_close;
2579     ftpfs_subclass.fh_free_data = ftpfs_fh_free_data;
2580     ftpfs_subclass.dir_load = ftpfs_dir_load;
2581     ftpfs_subclass.file_store = ftpfs_file_store;
2582     ftpfs_subclass.linear_start = ftpfs_linear_start;
2583     ftpfs_subclass.linear_read = ftpfs_linear_read;
2584     ftpfs_subclass.linear_close = ftpfs_linear_close;
2585
2586     vfs_s_init_class (&vfs_ftpfs_ops, &ftpfs_subclass);
2587     vfs_ftpfs_ops.name = "ftpfs";
2588     vfs_ftpfs_ops.flags = VFSF_NOLINKS;
2589     vfs_ftpfs_ops.prefix = "ftp";
2590     vfs_ftpfs_ops.done = &ftpfs_done;
2591     vfs_ftpfs_ops.fill_names = ftpfs_fill_names;
2592     vfs_ftpfs_ops.chmod = ftpfs_chmod;
2593     vfs_ftpfs_ops.chown = ftpfs_chown;
2594     vfs_ftpfs_ops.unlink = ftpfs_unlink;
2595     vfs_ftpfs_ops.rename = ftpfs_rename;
2596     vfs_ftpfs_ops.mkdir = ftpfs_mkdir;
2597     vfs_ftpfs_ops.rmdir = ftpfs_rmdir;
2598     vfs_ftpfs_ops.ctl = ftpfs_ctl;
2599     vfs_register_class (&vfs_ftpfs_ops);
2600 }
2601
2602 /* --------------------------------------------------------------------------------------------- */