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 (*I == '"')
 639             InQuote = !InQuote;
 640
 641          if (InQuote == false && (*I == '{' || *I == ';' || *I == '}'))
 642          {
 643             // Put the last fragment into the buffer
 644             std::string::const_iterator NonWhitespaceStart = Start;
 645             std::string::const_iterator NonWhitespaceStop = I;
 646             for (; NonWhitespaceStart != I && isspace(*NonWhitespaceStart) != 0; NonWhitespaceStart++)
 647               ;
 648             for (; NonWhitespaceStop != NonWhitespaceStart && isspace(NonWhitespaceStop[-1]) != 0; NonWhitespaceStop--)
 649               ;
 650             if (LineBuffer.empty() == false && NonWhitespaceStop - NonWhitespaceStart != 0)
 651                LineBuffer += ' ';
 652             LineBuffer += string(NonWhitespaceStart, NonWhitespaceStop);
 653
 654             // Drop this from the input string, saving the character
 655             // that terminated the construct we just closed. (i.e., a
 656             // brace or a semicolon)
 657             char TermChar = *I;
 658             Start = I + 1;
 659
 660             // Syntax Error
 661             if (TermChar == '{' && LineBuffer.empty() == true)
 662                return _error->Error(_("Syntax error %s:%u: Block starts with no name."),FName.c_str(),CurLine);
 663
 664             // No string on this line
 665             if (LineBuffer.empty() == true)
 666             {
 667                if (TermChar == '}')
 668                {
 669                   if (StackPos == 0)
 670                      ParentTag = string();
 671                   else
 672                      ParentTag = Stack[--StackPos];
 673                }
 674                continue;
 675             }
 676
 677             // Parse off the tag
 678             string Tag;
 679             const char *Pos = LineBuffer.c_str();
 680             if (ParseQuoteWord(Pos,Tag) == false)
 681                return _error->Error(_("Syntax error %s:%u: Malformed tag"),FName.c_str(),CurLine);
 682
 683             // Parse off the word
 684             string Word;
 685             bool NoWord = false;
 686             if (ParseCWord(Pos,Word) == false &&
 687                 ParseQuoteWord(Pos,Word) == false)
 688             {
 689                if (TermChar != '{')
 690                {
 691                   Word = Tag;
 692                   Tag = "";
 693                }
 694                else
 695                   NoWord = true;
 696             }
 697             if (strlen(Pos) != 0)
 698                return _error->Error(_("Syntax error %s:%u: Extra junk after value"),FName.c_str(),CurLine);
 699
 700             // Go down a level
 701             if (TermChar == '{')
 702             {
 703                if (StackPos <= 100)
 704                   Stack[StackPos++] = ParentTag;
 705
 706                /* Make sectional tags incorperate the section into the
 707                   tag string */
 708                if (AsSectional == true && Word.empty() == false)
 709                {
 710                   Tag += "::" ;
 711                   Tag += Word;
 712                   Word = "";
 713                }
 714
 715                if (ParentTag.empty() == true)
 716                   ParentTag = Tag;
 717                else
 718                   ParentTag += string("::") + Tag;
 719                Tag = string();
 720             }
 721
 722             // Generate the item name
 723             string Item;
 724             if (ParentTag.empty() == true)
 725                Item = Tag;
 726             else
 727             {
 728                if (TermChar != '{' || Tag.empty() == false)
 729                   Item = ParentTag + "::" + Tag;
 730                else
 731                   Item = ParentTag;
 732             }
 733
 734             // Specials
 735             if (Tag.length() >= 1 && Tag[0] == '#')
 736             {
 737                if (ParentTag.empty() == false)
 738                   return _error->Error(_("Syntax error %s:%u: Directives can only be done at the top level"),FName.c_str(),CurLine);
 739                Tag.erase(Tag.begin());
 740                if (Tag == "clear")
 741                   Conf.Clear(Word);
 742                else if (Tag == "include")
 743                {
 744                   if (Depth > 10)
 745                      return _error->Error(_("Syntax error %s:%u: Too many nested includes"),FName.c_str(),CurLine);
 746                   if (Word.length() > 2 && Word.end()[-1] == '/')
 747                   {
 748                      if (ReadConfigDir(Conf,Word,AsSectional,Depth+1) == false)
 749                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 750                   }
 751                   else
 752                   {
 753                      if (ReadConfigFile(Conf,Word,AsSectional,Depth+1) == false)
 754                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 755                   }
 756                }
 757                else
 758                   return _error->Error(_("Syntax error %s:%u: Unsupported directive '%s'"),FName.c_str(),CurLine,Tag.c_str());
 759             }
 760             else
 761             {
 762                // Set the item in the configuration class
 763                if (NoWord == false)
 764                   Conf.Set(Item,Word);
 765             }
 766
 767             // Empty the buffer
 768             LineBuffer.clear();
 769
 770             // Move up a tag, but only if there is no bit to parse
 771             if (TermChar == '}')
 772             {
 773                if (StackPos == 0)
 774                   ParentTag.clear();
 775                else
 776                   ParentTag = Stack[--StackPos];
 777             }
 778
 779          }
 780       }
 781
 782       // Store the remaining text, if any, in the current line buffer.
 783
 784       // NB: could change this to use string-based operations; I'm
 785       // using strstrip now to ensure backwards compatibility.
 786       //   -- dburrows 2008-04-01
 787       {
 788         char *Buffer = new char[End - Start + 1];
 789         try
 790           {
 791             std::copy(Start, End, Buffer);
 792             Buffer[End - Start] = '\0';
 793
 794             const char *Stripd = _strstrip(Buffer);
 795             if (*Stripd != 0 && LineBuffer.empty() == false)
 796               LineBuffer += " ";
 797             LineBuffer += Stripd;
 798           }
 799         catch(...)
 800           {
 801             delete[] Buffer;
 802             throw;
 803           }
 804         delete[] Buffer;
 805       }
 806    }
 807
 808    if (LineBuffer.empty() == false)
 809       return _error->Error(_("Syntax error %s:%u: Extra junk at end of file"),FName.c_str(),CurLine);
 810    return true;
 811 }
 812                                                                         /*}}}*/
 813 // ReadConfigDir - Read a directory of config files                     /*{{{*/
 814 // ---------------------------------------------------------------------
 815 /* */
 816 bool ReadConfigDir(Configuration &Conf,const string &Dir,bool AsSectional,
 817                    unsigned Depth)
 818 {
 819    DIR *D = opendir(Dir.c_str());
 820    if (D == 0)
 821       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 822
 823    vector<string> List;
 824
 825    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 826    {
 827       if (Ent->d_name[0] == '.')
 828          continue;
 829
 830       // Skip bad file names ala run-parts
 831       const char *C = Ent->d_name;
 832       for (; *C != 0; C++)
 833          if (isalpha(*C) == 0 && isdigit(*C) == 0 && *C != '_' && *C != '-')
 834             break;
 835       if (*C != 0)
 836          continue;
 837
 838       // Make sure it is a file and not something else
 839       string File = flCombine(Dir,Ent->d_name);
 840       struct stat St;
 841       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)
 842          continue;
 843
 844       List.push_back(File);
 845    }
 846    closedir(D);
 847
 848    sort(List.begin(),List.end());
 849
 850    // Read the files
 851    for (vector<string>::const_iterator I = List.begin(); I != List.end(); I++)
 852       if (ReadConfigFile(Conf,*I,AsSectional,Depth) == false)
 853          return false;
 854    return true;
 855 }
 856                                                                         /*}}}*/