]> git.saurik.com Git - apt.git/blob - apt-pkg/contrib/configuration.cc
* apt-pkg/acquire-item.cc:
[apt.git] / 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 /*}}}*/