methods/rsh.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: rsh.cc,v 1.6.2.1 2004/01/16 18:58:50 mdz Exp $
   4 /* ######################################################################
   5
   6    RSH method - Transfer files via rsh compatible program
   7
   8    Written by Ben Collins <bcollins@debian.org>, Copyright (c) 2000
   9    Licensed under the GNU General Public License v2 [no exception clauses]
  10
  11    ##################################################################### */
  12                                                                         /*}}}*/
  13 // Include Files                                                        /*{{{*/
  14 #include <config.h>
  15
  16 #include <apt-pkg/error.h>
  17 #include <apt-pkg/fileutl.h>
  18 #include <apt-pkg/hashes.h>
  19 #include <apt-pkg/configuration.h>
  20 #include <apt-pkg/strutl.h>
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <sys/time.h>
  26 #include <unistd.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <errno.h>
  30 #include <stdarg.h>
  31 #include "rsh.h"
  32
  33 #include <apti18n.h>
  34                                                                         /*}}}*/
  35
  36 unsigned long TimeOut = 120;
  37 Configuration::Item const *RshOptions = 0;
  38 time_t RSHMethod::FailTime = 0;
  39 std::string RSHMethod::FailFile;
  40 int RSHMethod::FailFd = -1;
  41
  42 // RSHConn::RSHConn - Constructor                                       /*{{{*/
  43 // ---------------------------------------------------------------------
  44 /* */
  45 RSHConn::RSHConn(std::string const &pProg, URI Srv) : Len(0), WriteFd(-1), ReadFd(-1),
  46                             ServerName(Srv), Prog(pProg), Process(-1) {
  47    Buffer[0] = '\0';
  48 }
  49                                                                         /*}}}*/
  50 // RSHConn::RSHConn - Destructor                                        /*{{{*/
  51 // ---------------------------------------------------------------------
  52 /* */
  53 RSHConn::~RSHConn()
  54 {
  55    Close();
  56 }
  57                                                                         /*}}}*/
  58 // RSHConn::Close - Forcibly terminate the connection                   /*{{{*/
  59 // ---------------------------------------------------------------------
  60 /* Often this is called when things have gone wrong to indicate that the
  61    connection is no longer usable. */
  62 void RSHConn::Close()
  63 {
  64    if (Process == -1)
  65       return;
  66
  67    close(WriteFd);
  68    close(ReadFd);
  69    kill(Process,SIGINT);
  70    ExecWait(Process,"",true);
  71    WriteFd = -1;
  72    ReadFd = -1;
  73    Process = -1;
  74 }
  75                                                                         /*}}}*/
  76 // RSHConn::Open - Connect to a host                                    /*{{{*/
  77 // ---------------------------------------------------------------------
  78 /* */
  79 bool RSHConn::Open()
  80 {
  81    // Use the already open connection if possible.
  82    if (Process != -1)
  83       return true;
  84
  85    if (Connect(ServerName.Host,ServerName.Port,ServerName.User) == false)
  86       return false;
  87
  88    return true;
  89 }
  90                                                                         /*}}}*/
  91 // RSHConn::Connect - Fire up rsh and connect                           /*{{{*/
  92 // ---------------------------------------------------------------------
  93 /* */
  94 bool RSHConn::Connect(std::string Host, unsigned int Port, std::string User)
  95 {
  96    char *PortStr = NULL;
  97    if (Port != 0)
  98    {
  99       if (asprintf (&PortStr, "%d", Port) == -1 || PortStr == NULL)
 100          return _error->Errno("asprintf", _("Failed"));
 101    }
 102
 103    // Create the pipes
 104    int Pipes[4] = {-1,-1,-1,-1};
 105    if (pipe(Pipes) != 0 || pipe(Pipes+2) != 0)
 106    {
 107       _error->Errno("pipe",_("Failed to create IPC pipe to subprocess"));
 108       for (int I = 0; I != 4; I++)
 109          close(Pipes[I]);
 110       return false;
 111    }
 112    for (int I = 0; I != 4; I++)
 113       SetCloseExec(Pipes[I],true);
 114
 115    Process = ExecFork();
 116
 117    // The child
 118    if (Process == 0)
 119    {
 120       const char *Args[400];
 121       unsigned int i = 0;
 122
 123       dup2(Pipes[1],STDOUT_FILENO);
 124       dup2(Pipes[2],STDIN_FILENO);
 125
 126       // Probably should do
 127       // dup2(open("/dev/null",O_RDONLY),STDERR_FILENO);
 128
 129       Args[i++] = Prog.c_str();
 130
 131       // Insert user-supplied command line options
 132       Configuration::Item const *Opts = RshOptions;
 133       if (Opts != 0)
 134       {
 135          Opts = Opts->Child;
 136          for (; Opts != 0; Opts = Opts->Next)
 137          {
 138             if (Opts->Value.empty() == true)
 139                continue;
 140             Args[i++] = Opts->Value.c_str();
 141          }
 142       }
 143
 144       if (User.empty() == false) {
 145          Args[i++] = "-l";
 146          Args[i++] = User.c_str();
 147       }
 148       if (PortStr != NULL) {
 149          Args[i++] = "-p";
 150          Args[i++] = PortStr;
 151       }
 152       if (Host.empty() == false) {
 153          Args[i++] = Host.c_str();
 154       }
 155       Args[i++] = "/bin/sh";
 156       Args[i] = 0;
 157       execvp(Args[0],(char **)Args);
 158       exit(100);
 159    }
 160
 161    if (PortStr != NULL)
 162       free(PortStr);
 163
 164    ReadFd = Pipes[0];
 165    WriteFd = Pipes[3];
 166    SetNonBlock(Pipes[0],true);
 167    SetNonBlock(Pipes[3],true);
 168    close(Pipes[1]);
 169    close(Pipes[2]);
 170
 171    return true;
 172 }
 173 bool RSHConn::Connect(std::string Host, std::string User)
 174 {
 175    return Connect(Host, 0, User);
 176 }
 177                                                                         /*}}}*/
 178 // RSHConn::ReadLine - Very simple buffered read with timeout           /*{{{*/
 179 // ---------------------------------------------------------------------
 180 /* */
 181 bool RSHConn::ReadLine(std::string &Text)
 182 {
 183    if (Process == -1 || ReadFd == -1)
 184       return false;
 185
 186    // Suck in a line
 187    while (Len < sizeof(Buffer))
 188    {
 189       // Scan the buffer for a new line
 190       for (unsigned int I = 0; I != Len; I++)
 191       {
 192          // Escape some special chars
 193          if (Buffer[I] == 0)
 194             Buffer[I] = '?';
 195
 196          // End of line?
 197          if (Buffer[I] != '\n')
 198             continue;
 199
 200          I++;
 201          Text = std::string(Buffer,I);
 202          memmove(Buffer,Buffer+I,Len - I);
 203          Len -= I;
 204          return true;
 205       }
 206
 207       // Wait for some data..
 208       if (WaitFd(ReadFd,false,TimeOut) == false)
 209       {
 210          Close();
 211          return _error->Error(_("Connection timeout"));
 212       }
 213
 214       // Suck it back
 215       int Res = read(ReadFd,Buffer + Len,sizeof(Buffer) - Len);
 216       if (Res <= 0)
 217       {
 218          _error->Errno("read",_("Read error"));
 219          Close();
 220          return false;
 221       }
 222       Len += Res;
 223    }
 224
 225    return _error->Error(_("A response overflowed the buffer."));
 226 }
 227                                                                         /*}}}*/
 228 // RSHConn::WriteMsg - Send a message with optional remote sync.        /*{{{*/
 229 // ---------------------------------------------------------------------
 230 /* The remote sync flag appends a || echo which will insert blank line
 231    once the command completes. */
 232 bool RSHConn::WriteMsg(std::string &Text,bool Sync,const char *Fmt,...)
 233 {
 234    va_list args;
 235    va_start(args,Fmt);
 236
 237    // sprintf into a buffer
 238    char Tmp[1024];
 239    vsnprintf(Tmp,sizeof(Tmp),Fmt,args);
 240    va_end(args);
 241
 242    // concat to create the real msg
 243    std::string Msg;
 244    if (Sync == true)
 245       Msg = std::string(Tmp) + " 2> /dev/null || echo\n";
 246    else
 247       Msg = std::string(Tmp) + " 2> /dev/null\n";
 248
 249    // Send it off
 250    const char *S = Msg.c_str();
 251    unsigned long Len = strlen(S);
 252    unsigned long Start = 0;
 253    while (Len != 0)
 254    {
 255       if (WaitFd(WriteFd,true,TimeOut) == false)
 256       {
 257
 258          Close();
 259          return _error->Error(_("Connection timeout"));
 260       }
 261
 262       int Res = write(WriteFd,S + Start,Len);
 263       if (Res <= 0)
 264       {
 265          _error->Errno("write",_("Write error"));
 266          Close();
 267          return false;
 268       }
 269
 270       Len -= Res;
 271       Start += Res;
 272    }
 273
 274    if (Sync == true)
 275       return ReadLine(Text);
 276    return true;
 277 }
 278                                                                         /*}}}*/
 279 // RSHConn::Size - Return the size of the file                          /*{{{*/
 280 // ---------------------------------------------------------------------
 281 /* Right now for successful transfer the file size must be known in
 282    advance. */
 283 bool RSHConn::Size(const char *Path,unsigned long long &Size)
 284 {
 285    // Query the size
 286         std::string Msg;
 287    Size = 0;
 288
 289    if (WriteMsg(Msg,true,"find %s -follow -printf '%%s\\n'",Path) == false)
 290       return false;
 291
 292    // FIXME: Sense if the bad reply is due to a File Not Found.
 293
 294    char *End;
 295    Size = strtoull(Msg.c_str(),&End,10);
 296    if (End == Msg.c_str())
 297       return _error->Error(_("File not found"));
 298    return true;
 299 }
 300                                                                         /*}}}*/
 301 // RSHConn::ModTime - Get the modification time in UTC                  /*{{{*/
 302 // ---------------------------------------------------------------------
 303 /* */
 304 bool RSHConn::ModTime(const char *Path, time_t &Time)
 305 {
 306    Time = time(&Time);
 307    // Query the mod time
 308    std::string Msg;
 309
 310    if (WriteMsg(Msg,true,"TZ=UTC find %s -follow -printf '%%TY%%Tm%%Td%%TH%%TM%%TS\\n'",Path) == false)
 311       return false;
 312
 313    // Parse it
 314    return FTPMDTMStrToTime(Msg.c_str(), Time);
 315 }
 316                                                                         /*}}}*/
 317 // RSHConn::Get - Get a file                                            /*{{{*/
 318 // ---------------------------------------------------------------------
 319 /* */
 320 bool RSHConn::Get(const char *Path,FileFd &To,unsigned long long Resume,
 321                   Hashes &Hash,bool &Missing, unsigned long long Size)
 322 {
 323    Missing = false;
 324
 325    // Round to a 2048 byte block
 326    Resume = Resume - (Resume % 2048);
 327
 328    if (To.Truncate(Resume) == false)
 329       return false;
 330    if (To.Seek(0) == false)
 331       return false;
 332
 333    if (Resume != 0) {
 334       if (Hash.AddFD(To,Resume) == false) {
 335          _error->Errno("read",_("Problem hashing file"));
 336          return false;
 337       }
 338    }
 339
 340    // FIXME: Detect file-not openable type errors.
 341    std::string Jnk;
 342    if (WriteMsg(Jnk,false,"dd if=%s bs=2048 skip=%u", Path, Resume / 2048) == false)
 343       return false;
 344
 345    // Copy loop
 346    unsigned long long MyLen = Resume;
 347    unsigned char Buffer[4096];
 348    while (MyLen < Size)
 349    {
 350       // Wait for some data..
 351       if (WaitFd(ReadFd,false,TimeOut) == false)
 352       {
 353          Close();
 354          return _error->Error(_("Data socket timed out"));
 355       }
 356
 357       // Read the data..
 358       int Res = read(ReadFd,Buffer,sizeof(Buffer));
 359       if (Res == 0)
 360       {
 361          Close();
 362          return _error->Error(_("Connection closed prematurely"));
 363       }
 364
 365       if (Res < 0)
 366       {
 367          if (errno == EAGAIN)
 368             continue;
 369          break;
 370       }
 371       MyLen += Res;
 372
 373       Hash.Add(Buffer,Res);
 374       if (To.Write(Buffer,Res) == false)
 375       {
 376          Close();
 377          return false;
 378       }
 379    }
 380
 381    return true;
 382 }
 383                                                                         /*}}}*/
 384
 385 // RSHMethod::RSHMethod - Constructor                                   /*{{{*/
 386 // ---------------------------------------------------------------------
 387 /* */
 388 RSHMethod::RSHMethod(std::string const &pProg) : aptMethod(pProg.c_str(),"1.0",SendConfig), Prog(pProg)
 389 {
 390    signal(SIGTERM,SigTerm);
 391    signal(SIGINT,SigTerm);
 392    Server = 0;
 393    FailFd = -1;
 394 }
 395                                                                         /*}}}*/
 396 // RSHMethod::Configuration - Handle a configuration message            /*{{{*/
 397 // ---------------------------------------------------------------------
 398 bool RSHMethod::Configuration(std::string Message)
 399 {
 400    // enabling privilege dropping for this method requires configuration…
 401    // … which is otherwise lifted straight from root, so use it by default.
 402    _config->Set(std::string("Binary::") + Prog + "::APT::Sandbox::User", "");
 403
 404    if (aptMethod::Configuration(Message) == false)
 405       return false;
 406
 407    std::string const timeconf = std::string("Acquire::") + Prog + "::Timeout";
 408    TimeOut = _config->FindI(timeconf, TimeOut);
 409    std::string const optsconf = std::string("Acquire::") + Prog + "::Options";
 410    RshOptions = _config->Tree(optsconf.c_str());
 411
 412    return true;
 413 }
 414                                                                         /*}}}*/
 415 // RSHMethod::SigTerm - Clean up and timestamp the files on exit        /*{{{*/
 416 // ---------------------------------------------------------------------
 417 /* */
 418 void RSHMethod::SigTerm(int)
 419 {
 420    if (FailFd == -1)
 421       _exit(100);
 422
 423    // Transfer the modification times
 424    struct timeval times[2];
 425    times[0].tv_sec = FailTime;
 426    times[1].tv_sec = FailTime;
 427    times[0].tv_usec = times[1].tv_usec = 0;
 428    utimes(FailFile.c_str(), times);
 429    close(FailFd);
 430
 431    _exit(100);
 432 }
 433                                                                         /*}}}*/
 434 // RSHMethod::Fetch - Fetch a URI                                       /*{{{*/
 435 // ---------------------------------------------------------------------
 436 /* */
 437 bool RSHMethod::Fetch(FetchItem *Itm)
 438 {
 439    URI Get = Itm->Uri;
 440    const char *File = Get.Path.c_str();
 441    FetchResult Res;
 442    Res.Filename = Itm->DestFile;
 443    Res.IMSHit = false;
 444
 445    // Connect to the server
 446    if (Server == 0 || Server->Comp(Get) == false) {
 447       delete Server;
 448       Server = new RSHConn(Prog, Get);
 449    }
 450
 451    // Could not connect is a transient error..
 452    if (Server->Open() == false) {
 453       Server->Close();
 454       Fail(true);
 455       return true;
 456    }
 457
 458    // We say this mainly because the pause here is for the
 459    // ssh connection that is still going
 460    Status(_("Connecting to %s"), Get.Host.c_str());
 461
 462    // Get the files information
 463    unsigned long long Size;
 464    if (Server->Size(File,Size) == false ||
 465        Server->ModTime(File,FailTime) == false)
 466    {
 467       //Fail(true);
 468       //_error->Error(_("File not found")); // Will be handled by Size
 469       return false;
 470    }
 471    Res.Size = Size;
 472
 473    // See if it is an IMS hit
 474    if (Itm->LastModified == FailTime) {
 475       Res.Size = 0;
 476       Res.IMSHit = true;
 477       URIDone(Res);
 478       return true;
 479    }
 480
 481    // See if the file exists
 482    struct stat Buf;
 483    if (stat(Itm->DestFile.c_str(),&Buf) == 0) {
 484       if (Size == (unsigned long long)Buf.st_size && FailTime == Buf.st_mtime) {
 485          Res.Size = Buf.st_size;
 486          Res.LastModified = Buf.st_mtime;
 487          Res.ResumePoint = Buf.st_size;
 488          URIDone(Res);
 489          return true;
 490       }
 491
 492       // Resume?
 493       if (FailTime == Buf.st_mtime && Size > (unsigned long long)Buf.st_size)
 494          Res.ResumePoint = Buf.st_size;
 495    }
 496
 497    // Open the file
 498    Hashes Hash(Itm->ExpectedHashes);
 499    {
 500       FileFd Fd(Itm->DestFile,FileFd::WriteAny);
 501       if (_error->PendingError() == true)
 502          return false;
 503
 504       URIStart(Res);
 505
 506       FailFile = Itm->DestFile;
 507       FailFile.c_str();   // Make sure we don't do a malloc in the signal handler
 508       FailFd = Fd.Fd();
 509
 510       bool Missing;
 511       if (Server->Get(File,Fd,Res.ResumePoint,Hash,Missing,Res.Size) == false)
 512       {
 513          Fd.Close();
 514
 515          // Timestamp
 516          struct timeval times[2];
 517          times[0].tv_sec = FailTime;
 518          times[1].tv_sec = FailTime;
 519          times[0].tv_usec = times[1].tv_usec = 0;
 520          utimes(FailFile.c_str(), times);
 521
 522          // If the file is missing we hard fail otherwise transient fail
 523          if (Missing == true)
 524             return false;
 525          Fail(true);
 526          return true;
 527       }
 528
 529       Res.Size = Fd.Size();
 530       struct timeval times[2];
 531       times[0].tv_sec = FailTime;
 532       times[1].tv_sec = FailTime;
 533       times[0].tv_usec = times[1].tv_usec = 0;
 534       utimes(Fd.Name().c_str(), times);
 535       FailFd = -1;
 536    }
 537
 538    Res.LastModified = FailTime;
 539    Res.TakeHashes(Hash);
 540
 541    URIDone(Res);
 542
 543    return true;
 544 }
 545                                                                         /*}}}*/
 546
 547 int main(int, const char *argv[])
 548 {
 549    return RSHMethod(flNotDir(argv[0])).Run();
 550 }