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 // CNC:2003-03-03 - This is needed for ReadDir stuff.
  22 #include <algorithm>
  23 #include <stdio.h>
  24 #include <dirent.h>
  25 #include <sys/stat.h>
  26 #include <unistd.h>
  27                                                                         /*}}}*/
  28
  29 using namespace std;
  30
  31 // Global list of Items supported
  32 static  pkgSourceList::Type *ItmList[10];
  33 pkgSourceList::Type **pkgSourceList::Type::GlobalList = ItmList;
  34 unsigned long pkgSourceList::Type::GlobalListLen = 0;
  35
  36 // Type::Type - Constructor                                             /*{{{*/
  37 // ---------------------------------------------------------------------
  38 /* Link this to the global list of items*/
  39 pkgSourceList::Type::Type()
  40 {
  41    ItmList[GlobalListLen] = this;
  42    GlobalListLen++;
  43 }
  44                                                                         /*}}}*/
  45 // Type::GetType - Get a specific meta for a given type                 /*{{{*/
  46 // ---------------------------------------------------------------------
  47 /* */
  48 pkgSourceList::Type *pkgSourceList::Type::GetType(const char *Type)
  49 {
  50    for (unsigned I = 0; I != GlobalListLen; I++)
  51       if (strcmp(GlobalList[I]->Name,Type) == 0)
  52          return GlobalList[I];
  53    return 0;
  54 }
  55                                                                         /*}}}*/
  56 // Type::FixupURI - Normalize the URI and check it..                    /*{{{*/
  57 // ---------------------------------------------------------------------
  58 /* */
  59 bool pkgSourceList::Type::FixupURI(string &URI) const
  60 {
  61    if (URI.empty() == true)
  62       return false;
  63
  64    if (URI.find(':') == string::npos)
  65       return false;
  66
  67    URI = SubstVar(URI,"$(ARCH)",_config->Find("APT::Architecture"));
  68
  69    // Make sure that the URI is / postfixed
  70    if (URI[URI.size() - 1] != '/')
  71       URI += '/';
  72
  73    return true;
  74 }
  75                                                                         /*}}}*/
  76 // Type::ParseLine - Parse a single line                                /*{{{*/
  77 // ---------------------------------------------------------------------
  78 /* This is a generic one that is the 'usual' format for sources.list
  79    Weird types may override this. */
  80 bool pkgSourceList::Type::ParseLine(vector<metaIndex *> &List,
  81                                     const char *Buffer,
  82                                     unsigned long CurLine,
  83                                     string File) const
  84 {
  85    string URI;
  86    string Dist;
  87    string Section;
  88
  89    if (ParseQuoteWord(Buffer,URI) == false)
  90       return _error->Error(_("Malformed line %lu in source list %s (URI)"),CurLine,File.c_str());
  91    if (ParseQuoteWord(Buffer,Dist) == false)
  92       return _error->Error(_("Malformed line %lu in source list %s (dist)"),CurLine,File.c_str());
  93
  94    if (FixupURI(URI) == false)
  95       return _error->Error(_("Malformed line %lu in source list %s (URI parse)"),CurLine,File.c_str());
  96
  97    // Check for an absolute dists specification.
  98    if (Dist.empty() == false && Dist[Dist.size() - 1] == '/')
  99    {
 100       if (ParseQuoteWord(Buffer,Section) == true)
 101          return _error->Error(_("Malformed line %lu in source list %s (absolute dist)"),CurLine,File.c_str());
 102       Dist = SubstVar(Dist,"$(ARCH)",_config->Find("APT::Architecture"));
 103       return CreateItem(List,URI,Dist,Section);
 104    }
 105
 106    // Grab the rest of the dists
 107    if (ParseQuoteWord(Buffer,Section) == false)
 108       return _error->Error(_("Malformed line %lu in source list %s (dist parse)"),CurLine,File.c_str());
 109
 110    do
 111    {
 112       if (CreateItem(List,URI,Dist,Section) == false)
 113          return false;
 114    }
 115    while (ParseQuoteWord(Buffer,Section) == true);
 116
 117    return true;
 118 }
 119                                                                         /*}}}*/
 120
 121 // SourceList::pkgSourceList - Constructors                             /*{{{*/
 122 // ---------------------------------------------------------------------
 123 /* */
 124 pkgSourceList::pkgSourceList()
 125 {
 126 }
 127
 128 pkgSourceList::pkgSourceList(string File)
 129 {
 130    Read(File);
 131 }
 132                                                                         /*}}}*/
 133 // SourceList::~pkgSourceList - Destructor                              /*{{{*/
 134 // ---------------------------------------------------------------------
 135 /* */
 136 pkgSourceList::~pkgSourceList()
 137 {
 138    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 139       delete *I;
 140 }
 141                                                                         /*}}}*/
 142                                                                         /*}}}*/
 143 // SourceList::ReadMainList - Read the main source list from etc        /*{{{*/
 144 // ---------------------------------------------------------------------
 145 /* */
 146 bool pkgSourceList::ReadMainList()
 147 {
 148    // CNC:2003-03-03 - Multiple sources list support.
 149    bool Res = true;
 150 #if 0
 151    Res = ReadVendors();
 152    if (Res == false)
 153       return false;
 154 #endif
 155
 156    Reset();
 157    // CNC:2003-11-28 - Entries in sources.list have priority over
 158    //                  entries in sources.list.d.
 159    string Main = _config->FindFile("Dir::Etc::sourcelist");
 160    string noSourceMsg;
 161    if (FileExists(Main) == true)
 162       Res &= ReadAppend(Main);
 163    else
 164    {
 165       // only print the warning if we can't load a valid sourcefile in the end
 166       _error->WarningE("FileExists",_("Unable to read %s"),Main.c_str());
 167       _error->PopMessage(noSourceMsg);
 168    }
 169
 170    string Parts = _config->FindDir("Dir::Etc::sourceparts");
 171    if (FileExists(Parts) == true)
 172       Res &= ReadSourceDir(Parts);
 173    else
 174       _error->WarningE("FileExists",_("Unable to read %s"),Parts.c_str());
 175
 176    if (SrcList.empty() == true && noSourceMsg.empty() == false)
 177       _error->Warning(noSourceMsg.c_str());
 178
 179    return Res;
 180 }
 181                                                                         /*}}}*/
 182 // CNC:2003-03-03 - Needed to preserve backwards compatibility.
 183 // SourceList::Reset - Clear the sourcelist contents                    /*{{{*/
 184 // ---------------------------------------------------------------------
 185 /* */
 186 void pkgSourceList::Reset()
 187 {
 188    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 189       delete *I;
 190    SrcList.erase(SrcList.begin(),SrcList.end());
 191 }
 192                                                                         /*}}}*/
 193 // CNC:2003-03-03 - Function moved to ReadAppend() and Reset().
 194 // SourceList::Read - Parse the sourcelist file                         /*{{{*/
 195 // ---------------------------------------------------------------------
 196 /* */
 197 bool pkgSourceList::Read(string File)
 198 {
 199    Reset();
 200    return ReadAppend(File);
 201 }
 202                                                                         /*}}}*/
 203 // SourceList::ReadAppend - Parse a sourcelist file                     /*{{{*/
 204 // ---------------------------------------------------------------------
 205 /* */
 206 bool pkgSourceList::ReadAppend(string File)
 207 {
 208    // Open the stream for reading
 209    ifstream F(File.c_str(),ios::in /*| ios::nocreate*/);
 210    if (!F != 0)
 211       return _error->Errno("ifstream::ifstream",_("Opening %s"),File.c_str());
 212
 213 #if 0 // Now Reset() does this.
 214    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 215       delete *I;
 216    SrcList.erase(SrcList.begin(),SrcList.end());
 217 #endif
 218    // CNC:2003-12-10 - 300 is too short.
 219    char Buffer[1024];
 220
 221    int CurLine = 0;
 222    while (F.eof() == false)
 223    {
 224       F.getline(Buffer,sizeof(Buffer));
 225       CurLine++;
 226       _strtabexpand(Buffer,sizeof(Buffer));
 227       if (F.fail() && !F.eof())
 228          return _error->Error(_("Line %u too long in source list %s."),
 229                               CurLine,File.c_str());
 230
 231
 232       char *I;
 233       // CNC:2003-02-20 - Do not break if '#' is inside [].
 234       for (I = Buffer; *I != 0 && *I != '#'; I++)
 235          if (*I == '[')
 236             for (I++; *I != 0 && *I != ']'; I++);
 237       *I = 0;
 238
 239       const char *C = _strstrip(Buffer);
 240
 241       // Comment or blank
 242       if (C[0] == '#' || C[0] == 0)
 243          continue;
 244
 245       // Grok it
 246       string LineType;
 247       if (ParseQuoteWord(C,LineType) == false)
 248          return _error->Error(_("Malformed line %u in source list %s (type)"),CurLine,File.c_str());
 249
 250       Type *Parse = Type::GetType(LineType.c_str());
 251       if (Parse == 0)
 252          return _error->Error(_("Type '%s' is not known on line %u in source list %s"),LineType.c_str(),CurLine,File.c_str());
 253
 254       // Vendor name specified
 255       if (C[0] == '[')
 256       {
 257          string VendorID;
 258
 259          if (ParseQuoteWord(C,VendorID) == false)
 260              return _error->Error(_("Malformed line %u in source list %s (vendor id)"),CurLine,File.c_str());
 261
 262          if (VendorID.length() < 2 || VendorID.end()[-1] != ']')
 263              return _error->Error(_("Malformed line %u in source list %s (vendor id)"),CurLine,File.c_str());
 264          VendorID = string(VendorID,1,VendorID.size()-2);
 265
 266 //       for (vector<const Vendor *>::const_iterator iter = VendorList.begin();
 267 //            iter != VendorList.end(); iter++)
 268 //       {
 269 //          if ((*iter)->GetVendorID() == VendorID)
 270 //          {
 271 //            if (_config->FindB("Debug::sourceList", false))
 272 //              std::cerr << "Comparing VendorID \"" << VendorID << "\" with \"" << (*iter)->GetVendorID() << '"' << std::endl;
 273 //             Verifier = *iter;
 274 //             break;
 275 //          }
 276 //       }
 277
 278 //       if (Verifier == 0)
 279 //          return _error->Error(_("Unknown vendor ID '%s' in line %u of source list %s"),
 280 //                               VendorID.c_str(),CurLine,File.c_str());
 281       }
 282
 283       if (Parse->ParseLine(SrcList,C,CurLine,File) == false)
 284          return false;
 285    }
 286    return true;
 287 }
 288                                                                         /*}}}*/
 289 // SourceList::FindIndex - Get the index associated with a file         /*{{{*/
 290 // ---------------------------------------------------------------------
 291 /* */
 292 bool pkgSourceList::FindIndex(pkgCache::PkgFileIterator File,
 293                               pkgIndexFile *&Found) const
 294 {
 295    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 296    {
 297       vector<pkgIndexFile *> *Indexes = (*I)->GetIndexFiles();
 298       for (vector<pkgIndexFile *>::const_iterator J = Indexes->begin();
 299            J != Indexes->end(); J++)
 300       {
 301          if ((*J)->FindInCache(*File.Cache()) == File)
 302          {
 303             Found = (*J);
 304             return true;
 305          }
 306       }
 307    }
 308
 309    return false;
 310 }
 311                                                                         /*}}}*/
 312 // SourceList::GetIndexes - Load the index files into the downloader    /*{{{*/
 313 // ---------------------------------------------------------------------
 314 /* */
 315 bool pkgSourceList::GetIndexes(pkgAcquire *Owner, bool GetAll) const
 316 {
 317    for (const_iterator I = SrcList.begin(); I != SrcList.end(); I++)
 318       if ((*I)->GetIndexes(Owner,GetAll) == false)
 319          return false;
 320    return true;
 321 }
 322                                                                         /*}}}*/
 323 // CNC:2003-03-03 - By Anton V. Denisov <avd@altlinux.org>.
 324 // SourceList::ReadSourceDir - Read a directory with sources files
 325 // Based on ReadConfigDir()                                             /*{{{*/
 326 // ---------------------------------------------------------------------
 327 /* */
 328 bool pkgSourceList::ReadSourceDir(string Dir)
 329 {
 330    DIR *D = opendir(Dir.c_str());
 331    if (D == 0)
 332       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 333
 334    vector<string> List;
 335
 336    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 337    {
 338       if (Ent->d_name[0] == '.')
 339          continue;
 340
 341       // CNC:2003-12-02 Only accept .list files as valid sourceparts
 342       if (flExtension(Ent->d_name) != "list")
 343          continue;
 344
 345       // Skip bad file names ala run-parts
 346       const char *C = Ent->d_name;
 347       for (; *C != 0; C++)
 348          if (isalpha(*C) == 0 && isdigit(*C) == 0
 349              && *C != '_' && *C != '-' && *C != '.')
 350             break;
 351       if (*C != 0)
 352          continue;
 353
 354       // Make sure it is a file and not something else
 355       string File = flCombine(Dir,Ent->d_name);
 356       struct stat St;
 357       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)
 358          continue;
 359
 360       List.push_back(File);
 361    }
 362    closedir(D);
 363
 364    sort(List.begin(),List.end());
 365
 366    // Read the files
 367    for (vector<string>::const_iterator I = List.begin(); I != List.end(); I++)
 368       if (ReadAppend(*I) == false)
 369          return false;
 370    return true;
 371
 372 }
 373                                                                         /*}}}*/
 374