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