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    string LineBuffer;
 500    string Stack[100];
 501    unsigned int StackPos = 0;
 502
 503    // Parser state
 504    string ParentTag;
 505
 506    int CurLine = 0;
 507    bool InComment = false;
 508    while (F.eof() == false)
 509    {
 510       // The raw input line.
 511       std::string Input;
 512       // The input line with comments stripped.
 513       std::string Fragment;
 514
 515       // Grab the next line of F and place it in Input.
 516       do
 517         {
 518           char *Buffer = new char[1024];
 519
 520           F.clear();
 521           F.getline(Buffer,sizeof(Buffer) / 2);
 522
 523           Input += Buffer;
 524         }
 525       while (F.fail() && !F.eof());
 526
 527       // Expand tabs in the input line and remove leading and trailing
 528       // whitespace.
 529       {
 530         const int BufferSize = Input.size() * 8 + 1;
 531         char *Buffer = new char[BufferSize];
 532         try
 533           {
 534             memcpy(Buffer, Input.c_str(), Input.size() + 1);
 535
 536             _strtabexpand(Buffer, BufferSize);
 537             _strstrip(Buffer);
 538             Input = Buffer;
 539           }
 540         catch(...)
 541           {
 542             delete[] Buffer;
 543             throw;
 544           }
 545         delete[] Buffer;
 546       }
 547       CurLine++;
 548
 549       // Now strip comments; if the whole line is contained in a
 550       // comment, skip this line.
 551
 552       // The first meaningful character in the current fragment; will
 553       // be adjusted below as we remove bytes from the front.
 554       std::string::const_iterator Start = Input.begin();
 555       // The last meaningful character in the current fragment.
 556       std::string::const_iterator End = Input.end();
 557
 558       // Multi line comment
 559       if (InComment == true)
 560       {
 561         for (std::string::const_iterator I = Start;
 562              I != End; ++I)
 563          {
 564             if (*I == '*' && I + 1 != End && I[1] == '/')
 565             {
 566                Start = I + 2;
 567                InComment = false;
 568                break;
 569             }
 570          }
 571          if (InComment == true)
 572             continue;
 573       }
 574
 575       // Discard single line comments
 576       bool InQuote = false;
 577       for (std::string::const_iterator I = Start;
 578            I != End; ++I)
 579       {
 580          if (*I == '"')
 581             InQuote = !InQuote;
 582          if (InQuote == true)
 583             continue;
 584
 585          if (*I == '/' && I + 1 != End && I[1] == '/')
 586          {
 587             End = I;
 588             break;
 589          }
 590       }
 591
 592       // Look for multi line comments and build up the
 593       // fragment.
 594       Fragment.reserve(End - Start);
 595       InQuote = false;
 596       for (std::string::const_iterator I = Start;
 597            I != End; ++I)
 598       {
 599          if (*I == '"')
 600             InQuote = !InQuote;
 601          if (InQuote == true)
 602            Fragment.push_back(*I);
 603          else if (*I == '/' && I + 1 != End && I[1] == '*')
 604          {
 605             InComment = true;
 606             for (std::string::const_iterator J = I;
 607                  J != End; ++J)
 608             {
 609                if (*J == '*' && J + 1 != End && J[1] == '/')
 610                {
 611                   // Pretend we just finished walking over the
 612                   // comment, and don't add anything to the output
 613                   // fragment.
 614                   I = J + 1;
 615                   InComment = false;
 616                   break;
 617                }
 618             }
 619
 620             if (InComment == true)
 621               break;
 622          }
 623          else
 624            Fragment.push_back(*I);
 625       }
 626
 627       // Skip blank lines.
 628       if (Fragment.empty())
 629          continue;
 630
 631       // The line has actual content; interpret what it means.
 632       InQuote = false;
 633       Start = Fragment.begin();
 634       End = Fragment.end();
 635       for (std::string::const_iterator I = Start;
 636            I != End; ++I)
 637       {
 638          if(Start > End)
 639            {
 640              _error->Error("Why is Start > End?");
 641            }
 642
 643          if (*I == '"')
 644             InQuote = !InQuote;
 645
 646          if (InQuote == false && (*I == '{' || *I == ';' || *I == '}'))
 647          {
 648             // Put the last fragment into the buffer
 649             std::string::const_iterator FirstNonWhitespace = Start;
 650             std::string::const_iterator LastNonWhitespace = I;
 651             for (; FirstNonWhitespace != I && isspace(*FirstNonWhitespace) != 0; FirstNonWhitespace++)
 652               ;
 653             for (; LastNonWhitespace != FirstNonWhitespace && isspace(LastNonWhitespace[-1]) != 0; LastNonWhitespace--)
 654               ;
 655             if (LineBuffer.empty() == false && LastNonWhitespace - FirstNonWhitespace != 0)
 656                LineBuffer += ' ';
 657             LineBuffer += string(FirstNonWhitespace, LastNonWhitespace);
 658
 659             // Drop this from the input string, saving the character
 660             // that terminated the construct we just closed. (i.e., a
 661             // brace or a semicolon)
 662             char TermChar = *I;
 663             Start = I + 1;
 664
 665             // Syntax Error
 666             if (TermChar == '{' && LineBuffer.empty() == true)
 667                return _error->Error(_("Syntax error %s:%u: Block starts with no name."),FName.c_str(),CurLine);
 668
 669             // No string on this line
 670             if (LineBuffer.empty() == true)
 671             {
 672                if (TermChar == '}')
 673                {
 674                   if (StackPos == 0)
 675                      ParentTag = string();
 676                   else
 677                      ParentTag = Stack[--StackPos];
 678                }
 679                continue;
 680             }
 681
 682             // Parse off the tag
 683             string Tag;
 684             const char *Pos = LineBuffer.c_str();
 685             if (ParseQuoteWord(Pos,Tag) == false)
 686                return _error->Error(_("Syntax error %s:%u: Malformed tag"),FName.c_str(),CurLine);
 687
 688             // Parse off the word
 689             string Word;
 690             bool NoWord = false;
 691             if (ParseCWord(Pos,Word) == false &&
 692                 ParseQuoteWord(Pos,Word) == false)
 693             {
 694                if (TermChar != '{')
 695                {
 696                   Word = Tag;
 697                   Tag = "";
 698                }
 699                else
 700                   NoWord = true;
 701             }
 702             if (strlen(Pos) != 0)
 703                return _error->Error(_("Syntax error %s:%u: Extra junk after value"),FName.c_str(),CurLine);
 704
 705             // Go down a level
 706             if (TermChar == '{')
 707             {
 708                if (StackPos <= 100)
 709                   Stack[StackPos++] = ParentTag;
 710
 711                /* Make sectional tags incorperate the section into the
 712                   tag string */
 713                if (AsSectional == true && Word.empty() == false)
 714                {
 715                   Tag += "::" ;
 716                   Tag += Word;
 717                   Word = "";
 718                }
 719
 720                if (ParentTag.empty() == true)
 721                   ParentTag = Tag;
 722                else
 723                   ParentTag += string("::") + Tag;
 724                Tag = string();
 725             }
 726
 727             // Generate the item name
 728             string Item;
 729             if (ParentTag.empty() == true)
 730                Item = Tag;
 731             else
 732             {
 733                if (TermChar != '{' || Tag.empty() == false)
 734                   Item = ParentTag + "::" + Tag;
 735                else
 736                   Item = ParentTag;
 737             }
 738
 739             // Specials
 740             if (Tag.length() >= 1 && Tag[0] == '#')
 741             {
 742                if (ParentTag.empty() == false)
 743                   return _error->Error(_("Syntax error %s:%u: Directives can only be done at the top level"),FName.c_str(),CurLine);
 744                Tag.erase(Tag.begin());
 745                if (Tag == "clear")
 746                   Conf.Clear(Word);
 747                else if (Tag == "include")
 748                {
 749                   if (Depth > 10)
 750                      return _error->Error(_("Syntax error %s:%u: Too many nested includes"),FName.c_str(),CurLine);
 751                   if (Word.length() > 2 && Word.end()[-1] == '/')
 752                   {
 753                      if (ReadConfigDir(Conf,Word,AsSectional,Depth+1) == false)
 754                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 755                   }
 756                   else
 757                   {
 758                      if (ReadConfigFile(Conf,Word,AsSectional,Depth+1) == false)
 759                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 760                   }
 761                }
 762                else
 763                   return _error->Error(_("Syntax error %s:%u: Unsupported directive '%s'"),FName.c_str(),CurLine,Tag.c_str());
 764             }
 765             else
 766             {
 767                // Set the item in the configuration class
 768                if (NoWord == false)
 769                   Conf.Set(Item,Word);
 770             }
 771
 772             // Empty the buffer
 773             LineBuffer.clear();
 774
 775             // Move up a tag, but only if there is no bit to parse
 776             if (TermChar == '}')
 777             {
 778                if (StackPos == 0)
 779                   ParentTag.clear();
 780                else
 781                   ParentTag = Stack[--StackPos];
 782             }
 783
 784          }
 785       }
 786
 787       // Store the remaining text, if any, in the current line buffer.
 788
 789       // NB: could change this to use string-based operations; I'm
 790       // using strstrip now to ensure backwards compatibility.
 791       //   -- dburrows 2008-04-01
 792       {
 793         char *Buffer = new char[End - Start + 1];
 794         try
 795           {
 796             std::copy(Start, End, Buffer);
 797             Buffer[End - Start] = '\0';
 798
 799             const char *Stripd = _strstrip(Buffer);
 800             if (*Stripd != 0 && LineBuffer.empty() == false)
 801               LineBuffer += " ";
 802             LineBuffer += Stripd;
 803           }
 804         catch(...)
 805           {
 806             delete[] Buffer;
 807             throw;
 808           }
 809         delete[] Buffer;
 810       }
 811    }
 812
 813    if (LineBuffer.empty() == false)
 814       return _error->Error(_("Syntax error %s:%u: Extra junk at end of file"),FName.c_str(),CurLine);
 815    return true;
 816 }
 817                                                                         /*}}}*/
 818 // ReadConfigDir - Read a directory of config files                     /*{{{*/
 819 // ---------------------------------------------------------------------
 820 /* */
 821 bool ReadConfigDir(Configuration &Conf,const string &Dir,bool AsSectional,
 822                    unsigned Depth)
 823 {
 824    DIR *D = opendir(Dir.c_str());
 825    if (D == 0)
 826       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 827
 828    vector<string> List;
 829
 830    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 831    {
 832       if (Ent->d_name[0] == '.')
 833          continue;
 834
 835       // Skip bad file names ala run-parts
 836       const char *C = Ent->d_name;
 837       for (; *C != 0; C++)
 838          if (isalpha(*C) == 0 && isdigit(*C) == 0 && *C != '_' && *C != '-')
 839             break;
 840       if (*C != 0)
 841          continue;
 842
 843       // Make sure it is a file and not something else
 844       string File = flCombine(Dir,Ent->d_name);
 845       struct stat St;
 846       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)
 847          continue;
 848
 849       List.push_back(File);
 850    }
 851    closedir(D);
 852
 853    sort(List.begin(),List.end());
 854
 855    // Read the files
 856    for (vector<string>::const_iterator I = List.begin(); I != List.end(); I++)
 857       if (ReadConfigFile(Conf,*I,AsSectional,Depth) == false)
 858          return false;
 859    return true;
 860 }
 861                                                                         /*}}}*/