methods/ftp.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: ftp.cc,v 1.31.2.1 2004/01/16 18:58:50 mdz Exp $
   4 /* ######################################################################
   5
   6    FTP Acquire Method - This is the FTP acquire method for APT.
   7
   8    This is a very simple implementation that does not try to optimize
   9    at all. Commands are sent syncronously with the FTP server (as the
  10    rfc recommends, but it is not really necessary..) and no tricks are
  11    done to speed things along.
  12
  13    RFC 2428 describes the IPv6 FTP behavior
  14
  15    ##################################################################### */
  16                                                                         /*}}}*/
  17 // Include Files                                                        /*{{{*/
  18 #include <config.h>
  19
  20 #include <apt-pkg/fileutl.h>
  21 #include <apt-pkg/error.h>
  22 #include <apt-pkg/hashes.h>
  23 #include <apt-pkg/netrc.h>
  24 #include <apt-pkg/configuration.h>
  25 #include <apt-pkg/strutl.h>
  26
  27 #include <ctype.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/stat.h>
  31 #include <sys/time.h>
  32 #include <unistd.h>
  33 #include <signal.h>
  34 #include <stdio.h>
  35 #include <errno.h>
  36 #include <stdarg.h>
  37 #include <iostream>
  38
  39 // Internet stuff
  40 #include <netinet/in.h>
  41 #include <arpa/inet.h>
  42 #include <netdb.h>
  43
  44 #include "rfc2553emu.h"
  45 #include "connect.h"
  46 #include "ftp.h"
  47
  48 #include <apti18n.h>
  49                                                                         /*}}}*/
  50
  51 using namespace std;
  52
  53 /* This table is for the EPRT and EPSV commands, it maps the OS address
  54    family to the IETF address families */
  55 struct AFMap
  56 {
  57    unsigned long Family;
  58    unsigned long IETFFamily;
  59 };
  60
  61 #ifndef AF_INET6
  62 struct AFMap AFMap[] = {{AF_INET,1},{0, 0}};
  63 #else
  64 struct AFMap AFMap[] = {{AF_INET,1},{AF_INET6,2},{0, 0}};
  65 #endif
  66
  67 unsigned long TimeOut = 120;
  68 URI Proxy;
  69 string FtpMethod::FailFile;
  70 int FtpMethod::FailFd = -1;
  71 time_t FtpMethod::FailTime = 0;
  72
  73 // FTPConn::FTPConn - Constructor                                       /*{{{*/
  74 // ---------------------------------------------------------------------
  75 /* */
  76 FTPConn::FTPConn(URI Srv) : Len(0), ServerFd(-1), DataFd(-1),
  77                             DataListenFd(-1), ServerName(Srv),
  78                             ForceExtended(false), TryPassive(true),
  79                             PeerAddrLen(0), ServerAddrLen(0)
  80 {
  81    Debug = _config->FindB("Debug::Acquire::Ftp",false);
  82    PasvAddr = 0;
  83    Buffer[0] = '\0';
  84 }
  85                                                                         /*}}}*/
  86 // FTPConn::~FTPConn - Destructor                                       /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* */
  89 FTPConn::~FTPConn()
  90 {
  91    Close();
  92 }
  93                                                                         /*}}}*/
  94 // FTPConn::Close - Close down the connection                           /*{{{*/
  95 // ---------------------------------------------------------------------
  96 /* Just tear down the socket and data socket */
  97 void FTPConn::Close()
  98 {
  99    close(ServerFd);
 100    ServerFd = -1;
 101    close(DataFd);
 102    DataFd = -1;
 103    close(DataListenFd);
 104    DataListenFd = -1;
 105
 106    if (PasvAddr != 0)
 107       freeaddrinfo(PasvAddr);
 108    PasvAddr = 0;
 109 }
 110                                                                         /*}}}*/
 111 // FTPConn::Open - Open a new connection                                /*{{{*/
 112 // ---------------------------------------------------------------------
 113 /* Connect to the server using a non-blocking connection and perform a
 114    login. */
 115 bool FTPConn::Open(pkgAcqMethod *Owner)
 116 {
 117    // Use the already open connection if possible.
 118    if (ServerFd != -1)
 119       return true;
 120
 121    Close();
 122
 123    // Determine the proxy setting
 124    string SpecificProxy = _config->Find("Acquire::ftp::Proxy::" + ServerName.Host);
 125    if (!SpecificProxy.empty())
 126    {
 127            if (SpecificProxy == "DIRECT")
 128                    Proxy = "";
 129            else
 130                    Proxy = SpecificProxy;
 131    }
 132    else
 133    {
 134            string DefProxy = _config->Find("Acquire::ftp::Proxy");
 135            if (!DefProxy.empty())
 136            {
 137                    Proxy = DefProxy;
 138            }
 139            else
 140            {
 141                    char* result = getenv("ftp_proxy");
 142                    Proxy = result ? result : "";
 143            }
 144    }
 145
 146    // Parse no_proxy, a , separated list of domains
 147    if (getenv("no_proxy") != 0)
 148    {
 149       if (CheckDomainList(ServerName.Host,getenv("no_proxy")) == true)
 150          Proxy = "";
 151    }
 152
 153    // Determine what host and port to use based on the proxy settings
 154    int Port = 0;
 155    string Host;
 156    if (Proxy.empty() == true)
 157    {
 158       if (ServerName.Port != 0)
 159          Port = ServerName.Port;
 160       Host = ServerName.Host;
 161    }
 162    else
 163    {
 164       if (Proxy.Port != 0)
 165          Port = Proxy.Port;
 166       Host = Proxy.Host;
 167    }
 168
 169    /* Connect to the remote server. Since FTP is connection oriented we
 170       want to make sure we get a new server every time we reconnect */
 171    RotateDNS();
 172    if (Connect(Host,Port,"ftp",21,ServerFd,TimeOut,Owner) == false)
 173       return false;
 174
 175    // Login must be before getpeername otherwise dante won't work.
 176    Owner->Status(_("Logging in"));
 177    bool Res = Login();
 178
 179    // Get the remote server's address
 180    PeerAddrLen = sizeof(PeerAddr);
 181    if (getpeername(ServerFd,(sockaddr *)&PeerAddr,&PeerAddrLen) != 0)
 182       return _error->Errno("getpeername",_("Unable to determine the peer name"));
 183
 184    // Get the local machine's address
 185    ServerAddrLen = sizeof(ServerAddr);
 186    if (getsockname(ServerFd,(sockaddr *)&ServerAddr,&ServerAddrLen) != 0)
 187       return _error->Errno("getsockname",_("Unable to determine the local name"));
 188
 189    return Res;
 190 }
 191                                                                         /*}}}*/
 192 // FTPConn::Login - Login to the remote server                          /*{{{*/
 193 // ---------------------------------------------------------------------
 194 /* This performs both normal login and proxy login using a simples script
 195    stored in the config file. */
 196 bool FTPConn::Login()
 197 {
 198    unsigned int Tag;
 199    string Msg;
 200
 201    // Setup the variables needed for authentication
 202    string User = "anonymous";
 203    string Pass = "apt_get_ftp_2.1@debian.linux.user";
 204
 205    // Fill in the user/pass
 206    if (ServerName.User.empty() == false)
 207       User = ServerName.User;
 208    if (ServerName.Password.empty() == false)
 209       Pass = ServerName.Password;
 210
 211    // Perform simple login
 212    if (Proxy.empty() == true)
 213    {
 214       // Read the initial response
 215       if (ReadResp(Tag,Msg) == false)
 216          return false;
 217       if (Tag >= 400)
 218          return _error->Error(_("The server refused the connection and said: %s"),Msg.c_str());
 219
 220       // Send the user
 221       if (WriteMsg(Tag,Msg,"USER %s",User.c_str()) == false)
 222          return false;
 223       if (Tag >= 400)
 224          return _error->Error(_("USER failed, server said: %s"),Msg.c_str());
 225
 226       if (Tag == 331) { // 331 User name okay, need password.
 227          // Send the Password
 228          if (WriteMsg(Tag,Msg,"PASS %s",Pass.c_str()) == false)
 229             return false;
 230          if (Tag >= 400)
 231             return _error->Error(_("PASS failed, server said: %s"),Msg.c_str());
 232       }
 233
 234       // Enter passive mode
 235       if (_config->Exists("Acquire::FTP::Passive::" + ServerName.Host) == true)
 236          TryPassive = _config->FindB("Acquire::FTP::Passive::" + ServerName.Host,true);
 237       else
 238          TryPassive = _config->FindB("Acquire::FTP::Passive",true);
 239    }
 240    else
 241    {
 242       // Read the initial response
 243       if (ReadResp(Tag,Msg) == false)
 244          return false;
 245       if (Tag >= 400)
 246          return _error->Error(_("The server refused the connection and said: %s"),Msg.c_str());
 247
 248       // Perform proxy script execution
 249       Configuration::Item const *Opts = _config->Tree("Acquire::ftp::ProxyLogin");
 250       if (Opts == 0 || Opts->Child == 0)
 251          return _error->Error(_("A proxy server was specified but no login "
 252                               "script, Acquire::ftp::ProxyLogin is empty."));
 253       Opts = Opts->Child;
 254
 255       // Iterate over the entire login script
 256       for (; Opts != 0; Opts = Opts->Next)
 257       {
 258          if (Opts->Value.empty() == true)
 259             continue;
 260
 261          // Substitute the variables into the command
 262          string Tmp = Opts->Value;
 263          Tmp = SubstVar(Tmp,"$(PROXY_USER)",Proxy.User);
 264          Tmp = SubstVar(Tmp,"$(PROXY_PASS)",Proxy.Password);
 265          Tmp = SubstVar(Tmp,"$(SITE_USER)",User);
 266          Tmp = SubstVar(Tmp,"$(SITE_PASS)",Pass);
 267          if (ServerName.Port != 0)
 268          {
 269             std::string SitePort;
 270             strprintf(SitePort, "%u", ServerName.Port);
 271             Tmp = SubstVar(Tmp,"$(SITE_PORT)", SitePort);
 272          }
 273          else
 274             Tmp = SubstVar(Tmp,"$(SITE_PORT)", "21");
 275          Tmp = SubstVar(Tmp,"$(SITE)",ServerName.Host);
 276
 277          // Send the command
 278          if (WriteMsg(Tag,Msg,"%s",Tmp.c_str()) == false)
 279             return false;
 280          if (Tag >= 400)
 281             return _error->Error(_("Login script command '%s' failed, server said: %s"),Tmp.c_str(),Msg.c_str());
 282       }
 283
 284       // Enter passive mode
 285       TryPassive = false;
 286       if (_config->Exists("Acquire::FTP::Passive::" + ServerName.Host) == true)
 287          TryPassive = _config->FindB("Acquire::FTP::Passive::" + ServerName.Host,true);
 288       else
 289       {
 290          if (_config->Exists("Acquire::FTP::Proxy::Passive") == true)
 291             TryPassive = _config->FindB("Acquire::FTP::Proxy::Passive",true);
 292          else
 293             TryPassive = _config->FindB("Acquire::FTP::Passive",true);
 294       }
 295    }
 296
 297    // Force the use of extended commands
 298    if (_config->Exists("Acquire::FTP::ForceExtended::" + ServerName.Host) == true)
 299       ForceExtended = _config->FindB("Acquire::FTP::ForceExtended::" + ServerName.Host,true);
 300    else
 301       ForceExtended = _config->FindB("Acquire::FTP::ForceExtended",false);
 302
 303    // Binary mode
 304    if (WriteMsg(Tag,Msg,"TYPE I") == false)
 305       return false;
 306    if (Tag >= 400)
 307       return _error->Error(_("TYPE failed, server said: %s"),Msg.c_str());
 308
 309    return true;
 310 }
 311                                                                         /*}}}*/
 312 // FTPConn::ReadLine - Read a line from the server                      /*{{{*/
 313 // ---------------------------------------------------------------------
 314 /* This performs a very simple buffered read. */
 315 bool FTPConn::ReadLine(string &Text)
 316 {
 317    if (ServerFd == -1)
 318       return false;
 319
 320    // Suck in a line
 321    while (Len < sizeof(Buffer))
 322    {
 323       // Scan the buffer for a new line
 324       for (unsigned int I = 0; I != Len; I++)
 325       {
 326          // Escape some special chars
 327          if (Buffer[I] == 0)
 328             Buffer[I] = '?';
 329
 330          // End of line?
 331          if (Buffer[I] != '\n')
 332             continue;
 333
 334          I++;
 335          Text = string(Buffer,I);
 336          memmove(Buffer,Buffer+I,Len - I);
 337          Len -= I;
 338          return true;
 339       }
 340
 341       // Wait for some data..
 342       if (WaitFd(ServerFd,false,TimeOut) == false)
 343       {
 344          Close();
 345          return _error->Error(_("Connection timeout"));
 346       }
 347
 348       // Suck it back
 349       int Res = read(ServerFd,Buffer + Len,sizeof(Buffer) - Len);
 350       if (Res == 0)
 351          _error->Error(_("Server closed the connection"));
 352       if (Res <= 0)
 353       {
 354          _error->Errno("read",_("Read error"));
 355          Close();
 356          return false;
 357       }
 358       Len += Res;
 359    }
 360
 361    return _error->Error(_("A response overflowed the buffer."));
 362 }
 363                                                                         /*}}}*/
 364 // FTPConn::ReadResp - Read a full response from the server             /*{{{*/
 365 // ---------------------------------------------------------------------
 366 /* This reads a reply code from the server, it handles both p */
 367 bool FTPConn::ReadResp(unsigned int &Ret,string &Text)
 368 {
 369    // Grab the first line of the response
 370    string Msg;
 371    if (ReadLine(Msg) == false)
 372        return false;
 373
 374    // Get the ID code
 375    char *End;
 376    Ret = strtol(Msg.c_str(),&End,10);
 377    if (End - Msg.c_str() != 3)
 378       return _error->Error(_("Protocol corruption"));
 379
 380    // All done ?
 381    Text = Msg.c_str()+4;
 382    if (*End == ' ')
 383    {
 384       if (Debug == true)
 385          cerr << "<- '" << QuoteString(Text,"") << "'" << endl;
 386       return true;
 387    }
 388
 389    if (*End != '-')
 390       return _error->Error(_("Protocol corruption"));
 391
 392    /* Okay, here we do the continued message trick. This is foolish, but
 393       proftpd follows the protocol as specified and wu-ftpd doesn't, so
 394       we filter. I wonder how many clients break if you use proftpd and
 395       put a '- in the 3rd spot in the message? */
 396    char Leader[4];
 397    strncpy(Leader,Msg.c_str(),3);
 398    Leader[3] = 0;
 399    while (ReadLine(Msg) == true)
 400    {
 401       // Short, it must be using RFC continuation..
 402       if (Msg.length() < 4)
 403       {
 404          Text += Msg;
 405          continue;
 406       }
 407
 408       // Oops, finished
 409       if (strncmp(Msg.c_str(),Leader,3) == 0 && Msg[3] == ' ')
 410       {
 411          Text += Msg.c_str()+4;
 412          break;
 413       }
 414
 415       // This message has the wu-ftpd style reply code prefixed
 416       if (strncmp(Msg.c_str(),Leader,3) == 0 && Msg[3] == '-')
 417       {
 418          Text += Msg.c_str()+4;
 419          continue;
 420       }
 421
 422       // Must be RFC style prefixing
 423       Text += Msg;
 424    }
 425
 426    if (Debug == true && _error->PendingError() == false)
 427       cerr << "<- '" << QuoteString(Text,"") << "'" << endl;
 428
 429    return !_error->PendingError();
 430 }
 431                                                                         /*}}}*/
 432 // FTPConn::WriteMsg - Send a message to the server                     /*{{{*/
 433 // ---------------------------------------------------------------------
 434 /* Simple printf like function.. */
 435 bool FTPConn::WriteMsg(unsigned int &Ret,string &Text,const char *Fmt,...)
 436 {
 437    va_list args;
 438    va_start(args,Fmt);
 439
 440    // sprintf the description
 441    char S[400];
 442    vsnprintf(S,sizeof(S) - 4,Fmt,args);
 443    strcat(S,"\r\n");
 444    va_end(args);
 445
 446    if (Debug == true)
 447       cerr << "-> '" << QuoteString(S,"") << "'" << endl;
 448
 449    // Send it off
 450    unsigned long Len = strlen(S);
 451    unsigned long Start = 0;
 452    while (Len != 0)
 453    {
 454       if (WaitFd(ServerFd,true,TimeOut) == false)
 455       {
 456          Close();
 457          return _error->Error(_("Connection timeout"));
 458       }
 459
 460       int Res = write(ServerFd,S + Start,Len);
 461       if (Res <= 0)
 462       {
 463          _error->Errno("write",_("Write error"));
 464          Close();
 465          return false;
 466       }
 467
 468       Len -= Res;
 469       Start += Res;
 470    }
 471
 472    return ReadResp(Ret,Text);
 473 }
 474                                                                         /*}}}*/
 475 // FTPConn::GoPasv - Enter Passive mode                                 /*{{{*/
 476 // ---------------------------------------------------------------------
 477 /* Try to enter passive mode, the return code does not indicate if passive
 478    mode could or could not be established, only if there was a fatal error.
 479    We have to enter passive mode every time we make a data connection :| */
 480 bool FTPConn::GoPasv()
 481 {
 482    /* The PASV command only works on IPv4 sockets, even though it could
 483       in theory suppory IPv6 via an all zeros reply */
 484    if (((struct sockaddr *)&PeerAddr)->sa_family != AF_INET ||
 485        ForceExtended == true)
 486       return ExtGoPasv();
 487
 488    if (PasvAddr != 0)
 489       freeaddrinfo(PasvAddr);
 490    PasvAddr = 0;
 491
 492    // Try to enable pasv mode
 493    unsigned int Tag;
 494    string Msg;
 495    if (WriteMsg(Tag,Msg,"PASV") == false)
 496       return false;
 497
 498    // Unsupported function
 499    string::size_type Pos = Msg.find('(');
 500    if (Tag >= 400)
 501       return true;
 502
 503    //wu-2.6.2(1) ftp server, returns
 504    //227 Entering Passive Mode 193,219,28,140,150,111
 505    //without parentheses, let's try to cope with it.
 506    //wget(1) and ftp(1) can.
 507    if (Pos == string::npos)
 508       Pos = Msg.rfind(' ');
 509    else
 510       ++Pos;
 511
 512    // Still unsupported function
 513    if (Pos == string::npos)
 514       return true;
 515
 516    // Scan it
 517    unsigned a0,a1,a2,a3,p0,p1;
 518    if (sscanf(Msg.c_str() + Pos,"%u,%u,%u,%u,%u,%u",&a0,&a1,&a2,&a3,&p0,&p1) != 6)
 519       return true;
 520
 521    /* Some evil servers return 0 to mean their addr. We can actually speak
 522       to these servers natively using IPv6 */
 523    if (a0 == 0 && a1 == 0 && a2 == 0 && a3 == 0)
 524    {
 525       // Get the IP in text form
 526       char Name[NI_MAXHOST];
 527       char Service[NI_MAXSERV];
 528       getnameinfo((struct sockaddr *)&PeerAddr,PeerAddrLen,
 529                   Name,sizeof(Name),Service,sizeof(Service),
 530                   NI_NUMERICHOST|NI_NUMERICSERV);
 531
 532       struct addrinfo Hints;
 533       memset(&Hints,0,sizeof(Hints));
 534       Hints.ai_socktype = SOCK_STREAM;
 535       Hints.ai_family = ((struct sockaddr *)&PeerAddr)->sa_family;
 536       Hints.ai_flags |= AI_NUMERICHOST;
 537
 538       // Get a new passive address.
 539       char Port[100];
 540       snprintf(Port,sizeof(Port),"%u",(p0 << 8) + p1);
 541       if (getaddrinfo(Name,Port,&Hints,&PasvAddr) != 0)
 542          return true;
 543       return true;
 544    }
 545
 546    struct addrinfo Hints;
 547    memset(&Hints,0,sizeof(Hints));
 548    Hints.ai_socktype = SOCK_STREAM;
 549    Hints.ai_family = AF_INET;
 550    Hints.ai_flags |= AI_NUMERICHOST;
 551
 552    // Get a new passive address.
 553    char Port[100];
 554    snprintf(Port,sizeof(Port),"%u",(p0 << 8) + p1);
 555    char Name[100];
 556    snprintf(Name,sizeof(Name),"%u.%u.%u.%u",a0,a1,a2,a3);
 557    if (getaddrinfo(Name,Port,&Hints,&PasvAddr) != 0)
 558       return true;
 559    return true;
 560 }
 561                                                                         /*}}}*/
 562 // FTPConn::ExtGoPasv - Enter Extended Passive mode                     /*{{{*/
 563 // ---------------------------------------------------------------------
 564 /* Try to enter extended passive mode. See GoPasv above and RFC 2428 */
 565 bool FTPConn::ExtGoPasv()
 566 {
 567    if (PasvAddr != 0)
 568       freeaddrinfo(PasvAddr);
 569    PasvAddr = 0;
 570
 571    // Try to enable pasv mode
 572    unsigned int Tag;
 573    string Msg;
 574    if (WriteMsg(Tag,Msg,"EPSV") == false)
 575       return false;
 576
 577    // Unsupported function
 578    string::size_type Pos = Msg.find('(');
 579    if (Tag >= 400 || Pos == string::npos)
 580       return true;
 581
 582    // Scan it
 583    string::const_iterator List[4];
 584    unsigned Count = 0;
 585    Pos++;
 586    for (string::const_iterator I = Msg.begin() + Pos; I < Msg.end(); ++I)
 587    {
 588       if (*I != Msg[Pos])
 589          continue;
 590       if (Count >= 4)
 591          return true;
 592       List[Count++] = I;
 593    }
 594    if (Count != 4)
 595       return true;
 596
 597    // Break it up ..
 598    unsigned long Proto = 0;
 599    unsigned long Port = 0;
 600    string IP;
 601    IP = string(List[1]+1,List[2]);
 602    Port = atoi(string(List[2]+1,List[3]).c_str());
 603    if (IP.empty() == false)
 604       Proto = atoi(string(List[0]+1,List[1]).c_str());
 605
 606    if (Port == 0)
 607       return false;
 608
 609    // String version of the port
 610    char PStr[100];
 611    snprintf(PStr,sizeof(PStr),"%lu",Port);
 612
 613    // Get the IP in text form
 614    struct addrinfo Hints;
 615    memset(&Hints,0,sizeof(Hints));
 616    Hints.ai_socktype = SOCK_STREAM;
 617    Hints.ai_flags |= AI_NUMERICHOST;
 618
 619    /* The RFC defined case, connect to the old IP/protocol using the
 620       new port. */
 621    if (IP.empty() == true)
 622    {
 623       // Get the IP in text form
 624       char Name[NI_MAXHOST];
 625       char Service[NI_MAXSERV];
 626       getnameinfo((struct sockaddr *)&PeerAddr,PeerAddrLen,
 627                   Name,sizeof(Name),Service,sizeof(Service),
 628                   NI_NUMERICHOST|NI_NUMERICSERV);
 629       IP = Name;
 630       Hints.ai_family = ((struct sockaddr *)&PeerAddr)->sa_family;
 631    }
 632    else
 633    {
 634       // Get the family..
 635       Hints.ai_family = 0;
 636       for (unsigned J = 0; AFMap[J].Family != 0; J++)
 637          if (AFMap[J].IETFFamily == Proto)
 638             Hints.ai_family = AFMap[J].Family;
 639       if (Hints.ai_family == 0)
 640          return true;
 641    }
 642
 643    // Get a new passive address.
 644    if (getaddrinfo(IP.c_str(),PStr,&Hints,&PasvAddr) != 0)
 645       return true;
 646
 647    return true;
 648 }
 649                                                                         /*}}}*/
 650 // FTPConn::Size - Return the size of a file                            /*{{{*/
 651 // ---------------------------------------------------------------------
 652 /* Grab the file size from the server, 0 means no size or empty file */
 653 bool FTPConn::Size(const char *Path,unsigned long long &Size)
 654 {
 655    // Query the size
 656    unsigned int Tag;
 657    string Msg;
 658    Size = 0;
 659    if (WriteMsg(Tag,Msg,"SIZE %s",Path) == false)
 660       return false;
 661
 662    char *End;
 663    Size = strtoull(Msg.c_str(),&End,10);
 664    if (Tag >= 400 || End == Msg.c_str())
 665       Size = 0;
 666    return true;
 667 }
 668                                                                         /*}}}*/
 669 // FTPConn::ModTime - Return the modification time of the file          /*{{{*/
 670 // ---------------------------------------------------------------------
 671 /* Like Size no error is returned if the command is not supported. If the
 672    command fails then time is set to the current time of day to fool
 673    date checks. */
 674 bool FTPConn::ModTime(const char *Path, time_t &Time)
 675 {
 676    Time = time(&Time);
 677
 678    // Query the mod time
 679    unsigned int Tag;
 680    string Msg;
 681    if (WriteMsg(Tag,Msg,"MDTM %s",Path) == false)
 682       return false;
 683    if (Tag >= 400 || Msg.empty() == true || isdigit(Msg[0]) == 0)
 684       return true;
 685
 686    // Parse it
 687    return FTPMDTMStrToTime(Msg.c_str(), Time);
 688 }
 689                                                                         /*}}}*/
 690 // FTPConn::CreateDataFd - Get a data connection                        /*{{{*/
 691 // ---------------------------------------------------------------------
 692 /* Create the data connection. Call FinalizeDataFd after this though.. */
 693 bool FTPConn::CreateDataFd()
 694 {
 695    close(DataFd);
 696    DataFd = -1;
 697
 698    // Attempt to enter passive mode.
 699    if (TryPassive == true)
 700    {
 701       if (GoPasv() == false)
 702          return false;
 703
 704       // Oops, didn't work out, don't bother trying again.
 705       if (PasvAddr == 0)
 706          TryPassive = false;
 707    }
 708
 709    // Passive mode?
 710    if (PasvAddr != 0)
 711    {
 712       // Get a socket
 713       if ((DataFd = socket(PasvAddr->ai_family,PasvAddr->ai_socktype,
 714                            PasvAddr->ai_protocol)) < 0)
 715          return _error->Errno("socket",_("Could not create a socket"));
 716
 717       // Connect to the server
 718       SetNonBlock(DataFd,true);
 719       if (connect(DataFd,PasvAddr->ai_addr,PasvAddr->ai_addrlen) < 0 &&
 720           errno != EINPROGRESS)
 721          return _error->Errno("socket",_("Could not create a socket"));
 722
 723       /* This implements a timeout for connect by opening the connection
 724          nonblocking */
 725       if (WaitFd(DataFd,true,TimeOut) == false)
 726          return _error->Error(_("Could not connect data socket, connection timed out"));
 727       unsigned int Err;
 728       unsigned int Len = sizeof(Err);
 729       if (getsockopt(DataFd,SOL_SOCKET,SO_ERROR,&Err,&Len) != 0)
 730          return _error->Errno("getsockopt",_("Failed"));
 731       if (Err != 0)
 732          return _error->Error(_("Could not connect passive socket."));
 733
 734       return true;
 735    }
 736
 737    // Port mode :<
 738    close(DataListenFd);
 739    DataListenFd = -1;
 740
 741    // Get the information for a listening socket.
 742    struct addrinfo *BindAddr = NULL;
 743    struct addrinfo Hints;
 744    memset(&Hints,0,sizeof(Hints));
 745    Hints.ai_socktype = SOCK_STREAM;
 746    Hints.ai_flags |= AI_PASSIVE;
 747    Hints.ai_family = ((struct sockaddr *)&ServerAddr)->sa_family;
 748    if (getaddrinfo(0,"0",&Hints,&BindAddr) != 0 || BindAddr == NULL)
 749       return _error->Error(_("getaddrinfo was unable to get a listening socket"));
 750
 751    // Construct the socket
 752    if ((DataListenFd = socket(BindAddr->ai_family,BindAddr->ai_socktype,
 753                               BindAddr->ai_protocol)) < 0)
 754    {
 755       freeaddrinfo(BindAddr);
 756       return _error->Errno("socket",_("Could not create a socket"));
 757    }
 758
 759    // Bind and listen
 760    if (::bind(DataListenFd,BindAddr->ai_addr,BindAddr->ai_addrlen) < 0)
 761    {
 762       freeaddrinfo(BindAddr);
 763       return _error->Errno("bind",_("Could not bind a socket"));
 764    }
 765    freeaddrinfo(BindAddr);
 766    if (listen(DataListenFd,1) < 0)
 767       return _error->Errno("listen",_("Could not listen on the socket"));
 768    SetNonBlock(DataListenFd,true);
 769
 770    // Determine the name to send to the remote
 771    struct sockaddr_storage Addr;
 772    socklen_t AddrLen = sizeof(Addr);
 773    if (getsockname(DataListenFd,(sockaddr *)&Addr,&AddrLen) < 0)
 774       return _error->Errno("getsockname",_("Could not determine the socket's name"));
 775
 776
 777    // Reverse the address. We need the server address and the data port.
 778    char Name[NI_MAXHOST];
 779    char Service[NI_MAXSERV];
 780    char Service2[NI_MAXSERV];
 781    getnameinfo((struct sockaddr *)&Addr,AddrLen,
 782                Name,sizeof(Name),Service,sizeof(Service),
 783                NI_NUMERICHOST|NI_NUMERICSERV);
 784    getnameinfo((struct sockaddr *)&ServerAddr,ServerAddrLen,
 785                Name,sizeof(Name),Service2,sizeof(Service2),
 786                NI_NUMERICHOST|NI_NUMERICSERV);
 787
 788    // Send off an IPv4 address in the old port format
 789    if (((struct sockaddr *)&Addr)->sa_family == AF_INET &&
 790        ForceExtended == false)
 791    {
 792       // Convert the dots in the quad into commas
 793       for (char *I = Name; *I != 0; I++)
 794          if (*I == '.')
 795             *I = ',';
 796       unsigned long Port = atoi(Service);
 797
 798       // Send the port command
 799       unsigned int Tag;
 800       string Msg;
 801       if (WriteMsg(Tag,Msg,"PORT %s,%d,%d",
 802                    Name,
 803                    (int)(Port >> 8) & 0xff, (int)(Port & 0xff)) == false)
 804          return false;
 805       if (Tag >= 400)
 806          return _error->Error(_("Unable to send PORT command"));
 807       return true;
 808    }
 809
 810    // Construct an EPRT command
 811    unsigned Proto = 0;
 812    for (unsigned J = 0; AFMap[J].Family != 0; J++)
 813       if (AFMap[J].Family == ((struct sockaddr *)&Addr)->sa_family)
 814          Proto = AFMap[J].IETFFamily;
 815    if (Proto == 0)
 816       return _error->Error(_("Unknown address family %u (AF_*)"),
 817                            ((struct sockaddr *)&Addr)->sa_family);
 818
 819    // Send the EPRT command
 820    unsigned int Tag;
 821    string Msg;
 822    if (WriteMsg(Tag,Msg,"EPRT |%u|%s|%s|",Proto,Name,Service) == false)
 823       return false;
 824    if (Tag >= 400)
 825       return _error->Error(_("EPRT failed, server said: %s"),Msg.c_str());
 826    return true;
 827 }
 828                                                                         /*}}}*/
 829 // FTPConn::Finalize - Complete the Data connection                     /*{{{*/
 830 // ---------------------------------------------------------------------
 831 /* If the connection is in port mode this waits for the other end to hook
 832    up to us. */
 833 bool FTPConn::Finalize()
 834 {
 835    // Passive mode? Do nothing
 836    if (PasvAddr != 0)
 837       return true;
 838
 839    // Close any old socket..
 840    close(DataFd);
 841    DataFd = -1;
 842
 843    // Wait for someone to connect..
 844    if (WaitFd(DataListenFd,false,TimeOut) == false)
 845       return _error->Error(_("Data socket connect timed out"));
 846
 847    // Accept the connection
 848    struct sockaddr_in Addr;
 849    socklen_t Len = sizeof(Addr);
 850    DataFd = accept(DataListenFd,(struct sockaddr *)&Addr,&Len);
 851    if (DataFd < 0)
 852       return _error->Errno("accept",_("Unable to accept connection"));
 853
 854    close(DataListenFd);
 855    DataListenFd = -1;
 856
 857    return true;
 858 }
 859                                                                         /*}}}*/
 860 // FTPConn::Get - Get a file                                            /*{{{*/
 861 // ---------------------------------------------------------------------
 862 /* This opens a data connection, sends REST and RETR and then
 863    transfers the file over. */
 864 bool FTPConn::Get(const char *Path,FileFd &To,unsigned long long Resume,
 865                   Hashes &Hash,bool &Missing, unsigned long long MaximumSize,
 866                   pkgAcqMethod *Owner)
 867 {
 868    Missing = false;
 869    if (CreateDataFd() == false)
 870       return false;
 871
 872    unsigned int Tag;
 873    string Msg;
 874    if (Resume != 0)
 875    {
 876       if (WriteMsg(Tag,Msg,"REST %u",Resume) == false)
 877          return false;
 878       if (Tag >= 400)
 879          Resume = 0;
 880    }
 881
 882    if (To.Truncate(Resume) == false)
 883       return false;
 884
 885    if (To.Seek(0) == false)
 886       return false;
 887
 888    if (Resume != 0)
 889    {
 890       if (Hash.AddFD(To,Resume) == false)
 891       {
 892          _error->Errno("read",_("Problem hashing file"));
 893          return false;
 894       }
 895    }
 896
 897    // Send the get command
 898    if (WriteMsg(Tag,Msg,"RETR %s",Path) == false)
 899       return false;
 900
 901    if (Tag >= 400)
 902    {
 903       if (Tag == 550)
 904          Missing = true;
 905       return _error->Error(_("Unable to fetch file, server said '%s'"),Msg.c_str());
 906    }
 907
 908    // Finish off the data connection
 909    if (Finalize() == false)
 910       return false;
 911
 912    // Copy loop
 913    unsigned char Buffer[4096];
 914    while (1)
 915    {
 916       // Wait for some data..
 917       if (WaitFd(DataFd,false,TimeOut) == false)
 918       {
 919          Close();
 920          return _error->Error(_("Data socket timed out"));
 921       }
 922
 923       // Read the data..
 924       int Res = read(DataFd,Buffer,sizeof(Buffer));
 925       if (Res == 0)
 926          break;
 927       if (Res < 0)
 928       {
 929          if (errno == EAGAIN)
 930             continue;
 931          break;
 932       }
 933
 934       Hash.Add(Buffer,Res);
 935       if (To.Write(Buffer,Res) == false)
 936       {
 937          Close();
 938          return false;
 939       }
 940
 941       if (MaximumSize > 0 && To.Tell() > MaximumSize)
 942       {
 943          Owner->SetFailReason("MaximumSizeExceeded");
 944          return _error->Error("Writing more data than expected (%llu > %llu)",
 945                               To.Tell(), MaximumSize);
 946       }
 947    }
 948
 949    // All done
 950    close(DataFd);
 951    DataFd = -1;
 952
 953    // Read the closing message from the server
 954    if (ReadResp(Tag,Msg) == false)
 955       return false;
 956    if (Tag >= 400)
 957       return _error->Error(_("Data transfer failed, server said '%s'"),Msg.c_str());
 958    return true;
 959 }
 960                                                                         /*}}}*/
 961
 962 // FtpMethod::FtpMethod - Constructor                                   /*{{{*/
 963 // ---------------------------------------------------------------------
 964 /* */
 965 FtpMethod::FtpMethod() : aptMethod("ftp","1.0",SendConfig)
 966 {
 967    signal(SIGTERM,SigTerm);
 968    signal(SIGINT,SigTerm);
 969
 970    Server = 0;
 971    FailFd = -1;
 972 }
 973                                                                         /*}}}*/
 974 // FtpMethod::SigTerm - Handle a fatal signal                           /*{{{*/
 975 // ---------------------------------------------------------------------
 976 /* This closes and timestamps the open file. This is necessary to get
 977    resume behavoir on user abort */
 978 void FtpMethod::SigTerm(int)
 979 {
 980    if (FailFd == -1)
 981       _exit(100);
 982
 983    // Timestamp
 984    struct timeval times[2];
 985    times[0].tv_sec = FailTime;
 986    times[1].tv_sec = FailTime;
 987    times[0].tv_usec = times[1].tv_usec = 0;
 988    utimes(FailFile.c_str(), times);
 989
 990    close(FailFd);
 991
 992    _exit(100);
 993 }
 994                                                                         /*}}}*/
 995 // FtpMethod::Configuration - Handle a configuration message            /*{{{*/
 996 // ---------------------------------------------------------------------
 997 /* We stash the desired pipeline depth */
 998 bool FtpMethod::Configuration(string Message)
 999 {
1000    if (aptMethod::Configuration(Message) == false)
1001       return false;
1002
1003    TimeOut = _config->FindI("Acquire::Ftp::Timeout",TimeOut);
1004
1005    return true;
1006 }
1007                                                                         /*}}}*/
1008 // FtpMethod::Fetch - Fetch a file                                      /*{{{*/
1009 // ---------------------------------------------------------------------
1010 /* Fetch a single file, called by the base class..  */
1011 bool FtpMethod::Fetch(FetchItem *Itm)
1012 {
1013    URI Get = Itm->Uri;
1014    const char *File = Get.Path.c_str();
1015    FetchResult Res;
1016    Res.Filename = Itm->DestFile;
1017    Res.IMSHit = false;
1018
1019    maybe_add_auth (Get, _config->FindFile("Dir::Etc::netrc"));
1020
1021    // Connect to the server
1022    if (Server == 0 || Server->Comp(Get) == false)
1023    {
1024       delete Server;
1025       Server = new FTPConn(Get);
1026    }
1027
1028    // Could not connect is a transient error..
1029    if (Server->Open(this) == false)
1030    {
1031       Server->Close();
1032       Fail(true);
1033       return true;
1034    }
1035
1036    // Get the files information
1037    Status(_("Query"));
1038    unsigned long long Size;
1039    if (Server->Size(File,Size) == false ||
1040        Server->ModTime(File,FailTime) == false)
1041    {
1042       Fail(true);
1043       return true;
1044    }
1045    Res.Size = Size;
1046
1047    // See if it is an IMS hit
1048    if (Itm->LastModified == FailTime)
1049    {
1050       Res.Size = 0;
1051       Res.IMSHit = true;
1052       URIDone(Res);
1053       return true;
1054    }
1055
1056    // See if the file exists
1057    struct stat Buf;
1058    if (stat(Itm->DestFile.c_str(),&Buf) == 0)
1059    {
1060       if (Size == (unsigned long long)Buf.st_size && FailTime == Buf.st_mtime)
1061       {
1062          Res.Size = Buf.st_size;
1063          Res.LastModified = Buf.st_mtime;
1064          Res.ResumePoint = Buf.st_size;
1065          URIDone(Res);
1066          return true;
1067       }
1068
1069       // Resume?
1070       if (FailTime == Buf.st_mtime && Size > (unsigned long long)Buf.st_size)
1071          Res.ResumePoint = Buf.st_size;
1072    }
1073
1074    // Open the file
1075    Hashes Hash(Itm->ExpectedHashes);
1076    {
1077       FileFd Fd(Itm->DestFile,FileFd::WriteAny);
1078       if (_error->PendingError() == true)
1079          return false;
1080
1081       URIStart(Res);
1082
1083       FailFile = Itm->DestFile;
1084       FailFile.c_str();   // Make sure we don't do a malloc in the signal handler
1085       FailFd = Fd.Fd();
1086
1087       bool Missing;
1088       if (Server->Get(File,Fd,Res.ResumePoint,Hash,Missing,Itm->MaximumSize,this) == false)
1089       {
1090          Fd.Close();
1091
1092          // Timestamp
1093          struct timeval times[2];
1094          times[0].tv_sec = FailTime;
1095          times[1].tv_sec = FailTime;
1096          times[0].tv_usec = times[1].tv_usec = 0;
1097          utimes(FailFile.c_str(), times);
1098
1099          // If the file is missing we hard fail and delete the destfile
1100          // otherwise transient fail
1101          if (Missing == true) {
1102             RemoveFile("ftp", FailFile);
1103             return false;
1104          }
1105          Fail(true);
1106          return true;
1107       }
1108
1109       Res.Size = Fd.Size();
1110
1111       // Timestamp
1112       struct timeval times[2];
1113       times[0].tv_sec = FailTime;
1114       times[1].tv_sec = FailTime;
1115       times[0].tv_usec = times[1].tv_usec = 0;
1116       utimes(Fd.Name().c_str(), times);
1117       FailFd = -1;
1118    }
1119
1120    Res.LastModified = FailTime;
1121    Res.TakeHashes(Hash);
1122
1123    URIDone(Res);
1124
1125    return true;
1126 }
1127                                                                         /*}}}*/
1128
1129 int main(int, const char *argv[])
1130 {
1131    /* See if we should be come the http client - we do this for http
1132       proxy urls */
1133    if (getenv("ftp_proxy") != 0)
1134    {
1135       URI Proxy = string(getenv("ftp_proxy"));
1136
1137       // Run the HTTP method
1138       if (Proxy.Access == "http")
1139       {
1140          // Copy over the environment setting
1141          char S[300];
1142          snprintf(S,sizeof(S),"http_proxy=%s",getenv("ftp_proxy"));
1143          putenv(S);
1144          putenv((char *)"no_proxy=");
1145
1146          // Run the http method
1147          string Path = flNotFile(argv[0]) + "http";
1148          execl(Path.c_str(),Path.c_str(),(char *)NULL);
1149          cerr << _("Unable to invoke ") << Path << endl;
1150          exit(100);
1151       }
1152    }
1153    return FtpMethod().Run();
1154 }