sjero.net Git - wget/blob - src/ftp-basic.c

   1 /* Basic FTP routines.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Wget.
   6
   7 GNU Wget is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3 of the License, or
  10  (at your option) any later version.
  11
  12 GNU Wget is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 Additional permission under GNU GPL version 3 section 7
  21
  22 If you modify this program, or any covered work, by linking or
  23 combining it with the OpenSSL project's OpenSSL library (or a
  24 modified version of that library), containing parts covered by the
  25 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
  26 grants you additional permission to convey the resulting work.
  27 Corresponding Source for a non-source form of such a combination
  28 shall include the source code for the parts of OpenSSL used as well
  29 as that of the covered work.  */
  30
  31 #include "wget.h"
  32
  33 #include <assert.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <errno.h>
  37
  38 #include <string.h>
  39 #ifdef HAVE_UNISTD_H
  40 # include <unistd.h>
  41 #endif
  42 #include "utils.h"
  43 #include "connect.h"
  44 #include "host.h"
  45 #include "ftp.h"
  46 #include "retr.h"
  47
  48 char ftp_last_respline[128];
  49
  50 \f
  51 /* Get the response of FTP server and allocate enough room to handle
  52    it.  <CR> and <LF> characters are stripped from the line, and the
  53    line is 0-terminated.  All the response lines but the last one are
  54    skipped.  The last line is determined as described in RFC959.
  55
  56    If the line is successfully read, FTPOK is returned, and *ret_line
  57    is assigned a freshly allocated line.  Otherwise, FTPRERR is
  58    returned, and the value of *ret_line should be ignored.  */
  59
  60 uerr_t
  61 ftp_response (int fd, char **ret_line)
  62 {
  63   while (1)
  64     {
  65       char *p;
  66       char *line = fd_read_line (fd);
  67       if (!line)
  68         return FTPRERR;
  69
  70       /* Strip trailing CRLF before printing the line, so that
  71          quotting doesn't include bogus \012 and \015. */
  72       p = strchr (line, '\0');
  73       if (p > line && p[-1] == '\n')
  74         *--p = '\0';
  75       if (p > line && p[-1] == '\r')
  76         *--p = '\0';
  77
  78       if (opt.server_response)
  79         logprintf (LOG_NOTQUIET, "%s\n",
  80                    quotearg_style (escape_quoting_style, line));
  81       else
  82         DEBUGP (("%s\n", quotearg_style (escape_quoting_style, line)));
  83
  84       /* The last line of output is the one that begins with "ddd ". */
  85       if (c_isdigit (line[0]) && c_isdigit (line[1]) && c_isdigit (line[2])
  86           && line[3] == ' ')
  87         {
  88           strncpy (ftp_last_respline, line, sizeof (ftp_last_respline));
  89           ftp_last_respline[sizeof (ftp_last_respline) - 1] = '\0';
  90           *ret_line = line;
  91           return FTPOK;
  92         }
  93       xfree (line);
  94     }
  95 }
  96
  97 /* Returns the malloc-ed FTP request, ending with <CR><LF>, printing
  98    it if printing is required.  If VALUE is NULL, just use
  99    command<CR><LF>.  */
 100 static char *
 101 ftp_request (const char *command, const char *value)
 102 {
 103   char *res;
 104   if (value)
 105     {
 106       /* Check for newlines in VALUE (possibly injected by the %0A URL
 107          escape) making the callers inadvertently send multiple FTP
 108          commands at once.  Without this check an attacker could
 109          intentionally redirect to ftp://server/fakedir%0Acommand.../
 110          and execute arbitrary FTP command on a remote FTP server.  */
 111       if (strpbrk (value, "\r\n"))
 112         {
 113           /* Copy VALUE to the stack and modify CR/LF to space. */
 114           char *defanged, *p;
 115           STRDUP_ALLOCA (defanged, value);
 116           for (p = defanged; *p; p++)
 117             if (*p == '\r' || *p == '\n')
 118               *p = ' ';
 119           DEBUGP (("\nDetected newlines in %s \"%s\"; changing to %s \"%s\"\n",
 120                    command, quotearg_style (escape_quoting_style, value),
 121                    command, quotearg_style (escape_quoting_style, defanged)));
 122           /* Make VALUE point to the defanged copy of the string. */
 123           value = defanged;
 124         }
 125       res = concat_strings (command, " ", value, "\r\n", (char *) 0);
 126     }
 127   else
 128     res = concat_strings (command, "\r\n", (char *) 0);
 129   if (opt.server_response)
 130     {
 131       /* Hack: don't print out password.  */
 132       if (strncmp (res, "PASS", 4) != 0)
 133         logprintf (LOG_ALWAYS, "--> %s\n", res);
 134       else
 135         logputs (LOG_ALWAYS, "--> PASS Turtle Power!\n\n");
 136     }
 137   else
 138     DEBUGP (("\n--> %s\n", res));
 139   return res;
 140 }
 141
 142 /* Sends the USER and PASS commands to the server, to control
 143    connection socket csock.  */
 144 uerr_t
 145 ftp_login (int csock, const char *acc, const char *pass)
 146 {
 147   uerr_t err;
 148   char *request, *respline;
 149   int nwritten;
 150
 151   /* Get greeting.  */
 152   err = ftp_response (csock, &respline);
 153   if (err != FTPOK)
 154     return err;
 155   if (*respline != '2')
 156     {
 157       xfree (respline);
 158       return FTPSRVERR;
 159     }
 160   xfree (respline);
 161   /* Send USER username.  */
 162   request = ftp_request ("USER", acc);
 163   nwritten = fd_write (csock, request, strlen (request), -1);
 164   if (nwritten < 0)
 165     {
 166       xfree (request);
 167       return WRITEFAILED;
 168     }
 169   xfree (request);
 170   /* Get appropriate response.  */
 171   err = ftp_response (csock, &respline);
 172   if (err != FTPOK)
 173     return err;
 174   /* An unprobable possibility of logging without a password.  */
 175   if (*respline == '2')
 176     {
 177       xfree (respline);
 178       return FTPOK;
 179     }
 180   /* Else, only response 3 is appropriate.  */
 181   if (*respline != '3')
 182     {
 183       xfree (respline);
 184       return FTPLOGREFUSED;
 185     }
 186 #ifdef ENABLE_OPIE
 187   {
 188     static const char *skey_head[] = {
 189       "331 s/key ",
 190       "331 opiekey "
 191     };
 192     size_t i;
 193     const char *seed = NULL;
 194
 195     for (i = 0; i < countof (skey_head); i++)
 196       {
 197         int l = strlen (skey_head[i]);
 198         if (0 == strncasecmp (skey_head[i], respline, l))
 199           {
 200             seed = respline + l;
 201             break;
 202           }
 203       }
 204     if (seed)
 205       {
 206         int skey_sequence = 0;
 207
 208         /* Extract the sequence from SEED.  */
 209         for (; c_isdigit (*seed); seed++)
 210           skey_sequence = 10 * skey_sequence + *seed - '0';
 211         if (*seed == ' ')
 212           ++seed;
 213         else
 214           {
 215             xfree (respline);
 216             return FTPLOGREFUSED;
 217           }
 218         /* Replace the password with the SKEY response to the
 219            challenge.  */
 220         pass = skey_response (skey_sequence, seed, pass);
 221       }
 222   }
 223 #endif /* ENABLE_OPIE */
 224   xfree (respline);
 225   /* Send PASS password.  */
 226   request = ftp_request ("PASS", pass);
 227   nwritten = fd_write (csock, request, strlen (request), -1);
 228   if (nwritten < 0)
 229     {
 230       xfree (request);
 231       return WRITEFAILED;
 232     }
 233   xfree (request);
 234   /* Get appropriate response.  */
 235   err = ftp_response (csock, &respline);
 236   if (err != FTPOK)
 237     return err;
 238   if (*respline != '2')
 239     {
 240       xfree (respline);
 241       return FTPLOGINC;
 242     }
 243   xfree (respline);
 244   /* All OK.  */
 245   return FTPOK;
 246 }
 247
 248 static void
 249 ip_address_to_port_repr (const ip_address *addr, int port, char *buf,
 250                          size_t buflen)
 251 {
 252   unsigned char *ptr;
 253
 254   assert (addr->family == AF_INET);
 255   /* buf must contain the argument of PORT (of the form a,b,c,d,e,f). */
 256   assert (buflen >= 6 * 4);
 257
 258   ptr = IP_INADDR_DATA (addr);
 259   snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d", ptr[0], ptr[1],
 260             ptr[2], ptr[3], (port & 0xff00) >> 8, port & 0xff);
 261   buf[buflen - 1] = '\0';
 262 }
 263
 264 /* Bind a port and send the appropriate PORT command to the FTP
 265    server.  Use acceptport after RETR, to get the socket of data
 266    connection.  */
 267 uerr_t
 268 ftp_port (int csock, int *local_sock)
 269 {
 270   uerr_t err;
 271   char *request, *respline;
 272   ip_address addr;
 273   int nwritten;
 274   int port;
 275   /* Must contain the argument of PORT (of the form a,b,c,d,e,f). */
 276   char bytes[6 * 4 + 1];
 277
 278   /* Get the address of this side of the connection. */
 279   if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
 280     return FTPSYSERR;
 281
 282   assert (addr.family == AF_INET);
 283
 284   /* Setting port to 0 lets the system choose a free port.  */
 285   port = 0;
 286
 287   /* Bind the port.  */
 288   *local_sock = bind_local (&addr, &port);
 289   if (*local_sock < 0)
 290     return FTPSYSERR;
 291
 292   /* Construct the argument of PORT (of the form a,b,c,d,e,f). */
 293   ip_address_to_port_repr (&addr, port, bytes, sizeof (bytes));
 294
 295   /* Send PORT request.  */
 296   request = ftp_request ("PORT", bytes);
 297   nwritten = fd_write (csock, request, strlen (request), -1);
 298   if (nwritten < 0)
 299     {
 300       xfree (request);
 301       fd_close (*local_sock);
 302       return WRITEFAILED;
 303     }
 304   xfree (request);
 305
 306   /* Get appropriate response.  */
 307   err = ftp_response (csock, &respline);
 308   if (err != FTPOK)
 309     {
 310       fd_close (*local_sock);
 311       return err;
 312     }
 313   if (*respline != '2')
 314     {
 315       xfree (respline);
 316       fd_close (*local_sock);
 317       return FTPPORTERR;
 318     }
 319   xfree (respline);
 320   return FTPOK;
 321 }
 322
 323 #ifdef ENABLE_IPV6
 324 static void
 325 ip_address_to_lprt_repr (const ip_address *addr, int port, char *buf,
 326                          size_t buflen)
 327 {
 328   unsigned char *ptr = IP_INADDR_DATA (addr);
 329
 330   /* buf must contain the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
 331   assert (buflen >= 21 * 4);
 332
 333   /* Construct the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
 334   switch (addr->family)
 335     {
 336     case AF_INET:
 337       snprintf (buf, buflen, "%d,%d,%d,%d,%d,%d,%d,%d,%d", 4, 4,
 338                 ptr[0], ptr[1], ptr[2], ptr[3], 2,
 339                 (port & 0xff00) >> 8, port & 0xff);
 340       break;
 341     case AF_INET6:
 342       snprintf (buf, buflen,
 343                 "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
 344                 6, 16,
 345                 ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7],
 346                 ptr[8], ptr[9], ptr[10], ptr[11], ptr[12], ptr[13], ptr[14], ptr[15],
 347                 2, (port & 0xff00) >> 8, port & 0xff);
 348       break;
 349     default:
 350       abort ();
 351     }
 352 }
 353
 354 /* Bind a port and send the appropriate PORT command to the FTP
 355    server.  Use acceptport after RETR, to get the socket of data
 356    connection.  */
 357 uerr_t
 358 ftp_lprt (int csock, int *local_sock)
 359 {
 360   uerr_t err;
 361   char *request, *respline;
 362   ip_address addr;
 363   int nwritten;
 364   int port;
 365   /* Must contain the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
 366   char bytes[21 * 4 + 1];
 367
 368   /* Get the address of this side of the connection. */
 369   if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
 370     return FTPSYSERR;
 371
 372   assert (addr.family == AF_INET || addr.family == AF_INET6);
 373
 374   /* Setting port to 0 lets the system choose a free port.  */
 375   port = 0;
 376
 377   /* Bind the port.  */
 378   *local_sock = bind_local (&addr, &port);
 379   if (*local_sock < 0)
 380     return FTPSYSERR;
 381
 382   /* Construct the argument of LPRT (of the form af,n,h1,h2,...,hn,p1,p2). */
 383   ip_address_to_lprt_repr (&addr, port, bytes, sizeof (bytes));
 384
 385   /* Send PORT request.  */
 386   request = ftp_request ("LPRT", bytes);
 387   nwritten = fd_write (csock, request, strlen (request), -1);
 388   if (nwritten < 0)
 389     {
 390       xfree (request);
 391       fd_close (*local_sock);
 392       return WRITEFAILED;
 393     }
 394   xfree (request);
 395   /* Get appropriate response.  */
 396   err = ftp_response (csock, &respline);
 397   if (err != FTPOK)
 398     {
 399       fd_close (*local_sock);
 400       return err;
 401     }
 402   if (*respline != '2')
 403     {
 404       xfree (respline);
 405       fd_close (*local_sock);
 406       return FTPPORTERR;
 407     }
 408   xfree (respline);
 409   return FTPOK;
 410 }
 411
 412 static void
 413 ip_address_to_eprt_repr (const ip_address *addr, int port, char *buf,
 414                          size_t buflen)
 415 {
 416   int afnum;
 417
 418   /* buf must contain the argument of EPRT (of the form |af|addr|port|).
 419    * 4 chars for the | separators, INET6_ADDRSTRLEN chars for addr
 420    * 1 char for af (1-2) and 5 chars for port (0-65535) */
 421   assert (buflen >= 4 + INET6_ADDRSTRLEN + 1 + 5);
 422
 423   /* Construct the argument of EPRT (of the form |af|addr|port|). */
 424   afnum = (addr->family == AF_INET ? 1 : 2);
 425   snprintf (buf, buflen, "|%d|%s|%d|", afnum, print_address (addr), port);
 426   buf[buflen - 1] = '\0';
 427 }
 428
 429 /* Bind a port and send the appropriate PORT command to the FTP
 430    server.  Use acceptport after RETR, to get the socket of data
 431    connection.  */
 432 uerr_t
 433 ftp_eprt (int csock, int *local_sock)
 434 {
 435   uerr_t err;
 436   char *request, *respline;
 437   ip_address addr;
 438   int nwritten;
 439   int port;
 440   /* Must contain the argument of EPRT (of the form |af|addr|port|).
 441    * 4 chars for the | separators, INET6_ADDRSTRLEN chars for addr
 442    * 1 char for af (1-2) and 5 chars for port (0-65535) */
 443   char bytes[4 + INET6_ADDRSTRLEN + 1 + 5 + 1];
 444
 445   /* Get the address of this side of the connection. */
 446   if (!socket_ip_address (csock, &addr, ENDPOINT_LOCAL))
 447     return FTPSYSERR;
 448
 449   /* Setting port to 0 lets the system choose a free port.  */
 450   port = 0;
 451
 452   /* Bind the port.  */
 453   *local_sock = bind_local (&addr, &port);
 454   if (*local_sock < 0)
 455     return FTPSYSERR;
 456
 457   /* Construct the argument of EPRT (of the form |af|addr|port|). */
 458   ip_address_to_eprt_repr (&addr, port, bytes, sizeof (bytes));
 459
 460   /* Send PORT request.  */
 461   request = ftp_request ("EPRT", bytes);
 462   nwritten = fd_write (csock, request, strlen (request), -1);
 463   if (nwritten < 0)
 464     {
 465       xfree (request);
 466       fd_close (*local_sock);
 467       return WRITEFAILED;
 468     }
 469   xfree (request);
 470   /* Get appropriate response.  */
 471   err = ftp_response (csock, &respline);
 472   if (err != FTPOK)
 473     {
 474       fd_close (*local_sock);
 475       return err;
 476     }
 477   if (*respline != '2')
 478     {
 479       xfree (respline);
 480       fd_close (*local_sock);
 481       return FTPPORTERR;
 482     }
 483   xfree (respline);
 484   return FTPOK;
 485 }
 486 #endif
 487
 488 /* Similar to ftp_port, but uses `PASV' to initiate the passive FTP
 489    transfer.  Reads the response from server and parses it.  Reads the
 490    host and port addresses and returns them.  */
 491 uerr_t
 492 ftp_pasv (int csock, ip_address *addr, int *port)
 493 {
 494   char *request, *respline, *s;
 495   int nwritten, i;
 496   uerr_t err;
 497   unsigned char tmp[6];
 498
 499   assert (addr != NULL);
 500   assert (port != NULL);
 501
 502   xzero (*addr);
 503
 504   /* Form the request.  */
 505   request = ftp_request ("PASV", NULL);
 506   /* And send it.  */
 507   nwritten = fd_write (csock, request, strlen (request), -1);
 508   if (nwritten < 0)
 509     {
 510       xfree (request);
 511       return WRITEFAILED;
 512     }
 513   xfree (request);
 514   /* Get the server response.  */
 515   err = ftp_response (csock, &respline);
 516   if (err != FTPOK)
 517     return err;
 518   if (*respline != '2')
 519     {
 520       xfree (respline);
 521       return FTPNOPASV;
 522     }
 523   /* Parse the request.  */
 524   s = respline;
 525   for (s += 4; *s && !c_isdigit (*s); s++)
 526     ;
 527   if (!*s)
 528     return FTPINVPASV;
 529   for (i = 0; i < 6; i++)
 530     {
 531       tmp[i] = 0;
 532       for (; c_isdigit (*s); s++)
 533         tmp[i] = (*s - '0') + 10 * tmp[i];
 534       if (*s == ',')
 535         s++;
 536       else if (i < 5)
 537         {
 538           /* When on the last number, anything can be a terminator.  */
 539           xfree (respline);
 540           return FTPINVPASV;
 541         }
 542     }
 543   xfree (respline);
 544
 545   addr->family = AF_INET;
 546   memcpy (IP_INADDR_DATA (addr), tmp, 4);
 547   *port = ((tmp[4] << 8) & 0xff00) + tmp[5];
 548
 549   return FTPOK;
 550 }
 551
 552 #ifdef ENABLE_IPV6
 553 /* Similar to ftp_lprt, but uses `LPSV' to initiate the passive FTP
 554    transfer.  Reads the response from server and parses it.  Reads the
 555    host and port addresses and returns them.  */
 556 uerr_t
 557 ftp_lpsv (int csock, ip_address *addr, int *port)
 558 {
 559   char *request, *respline, *s;
 560   int nwritten, i, af, addrlen, portlen;
 561   uerr_t err;
 562   unsigned char tmp[16];
 563   unsigned char tmpprt[2];
 564
 565   assert (addr != NULL);
 566   assert (port != NULL);
 567
 568   xzero (*addr);
 569
 570   /* Form the request.  */
 571   request = ftp_request ("LPSV", NULL);
 572
 573   /* And send it.  */
 574   nwritten = fd_write (csock, request, strlen (request), -1);
 575   if (nwritten < 0)
 576     {
 577       xfree (request);
 578       return WRITEFAILED;
 579     }
 580   xfree (request);
 581
 582   /* Get the server response.  */
 583   err = ftp_response (csock, &respline);
 584   if (err != FTPOK)
 585     return err;
 586   if (*respline != '2')
 587     {
 588       xfree (respline);
 589       return FTPNOPASV;
 590     }
 591
 592   /* Parse the response.  */
 593   s = respline;
 594   for (s += 4; *s && !c_isdigit (*s); s++)
 595     ;
 596   if (!*s)
 597     return FTPINVPASV;
 598
 599   /* First, get the address family */
 600   af = 0;
 601   for (; c_isdigit (*s); s++)
 602     af = (*s - '0') + 10 * af;
 603
 604   if (af != 4 && af != 6)
 605     {
 606       xfree (respline);
 607       return FTPINVPASV;
 608     }
 609
 610   if (!*s || *s++ != ',')
 611     {
 612       xfree (respline);
 613       return FTPINVPASV;
 614     }
 615
 616   /* Then, get the address length */
 617   addrlen = 0;
 618   for (; c_isdigit (*s); s++)
 619     addrlen = (*s - '0') + 10 * addrlen;
 620
 621   if (!*s || *s++ != ',')
 622     {
 623       xfree (respline);
 624       return FTPINVPASV;
 625     }
 626
 627   if (addrlen > 16)
 628     {
 629       xfree (respline);
 630       return FTPINVPASV;
 631     }
 632
 633   if ((af == 4 && addrlen != 4)
 634       || (af == 6 && addrlen != 16))
 635     {
 636       xfree (respline);
 637       return FTPINVPASV;
 638     }
 639
 640   /* Now, we get the actual address */
 641   for (i = 0; i < addrlen; i++)
 642     {
 643       tmp[i] = 0;
 644       for (; c_isdigit (*s); s++)
 645         tmp[i] = (*s - '0') + 10 * tmp[i];
 646       if (*s == ',')
 647         s++;
 648       else
 649         {
 650           xfree (respline);
 651           return FTPINVPASV;
 652         }
 653     }
 654
 655   /* Now, get the port length */
 656   portlen = 0;
 657   for (; c_isdigit (*s); s++)
 658     portlen = (*s - '0') + 10 * portlen;
 659
 660   if (!*s || *s++ != ',')
 661     {
 662       xfree (respline);
 663       return FTPINVPASV;
 664     }
 665
 666   if (portlen > 2)
 667     {
 668       xfree (respline);
 669       return FTPINVPASV;
 670     }
 671
 672   /* Finally, we get the port number */
 673   tmpprt[0] = 0;
 674   for (; c_isdigit (*s); s++)
 675     tmpprt[0] = (*s - '0') + 10 * tmpprt[0];
 676
 677   if (!*s || *s++ != ',')
 678     {
 679       xfree (respline);
 680       return FTPINVPASV;
 681     }
 682
 683   tmpprt[1] = 0;
 684   for (; c_isdigit (*s); s++)
 685     tmpprt[1] = (*s - '0') + 10 * tmpprt[1];
 686
 687   assert (s != NULL);
 688
 689   if (af == 4)
 690     {
 691       addr->family = AF_INET;
 692       memcpy (IP_INADDR_DATA (addr), tmp, 4);
 693       *port = ((tmpprt[0] << 8) & 0xff00) + tmpprt[1];
 694       DEBUGP (("lpsv addr is: %s\n", print_address(addr)));
 695       DEBUGP (("tmpprt[0] is: %d\n", tmpprt[0]));
 696       DEBUGP (("tmpprt[1] is: %d\n", tmpprt[1]));
 697       DEBUGP (("*port is: %d\n", *port));
 698     }
 699   else
 700     {
 701       assert (af == 6);
 702       addr->family = AF_INET6;
 703       memcpy (IP_INADDR_DATA (addr), tmp, 16);
 704       *port = ((tmpprt[0] << 8) & 0xff00) + tmpprt[1];
 705       DEBUGP (("lpsv addr is: %s\n", print_address(addr)));
 706       DEBUGP (("tmpprt[0] is: %d\n", tmpprt[0]));
 707       DEBUGP (("tmpprt[1] is: %d\n", tmpprt[1]));
 708       DEBUGP (("*port is: %d\n", *port));
 709     }
 710
 711   xfree (respline);
 712   return FTPOK;
 713 }
 714
 715 /* Similar to ftp_eprt, but uses `EPSV' to initiate the passive FTP
 716    transfer.  Reads the response from server and parses it.  Reads the
 717    host and port addresses and returns them.  */
 718 uerr_t
 719 ftp_epsv (int csock, ip_address *ip, int *port)
 720 {
 721   char *request, *respline, *start, delim, *s;
 722   int nwritten, i;
 723   uerr_t err;
 724   int tport;
 725
 726   assert (ip != NULL);
 727   assert (port != NULL);
 728
 729   /* IP already contains the IP address of the control connection's
 730      peer, so we don't need to call socket_ip_address here.  */
 731
 732   /* Form the request.  */
 733   /* EPSV 1 means that we ask for IPv4 and EPSV 2 means that we ask for IPv6. */
 734   request = ftp_request ("EPSV", (ip->family == AF_INET ? "1" : "2"));
 735
 736   /* And send it.  */
 737   nwritten = fd_write (csock, request, strlen (request), -1);
 738   if (nwritten < 0)
 739     {
 740       xfree (request);
 741       return WRITEFAILED;
 742     }
 743   xfree (request);
 744
 745   /* Get the server response.  */
 746   err = ftp_response (csock, &respline);
 747   if (err != FTPOK)
 748     return err;
 749   if (*respline != '2')
 750     {
 751       xfree (respline);
 752       return FTPNOPASV;
 753     }
 754
 755   assert (respline != NULL);
 756
 757   DEBUGP(("respline is %s\n", respline));
 758
 759   /* Parse the response.  */
 760   s = respline;
 761
 762   /* Skip the useless stuff and get what's inside the parentheses */
 763   start = strchr (respline, '(');
 764   if (start == NULL)
 765     {
 766       xfree (respline);
 767       return FTPINVPASV;
 768     }
 769
 770   /* Skip the first two void fields */
 771   s = start + 1;
 772   delim = *s++;
 773   if (delim < 33 || delim > 126)
 774     {
 775       xfree (respline);
 776       return FTPINVPASV;
 777     }
 778
 779   for (i = 0; i < 2; i++)
 780     {
 781       if (*s++ != delim)
 782         {
 783           xfree (respline);
 784         return FTPINVPASV;
 785         }
 786     }
 787
 788   /* Finally, get the port number */
 789   tport = 0;
 790   for (i = 1; c_isdigit (*s); s++)
 791     {
 792       if (i > 5)
 793         {
 794           xfree (respline);
 795           return FTPINVPASV;
 796         }
 797       tport = (*s - '0') + 10 * tport;
 798     }
 799
 800   /* Make sure that the response terminates correcty */
 801   if (*s++ != delim)
 802     {
 803       xfree (respline);
 804       return FTPINVPASV;
 805     }
 806
 807   if (*s++ != ')')
 808     {
 809       xfree (respline);
 810       return FTPINVPASV;
 811     }
 812
 813   *port = tport;
 814
 815   xfree (respline);
 816   return FTPOK;
 817 }
 818 #endif
 819
 820 /* Sends the TYPE request to the server.  */
 821 uerr_t
 822 ftp_type (int csock, int type)
 823 {
 824   char *request, *respline;
 825   int nwritten;
 826   uerr_t err;
 827   char stype[2];
 828
 829   /* Construct argument.  */
 830   stype[0] = type;
 831   stype[1] = 0;
 832   /* Send TYPE request.  */
 833   request = ftp_request ("TYPE", stype);
 834   nwritten = fd_write (csock, request, strlen (request), -1);
 835   if (nwritten < 0)
 836     {
 837       xfree (request);
 838       return WRITEFAILED;
 839     }
 840   xfree (request);
 841   /* Get appropriate response.  */
 842   err = ftp_response (csock, &respline);
 843   if (err != FTPOK)
 844     return err;
 845   if (*respline != '2')
 846     {
 847       xfree (respline);
 848       return FTPUNKNOWNTYPE;
 849     }
 850   xfree (respline);
 851   /* All OK.  */
 852   return FTPOK;
 853 }
 854
 855 /* Changes the working directory by issuing a CWD command to the
 856    server.  */
 857 uerr_t
 858 ftp_cwd (int csock, const char *dir)
 859 {
 860   char *request, *respline;
 861   int nwritten;
 862   uerr_t err;
 863
 864   /* Send CWD request.  */
 865   request = ftp_request ("CWD", dir);
 866   nwritten = fd_write (csock, request, strlen (request), -1);
 867   if (nwritten < 0)
 868     {
 869       xfree (request);
 870       return WRITEFAILED;
 871     }
 872   xfree (request);
 873   /* Get appropriate response.  */
 874   err = ftp_response (csock, &respline);
 875   if (err != FTPOK)
 876     return err;
 877   if (*respline == '5')
 878     {
 879       xfree (respline);
 880       return FTPNSFOD;
 881     }
 882   if (*respline != '2')
 883     {
 884       xfree (respline);
 885       return FTPRERR;
 886     }
 887   xfree (respline);
 888   /* All OK.  */
 889   return FTPOK;
 890 }
 891
 892 /* Sends REST command to the FTP server.  */
 893 uerr_t
 894 ftp_rest (int csock, wgint offset)
 895 {
 896   char *request, *respline;
 897   int nwritten;
 898   uerr_t err;
 899
 900   request = ftp_request ("REST", number_to_static_string (offset));
 901   nwritten = fd_write (csock, request, strlen (request), -1);
 902   if (nwritten < 0)
 903     {
 904       xfree (request);
 905       return WRITEFAILED;
 906     }
 907   xfree (request);
 908   /* Get appropriate response.  */
 909   err = ftp_response (csock, &respline);
 910   if (err != FTPOK)
 911     return err;
 912   if (*respline != '3')
 913     {
 914       xfree (respline);
 915       return FTPRESTFAIL;
 916     }
 917   xfree (respline);
 918   /* All OK.  */
 919   return FTPOK;
 920 }
 921
 922 /* Sends RETR command to the FTP server.  */
 923 uerr_t
 924 ftp_retr (int csock, const char *file)
 925 {
 926   char *request, *respline;
 927   int nwritten;
 928   uerr_t err;
 929
 930   /* Send RETR request.  */
 931   request = ftp_request ("RETR", file);
 932   nwritten = fd_write (csock, request, strlen (request), -1);
 933   if (nwritten < 0)
 934     {
 935       xfree (request);
 936       return WRITEFAILED;
 937     }
 938   xfree (request);
 939   /* Get appropriate response.  */
 940   err = ftp_response (csock, &respline);
 941   if (err != FTPOK)
 942     return err;
 943   if (*respline == '5')
 944     {
 945       xfree (respline);
 946       return FTPNSFOD;
 947     }
 948   if (*respline != '1')
 949     {
 950       xfree (respline);
 951       return FTPRERR;
 952     }
 953   xfree (respline);
 954   /* All OK.  */
 955   return FTPOK;
 956 }
 957
 958 /* Sends the LIST command to the server.  If FILE is NULL, send just
 959    `LIST' (no space).  */
 960 uerr_t
 961 ftp_list (int csock, const char *file, enum stype rs)
 962 {
 963   char *request, *respline;
 964   int nwritten;
 965   uerr_t err;
 966   bool ok = false;
 967   size_t i = 0;
 968   /* Try `LIST -a' first and revert to `LIST' in case of failure.  */
 969   const char *list_commands[] = { "LIST -a",
 970                                   "LIST" };
 971
 972   /* 2008-01-29  SMS.  For a VMS FTP server, where "LIST -a" may not
 973      fail, but will never do what is desired here, skip directly to the
 974      simple "LIST" command (assumed to be the last one in the list).
 975   */
 976   if (rs == ST_VMS)
 977     i = countof (list_commands)- 1;
 978
 979   do {
 980     /* Send request.  */
 981     request = ftp_request (list_commands[i], file);
 982     nwritten = fd_write (csock, request, strlen (request), -1);
 983     if (nwritten < 0)
 984       {
 985         xfree (request);
 986         return WRITEFAILED;
 987       }
 988     xfree (request);
 989     /* Get appropriate response.  */
 990     err = ftp_response (csock, &respline);
 991     if (err == FTPOK)
 992       {
 993         if (*respline == '5')
 994           {
 995             err = FTPNSFOD;
 996           }
 997         else if (*respline == '1')
 998           {
 999             err = FTPOK;
1000             ok = true;
1001           }
1002         else
1003           {
1004             err = FTPRERR;
1005           }
1006         xfree (respline);
1007       }
1008     ++i;
1009   } while (i < countof (list_commands) && !ok);
1010
1011   return err;
1012 }
1013
1014 /* Sends the SYST command to the server. */
1015 uerr_t
1016 ftp_syst (int csock, enum stype *server_type)
1017 {
1018   char *request, *respline;
1019   int nwritten;
1020   uerr_t err;
1021
1022   /* Send SYST request.  */
1023   request = ftp_request ("SYST", NULL);
1024   nwritten = fd_write (csock, request, strlen (request), -1);
1025   if (nwritten < 0)
1026     {
1027       xfree (request);
1028       return WRITEFAILED;
1029     }
1030   xfree (request);
1031
1032   /* Get appropriate response.  */
1033   err = ftp_response (csock, &respline);
1034   if (err != FTPOK)
1035     return err;
1036   if (*respline == '5')
1037     {
1038       xfree (respline);
1039       return FTPSRVERR;
1040     }
1041
1042   /* Skip the number (215, but 200 (!!!) in case of VMS) */
1043   strtok (respline, " ");
1044
1045   /* Which system type has been reported (we are interested just in the
1046      first word of the server response)?  */
1047   request = strtok (NULL, " ");
1048
1049   if (request == NULL)
1050     *server_type = ST_OTHER;
1051   else if (!strcasecmp (request, "VMS"))
1052     *server_type = ST_VMS;
1053   else if (!strcasecmp (request, "UNIX"))
1054     *server_type = ST_UNIX;
1055   else if (!strcasecmp (request, "WINDOWS_NT")
1056            || !strcasecmp (request, "WINDOWS2000"))
1057     *server_type = ST_WINNT;
1058   else if (!strcasecmp (request, "MACOS"))
1059     *server_type = ST_MACOS;
1060   else if (!strcasecmp (request, "OS/400"))
1061     *server_type = ST_OS400;
1062   else
1063     *server_type = ST_OTHER;
1064
1065   xfree (respline);
1066   /* All OK.  */
1067   return FTPOK;
1068 }
1069
1070 /* Sends the PWD command to the server. */
1071 uerr_t
1072 ftp_pwd (int csock, char **pwd)
1073 {
1074   char *request, *respline;
1075   int nwritten;
1076   uerr_t err;
1077
1078   /* Send PWD request.  */
1079   request = ftp_request ("PWD", NULL);
1080   nwritten = fd_write (csock, request, strlen (request), -1);
1081   if (nwritten < 0)
1082     {
1083       xfree (request);
1084       return WRITEFAILED;
1085     }
1086   xfree (request);
1087   /* Get appropriate response.  */
1088   err = ftp_response (csock, &respline);
1089   if (err != FTPOK)
1090     return err;
1091   if (*respline == '5')
1092     {
1093     err:
1094       xfree (respline);
1095       return FTPSRVERR;
1096     }
1097
1098   /* Skip the number (257), leading citation mark, trailing citation mark
1099      and everything following it. */
1100   strtok (respline, "\"");
1101   request = strtok (NULL, "\"");
1102   if (!request)
1103     /* Treat the malformed response as an error, which the caller has
1104        to handle gracefully anyway.  */
1105     goto err;
1106
1107   /* Has the `pwd' been already allocated?  Free! */
1108   xfree_null (*pwd);
1109
1110   *pwd = xstrdup (request);
1111
1112   xfree (respline);
1113   /* All OK.  */
1114   return FTPOK;
1115 }
1116
1117 /* Sends the SIZE command to the server, and returns the value in 'size'.
1118  * If an error occurs, size is set to zero. */
1119 uerr_t
1120 ftp_size (int csock, const char *file, wgint *size)
1121 {
1122   char *request, *respline;
1123   int nwritten;
1124   uerr_t err;
1125
1126   /* Send PWD request.  */
1127   request = ftp_request ("SIZE", file);
1128   nwritten = fd_write (csock, request, strlen (request), -1);
1129   if (nwritten < 0)
1130     {
1131       xfree (request);
1132       *size = 0;
1133       return WRITEFAILED;
1134     }
1135   xfree (request);
1136   /* Get appropriate response.  */
1137   err = ftp_response (csock, &respline);
1138   if (err != FTPOK)
1139     {
1140       *size = 0;
1141       return err;
1142     }
1143   if (*respline == '5')
1144     {
1145       /*
1146        * Probably means SIZE isn't supported on this server.
1147        * Error is nonfatal since SIZE isn't in RFC 959
1148        */
1149       xfree (respline);
1150       *size = 0;
1151       return FTPOK;
1152     }
1153
1154   errno = 0;
1155   *size = str_to_wgint (respline + 4, NULL, 10);
1156   if (errno)
1157     {
1158       /*
1159        * Couldn't parse the response for some reason.  On the (few)
1160        * tests I've done, the response is 213 <SIZE> with nothing else -
1161        * maybe something a bit more resilient is necessary.  It's not a
1162        * fatal error, however.
1163        */
1164       xfree (respline);
1165       *size = 0;
1166       return FTPOK;
1167     }
1168
1169   xfree (respline);
1170   /* All OK.  */
1171   return FTPOK;
1172 }
1173
1174 /* If URL's params are of the form "type=X", return character X.
1175    Otherwise, return 'I' (the default type).  */
1176 char
1177 ftp_process_type (const char *params)
1178 {
1179   if (params
1180       && 0 == strncasecmp (params, "type=", 5)
1181       && params[5] != '\0')
1182     return c_toupper (params[5]);
1183   else
1184     return 'I';
1185 }