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 <apt-pkg/sourcelist.h>
  12 #include <apt-pkg/error.h>
  13 #include <apt-pkg/fileutl.h>
  14 #include <apt-pkg/strutl.h>
  15 #include <apt-pkg/configuration.h>
  16
  17 #include <apti18n.h>
  18
  19 #include <fstream>
  20                                                                         /*}}}*/
  21
  22 using namespace std;
  23
  24 // Global list of Items supported
  25 static  pkgSourceList::Type *ItmList[10];
  26 pkgSourceList::Type **pkgSourceList::Type::GlobalList = ItmList;
  27 unsigned long pkgSourceList::Type::GlobalListLen = 0;
  28
  29 // Type::Type - Constructor                                             /*{{{*/
  30 // ---------------------------------------------------------------------
  31 /* Link this to the global list of items*/
  32 pkgSourceList::Type::Type()
  33 {
  34    ItmList[GlobalListLen] = this;
  35    GlobalListLen++;
  36 }
  37                                                                         /*}}}*/
  38 // Type::GetType - Get a specific meta for a given type                 /*{{{*/
  39 // ---------------------------------------------------------------------
  40 /* */
  41 pkgSourceList::Type *pkgSourceList::Type::GetType(const char *Type)
  42 {
  43    for (unsigned I = 0; I != GlobalListLen; I++)
  44       if (strcmp(GlobalList[I]->Name,Type) == 0)
  45          return GlobalList[I];
  46    return 0;
  47 }
  48                                                                         /*}}}*/
  49 // Type::FixupURI - Normalize the URI and check it..                    /*{{{*/
  50 // ---------------------------------------------------------------------
  51 /* */
  52 bool pkgSourceList::Type::FixupURI(string &URI) const
  53 {
  54    if (URI.empty() == true)
  55       return false;
  56
  57    if (URI.find(':') == string::npos)
  58       return false;
  59
  60    URI = SubstVar(URI,"$(ARCH)",_config->Find("APT::Architecture"));
  61
  62    // Make sure that the URI is / postfixed
  63    if (URI[URI.size() - 1] != '/')
  64       URI += '/';
  65
  66    return true;
  67 }
  68                                                                         /*}}}*/
  69 // Type::ParseLine - Parse a single line                                /*{{{*/
  70 // ---------------------------------------------------------------------
  71 /* This is a generic one that is the 'usual' format for sources.list
  72    Weird types may override this. */
  73 bool pkgSourceList::Type::ParseLine(vector<metaIndex *> &List,
  74                                     const char *Buffer,
  75                                     unsigned long const &CurLine,
  76                                     string const &File) const
  77 {
  78    for (;Buffer != 0 && isspace(*Buffer); ++Buffer); // Skip whitespaces
  79
  80    // Parse option field if it exists
  81    // e.g.: [ option1=value1 option2=value2 ]
  82    map<string, string> Options;
  83    if (Buffer != 0 && Buffer[0] == '[')
  84    {
  85       ++Buffer; // ignore the [
  86       for (;Buffer != 0 && isspace(*Buffer); ++Buffer); // Skip whitespaces
  87       while (*Buffer != ']')
  88       {
  89          // get one option, e.g. option1=value1
  90          string option;
  91          if (ParseQuoteWord(Buffer,option) == false)
  92             return _error->Error(_("Malformed line %lu in source list %s ([option] unparseable)"),CurLine,File.c_str());
  93
  94          if (option.length() < 3)
  95             return _error->Error(_("Malformed line %lu in source list %s ([option] too short)"),CurLine,File.c_str());
  96
  97          size_t const needle = option.find('=');
  98          if (needle == string::npos)
  99             return _error->Error(_("Malformed line %lu in source list %s ([%s] is not an assignment)"),CurLine,File.c_str(), option.c_str());
 100
 101          string const key = string(option, 0, needle);
 102          string const value = string(option, needle + 1, option.length());
 103
 104          if (key.empty() == true)
 105             return _error->Error(_("Malformed line %lu in source list %s ([%s] has no key)"),CurLine,File.c_str(), option.c_str());
 106
 107          if (value.empty() == true)
 108             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());
 109
 110          Options[key] = value;
 111       }
 112       ++Buffer; // ignore the ]
 113       for (;Buffer != 0 && isspace(*Buffer); ++Buffer); // Skip whitespaces
 114    }
 115
 116    string URI;
 117    string Dist;
 118    string Section;
 119
 120    if (ParseQuoteWord(Buffer,URI) == false)
 121       return _error->Error(_("Malformed line %lu in source list %s (URI)"),CurLine,File.c_str());
 122    if (ParseQuoteWord(Buffer,Dist) == false)
 123       return _error->Error(_("Malformed line %lu in source list %s (dist)"),CurLine,File.c_str());
 124
 125    if (FixupURI(URI) == false)
 126       return _error->Error(_("Malformed line %lu in source list %s (URI parse)"),CurLine,File.c_str());
 127
 128    // Check for an absolute dists specification.
 129    if (Dist.empty() == false && Dist[Dist.size() - 1] == '/')
 130    {
 131       if (ParseQuoteWord(Buffer,Section) == true)
 132          return _error->Error(_("Malformed line %lu in source list %s (absolute dist)"),CurLine,File.c_str());
 133       Dist = SubstVar(Dist,"$(ARCH)",_config->Find("APT::Architecture"));
 134       return CreateItem(List, URI, Dist, Section, Options);
 135    }
 136
 137    // Grab the rest of the dists
 138    if (ParseQuoteWord(Buffer,Section) == false)
 139       return _error->Error(_("Malformed line %lu in source list %s (dist parse)"),CurLine,File.c_str());
 140
 141    do
 142    {
 143       if (CreateItem(List, URI, Dist, Section, Options) == false)
 144          return false;
 145    }
 146    while (ParseQuoteWord(Buffer,Section) == true);
 147
 148    return true;
 149 }
 150                                                                         /*}}}*/
 151
 152 // SourceList::pkgSourceList - Constructors                             /*{{{*/
 153 // ---------------------------------------------------------------------
 154 /* */
 155 pkgSourceList::pkgSourceList()
 156 {
 157 }
 158
 159 pkgSourceList::pkgSourceList(string File)
 160 {
 161    Read(File);
 162 }
 163                                                                         /*}}}*/
 164 // SourceList::~pkgSourceList - Destructor                              /*{{{*/
 165 // ---------------------------------------------------------------------
 166 /* */
 167 pkgSourceList::~pkgSourceList()
 168 {
 169    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 170       delete *I;
 171 }
 172                                                                         /*}}}*/
 173                                                                         /*}}}*/
 174 // SourceList::ReadMainList - Read the main source list from etc        /*{{{*/
 175 // ---------------------------------------------------------------------
 176 /* */
 177 bool pkgSourceList::ReadMainList()
 178 {
 179    // CNC:2003-03-03 - Multiple sources list support.
 180    bool Res = true;
 181 #if 0
 182    Res = ReadVendors();
 183    if (Res == false)
 184       return false;
 185 #endif
 186
 187    Reset();
 188    // CNC:2003-11-28 - Entries in sources.list have priority over
 189    //                  entries in sources.list.d.
 190    string Main = _config->FindFile("Dir::Etc::sourcelist");
 191    string Parts = _config->FindDir("Dir::Etc::sourceparts");
 192
 193    if (FileExists(Main) == true)
 194       Res &= ReadAppend(Main);
 195    else if (FileExists(Parts) == false)
 196       // Only warn if there are no sources.list.d.
 197       _error->WarningE("FileExists",_("Unable to read %s"),Main.c_str());
 198
 199    if (FileExists(Parts) == true)
 200       Res &= ReadSourceDir(Parts);
 201    else if (FileExists(Main) == false)
 202       // Only warn if there is no sources.list file.
 203       _error->WarningE("FileExists",_("Unable to read %s"),Parts.c_str());
 204
 205    return Res;
 206 }
 207                                                                         /*}}}*/
 208 // CNC:2003-03-03 - Needed to preserve backwards compatibility.
 209 // SourceList::Reset - Clear the sourcelist contents                    /*{{{*/
 210 // ---------------------------------------------------------------------
 211 /* */
 212 void pkgSourceList::Reset()
 213 {
 214    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 215       delete *I;
 216    SrcList.erase(SrcList.begin(),SrcList.end());
 217 }
 218                                                                         /*}}}*/
 219 // CNC:2003-03-03 - Function moved to ReadAppend() and Reset().
 220 // SourceList::Read - Parse the sourcelist file                         /*{{{*/
 221 // ---------------------------------------------------------------------
 222 /* */
 223 bool pkgSourceList::Read(string File)
 224 {
 225    Reset();
 226    return ReadAppend(File);
 227 }
 228                                                                         /*}}}*/
 229 // SourceList::ReadAppend - Parse a sourcelist file                     /*{{{*/
 230 // ---------------------------------------------------------------------
 231 /* */
 232 bool pkgSourceList::ReadAppend(string File)
 233 {
 234    // Open the stream for reading
 235    ifstream F(File.c_str(),ios::in /*| ios::nocreate*/);
 236    if (!F != 0)
 237       return _error->Errno("ifstream::ifstream",_("Opening %s"),File.c_str());
 238
 239 #if 0 // Now Reset() does this.
 240    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 241       delete *I;
 242    SrcList.erase(SrcList.begin(),SrcList.end());
 243 #endif
 244    // CNC:2003-12-10 - 300 is too short.
 245    char Buffer[1024];
 246
 247    int CurLine = 0;
 248    while (F.eof() == false)
 249    {
 250       F.getline(Buffer,sizeof(Buffer));
 251       CurLine++;
 252       _strtabexpand(Buffer,sizeof(Buffer));
 253       if (F.fail() && !F.eof())
 254          return _error->Error(_("Line %u too long in source list %s."),
 255                               CurLine,File.c_str());
 256
 257
 258       char *I;
 259       // CNC:2003-02-20 - Do not break if '#' is inside [].
 260       for (I = Buffer; *I != 0 && *I != '#'; I++)
 261          if (*I == '[')
 262             for (I++; *I != 0 && *I != ']'; I++);
 263       *I = 0;
 264
 265       const char *C = _strstrip(Buffer);
 266
 267       // Comment or blank
 268       if (C[0] == '#' || C[0] == 0)
 269          continue;
 270
 271       // Grok it
 272       string LineType;
 273       if (ParseQuoteWord(C,LineType) == false)
 274          return _error->Error(_("Malformed line %u in source list %s (type)"),CurLine,File.c_str());
 275
 276       Type *Parse = Type::GetType(LineType.c_str());
 277       if (Parse == 0)
 278          return _error->Error(_("Type '%s' is not known on line %u in source list %s"),LineType.c_str(),CurLine,File.c_str());
 279
 280       if (Parse->ParseLine(SrcList, C, CurLine, File) == false)
 281          return false;
 282    }
 283    return true;
 284 }
 285                                                                         /*}}}*/
 286 // SourceList::FindIndex - Get the index associated with a file         /*{{{*/
 287 // ---------------------------------------------------------------------
 288 /* */
 289 bool pkgSourceList::FindIndex(pkgCache::PkgFileIterator File,
 290                               pkgIndexFile *&Found) const
 291 {
 292    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 293    {
 294       vector<pkgIndexFile *> *Indexes = (*I)->GetIndexFiles();
 295       for (vector<pkgIndexFile *>::const_iterator J = Indexes->begin();
 296            J != Indexes->end(); J++)
 297       {
 298          if ((*J)->FindInCache(*File.Cache()) == File)
 299          {
 300             Found = (*J);
 301             return true;
 302          }
 303       }
 304    }
 305
 306    return false;
 307 }
 308                                                                         /*}}}*/
 309 // SourceList::GetIndexes - Load the index files into the downloader    /*{{{*/
 310 // ---------------------------------------------------------------------
 311 /* */
 312 bool pkgSourceList::GetIndexes(pkgAcquire *Owner, bool GetAll) const
 313 {
 314    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 315       if ((*I)->GetIndexes(Owner,GetAll) == false)
 316          return false;
 317    return true;
 318 }
 319                                                                         /*}}}*/
 320 // CNC:2003-03-03 - By Anton V. Denisov <avd@altlinux.org>.
 321 // SourceList::ReadSourceDir - Read a directory with sources files
 322 // Based on ReadConfigDir()                                             /*{{{*/
 323 // ---------------------------------------------------------------------
 324 /* */
 325 bool pkgSourceList::ReadSourceDir(string Dir)
 326 {
 327    vector<string> const List = GetListOfFilesInDir(Dir, "list", true);
 328
 329    // Read the files
 330    for (vector<string>::const_iterator I = List.begin(); I != List.end(); I++)
 331       if (ReadAppend(*I) == false)
 332          return false;
 333    return true;
 334
 335 }
 336                                                                         /*}}}*/
 337