apt-pkg/sourcelist.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: sourcelist.cc,v 1.3 2002/08/15 20:51:37 niemeyer Exp $
   4 /* ######################################################################
   5
   6    List of Sources
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #include<config.h>
  12
  13 #include <apt-pkg/sourcelist.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/fileutl.h>
  16 #include <apt-pkg/strutl.h>
  17 #include <apt-pkg/configuration.h>
  18 #include <apt-pkg/metaindex.h>
  19 #include <apt-pkg/indexfile.h>
  20 #include <apt-pkg/tagfile.h>
  21
  22 #include <fstream>
  23
  24 #include <apti18n.h>
  25                                                                         /*}}}*/
  26
  27 using namespace std;
  28
  29 // Global list of Items supported
  30 static  pkgSourceList::Type *ItmList[10];
  31 pkgSourceList::Type **pkgSourceList::Type::GlobalList = ItmList;
  32 unsigned long pkgSourceList::Type::GlobalListLen = 0;
  33
  34 // Type::Type - Constructor                                             /*{{{*/
  35 // ---------------------------------------------------------------------
  36 /* Link this to the global list of items*/
  37 pkgSourceList::Type::Type() : Name(NULL), Label(NULL)
  38 {
  39    ItmList[GlobalListLen] = this;
  40    GlobalListLen++;
  41 }
  42                                                                         /*}}}*/
  43 // Type::GetType - Get a specific meta for a given type                 /*{{{*/
  44 // ---------------------------------------------------------------------
  45 /* */
  46 pkgSourceList::Type *pkgSourceList::Type::GetType(const char *Type)
  47 {
  48    for (unsigned I = 0; I != GlobalListLen; I++)
  49       if (strcmp(GlobalList[I]->Name,Type) == 0)
  50          return GlobalList[I];
  51    return 0;
  52 }
  53                                                                         /*}}}*/
  54 // Type::FixupURI - Normalize the URI and check it..                    /*{{{*/
  55 // ---------------------------------------------------------------------
  56 /* */
  57 bool pkgSourceList::Type::FixupURI(string &URI) const
  58 {
  59    if (URI.empty() == true)
  60       return false;
  61
  62    if (URI.find(':') == string::npos)
  63       return false;
  64
  65    URI = SubstVar(URI,"$(ARCH)",_config->Find("APT::Architecture"));
  66
  67    // Make sure that the URI is / postfixed
  68    if (URI[URI.size() - 1] != '/')
  69       URI += '/';
  70
  71    return true;
  72 }
  73                                                                         /*}}}*/
  74 // Type::ParseLine - Parse a single line                                /*{{{*/
  75 // ---------------------------------------------------------------------
  76 /* This is a generic one that is the 'usual' format for sources.list
  77    Weird types may override this. */
  78 bool pkgSourceList::Type::ParseLine(vector<metaIndex *> &List,
  79                                     const char *Buffer,
  80                                     unsigned long const &CurLine,
  81                                     string const &File) const
  82 {
  83    for (;Buffer != 0 && isspace(*Buffer); ++Buffer); // Skip whitespaces
  84
  85    // Parse option field if it exists
  86    // e.g.: [ option1=value1 option2=value2 ]
  87    map<string, string> Options;
  88    if (Buffer != 0 && Buffer[0] == '[')
  89    {
  90       ++Buffer; // ignore the [
  91       for (;Buffer != 0 && isspace(*Buffer); ++Buffer); // Skip whitespaces
  92       while (*Buffer != ']')
  93       {
  94          // get one option, e.g. option1=value1
  95          string option;
  96          if (ParseQuoteWord(Buffer,option) == false)
  97             return _error->Error(_("Malformed line %lu in source list %s ([option] unparseable)"),CurLine,File.c_str());
  98
  99          if (option.length() < 3)
 100             return _error->Error(_("Malformed line %lu in source list %s ([option] too short)"),CurLine,File.c_str());
 101
 102          // accept options even if the last has no space before the ]-end marker
 103          if (option.at(option.length()-1) == ']')
 104          {
 105             for (; *Buffer != ']'; --Buffer);
 106             option.resize(option.length()-1);
 107          }
 108
 109          size_t const needle = option.find('=');
 110          if (needle == string::npos)
 111             return _error->Error(_("Malformed line %lu in source list %s ([%s] is not an assignment)"),CurLine,File.c_str(), option.c_str());
 112
 113          string const key = string(option, 0, needle);
 114          string const value = string(option, needle + 1, option.length());
 115
 116          if (key.empty() == true)
 117             return _error->Error(_("Malformed line %lu in source list %s ([%s] has no key)"),CurLine,File.c_str(), option.c_str());
 118
 119          if (value.empty() == true)
 120             return _error->Error(_("Malformed line %lu in source list %s ([%s] key %s has no value)"),CurLine,File.c_str(),option.c_str(),key.c_str());
 121
 122          Options[key] = value;
 123       }
 124       ++Buffer; // ignore the ]
 125       for (;Buffer != 0 && isspace(*Buffer); ++Buffer); // Skip whitespaces
 126    }
 127
 128    string URI;
 129    string Dist;
 130    string Section;
 131
 132    if (ParseQuoteWord(Buffer,URI) == false)
 133       return _error->Error(_("Malformed line %lu in source list %s (URI)"),CurLine,File.c_str());
 134    if (ParseQuoteWord(Buffer,Dist) == false)
 135       return _error->Error(_("Malformed line %lu in source list %s (dist)"),CurLine,File.c_str());
 136
 137    if (FixupURI(URI) == false)
 138       return _error->Error(_("Malformed line %lu in source list %s (URI parse)"),CurLine,File.c_str());
 139
 140    // Check for an absolute dists specification.
 141    if (Dist.empty() == false && Dist[Dist.size() - 1] == '/')
 142    {
 143       if (ParseQuoteWord(Buffer,Section) == true)
 144          return _error->Error(_("Malformed line %lu in source list %s (absolute dist)"),CurLine,File.c_str());
 145       Dist = SubstVar(Dist,"$(ARCH)",_config->Find("APT::Architecture"));
 146       return CreateItem(List, URI, Dist, Section, Options);
 147    }
 148
 149    // Grab the rest of the dists
 150    if (ParseQuoteWord(Buffer,Section) == false)
 151       return _error->Error(_("Malformed line %lu in source list %s (dist parse)"),CurLine,File.c_str());
 152
 153    do
 154    {
 155       if (CreateItem(List, URI, Dist, Section, Options) == false)
 156          return false;
 157    }
 158    while (ParseQuoteWord(Buffer,Section) == true);
 159
 160    return true;
 161 }
 162                                                                         /*}}}*/
 163 // SourceList::pkgSourceList - Constructors                             /*{{{*/
 164 // ---------------------------------------------------------------------
 165 /* */
 166 pkgSourceList::pkgSourceList()
 167 {
 168 }
 169
 170 pkgSourceList::pkgSourceList(string File)
 171 {
 172    Read(File);
 173 }
 174                                                                         /*}}}*/
 175 // SourceList::~pkgSourceList - Destructor                              /*{{{*/
 176 // ---------------------------------------------------------------------
 177 /* */
 178 pkgSourceList::~pkgSourceList()
 179 {
 180    for (const_iterator I = SrcList.begin(); I != SrcList.end(); ++I)
 181       delete *I;
 182 }
 183                                                                         /*}}}*/
 184 // SourceList::ReadMainList - Read the main source list from etc        /*{{{*/
 185 // ---------------------------------------------------------------------
 186 /* */
 187 bool pkgSourceList::ReadMainList()
 188 {
 189    // CNC:2003-03-03 - Multiple sources list support.
 190    bool Res = true;
 191 #if 0
 192    Res = ReadVendors();
 193    if (Res == false)
 194       return false;
 195 #endif
 196
 197    Reset();
 198    // CNC:2003-11-28 - Entries in sources.list have priority over
 199    //                  entries in sources.list.d.
 200    string Main = _config->FindFile("Dir::Etc::sourcelist");
 201    string Parts = _config->FindDir("Dir::Etc::sourceparts");
 202
 203    if (RealFileExists(Main) == true)
 204       Res &= ReadAppend(Main);
 205    else if (DirectoryExists(Parts) == false)
 206       // Only warn if there are no sources.list.d.
 207       _error->WarningE("DirectoryExists", _("Unable to read %s"), Parts.c_str());
 208
 209    if (DirectoryExists(Parts) == true)
 210       Res &= ReadSourceDir(Parts);
 211    else if (RealFileExists(Main) == false)
 212       // Only warn if there is no sources.list file.
 213       _error->WarningE("RealFileExists", _("Unable to read %s"), Main.c_str());
 214
 215    return Res;
 216 }
 217                                                                         /*}}}*/
 218 // SourceList::Reset - Clear the sourcelist contents                    /*{{{*/
 219 // ---------------------------------------------------------------------
 220 /* */
 221 void pkgSourceList::Reset()
 222 {
 223    for (const_iterator I = SrcList.begin(); I != SrcList.end(); ++I)
 224       delete *I;
 225    SrcList.erase(SrcList.begin(),SrcList.end());
 226 }
 227                                                                         /*}}}*/
 228 // SourceList::Read - Parse the sourcelist file                         /*{{{*/
 229 // ---------------------------------------------------------------------
 230 /* */
 231 bool pkgSourceList::Read(string File)
 232 {
 233    Reset();
 234    return ReadAppend(File);
 235 }
 236                                                                         /*}}}*/
 237 // SourceList::ReadAppend - Parse a sourcelist file                     /*{{{*/
 238 // ---------------------------------------------------------------------
 239 /* */
 240 bool pkgSourceList::ReadAppend(string File)
 241 {
 242    if (_config->FindB("APT::Sources::Use-Deb822", true) == true)
 243    {
 244       int lines_parsed =ParseFileDeb822(File);
 245       if (lines_parsed < 0)
 246          return false;
 247       else if (lines_parsed > 0)
 248          return true;
 249       // no lines parsed  ... fall through and use old style parser
 250    }
 251    return ParseFileOldStyle(File);
 252 }
 253
 254 // SourceList::ReadFileOldStyle - Read Traditional style sources.list   /*{{{*/
 255 // ---------------------------------------------------------------------
 256 /* */
 257 bool pkgSourceList::ParseFileOldStyle(string File)
 258 {
 259    // Open the stream for reading
 260    ifstream F(File.c_str(),ios::in /*| ios::nocreate*/);
 261    if (!F != 0)
 262       return _error->Errno("ifstream::ifstream",_("Opening %s"),File.c_str());
 263
 264    // CNC:2003-12-10 - 300 is too short.
 265    char Buffer[1024];
 266
 267    int CurLine = 0;
 268    while (F.eof() == false)
 269    {
 270       F.getline(Buffer,sizeof(Buffer));
 271       CurLine++;
 272       _strtabexpand(Buffer,sizeof(Buffer));
 273       if (F.fail() && !F.eof())
 274          return _error->Error(_("Line %u too long in source list %s."),
 275                               CurLine,File.c_str());
 276
 277
 278       char *I;
 279       // CNC:2003-02-20 - Do not break if '#' is inside [].
 280       for (I = Buffer; *I != 0 && *I != '#'; I++)
 281          if (*I == '[')
 282          {
 283             char *b_end = strchr(I + 1, ']');
 284             if (b_end != NULL)
 285                I = b_end;
 286          }
 287       *I = 0;
 288
 289       const char *C = _strstrip(Buffer);
 290
 291       // Comment or blank
 292       if (C[0] == '#' || C[0] == 0)
 293          continue;
 294
 295       // Grok it
 296       string LineType;
 297       if (ParseQuoteWord(C,LineType) == false)
 298          return _error->Error(_("Malformed line %u in source list %s (type)"),CurLine,File.c_str());
 299
 300       Type *Parse = Type::GetType(LineType.c_str());
 301       if (Parse == 0)
 302          return _error->Error(_("Type '%s' is not known on line %u in source list %s"),LineType.c_str(),CurLine,File.c_str());
 303
 304       if (Parse->ParseLine(SrcList, C, CurLine, File) == false)
 305          return false;
 306    }
 307    return true;
 308 }
 309                                                                         /*}}}*/
 310 // SourceList::ParseFileDeb822 - Parse deb822 style sources.list        /*{{{*/
 311 // ---------------------------------------------------------------------
 312 /* Returns: the number of stanzas parsed*/
 313 int pkgSourceList::ParseFileDeb822(string File)
 314 {
 315    pkgTagSection Tags;
 316    map<string, string> Options;
 317    unsigned int i=0;
 318
 319    // see if we can read the file
 320    _error->PushToStack();
 321    FileFd Fd(File, FileFd::ReadOnly);
 322    pkgTagFile Sources(&Fd);
 323    if (_error->PendingError() == true)
 324    {
 325       _error->RevertToStack();
 326       return 0;
 327    }
 328    _error->MergeWithStack();
 329
 330    // read step by step
 331    while (Sources.Step(Tags) == true)
 332    {
 333       if(!Tags.Exists("Type"))
 334          continue;
 335
 336       string const type = Tags.FindS("Type");
 337       Type *Parse = Type::GetType(type.c_str());
 338       if (Parse == 0)
 339       {
 340          _error->Error(_("Type '%s' is not known on stanza %u in source list %s"),type.c_str(),i,Fd.Name().c_str());
 341          // true means we do not retry with old-style sources.list
 342          return -1;
 343       }
 344
 345       string URI = Tags.FindS("URL");
 346       if (!Parse->FixupURI(URI))
 347       {
 348          _error->Error(_("Malformed stanza %u in source list %s (URI parse)"),i,Fd.Name().c_str());
 349          // means we do not retry with old-style sources.list
 350          return -1;
 351       }
 352
 353       string Dist = Tags.FindS("Dist");
 354       Dist = SubstVar(Dist,"$(ARCH)",_config->Find("APT::Architecture"));
 355
 356       // check if there are any options we support
 357       const char* option_str[] = {
 358          "arch", "arch+", "arch-", "trusted",
 359       };
 360       for (unsigned int j=0; j < sizeof(option_str)/sizeof(char*); j++)
 361          if (Tags.Exists(option_str[j]))
 362             Options[option_str[j]] = Tags.FindS(option_str[j]);
 363
 364       // now create one item per section
 365       string const Section = Tags.FindS("Section");
 366       std::vector<std::string> list = StringSplit(Section, " ");
 367       for (std::vector<std::string>::const_iterator I = list.begin();
 368            I != list.end(); I++)
 369          Parse->CreateItem(SrcList, URI, Dist, (*I), Options);
 370
 371       i++;
 372    }
 373
 374    // we are done, return the number of stanzas read
 375    return i;
 376 }
 377                                                                         /*}}}*/
 378 // SourceList::FindIndex - Get the index associated with a file         /*{{{*/
 379 // ---------------------------------------------------------------------
 380 /* */
 381 bool pkgSourceList::FindIndex(pkgCache::PkgFileIterator File,
 382                               pkgIndexFile *&Found) const
 383 {
 384    for (const_iterator I = SrcList.begin(); I != SrcList.end(); ++I)
 385    {
 386       vector<pkgIndexFile *> *Indexes = (*I)->GetIndexFiles();
 387       for (vector<pkgIndexFile *>::const_iterator J = Indexes->begin();
 388            J != Indexes->end(); ++J)
 389       {
 390          if ((*J)->FindInCache(*File.Cache()) == File)
 391          {
 392             Found = (*J);
 393             return true;
 394          }
 395       }
 396    }
 397
 398    return false;
 399 }
 400                                                                         /*}}}*/
 401 // SourceList::GetIndexes - Load the index files into the downloader    /*{{{*/
 402 // ---------------------------------------------------------------------
 403 /* */
 404 bool pkgSourceList::GetIndexes(pkgAcquire *Owner, bool GetAll) const
 405 {
 406    for (const_iterator I = SrcList.begin(); I != SrcList.end(); ++I)
 407       if ((*I)->GetIndexes(Owner,GetAll) == false)
 408          return false;
 409    return true;
 410 }
 411                                                                         /*}}}*/
 412 // CNC:2003-03-03 - By Anton V. Denisov <avd@altlinux.org>.
 413 // SourceList::ReadSourceDir - Read a directory with sources files
 414 // Based on ReadConfigDir()                                             /*{{{*/
 415 // ---------------------------------------------------------------------
 416 /* */
 417 bool pkgSourceList::ReadSourceDir(string Dir)
 418 {
 419    vector<string> const List = GetListOfFilesInDir(Dir, "list", true);
 420
 421    // Read the files
 422    for (vector<string>::const_iterator I = List.begin(); I != List.end(); ++I)
 423       if (ReadAppend(*I) == false)
 424          return false;
 425    return true;
 426
 427 }
 428                                                                         /*}}}*/
 429 // GetLastModified()                                            /*{{{*/
 430 // ---------------------------------------------------------------------
 431 /* */
 432 time_t pkgSourceList::GetLastModifiedTime()
 433 {
 434    vector<string> List;
 435
 436    string Main = _config->FindFile("Dir::Etc::sourcelist");
 437    string Parts = _config->FindDir("Dir::Etc::sourceparts");
 438
 439    // go over the parts
 440    if (DirectoryExists(Parts) == true)
 441       List = GetListOfFilesInDir(Parts, "list", true);
 442
 443    // calculate the time
 444    time_t mtime_sources = GetModificationTime(Main);
 445    for (vector<string>::const_iterator I = List.begin(); I != List.end(); ++I)
 446       mtime_sources = std::max(mtime_sources, GetModificationTime(*I));
 447
 448    return mtime_sources;
 449 }
 450                                                                         /*}}}*/
 451