apt-private/private-search.cc

   1 // Includes                                                             /*{{{*/
   2 #include <config.h>
   3
   4 #include <apt-pkg/cachefile.h>
   5 #include <apt-pkg/cacheset.h>
   6 #include <apt-pkg/cmndline.h>
   7 #include <apt-pkg/pkgrecords.h>
   8 #include <apt-pkg/policy.h>
   9 #include <apt-pkg/progress.h>
  10 #include <apt-pkg/cacheiterators.h>
  11 #include <apt-pkg/configuration.h>
  12 #include <apt-pkg/depcache.h>
  13 #include <apt-pkg/macros.h>
  14 #include <apt-pkg/pkgcache.h>
  15
  16 #include <apt-private/private-cacheset.h>
  17 #include <apt-private/private-output.h>
  18 #include <apt-private/private-search.h>
  19 #include <apt-private/private-show.h>
  20
  21 #include <string.h>
  22 #include <iostream>
  23 #include <sstream>
  24 #include <map>
  25 #include <string>
  26 #include <utility>
  27
  28 #include <apti18n.h>
  29                                                                         /*}}}*/
  30
  31 static bool FullTextSearch(CommandLine &CmdL)                           /*{{{*/
  32 {
  33    pkgCacheFile CacheFile;
  34    pkgCache *Cache = CacheFile.GetPkgCache();
  35    pkgDepCache::Policy *Plcy = CacheFile.GetPolicy();
  36    if (unlikely(Cache == NULL || Plcy == NULL))
  37       return false;
  38
  39    // Make sure there is at least one argument
  40    unsigned int const NumPatterns = CmdL.FileSize() -1;
  41    if (NumPatterns < 1)
  42       return _error->Error(_("You must give at least one search pattern"));
  43
  44 #define APT_FREE_PATTERNS() for (std::vector<regex_t>::iterator P = Patterns.begin(); \
  45       P != Patterns.end(); ++P) { regfree(&(*P)); }
  46
  47    // Compile the regex pattern
  48    std::vector<regex_t> Patterns;
  49    for (unsigned int I = 0; I != NumPatterns; ++I)
  50    {
  51       regex_t pattern;
  52       if (regcomp(&pattern, CmdL.FileList[I + 1], REG_EXTENDED | REG_ICASE | REG_NOSUB) != 0)
  53       {
  54          APT_FREE_PATTERNS();
  55          return _error->Error("Regex compilation error");
  56       }
  57       Patterns.push_back(pattern);
  58    }
  59
  60    std::map<std::string, std::string> output_map;
  61
  62    LocalitySortedVersionSet bag;
  63    OpTextProgress progress(*_config);
  64    progress.OverallProgress(0, 100, 50,  _("Sorting"));
  65    GetLocalitySortedVersionSet(CacheFile, &bag, &progress);
  66    LocalitySortedVersionSet::iterator V = bag.begin();
  67
  68    progress.OverallProgress(50, 100, 50,  _("Full Text Search"));
  69    progress.SubProgress(bag.size());
  70    pkgRecords records(CacheFile);
  71
  72    std::string format = "${color:highlight}${Package}${color:neutral}/${Origin} ${Version} ${Architecture}${ }${apt:Status}\n";
  73    if (_config->FindB("APT::Cache::ShowFull",false) == false)
  74       format += "  ${Description}\n";
  75    else
  76       format += "  ${LongDescription}\n";
  77
  78    bool const NamesOnly = _config->FindB("APT::Cache::NamesOnly", false);
  79    int Done = 0;
  80    std::vector<bool> PkgsDone(Cache->Head().PackageCount, false);
  81    for ( ;V != bag.end(); ++V)
  82    {
  83       if (Done%500 == 0)
  84          progress.Progress(Done);
  85       ++Done;
  86
  87       // we want to list each package only once
  88       pkgCache::PkgIterator const P = V.ParentPkg();
  89       if (PkgsDone[P->ID] == true)
  90          continue;
  91
  92       char const * const PkgName = P.Name();
  93       pkgCache::DescIterator Desc = V.TranslatedDescription();
  94       pkgRecords::Parser &parser = records.Lookup(Desc.FileList());
  95       std::string const LongDesc = parser.LongDesc();
  96
  97       bool all_found = true;
  98       for (std::vector<regex_t>::const_iterator pattern = Patterns.begin();
  99             pattern != Patterns.end(); ++pattern)
 100       {
 101          if (regexec(&(*pattern), PkgName, 0, 0, 0) == 0)
 102             continue;
 103          else if (NamesOnly == false && regexec(&(*pattern), LongDesc.c_str(), 0, 0, 0) == 0)
 104             continue;
 105          // search patterns are AND, so one failing fails all
 106          all_found = false;
 107          break;
 108       }
 109       if (all_found == true)
 110       {
 111          PkgsDone[P->ID] = true;
 112          std::stringstream outs;
 113          ListSingleVersion(CacheFile, records, V, outs, format);
 114          output_map.insert(std::make_pair<std::string, std::string>(
 115                   PkgName, outs.str()));
 116       }
 117    }
 118    APT_FREE_PATTERNS();
 119    progress.Done();
 120
 121    // FIXME: SORT! and make sorting flexible (alphabetic, by pkg status)
 122    // output the sorted map
 123    std::map<std::string, std::string>::const_iterator K;
 124    for (K = output_map.begin(); K != output_map.end(); ++K)
 125       std::cout << (*K).second << std::endl;
 126
 127    return true;
 128 }
 129                                                                         /*}}}*/
 130 // LocalitySort - Sort a version list by package file locality          /*{{{*/
 131 static int LocalityCompare(const void * const a, const void * const b)
 132 {
 133    pkgCache::VerFile const * const A = *(pkgCache::VerFile const * const * const)a;
 134    pkgCache::VerFile const * const B = *(pkgCache::VerFile const * const * const)b;
 135
 136    if (A == 0 && B == 0)
 137       return 0;
 138    if (A == 0)
 139       return 1;
 140    if (B == 0)
 141       return -1;
 142
 143    if (A->File == B->File)
 144       return A->Offset - B->Offset;
 145    return A->File - B->File;
 146 }
 147 void LocalitySort(pkgCache::VerFile ** const begin, unsigned long long const Count,size_t const Size)
 148 {
 149    qsort(begin,Count,Size,LocalityCompare);
 150 }
 151 static void LocalitySort(pkgCache::DescFile ** const begin, unsigned long long const Count,size_t const Size)
 152 {
 153    qsort(begin,Count,Size,LocalityCompare);
 154 }
 155                                                                         /*}}}*/
 156 // Search - Perform a search                                            /*{{{*/
 157 // ---------------------------------------------------------------------
 158 /* This searches the package names and package descriptions for a pattern */
 159 struct ExDescFile
 160 {
 161    pkgCache::DescFile *Df;
 162    pkgCache::VerIterator V;
 163    map_id_t ID;
 164 };
 165 static bool Search(CommandLine &CmdL)
 166 {
 167    bool const ShowFull = _config->FindB("APT::Cache::ShowFull",false);
 168    unsigned int const NumPatterns = CmdL.FileSize() -1;
 169
 170    pkgCacheFile CacheFile;
 171    pkgCache *Cache = CacheFile.GetPkgCache();
 172    pkgDepCache::Policy *Plcy = CacheFile.GetPolicy();
 173    if (unlikely(Cache == NULL || Plcy == NULL))
 174       return false;
 175
 176    // Make sure there is at least one argument
 177    if (NumPatterns < 1)
 178       return _error->Error(_("You must give at least one search pattern"));
 179
 180    // Compile the regex pattern
 181    regex_t *Patterns = new regex_t[NumPatterns];
 182    memset(Patterns,0,sizeof(*Patterns)*NumPatterns);
 183    for (unsigned I = 0; I != NumPatterns; I++)
 184    {
 185       if (regcomp(&Patterns[I],CmdL.FileList[I+1],REG_EXTENDED | REG_ICASE |
 186                   REG_NOSUB) != 0)
 187       {
 188          for (; I != 0; I--)
 189             regfree(&Patterns[I]);
 190          return _error->Error("Regex compilation error");
 191       }
 192    }
 193
 194    if (_error->PendingError() == true)
 195    {
 196       for (unsigned I = 0; I != NumPatterns; I++)
 197          regfree(&Patterns[I]);
 198       return false;
 199    }
 200
 201    size_t const descCount = Cache->HeaderP->GroupCount + 1;
 202    ExDescFile *DFList = new ExDescFile[descCount];
 203    memset(DFList,0,sizeof(*DFList) * descCount);
 204
 205    bool *PatternMatch = new bool[descCount * NumPatterns];
 206    memset(PatternMatch,false,sizeof(*PatternMatch) * descCount * NumPatterns);
 207
 208    // Map versions that we want to write out onto the VerList array.
 209    bool const NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
 210    for (pkgCache::GrpIterator G = Cache->GrpBegin(); G.end() == false; ++G)
 211    {
 212       size_t const PatternOffset = G->ID * NumPatterns;
 213       size_t unmatched = 0, matched = 0;
 214       for (unsigned I = 0; I < NumPatterns; ++I)
 215       {
 216          if (PatternMatch[PatternOffset + I] == true)
 217             ++matched;
 218          else if (regexec(&Patterns[I],G.Name(),0,0,0) == 0)
 219             PatternMatch[PatternOffset + I] = true;
 220          else
 221             ++unmatched;
 222       }
 223
 224       // already dealt with this package?
 225       if (matched == NumPatterns)
 226          continue;
 227
 228       // Doing names only, drop any that don't match..
 229       if (NamesOnly == true && unmatched == NumPatterns)
 230          continue;
 231
 232       // Find the proper version to use
 233       pkgCache::PkgIterator P = G.FindPreferredPkg();
 234       if (P.end() == true)
 235          continue;
 236       pkgCache::VerIterator V = Plcy->GetCandidateVer(P);
 237       if (V.end() == false)
 238       {
 239          pkgCache::DescIterator const D = V.TranslatedDescription();
 240          //FIXME: packages without a description can't be found
 241          if (D.end() == true)
 242             continue;
 243          DFList[G->ID].Df = D.FileList();
 244          DFList[G->ID].V = V;
 245          DFList[G->ID].ID = G->ID;
 246       }
 247
 248       if (unmatched == NumPatterns)
 249          continue;
 250
 251       // Include all the packages that provide matching names too
 252       for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; ++Prv)
 253       {
 254          pkgCache::VerIterator V = Plcy->GetCandidateVer(Prv.OwnerPkg());
 255          if (V.end() == true)
 256             continue;
 257
 258          unsigned long id = Prv.OwnerPkg().Group()->ID;
 259          pkgCache::DescIterator const D = V.TranslatedDescription();
 260          //FIXME: packages without a description can't be found
 261          if (D.end() == true)
 262             continue;
 263          DFList[id].Df = D.FileList();
 264          DFList[id].V = V;
 265          DFList[id].ID = id;
 266
 267          size_t const PrvPatternOffset = id * NumPatterns;
 268          for (unsigned I = 0; I < NumPatterns; ++I)
 269             PatternMatch[PrvPatternOffset + I] |= PatternMatch[PatternOffset + I];
 270       }
 271    }
 272
 273    LocalitySort(&DFList->Df, Cache->HeaderP->GroupCount, sizeof(*DFList));
 274
 275    // Create the text record parser
 276    pkgRecords Recs(*Cache);
 277    // Iterate over all the version records and check them
 278    for (ExDescFile *J = DFList; J->Df != 0; ++J)
 279    {
 280       pkgRecords::Parser &P = Recs.Lookup(pkgCache::DescFileIterator(*Cache,J->Df));
 281       size_t const PatternOffset = J->ID * NumPatterns;
 282
 283       if (NamesOnly == false)
 284       {
 285          std::string const LongDesc = P.LongDesc();
 286          for (unsigned I = 0; I < NumPatterns; ++I)
 287          {
 288             if (PatternMatch[PatternOffset + I] == true)
 289                continue;
 290             else if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
 291                PatternMatch[PatternOffset + I] = true;
 292          }
 293       }
 294
 295       bool matchedAll = true;
 296       for (unsigned I = 0; I < NumPatterns; ++I)
 297          if (PatternMatch[PatternOffset + I] == false)
 298          {
 299             matchedAll = false;
 300             break;
 301          }
 302
 303       if (matchedAll == true)
 304       {
 305          if (ShowFull == true)
 306             DisplayRecordV1(CacheFile, J->V, std::cout);
 307          else
 308             printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
 309       }
 310    }
 311
 312    delete [] DFList;
 313    delete [] PatternMatch;
 314    for (unsigned I = 0; I != NumPatterns; I++)
 315       regfree(&Patterns[I]);
 316    delete [] Patterns;
 317    if (ferror(stdout))
 318        return _error->Error("Write to stdout failed");
 319    return true;
 320 }
 321                                                                         /*}}}*/
 322 bool DoSearch(CommandLine &CmdL)                                        /*{{{*/
 323 {
 324    int const ShowVersion = _config->FindI("APT::Cache::Search::Version", 1);
 325    if (ShowVersion <= 1)
 326       return Search(CmdL);
 327    return FullTextSearch(CmdL);
 328 }
 329