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 <config.h>
  19
  20 #include <apt-pkg/configuration.h>
  21 #include <apt-pkg/error.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/fileutl.h>
  24
  25 #include <vector>
  26 #include <fstream>
  27 #include <iostream>
  28
  29 #include <apti18n.h>
  30
  31 using namespace std;
  32                                                                         /*}}}*/
  33
  34 Configuration *_config = new Configuration;
  35
  36 // Configuration::Configuration - Constructor                           /*{{{*/
  37 // ---------------------------------------------------------------------
  38 /* */
  39 Configuration::Configuration() : ToFree(true)
  40 {
  41    Root = new Item;
  42 }
  43 Configuration::Configuration(const Item *Root) : Root((Item *)Root), ToFree(false)
  44 {
  45 };
  46
  47                                                                         /*}}}*/
  48 // Configuration::~Configuration - Destructor                           /*{{{*/
  49 // ---------------------------------------------------------------------
  50 /* */
  51 Configuration::~Configuration()
  52 {
  53    if (ToFree == false)
  54       return;
  55
  56    Item *Top = Root;
  57    for (; Top != 0;)
  58    {
  59       if (Top->Child != 0)
  60       {
  61          Top = Top->Child;
  62          continue;
  63       }
  64
  65       while (Top != 0 && Top->Next == 0)
  66       {
  67          Item *Parent = Top->Parent;
  68          delete Top;
  69          Top = Parent;
  70       }
  71       if (Top != 0)
  72       {
  73          Item *Next = Top->Next;
  74          delete Top;
  75          Top = Next;
  76       }
  77    }
  78 }
  79                                                                         /*}}}*/
  80 // Configuration::Lookup - Lookup a single item                         /*{{{*/
  81 // ---------------------------------------------------------------------
  82 /* This will lookup a single item by name below another item. It is a
  83    helper function for the main lookup function */
  84 Configuration::Item *Configuration::Lookup(Item *Head,const char *S,
  85                                            unsigned long const &Len,bool const &Create)
  86 {
  87    int Res = 1;
  88    Item *I = Head->Child;
  89    Item **Last = &Head->Child;
  90
  91    // Empty strings match nothing. They are used for lists.
  92    if (Len != 0)
  93    {
  94       for (; I != 0; Last = &I->Next, I = I->Next)
  95          if ((Res = stringcasecmp(I->Tag,S,S + Len)) == 0)
  96             break;
  97    }
  98    else
  99       for (; I != 0; Last = &I->Next, I = I->Next);
 100
 101    if (Res == 0)
 102       return I;
 103    if (Create == false)
 104       return 0;
 105
 106    I = new Item;
 107    I->Tag.assign(S,Len);
 108    I->Next = *Last;
 109    I->Parent = Head;
 110    *Last = I;
 111    return I;
 112 }
 113                                                                         /*}}}*/
 114 // Configuration::Lookup - Lookup a fully scoped item                   /*{{{*/
 115 // ---------------------------------------------------------------------
 116 /* This performs a fully scoped lookup of a given name, possibly creating
 117    new items */
 118 Configuration::Item *Configuration::Lookup(const char *Name,bool const &Create)
 119 {
 120    if (Name == 0)
 121       return Root->Child;
 122
 123    const char *Start = Name;
 124    const char *End = Start + strlen(Name);
 125    const char *TagEnd = Name;
 126    Item *Itm = Root;
 127    for (; End - TagEnd >= 2; TagEnd++)
 128    {
 129       if (TagEnd[0] == ':' && TagEnd[1] == ':')
 130       {
 131          Itm = Lookup(Itm,Start,TagEnd - Start,Create);
 132          if (Itm == 0)
 133             return 0;
 134          TagEnd = Start = TagEnd + 2;
 135       }
 136    }
 137
 138    // This must be a trailing ::, we create unique items in a list
 139    if (End - Start == 0)
 140    {
 141       if (Create == false)
 142          return 0;
 143    }
 144
 145    Itm = Lookup(Itm,Start,End - Start,Create);
 146    return Itm;
 147 }
 148                                                                         /*}}}*/
 149 // Configuration::Find - Find a value                                   /*{{{*/
 150 // ---------------------------------------------------------------------
 151 /* */
 152 string Configuration::Find(const char *Name,const char *Default) const
 153 {
 154    const Item *Itm = Lookup(Name);
 155    if (Itm == 0 || Itm->Value.empty() == true)
 156    {
 157       if (Default == 0)
 158          return "";
 159       else
 160          return Default;
 161    }
 162
 163    return Itm->Value;
 164 }
 165                                                                         /*}}}*/
 166 // Configuration::FindFile - Find a Filename                            /*{{{*/
 167 // ---------------------------------------------------------------------
 168 /* Directories are stored as the base dir in the Parent node and the
 169    sub directory in sub nodes with the final node being the end filename
 170  */
 171 string Configuration::FindFile(const char *Name,const char *Default) const
 172 {
 173    const Item *RootItem = Lookup("RootDir");
 174    std::string rootDir =  (RootItem == 0) ? "" : RootItem->Value;
 175    if(rootDir.size() > 0 && rootDir[rootDir.size() - 1] != '/')
 176      rootDir.push_back('/');
 177
 178    const Item *Itm = Lookup(Name);
 179    if (Itm == 0 || Itm->Value.empty() == true)
 180    {
 181       if (Default == 0)
 182          return rootDir;
 183       else
 184          return rootDir + Default;
 185    }
 186
 187    string val = Itm->Value;
 188    while (Itm->Parent != 0)
 189    {
 190       if (Itm->Parent->Value.empty() == true)
 191       {
 192          Itm = Itm->Parent;
 193          continue;
 194       }
 195
 196       // Absolute
 197       if (val.length() >= 1 && val[0] == '/')
 198          break;
 199
 200       // ~/foo or ./foo
 201       if (val.length() >= 2 && (val[0] == '~' || val[0] == '.') && val[1] == '/')
 202          break;
 203
 204       // ../foo
 205       if (val.length() >= 3 && val[0] == '.' && val[1] == '.' && val[2] == '/')
 206          break;
 207
 208       if (Itm->Parent->Value.end()[-1] != '/')
 209          val.insert(0, "/");
 210
 211       val.insert(0, Itm->Parent->Value);
 212       Itm = Itm->Parent;
 213    }
 214
 215    return rootDir + val;
 216 }
 217                                                                         /*}}}*/
 218 // Configuration::FindDir - Find a directory name                       /*{{{*/
 219 // ---------------------------------------------------------------------
 220 /* This is like findfile execept the result is terminated in a / */
 221 string Configuration::FindDir(const char *Name,const char *Default) const
 222 {
 223    string Res = FindFile(Name,Default);
 224    if (Res.end()[-1] != '/')
 225       return Res + '/';
 226    return Res;
 227 }
 228                                                                         /*}}}*/
 229 // Configuration::FindVector - Find a vector of values                  /*{{{*/
 230 // ---------------------------------------------------------------------
 231 /* Returns a vector of config values under the given item */
 232 vector<string> Configuration::FindVector(const char *Name) const
 233 {
 234    vector<string> Vec;
 235    const Item *Top = Lookup(Name);
 236    if (Top == NULL)
 237       return Vec;
 238
 239    Item *I = Top->Child;
 240    while(I != NULL)
 241    {
 242       Vec.push_back(I->Value);
 243       I = I->Next;
 244    }
 245    return Vec;
 246 }
 247                                                                         /*}}}*/
 248 // Configuration::FindI - Find an integer value                         /*{{{*/
 249 // ---------------------------------------------------------------------
 250 /* */
 251 int Configuration::FindI(const char *Name,int const &Default) const
 252 {
 253    const Item *Itm = Lookup(Name);
 254    if (Itm == 0 || Itm->Value.empty() == true)
 255       return Default;
 256
 257    char *End;
 258    int Res = strtol(Itm->Value.c_str(),&End,0);
 259    if (End == Itm->Value.c_str())
 260       return Default;
 261
 262    return Res;
 263 }
 264                                                                         /*}}}*/
 265 // Configuration::FindB - Find a boolean type                           /*{{{*/
 266 // ---------------------------------------------------------------------
 267 /* */
 268 bool Configuration::FindB(const char *Name,bool const &Default) const
 269 {
 270    const Item *Itm = Lookup(Name);
 271    if (Itm == 0 || Itm->Value.empty() == true)
 272       return Default;
 273
 274    return StringToBool(Itm->Value,Default);
 275 }
 276                                                                         /*}}}*/
 277 // Configuration::FindAny - Find an arbitrary type                      /*{{{*/
 278 // ---------------------------------------------------------------------
 279 /* a key suffix of /f, /d, /b or /i calls Find{File,Dir,B,I} */
 280 string Configuration::FindAny(const char *Name,const char *Default) const
 281 {
 282    string key = Name;
 283    char type = 0;
 284
 285    if (key.size() > 2 && key.end()[-2] == '/')
 286    {
 287       type = key.end()[-1];
 288       key.resize(key.size() - 2);
 289    }
 290
 291    switch (type)
 292    {
 293       // file
 294       case 'f':
 295       return FindFile(key.c_str(), Default);
 296
 297       // directory
 298       case 'd':
 299       return FindDir(key.c_str(), Default);
 300
 301       // bool
 302       case 'b':
 303       return FindB(key, Default) ? "true" : "false";
 304
 305       // int
 306       case 'i':
 307       {
 308          char buf[16];
 309          snprintf(buf, sizeof(buf)-1, "%d", FindI(key, Default ? atoi(Default) : 0 ));
 310          return buf;
 311       }
 312    }
 313
 314    // fallback
 315    return Find(Name, Default);
 316 }
 317                                                                         /*}}}*/
 318 // Configuration::CndSet - Conditinal Set a value                       /*{{{*/
 319 // ---------------------------------------------------------------------
 320 /* This will not overwrite */
 321 void Configuration::CndSet(const char *Name,const string &Value)
 322 {
 323    Item *Itm = Lookup(Name,true);
 324    if (Itm == 0)
 325       return;
 326    if (Itm->Value.empty() == true)
 327       Itm->Value = Value;
 328 }
 329                                                                         /*}}}*/
 330 // Configuration::Set - Set an integer value                            /*{{{*/
 331 // ---------------------------------------------------------------------
 332 /* */
 333 void Configuration::CndSet(const char *Name,int const Value)
 334 {
 335    Item *Itm = Lookup(Name,true);
 336    if (Itm == 0 || Itm->Value.empty() == false)
 337       return;
 338    char S[300];
 339    snprintf(S,sizeof(S),"%i",Value);
 340    Itm->Value = S;
 341 }
 342                                                                         /*}}}*/
 343 // Configuration::Set - Set a value                                     /*{{{*/
 344 // ---------------------------------------------------------------------
 345 /* */
 346 void Configuration::Set(const char *Name,const string &Value)
 347 {
 348    Item *Itm = Lookup(Name,true);
 349    if (Itm == 0)
 350       return;
 351    Itm->Value = Value;
 352 }
 353                                                                         /*}}}*/
 354 // Configuration::Set - Set an integer value                            /*{{{*/
 355 // ---------------------------------------------------------------------
 356 /* */
 357 void Configuration::Set(const char *Name,int const &Value)
 358 {
 359    Item *Itm = Lookup(Name,true);
 360    if (Itm == 0)
 361       return;
 362    char S[300];
 363    snprintf(S,sizeof(S),"%i",Value);
 364    Itm->Value = S;
 365 }
 366                                                                         /*}}}*/
 367 // Configuration::Clear - Clear an single value from a list             /*{{{*/
 368 // ---------------------------------------------------------------------
 369 /* */
 370 void Configuration::Clear(string const &Name, int const &Value)
 371 {
 372    char S[300];
 373    snprintf(S,sizeof(S),"%i",Value);
 374    Clear(Name, S);
 375 }
 376                                                                         /*}}}*/
 377 // Configuration::Clear - Clear an single value from a list             /*{{{*/
 378 // ---------------------------------------------------------------------
 379 /* */
 380 void Configuration::Clear(string const &Name, string const &Value)
 381 {
 382    Item *Top = Lookup(Name.c_str(),false);
 383    if (Top == 0 || Top->Child == 0)
 384       return;
 385
 386    Item *Tmp, *Prev, *I;
 387    Prev = I = Top->Child;
 388
 389    while(I != NULL)
 390    {
 391       if(I->Value == Value)
 392       {
 393          Tmp = I;
 394          // was first element, point parent to new first element
 395          if(Top->Child == Tmp)
 396             Top->Child = I->Next;
 397          I = I->Next;
 398          Prev->Next = I;
 399          delete Tmp;
 400       } else {
 401          Prev = I;
 402          I = I->Next;
 403       }
 404    }
 405
 406 }
 407                                                                         /*}}}*/
 408 // Configuration::Clear - Clear an entire tree                          /*{{{*/
 409 // ---------------------------------------------------------------------
 410 /* */
 411 void Configuration::Clear(string const &Name)
 412 {
 413    Item *Top = Lookup(Name.c_str(),false);
 414    if (Top == 0)
 415       return;
 416
 417    Top->Value.clear();
 418    Item *Stop = Top;
 419    Top = Top->Child;
 420    Stop->Child = 0;
 421    for (; Top != 0;)
 422    {
 423       if (Top->Child != 0)
 424       {
 425          Top = Top->Child;
 426          continue;
 427       }
 428
 429       while (Top != 0 && Top->Next == 0)
 430       {
 431          Item *Tmp = Top;
 432          Top = Top->Parent;
 433          delete Tmp;
 434
 435          if (Top == Stop)
 436             return;
 437       }
 438
 439       Item *Tmp = Top;
 440       if (Top != 0)
 441          Top = Top->Next;
 442       delete Tmp;
 443    }
 444 }
 445                                                                         /*}}}*/
 446 // Configuration::Exists - Returns true if the Name exists              /*{{{*/
 447 // ---------------------------------------------------------------------
 448 /* */
 449 bool Configuration::Exists(const char *Name) const
 450 {
 451    const Item *Itm = Lookup(Name);
 452    if (Itm == 0)
 453       return false;
 454    return true;
 455 }
 456                                                                         /*}}}*/
 457 // Configuration::ExistsAny - Returns true if the Name, possibly        /*{{{*/
 458 // ---------------------------------------------------------------------
 459 /* qualified by /[fdbi] exists */
 460 bool Configuration::ExistsAny(const char *Name) const
 461 {
 462    string key = Name;
 463
 464    if (key.size() > 2 && key.end()[-2] == '/')
 465    {
 466       if (key.find_first_of("fdbi",key.size()-1) < key.size())
 467       {
 468          key.resize(key.size() - 2);
 469          if (Exists(key.c_str()))
 470             return true;
 471       }
 472       else
 473       {
 474          _error->Warning(_("Unrecognized type abbreviation: '%c'"), key.end()[-3]);
 475       }
 476    }
 477    return Exists(Name);
 478 }
 479                                                                         /*}}}*/
 480 // Configuration::Dump - Dump the config                                /*{{{*/
 481 // ---------------------------------------------------------------------
 482 /* Dump the entire configuration space */
 483 void Configuration::Dump(ostream& str)
 484 {
 485    Dump(str, NULL, "%f \"%v\";\n", true);
 486 }
 487 void Configuration::Dump(ostream& str, char const * const root,
 488                          char const * const formatstr, bool const emptyValue)
 489 {
 490    const Configuration::Item* Top = Tree(root);
 491    if (Top == 0)
 492       return;
 493    const Configuration::Item* const Root = (root == NULL) ? NULL : Top;
 494    std::vector<std::string> const format = VectorizeString(formatstr, '%');
 495
 496    /* Write out all of the configuration directives by walking the
 497       configuration tree */
 498    do {
 499       if (emptyValue == true || Top->Value.empty() == emptyValue)
 500       {
 501          std::vector<std::string>::const_iterator f = format.begin();
 502          str << *f;
 503          for (++f; f != format.end(); ++f)
 504          {
 505             if (f->empty() == true)
 506             {
 507                ++f;
 508                str << '%' << *f;
 509                continue;
 510             }
 511             char const type = (*f)[0];
 512             if (type == 'f')
 513                str << Top->FullTag();
 514             else if (type == 't')
 515                str << Top->Tag;
 516             else if (type == 'v')
 517                str << Top->Value;
 518             else if (type == 'F')
 519                str << QuoteString(Top->FullTag(), "=\"\n");
 520             else if (type == 'T')
 521                str << QuoteString(Top->Tag, "=\"\n");
 522             else if (type == 'V')
 523                str << QuoteString(Top->Value, "=\"\n");
 524             else if (type == 'n')
 525                str << "\n";
 526             else if (type == 'N')
 527                str << "\t";
 528             else
 529                str << '%' << type;
 530             str << f->c_str() + 1;
 531          }
 532       }
 533
 534       if (Top->Child != 0)
 535       {
 536          Top = Top->Child;
 537          continue;
 538       }
 539
 540       while (Top != 0 && Top->Next == 0)
 541          Top = Top->Parent;
 542       if (Top != 0)
 543          Top = Top->Next;
 544
 545       if (Root != NULL)
 546       {
 547          const Configuration::Item* I = Top;
 548          while(I != 0)
 549          {
 550             if (I == Root)
 551                break;
 552             else
 553                I = I->Parent;
 554          }
 555          if (I == 0)
 556             break;
 557       }
 558    } while (Top != 0);
 559 }
 560                                                                         /*}}}*/
 561
 562 // Configuration::Item::FullTag - Return the fully scoped tag           /*{{{*/
 563 // ---------------------------------------------------------------------
 564 /* Stop sets an optional max recursion depth if this item is being viewed as
 565    part of a sub tree. */
 566 string Configuration::Item::FullTag(const Item *Stop) const
 567 {
 568    if (Parent == 0 || Parent->Parent == 0 || Parent == Stop)
 569       return Tag;
 570    return Parent->FullTag(Stop) + "::" + Tag;
 571 }
 572                                                                         /*}}}*/
 573
 574 // ReadConfigFile - Read a configuration file                           /*{{{*/
 575 // ---------------------------------------------------------------------
 576 /* The configuration format is very much like the named.conf format
 577    used in bind8, in fact this routine can parse most named.conf files.
 578    Sectional config files are like bind's named.conf where there are
 579    sections like 'zone "foo.org" { .. };' This causes each section to be
 580    added in with a tag like "zone::foo.org" instead of being split
 581    tag/value. AsSectional enables Sectional parsing.*/
 582 bool ReadConfigFile(Configuration &Conf,const string &FName,bool const &AsSectional,
 583                     unsigned const &Depth)
 584 {
 585    // Open the stream for reading
 586    ifstream F(FName.c_str(),ios::in);
 587    if (!F != 0)
 588       return _error->Errno("ifstream::ifstream",_("Opening configuration file %s"),FName.c_str());
 589
 590    string LineBuffer;
 591    string Stack[100];
 592    unsigned int StackPos = 0;
 593
 594    // Parser state
 595    string ParentTag;
 596
 597    int CurLine = 0;
 598    bool InComment = false;
 599    while (F.eof() == false)
 600    {
 601       // The raw input line.
 602       std::string Input;
 603       // The input line with comments stripped.
 604       std::string Fragment;
 605
 606       // Grab the next line of F and place it in Input.
 607       do
 608         {
 609           char *Buffer = new char[1024];
 610
 611           F.clear();
 612           F.getline(Buffer,sizeof(Buffer) / 2);
 613
 614           Input += Buffer;
 615           delete[] Buffer;
 616         }
 617       while (F.fail() && !F.eof());
 618
 619       // Expand tabs in the input line and remove leading and trailing
 620       // whitespace.
 621       {
 622         const int BufferSize = Input.size() * 8 + 1;
 623         char *Buffer = new char[BufferSize];
 624         try
 625           {
 626             memcpy(Buffer, Input.c_str(), Input.size() + 1);
 627
 628             _strtabexpand(Buffer, BufferSize);
 629             _strstrip(Buffer);
 630             Input = Buffer;
 631           }
 632         catch(...)
 633           {
 634             delete[] Buffer;
 635             throw;
 636           }
 637         delete[] Buffer;
 638       }
 639       CurLine++;
 640
 641       // Now strip comments; if the whole line is contained in a
 642       // comment, skip this line.
 643
 644       // The first meaningful character in the current fragment; will
 645       // be adjusted below as we remove bytes from the front.
 646       std::string::const_iterator Start = Input.begin();
 647       // The last meaningful character in the current fragment.
 648       std::string::const_iterator End = Input.end();
 649
 650       // Multi line comment
 651       if (InComment == true)
 652       {
 653         for (std::string::const_iterator I = Start;
 654              I != End; ++I)
 655          {
 656             if (*I == '*' && I + 1 != End && I[1] == '/')
 657             {
 658                Start = I + 2;
 659                InComment = false;
 660                break;
 661             }
 662          }
 663          if (InComment == true)
 664             continue;
 665       }
 666
 667       // Discard single line comments
 668       bool InQuote = false;
 669       for (std::string::const_iterator I = Start;
 670            I != End; ++I)
 671       {
 672          if (*I == '"')
 673             InQuote = !InQuote;
 674          if (InQuote == true)
 675             continue;
 676
 677          if ((*I == '/' && I + 1 != End && I[1] == '/') ||
 678              (*I == '#' && strcmp(string(I,I+6).c_str(),"#clear") != 0 &&
 679               strcmp(string(I,I+8).c_str(),"#include") != 0))
 680          {
 681             End = I;
 682             break;
 683          }
 684       }
 685
 686       // Look for multi line comments and build up the
 687       // fragment.
 688       Fragment.reserve(End - Start);
 689       InQuote = false;
 690       for (std::string::const_iterator I = Start;
 691            I != End; ++I)
 692       {
 693          if (*I == '"')
 694             InQuote = !InQuote;
 695          if (InQuote == true)
 696            Fragment.push_back(*I);
 697          else if (*I == '/' && I + 1 != End && I[1] == '*')
 698          {
 699             InComment = true;
 700             for (std::string::const_iterator J = I;
 701                  J != End; ++J)
 702             {
 703                if (*J == '*' && J + 1 != End && J[1] == '/')
 704                {
 705                   // Pretend we just finished walking over the
 706                   // comment, and don't add anything to the output
 707                   // fragment.
 708                   I = J + 1;
 709                   InComment = false;
 710                   break;
 711                }
 712             }
 713
 714             if (InComment == true)
 715               break;
 716          }
 717          else
 718            Fragment.push_back(*I);
 719       }
 720
 721       // Skip blank lines.
 722       if (Fragment.empty())
 723          continue;
 724
 725       // The line has actual content; interpret what it means.
 726       InQuote = false;
 727       Start = Fragment.begin();
 728       End = Fragment.end();
 729       for (std::string::const_iterator I = Start;
 730            I != End; ++I)
 731       {
 732          if (*I == '"')
 733             InQuote = !InQuote;
 734
 735          if (InQuote == false && (*I == '{' || *I == ';' || *I == '}'))
 736          {
 737             // Put the last fragment into the buffer
 738             std::string::const_iterator NonWhitespaceStart = Start;
 739             std::string::const_iterator NonWhitespaceStop = I;
 740             for (; NonWhitespaceStart != I && isspace(*NonWhitespaceStart) != 0; ++NonWhitespaceStart)
 741               ;
 742             for (; NonWhitespaceStop != NonWhitespaceStart && isspace(NonWhitespaceStop[-1]) != 0; --NonWhitespaceStop)
 743               ;
 744             if (LineBuffer.empty() == false && NonWhitespaceStop - NonWhitespaceStart != 0)
 745                LineBuffer += ' ';
 746             LineBuffer += string(NonWhitespaceStart, NonWhitespaceStop);
 747
 748             // Drop this from the input string, saving the character
 749             // that terminated the construct we just closed. (i.e., a
 750             // brace or a semicolon)
 751             char TermChar = *I;
 752             Start = I + 1;
 753
 754             // Syntax Error
 755             if (TermChar == '{' && LineBuffer.empty() == true)
 756                return _error->Error(_("Syntax error %s:%u: Block starts with no name."),FName.c_str(),CurLine);
 757
 758             // No string on this line
 759             if (LineBuffer.empty() == true)
 760             {
 761                if (TermChar == '}')
 762                {
 763                   if (StackPos == 0)
 764                      ParentTag = string();
 765                   else
 766                      ParentTag = Stack[--StackPos];
 767                }
 768                continue;
 769             }
 770
 771             // Parse off the tag
 772             string Tag;
 773             const char *Pos = LineBuffer.c_str();
 774             if (ParseQuoteWord(Pos,Tag) == false)
 775                return _error->Error(_("Syntax error %s:%u: Malformed tag"),FName.c_str(),CurLine);
 776
 777             // Parse off the word
 778             string Word;
 779             bool NoWord = false;
 780             if (ParseCWord(Pos,Word) == false &&
 781                 ParseQuoteWord(Pos,Word) == false)
 782             {
 783                if (TermChar != '{')
 784                {
 785                   Word = Tag;
 786                   Tag = "";
 787                }
 788                else
 789                   NoWord = true;
 790             }
 791             if (strlen(Pos) != 0)
 792                return _error->Error(_("Syntax error %s:%u: Extra junk after value"),FName.c_str(),CurLine);
 793
 794             // Go down a level
 795             if (TermChar == '{')
 796             {
 797                if (StackPos <= 100)
 798                   Stack[StackPos++] = ParentTag;
 799
 800                /* Make sectional tags incorperate the section into the
 801                   tag string */
 802                if (AsSectional == true && Word.empty() == false)
 803                {
 804                   Tag += "::" ;
 805                   Tag += Word;
 806                   Word = "";
 807                }
 808
 809                if (ParentTag.empty() == true)
 810                   ParentTag = Tag;
 811                else
 812                   ParentTag += string("::") + Tag;
 813                Tag = string();
 814             }
 815
 816             // Generate the item name
 817             string Item;
 818             if (ParentTag.empty() == true)
 819                Item = Tag;
 820             else
 821             {
 822                if (TermChar != '{' || Tag.empty() == false)
 823                   Item = ParentTag + "::" + Tag;
 824                else
 825                   Item = ParentTag;
 826             }
 827
 828             // Specials
 829             if (Tag.length() >= 1 && Tag[0] == '#')
 830             {
 831                if (ParentTag.empty() == false)
 832                   return _error->Error(_("Syntax error %s:%u: Directives can only be done at the top level"),FName.c_str(),CurLine);
 833                Tag.erase(Tag.begin());
 834                if (Tag == "clear")
 835                   Conf.Clear(Word);
 836                else if (Tag == "include")
 837                {
 838                   if (Depth > 10)
 839                      return _error->Error(_("Syntax error %s:%u: Too many nested includes"),FName.c_str(),CurLine);
 840                   if (Word.length() > 2 && Word.end()[-1] == '/')
 841                   {
 842                      if (ReadConfigDir(Conf,Word,AsSectional,Depth+1) == false)
 843                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 844                   }
 845                   else
 846                   {
 847                      if (ReadConfigFile(Conf,Word,AsSectional,Depth+1) == false)
 848                         return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);
 849                   }
 850                }
 851                else
 852                   return _error->Error(_("Syntax error %s:%u: Unsupported directive '%s'"),FName.c_str(),CurLine,Tag.c_str());
 853             }
 854             else if (Tag.empty() == true && NoWord == false && Word == "#clear")
 855                return _error->Error(_("Syntax error %s:%u: clear directive requires an option tree as argument"),FName.c_str(),CurLine);
 856             else
 857             {
 858                // Set the item in the configuration class
 859                if (NoWord == false)
 860                   Conf.Set(Item,Word);
 861             }
 862
 863             // Empty the buffer
 864             LineBuffer.clear();
 865
 866             // Move up a tag, but only if there is no bit to parse
 867             if (TermChar == '}')
 868             {
 869                if (StackPos == 0)
 870                   ParentTag.clear();
 871                else
 872                   ParentTag = Stack[--StackPos];
 873             }
 874
 875          }
 876       }
 877
 878       // Store the remaining text, if any, in the current line buffer.
 879
 880       // NB: could change this to use string-based operations; I'm
 881       // using strstrip now to ensure backwards compatibility.
 882       //   -- dburrows 2008-04-01
 883       {
 884         char *Buffer = new char[End - Start + 1];
 885         try
 886           {
 887             std::copy(Start, End, Buffer);
 888             Buffer[End - Start] = '\0';
 889
 890             const char *Stripd = _strstrip(Buffer);
 891             if (*Stripd != 0 && LineBuffer.empty() == false)
 892               LineBuffer += " ";
 893             LineBuffer += Stripd;
 894           }
 895         catch(...)
 896           {
 897             delete[] Buffer;
 898             throw;
 899           }
 900         delete[] Buffer;
 901       }
 902    }
 903
 904    if (LineBuffer.empty() == false)
 905       return _error->Error(_("Syntax error %s:%u: Extra junk at end of file"),FName.c_str(),CurLine);
 906    return true;
 907 }
 908                                                                         /*}}}*/
 909 // ReadConfigDir - Read a directory of config files                     /*{{{*/
 910 // ---------------------------------------------------------------------
 911 /* */
 912 bool ReadConfigDir(Configuration &Conf,const string &Dir,
 913                    bool const &AsSectional, unsigned const &Depth)
 914 {
 915    vector<string> const List = GetListOfFilesInDir(Dir, "conf", true, true);
 916
 917    // Read the files
 918    for (vector<string>::const_iterator I = List.begin(); I != List.end(); ++I)
 919       if (ReadConfigFile(Conf,*I,AsSectional,Depth) == false)
 920          return false;
 921    return true;
 922 }
 923                                                                         /*}}}*/
 924 // MatchAgainstConfig Constructor                                       /*{{{*/
 925 Configuration::MatchAgainstConfig::MatchAgainstConfig(char const * Config)
 926 {
 927    std::vector<std::string> const strings = _config->FindVector(Config);
 928    for (std::vector<std::string>::const_iterator s = strings.begin();
 929         s != strings.end(); ++s)
 930    {
 931       regex_t *p = new regex_t;
 932       if (regcomp(p, s->c_str(), REG_EXTENDED | REG_ICASE | REG_NOSUB) == 0)
 933          patterns.push_back(p);
 934       else
 935       {
 936          regfree(p);
 937          delete p;
 938          _error->Warning("Invalid regular expression '%s' in configuration "
 939                          "option '%s' will be ignored.",
 940                          s->c_str(), Config);
 941          continue;
 942       }
 943    }
 944    if (strings.size() == 0)
 945       patterns.push_back(NULL);
 946 }
 947                                                                         /*}}}*/
 948 // MatchAgainstConfig Destructor                                        /*{{{*/
 949 Configuration::MatchAgainstConfig::~MatchAgainstConfig()
 950 {
 951    clearPatterns();
 952 }
 953 void Configuration::MatchAgainstConfig::clearPatterns()
 954 {
 955    for(std::vector<regex_t *>::const_iterator p = patterns.begin();
 956         p != patterns.end(); ++p)
 957    {
 958       if (*p == NULL) continue;
 959       regfree(*p);
 960       delete *p;
 961    }
 962    patterns.clear();
 963 }
 964                                                                         /*}}}*/
 965 // MatchAgainstConfig::Match - returns true if a pattern matches        /*{{{*/
 966 bool Configuration::MatchAgainstConfig::Match(char const * str) const
 967 {
 968    for(std::vector<regex_t *>::const_iterator p = patterns.begin();
 969         p != patterns.end(); ++p)
 970       if (*p != NULL && regexec(*p, str, 0, 0, 0) == 0)
 971          return true;
 972
 973    return false;
 974 }
 975                                                                         /*}}}*/