apt-pkg/contrib/configuration.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: configuration.cc,v 1.28 2004/04/30 04:00:15 mdz Exp $
   4 /* ######################################################################
   5
   6    Configuration Class
   7
   8    This class provides a configuration file and command line parser
   9    for a tree-oriented configuration environment. All runtime configuration
  10    is stored in here.
  11
  12    This source is placed in the Public Domain, do with it what you will
  13    It was originally written by Jason Gunthorpe <jgg@debian.org>.
  14
  15    ##################################################################### */
  16                                                                         /*}}}*/
  17 // Include files                                                        /*{{{*/
  18 #include <apt-pkg/configuration.h>
  19 #include <apt-pkg/error.h>
  20 #include <apt-pkg/strutl.h>
  21 #include <apt-pkg/fileutl.h>
  22 #include <apti18n.h>
  23
  24 #include <vector>
  25 #include <algorithm>
  26 #include <fstream>
  27 #include <iostream>
  28
  29 #include <stdio.h>
  30 #include <dirent.h>
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33
  34 using namespace std;
  35                                                                         /*}}}*/
  36
  37 Configuration *_config = new Configuration;
  38
  39 // Configuration::Configuration - Constructor                           /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* */
  42 Configuration::Configuration() : ToFree(true)
  43 {
  44    Root = new Item;
  45 }
  46 Configuration::Configuration(const Item *Root) : Root((Item *)Root), ToFree(false)
  47 {
  48 };
  49
  50                                                                         /*}}}*/
  51 // Configuration::~Configuration - Destructor                           /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* */
  54 Configuration::~Configuration()
  55 {
  56    if (ToFree == false)
  57       return;
  58
  59    Item *Top = Root;
  60    for (; Top != 0;)
  61    {
  62       if (Top->Child != 0)
  63       {
  64          Top = Top->Child;
  65          continue;
  66       }
  67
  68       while (Top != 0 && Top->Next == 0)
  69       {
  70          Item *Parent = Top->Parent;
  71          delete Top;
  72          Top = Parent;
  73       }
  74       if (Top != 0)
  75       {
  76          Item *Next = Top->Next;
  77          delete Top;
  78          Top = Next;
  79       }
  80    }
  81 }
  82                                                                         /*}}}*/
  83 // Configuration::Lookup - Lookup a single item                         /*{{{*/
  84 // ---------------------------------------------------------------------
  85 /* This will lookup a single item by name below another item. It is a
  86    helper function for the main lookup function */
  87 Configuration::Item *Configuration::Lookup(Item *Head,const char *S,
  88                                            unsigned long Len,bool Create)
  89 {
  90    int Res = 1;
  91    Item *I = Head->Child;
  92    Item **Last = &Head->Child;
  93
  94    // Empty strings match nothing. They are used for lists.
  95    if (Len != 0)
  96    {
  97       for (; I != 0; Last = &I->Next, I = I->Next)
  98          if ((Res = stringcasecmp(I->Tag,S,S + Len)) == 0)
  99             break;
 100    }
 101    else
 102       for (; I != 0; Last = &I->Next, I = I->Next);
 103
 104    if (Res == 0)
 105       return I;
 106    if (Create == false)
 107       return 0;
 108
 109    I = new Item;
 110    I->Tag.assign(S,Len);
 111    I->Next = *Last;
 112    I->Parent = Head;
 113    *Last = I;
 114    return I;
 115 }
 116                                                                         /*}}}*/
 117 // Configuration::Lookup - Lookup a fully scoped item                   /*{{{*/
 118 // ---------------------------------------------------------------------
 119 /* This performs a fully scoped lookup of a given name, possibly creating
 120    new items */
 121 Configuration::Item *Configuration::Lookup(const char *Name,bool Create)
 122 {
 123    if (Name == 0)
 124       return Root->Child;
 125
 126    const char *Start = Name;
 127    const char *End = Start + strlen(Name);
 128    const char *TagEnd = Name;
 129    Item *Itm = Root;
 130    for (; End - TagEnd >= 2; TagEnd++)
 131    {
 132       if (TagEnd[0] == ':' && TagEnd[1] == ':')
 133       {
 134          Itm = Lookup(Itm,Start,TagEnd - Start,Create);
 135          if (Itm == 0)
 136             return 0;
 137          TagEnd = Start = TagEnd + 2;
 138       }
 139    }
 140
 141    // This must be a trailing ::, we create unique items in a list
 142    if (End - Start == 0)
 143    {
 144       if (Create == false)
 145          return 0;
 146    }
 147
 148    Itm = Lookup(Itm,Start,End - Start,Create);
 149    return Itm;
 150 }
 151                                                                         /*}}}*/
 152 // Configuration::Find - Find a value                                   /*{{{*/
 153 // ---------------------------------------------------------------------
 154 /* */
 155 string Configuration::Find(const char *Name,const char *Default) const
 156 {
 157    const Item *Itm = Lookup(Name);
 158    if (Itm == 0 || Itm->Value.empty() == true)
 159    {
 160       if (Default == 0)
 161          return "";
 162       else
 163          return Default;
 164    }
 165
 166    return Itm->Value;
 167 }
 168                                                                         /*}}}*/
 169 // Configuration::FindFile - Find a Filename                            /*{{{*/
 170 // ---------------------------------------------------------------------
 171 /* Directories are stored as the base dir in the Parent node and the
 172    sub directory in sub nodes with the final node being the end filename
 173  */
 174 string Configuration::FindFile(const char *Name,const char *Default) const
 175 {
 176    const Item *RootItem = Lookup("RootDir");
 177    std::string rootDir =  (RootItem == 0) ? "" : RootItem->Value;
 178    if(rootDir.size() > 0 && rootDir[rootDir.size() - 1] != '/')
 179      rootDir.push_back('/');
 180
 181    const Item *Itm = Lookup(Name);
 182    if (Itm == 0 || Itm->Value.empty() == true)
 183    {
 184       if (Default == 0)
 185          return "";
 186       else
 187          return Default;
 188    }
 189
 190    string val = Itm->Value;
 191    while (Itm->Parent != 0 && Itm->Parent->Value.empty() == false)
 192    {
 193       // Absolute
 194       if (val.length() >= 1 && val[0] == '/')
 195          break;
 196
 197       // ~/foo or ./foo
 198       if (val.length() >= 2 && (val[0] == '~' || val[0] == '.') && val[1] == '/')
 199          break;
 200
 201       // ../foo
 202       if (val.length() >= 3 && val[0] == '.' && val[1] == '.' && val[2] == '/')
 203          break;
 204
 205       if (Itm->Parent->Value.end()[-1] != '/')
 206          val.insert(0, "/");
 207
 208       val.insert(0, Itm->Parent->Value);
 209       Itm = Itm->Parent;
 210    }
 211
 212    return rootDir + val;
 213 }
 214                                                                         /*}}}*/
 215 // Configuration::FindDir - Find a directory name                       /*{{{*/
 216 // ---------------------------------------------------------------------
 217 /* This is like findfile execept the result is terminated in a / */
 218 string Configuration::FindDir(const char *Name,const char *Default) const
 219 {
 220    string Res = FindFile(Name,Default);
 221    if (Res.end()[-1] != '/')
 222       return Res + '/';
 223    return Res;
 224 }
 225                                                                         /*}}}*/
 226 // Configuration::FindI - Find an integer value                         /*{{{*/
 227 // ---------------------------------------------------------------------
 228 /* */
 229 int Configuration::FindI(const char *Name,int Default) const
 230 {
 231    const Item *Itm = Lookup(Name);
 232    if (Itm == 0 || Itm->Value.empty() == true)
 233       return Default;
 234
 235    char *End;
 236    int Res = strtol(Itm->Value.c_str(),&End,0);
 237    if (End == Itm->Value.c_str())
 238       return Default;
 239
 240    return Res;
 241 }
 242                                                                         /*}}}*/
 243 // Configuration::FindB - Find a boolean type                           /*{{{*/
 244 // ---------------------------------------------------------------------
 245 /* */
 246 bool Configuration::FindB(const char *Name,bool Default) const
 247 {
 248    const Item *Itm = Lookup(Name);
 249    if (Itm == 0 || Itm->Value.empty() == true)
 250       return Default;
 251
 252    return StringToBool(Itm->Value,Default);
 253 }
 254                                                                         /*}}}*/
 255 // Configuration::FindAny - Find an arbitrary type                      /*{{{*/
 256 // ---------------------------------------------------------------------
 257 /* a key suffix of /f, /d, /b or /i calls Find{File,Dir,B,I} */
 258 string Configuration::FindAny(const char *Name,const char *Default) const
 259 {
 260    string key = Name;
 261    char type = 0;
 262
 263    if (key.size() > 2 && key.end()[-2] == '/')
 264    {
 265       type = key.end()[-1];
 266       key.resize(key.size() - 2);
 267    }
 268
 269    switch (type)
 270    {
 271       // file
 272       case 'f':
 273       return FindFile(key.c_str(), Default);
 274
 275       // directory
 276       case 'd':
 277       return FindDir(key.c_str(), Default);
 278
 279       // bool
 280       case 'b':
 281       return FindB(key, Default) ? "true" : "false";
 282
 283       // int
 284       case 'i':
 285       {
 286          char buf[16];
 287          snprintf(buf, sizeof(buf)-1, "%d", FindI(key, Default ? atoi(Default) : 0 ));
 288          return buf;
 289       }
 290    }
 291
 292    // fallback
 293    return Find(Name, Default);
 294 }
 295                                                                         /*}}}*/
 296 // Configuration::CndSet - Conditinal Set a value                       /*{{{*/
 297 // ---------------------------------------------------------------------
 298 /* This will not overwrite */
 299 void Configuration::CndSet(const char *Name,const string &Value)
 300 {
 301    Item *Itm = Lookup(Name,true);
 302    if (Itm == 0)
 303       return;
 304    if (Itm->Value.empty() == true)
 305       Itm->Value = Value;
 306 }
 307                                                                         /*}}}*/
 308 // Configuration::Set - Set a value                                     /*{{{*/
 309 // ---------------------------------------------------------------------
 310 /* */
 311 void Configuration::Set(const char *Name,const string &Value)
 312 {
 313    Item *Itm = Lookup(Name,true);
 314    if (Itm == 0)
 315       return;
 316    Itm->Value = Value;
 317 }
 318                                                                         /*}}}*/
 319 // Configuration::Set - Set an integer value                            /*{{{*/
 320 // ---------------------------------------------------------------------
 321 /* */
 322 void Configuration::Set(const char *Name,int Value)
 323 {
 324    Item *Itm = Lookup(Name,true);
 325    if (Itm == 0)
 326       return;
 327    char S[300];
 328    snprintf(S,sizeof(S),"%i",Value);
 329    Itm->Value = S;
 330 }
 331                                                                         /*}}}*/
 332 // Configuration::Clear - Clear an single value from a list             /*{{{*/
 333 // ---------------------------------------------------------------------
 334 /* */
 335 void Configuration::Clear(const string Name, int Value)
 336 {
 337    char S[300];
 338    snprintf(S,sizeof(S),"%i",Value);
 339    Clear(Name, S);
 340 }
 341                                                                         /*}}}*/
 342 // Configuration::Clear - Clear an single value from a list             /*{{{*/
 343 // ---------------------------------------------------------------------
 344 /* */
 345 void Configuration::Clear(const string Name, string Value)
 346 {
 347    Item *Top = Lookup(Name.c_str(),false);
 348    if (Top == 0 || Top->Child == 0)
 349       return;
 350
 351    Item *Tmp, *Prev, *I;
 352    Prev = I = Top->Child;
 353
 354    while(I != NULL)
 355    {
 356       if(I->Value == Value)
 357       {
 358          Tmp = I;
 359          // was first element, point parent to new first element
 360          if(Top->Child == Tmp)
 361             Top->Child = I->Next;
 362          I = I->Next;
 363          Prev->Next = I;
 364          delete Tmp;
 365       } else {
 366          Prev = I;
 367          I = I->Next;
 368       }
 369    }
 370
 371 }
 372                                                                         /*}}}*/
 373 // Configuration::Clear - Clear an entire tree                          /*{{{*/
 374 // ---------------------------------------------------------------------
 375 /* */
 376 void Configuration::Clear(string Name)
 377 {
 378    Item *Top = Lookup(Name.c_str(),false);
 379    if (Top == 0)
 380       return;
 381
 382    Top->Value.clear();
 383    Item *Stop = Top;
 384    Top = Top->Child;
 385    Stop->Child = 0;
 386    for (; Top != 0;)
 387    {
 388       if (Top->Child != 0)
 389       {
 390          Top = Top->Child;
 391          continue;
 392       }
 393
 394       while (Top != 0 && Top->Next == 0)
 395       {
 396          Item *Tmp = Top;
 397          Top = Top->Parent;
 398          delete Tmp;
 399
 400          if (Top == Stop)
 401             return;
 402       }
 403
 404       Item *Tmp = Top;
 405       if (Top != 0)
 406          Top = Top->Next;
 407       delete Tmp;
 408    }
 409 }
 410                                                                         /*}}}*/
 411 // Configuration::Exists - Returns true if the Name exists              /*{{{*/
 412 // ---------------------------------------------------------------------
 413 /* */
 414 bool Configuration::Exists(const char *Name) const
 415 {
 416    const Item *Itm = Lookup(Name);
 417    if (Itm == 0)
 418       return false;
 419    return true;
 420 }
 421                                                                         /*}}}*/
 422 // Configuration::ExistsAny - Returns true if the Name, possibly        /*{{{*/
 423 // ---------------------------------------------------------------------
 424 /* qualified by /[fdbi] exists */
 425 bool Configuration::ExistsAny(const char *Name) const
 426 {
 427    string key = Name;
 428
 429    if (key.size() > 2 && key.end()[-2] == '/')
 430    {
 431       if (key.find_first_of("fdbi",key.size()-1) < key.size())
 432       {
 433          key.resize(key.size() - 2);
 434          if (Exists(key.c_str()))
 435             return true;
 436       }
 437       else
 438       {
 439          _error->Warning(_("Unrecognized type abbreviation: '%c'"), key.end()[-3]);
 440       }
 441    }
 442    return Exists(Name);
 443 }
 444                                                                         /*}}}*/
 445 // Configuration::Dump - Dump the config                                /*{{{*/
 446 // ---------------------------------------------------------------------
 447 /* Dump the entire configuration space */
 448 void Configuration::Dump(ostream& str)
 449 {
 450    /* Write out all of the configuration directives by walking the
 451       configuration tree */
 452    const Configuration::Item *Top = Tree(0);
 453    for (; Top != 0;)
 454    {
 455       str << Top->FullTag() << " \"" << Top->Value << "\";" << endl;
 456
 457       if (Top->Child != 0)
 458       {
 459          Top = Top->Child;
 460          continue;
 461       }
 462
 463       while (Top != 0 && Top->Next == 0)
 464          Top = Top->Parent;
 465       if (Top != 0)
 466          Top = Top->Next;
 467    }
 468 }
 469                                                                         /*}}}*/
 470
 471 // Configuration::Item::FullTag - Return the fully scoped tag           /*{{{*/
 472 // ---------------------------------------------------------------------
 473 /* Stop sets an optional max recursion depth if this item is being viewed as
 474    part of a sub tree. */
 475 string Configuration::Item::FullTag(const Item *Stop) const
 476 {
 477    if (Parent == 0 || Parent->Parent == 0 || Parent == Stop)
 478       return Tag;
 479    return Parent->FullTag(Stop) + "::" + Tag;
 480 }
 481                                                                         /*}}}*/
 482
 483 // ReadConfigFile - Read a configuration file                           /*{{{*/
 484 // ---------------------------------------------------------------------
 485 /* The configuration format is very much like the named.conf format
 486    used in bind8, in fact this routine can parse most named.conf files.
 487    Sectional config files are like bind's named.conf where there are
 488    sections like 'zone "foo.org" { .. };' This causes each section to be
 489    added in with a tag like "zone::foo.org" instead of being split
 490    tag/value. AsSectional enables Sectional parsing.*/
 491 bool ReadConfigFile(Configuration &Conf,const string &FName,bool AsSectional,
 492                     unsigned Depth)
 493 {
 494    // Open the stream for reading
 495    ifstream F(FName.c_str(),ios::in);
 496    if (!F != 0)
 497       return _error->Errno("ifstream::ifstream",_("Opening configuration file %s"),FName.c_str());
 498
 499    char Buffer[1024];
 500    string LineBuffer;
 501    string Stack[100];
 502    unsigned int StackPos = 0;
 503
 504    // Parser state
 505    string ParentTag;
 506
 507    int CurLine = 0;
 508    bool InComment = false;
 509    while (F.eof() == false)
 510    {
 511       F.getline(Buffer,sizeof(Buffer));
 512       CurLine++;
 513       // This should be made to work instead, but this is better than looping
 514       if (F.fail() && !F.eof())
 515          return _error->Error(_("%s: Line %d too long (max %lu)"),
 516                               FName.c_str(), CurLine, sizeof(Buffer));
 517
 518       _strtabexpand(Buffer,sizeof(Buffer));
 519       _strstrip(Buffer);
 520
 521       // Multi line comment
 522       if (InComment == true)
 523       {
 524          for (const char *I = Buffer; *I != 0; I++)
 525          {
 526             if (*I == '*' && I[1] == '/')
 527             {
 528                memmove(Buffer,I+2,strlen(I+2) + 1);
 529                InComment = false;
 530                break;
 531             }
 532          }
 533          if (InComment == true)
 534             continue;
 535       }
 536
 537       // Discard single line comments
 538       bool InQuote = false;
 539       for (char *I = Buffer; *I != 0; I++)
 540       {
 541          if (*I == '"')
 542             InQuote = !InQuote;
 543          if (InQuote == true)
 544             continue;
 545
 546          if (*I == '/' && I[1] == '/')
 547          {
 548             *I = 0;
 549             break;
 550          }
 551       }
 552
 553       // Look for multi line comments
 554       InQuote = false;
 555       for (char *I = Buffer; *I != 0; I++)
 556       {
 557          if (*I == '"')
 558             InQuote = !InQuote;
 559          if (InQuote == true)
 560             continue;
 561
 562          if (*I == '/' && I[1] == '*')
 563          {
 564             InComment = true;
 565             for (char *J = Buffer; *J != 0; J++)
 566             {
 567                if (*J == '*' && J[1] == '/')
 568                {
 569                   memmove(I,J+2,strlen(J+2) + 1);
 570                   InComment = false;
 571                   break;
 572                }
 573             }
 574
 575             if (InComment == true)
 576             {
 577                *I = 0;
 578                break;
 579             }
 580          }
 581       }
 582
 583       // Blank
 584       if (Buffer[0] == 0)
 585          continue;
 586
 587       // We now have a valid line fragment
 588       InQuote = false;
 589       for (char *I = Buffer; *I != 0;)
 590       {
 591          if (*I == '"')
 592             InQuote = !InQuote;
 593
 594          if (InQuote == false && (*I == '{' || *I == ';' || *I == '}'))
 595          {
 596             // Put the last fragment into the buffer
 597             char *Start = Buffer;
 598             char *Stop = I;
 599             for (; Start != I && isspace(*Start) != 0; Start++);
 600             for (; Stop != Start && isspace(Stop[-1]) != 0; Stop--);
 601             if (LineBuffer.empty() == false && Stop - Start != 0)
 602                LineBuffer += ' ';
 603             LineBuffer += string(Start,Stop - Start);
 604
 605             // Remove the fragment
 606             char TermChar = *I;
 607             memmove(Buffer,I + 1,strlen(I + 1) + 1);
 608             I = Buffer;
 609
 610             // Syntax Error
 611             if (TermChar == '{' && LineBuffer.empty() == true)
 612                return _error->Error(_("Syntax error %s:%u: Block starts with no name."),FName.c_str(),CurLine);
 613
 614             // No string on this line
 615             if (LineBuffer.empty() == true)
 616             {
 617                if (TermChar == '}')
 618                {
 619                   if (StackPos == 0)
 620                      ParentTag = string();
 621                   else
 622                      ParentTag = Stack[--StackPos];
 623                }
 624                continue;
 625             }
 626
 627             // Parse off the tag
 628             string Tag;
 629             const char *Pos = LineBuffer.c_str();
 630             if (ParseQuoteWord(Pos,Tag) == false)
 631                return _error->Error(_("Syntax error %s:%u: Malformed tag"),FName.c_str(),CurLine);
 632
 633             // Parse off the word
 634             string Word;
 635             bool NoWord = false;
 636             if (ParseCWord(Pos,Word) == false &&
 637                 ParseQuoteWord(Pos,Word) == false)
 638             {
 639                if (TermChar != '{')
 640                {
 641                   Word = Tag;
 642                   Tag = "";
 643                }
 644                else
 645                   NoWord = true;
 646             }
 647             if (strlen(Pos) != 0)
 648                return _error->Error(_("Syntax error %s:%u: Extra junk after value"),FName.c_str(),CurLine);
 649
 650             // Go down a level
 651             if (TermChar == '{')
 652             {
 653                if (StackPos <= 100)
 654                   Stack[StackPos++] = ParentTag;
 655
 656                /* Make sectional tags incorperate the section into the
 657                   tag string */
 658                if (AsSectional == true && Word.empty() == false)
 659                {
 660                   Tag += "::" ;
 661                   Tag += Word;
 662                   Word = "";
 663                }
 664
 665                if (ParentTag.empty() == true)
 666                   ParentTag = Tag;
 667                else
 668                   ParentTag += string("::") + Tag;
 669                Tag = string();
 670             }
 671
 672             // Generate the item name
 673             string Item;
 674             if (ParentTag.empty() == true)
 675                Item = Tag;
 676             else
 677             {
 678                if (TermChar != '{' || Tag.empty() == false)
 679                   Item = ParentTag + "::" + Tag;
 680                else
 681                   Item = ParentTag;
 682             }
 683
 684             // Specials
 685             if (Tag.length() >= 1 && Tag[0] == '#')
 686             {
 687                if (ParentTag.empty() == false)
 688                   return _error->Error(_("Syntax error %s:%u: Directives can only be done at the top level"),FName.c_str(),CurLine);
 689                Tag.erase(Tag.begin());
 690                if (Tag == "clear")
 691                   Conf.Clear(Word);
 692                else if (Tag == "include")
 693                {
 694                   if (Depth > 10)
 695                      return _error->Error(_("Syntax error %s:%u: Too many nested includes"),FName.c_str(),CurLine);
 696                   if (Word.length() > 2 && Word.end()[-1] == '/')
 697                   {
 698                      if (ReadConfigDir(Conf,Word,AsSectional,Depth+1) == false)
 699                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 700                   }
 701                   else
 702                   {
 703                      if (ReadConfigFile(Conf,Word,AsSectional,Depth+1) == false)
 704                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 705                   }
 706                }
 707                else
 708                   return _error->Error(_("Syntax error %s:%u: Unsupported directive '%s'"),FName.c_str(),CurLine,Tag.c_str());
 709             }
 710             else
 711             {
 712                // Set the item in the configuration class
 713                if (NoWord == false)
 714                   Conf.Set(Item,Word);
 715             }
 716
 717             // Empty the buffer
 718             LineBuffer.clear();
 719
 720             // Move up a tag, but only if there is no bit to parse
 721             if (TermChar == '}')
 722             {
 723                if (StackPos == 0)
 724                   ParentTag.clear();
 725                else
 726                   ParentTag = Stack[--StackPos];
 727             }
 728
 729          }
 730          else
 731             I++;
 732       }
 733
 734       // Store the fragment
 735       const char *Stripd = _strstrip(Buffer);
 736       if (*Stripd != 0 && LineBuffer.empty() == false)
 737          LineBuffer += " ";
 738       LineBuffer += Stripd;
 739    }
 740
 741    if (LineBuffer.empty() == false)
 742       return _error->Error(_("Syntax error %s:%u: Extra junk at end of file"),FName.c_str(),CurLine);
 743    return true;
 744 }
 745                                                                         /*}}}*/
 746 // ReadConfigDir - Read a directory of config files                     /*{{{*/
 747 // ---------------------------------------------------------------------
 748 /* */
 749 bool ReadConfigDir(Configuration &Conf,const string &Dir,bool AsSectional,
 750                    unsigned Depth)
 751 {
 752    DIR *D = opendir(Dir.c_str());
 753    if (D == 0)
 754       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 755
 756    vector<string> List;
 757
 758    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 759    {
 760       if (Ent->d_name[0] == '.')
 761          continue;
 762
 763       // Skip bad file names ala run-parts
 764       const char *C = Ent->d_name;
 765       for (; *C != 0; C++)
 766          if (isalpha(*C) == 0 && isdigit(*C) == 0 && *C != '_' && *C != '-')
 767             break;
 768       if (*C != 0)
 769          continue;
 770
 771       // Make sure it is a file and not something else
 772       string File = flCombine(Dir,Ent->d_name);
 773       struct stat St;
 774       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)
 775          continue;
 776
 777       List.push_back(File);
 778    }
 779    closedir(D);
 780
 781    sort(List.begin(),List.end());
 782
 783    // Read the files
 784    for (vector<string>::const_iterator I = List.begin(); I != List.end(); I++)
 785       if (ReadConfigFile(Conf,*I,AsSectional,Depth) == false)
 786          return false;
 787    return true;
 788 }
 789                                                                         /*}}}*/