]> git.stg.codes - stg.git/blob - stglibs/dotconfpp.lib/dotconfpp.cpp
Merge branch 'stg-2.409' into stg-2.409-radius
[stg.git] / stglibs / dotconfpp.lib / dotconfpp.cpp
1 /*  Copyright (C) 2003 Aleksey Krivoshey <krivoshey@users.sourceforge.net>
2 *
3 *   This program is free software; you can redistribute it and/or modify
4 *   it under the terms of the GNU General Public License as published by
5 *   the Free Software Foundation; either version 2 of the License, or
6 *   (at your option) any later version.
7 *
8 *   This program is distributed in the hope that it will be useful,
9 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
10 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 *   GNU General Public License for more details.
12 *
13 *   You should have received a copy of the GNU General Public License
14 *   along with this program; if not, write to the Free Software
15 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 */
17
18 #include <libgen.h> // dirname
19 #include <glob.h> // glob
20 #include <string>
21
22 #include "stg/dotconfpp.h"
23 #include "mempool.h"
24
25 DOTCONFDocumentNode::DOTCONFDocumentNode():previousNode(NULL), nextNode(NULL), parentNode(NULL), childNode(NULL),
26     values(NULL), valuesCount(0), 
27     name(NULL), lineNum(0), fileName(NULL), closed(true)
28 {
29 }
30
31 DOTCONFDocumentNode::~DOTCONFDocumentNode()
32 {
33     free(name);
34     if(values != NULL){
35         for(int i = 0 ; i < valuesCount; i++){
36             free(values[i]);
37         }
38         free(values);
39     }
40 }
41
42 void DOTCONFDocumentNode::pushValue(char * _value)
43 {
44     valuesCount++;
45     values = (char**)realloc(values, valuesCount*sizeof(char*));
46     values[valuesCount-1] = strdup(_value);
47 }
48
49 const char* DOTCONFDocumentNode::getValue(int index) const
50 {
51     if(index >= valuesCount){
52         return NULL;
53     }
54     return values[index];
55 }
56
57 DOTCONFDocument::DOTCONFDocument(DOTCONFDocument::CaseSensitive caseSensitivity):
58     mempool(NULL),
59     curParent(NULL), curPrev(NULL), errorCallback(NULL), errorCallbackData(NULL),
60     curLine(0), file(NULL), fileName(NULL)
61 {
62     if(caseSensitivity == CASESENSITIVE){
63         cmp_func = strcmp;
64     } else {
65         cmp_func = strcasecmp;
66     }
67
68     mempool = new AsyncDNSMemPool(1024);
69     mempool->initialize();
70 }
71
72 DOTCONFDocument::~DOTCONFDocument()
73 {
74     for(std::list<DOTCONFDocumentNode*>::iterator i = nodeTree.begin(); i != nodeTree.end(); ++i){
75         delete(*i);
76     }
77     for(std::list<char*>::iterator i = requiredOptions.begin(); i != requiredOptions.end(); ++i){
78         free(*i);
79     }
80     for(std::list<char*>::iterator i = processedFiles.begin(); i != processedFiles.end(); ++i){
81         free(*i);
82     }
83     free(fileName);
84     delete mempool;
85 }
86
87 int DOTCONFDocument::cleanupLine(char * line)
88 {
89     char * start = line;
90     char * bg = line;
91     bool multiline = false;
92     bool concat = false;
93     char * word = NULL;
94
95     if(!words.empty() && quoted)
96         concat = true;
97
98     while(*line){
99         if((*line == '#' || *line == ';') && !quoted){
100             *bg = 0;
101             if(strlen(start)){
102                 //printf("2start='%s'\n", start);
103                 if(concat){
104                     word = (char*)mempool->alloc(strlen(words.back())+strlen(start)+1);
105                     strcpy(word, words.back());
106                     strcat(word, start);
107                     words.pop_back();
108                     concat = false;
109                 } else {
110                     word = mempool->strdup(start);
111                 }
112                 words.push_back(word);
113             }
114             break;
115         }
116         if(*line == '=' && !quoted){ // 'parameter = value' is the same as 'parameter value' but do not replace with ' ' when used in quoted value
117             *line = ' ';continue;
118         }
119         if(*line == '\\' && (*(line+1) == '"' || *(line+1) == '\'')){
120             *bg++ = *(line+1); 
121             line+=2; continue;
122         }
123         if(*line == '\\' && *(line+1) == 'n'){
124             *bg++ = '\n'; 
125             line+=2; continue;
126         }
127         if(*line == '\\' && *(line+1) == 'r'){
128             *bg++ = '\r'; 
129             line+=2; continue;
130         }
131         if(*line == '\\' && (*(line+1) == '\n' || *(line+1) == '\r')){ //multiline
132             *bg = 0;
133             if(strlen(start)){
134                 //printf("3start='%s'\n", start);
135                 if(concat){
136                     word = (char*)mempool->alloc(strlen(words.back())+strlen(start)+1);
137                     strcpy(word, words.back());
138                     strcat(word, start);
139                     words.pop_back();
140                     concat = false;
141                 } else {
142                     word = mempool->strdup(start);
143                 }
144                 words.push_back(word);
145             }
146             multiline = true;
147             break;
148         }
149         if(*line == '"' || *line == '\''){ //need to handle quotes because of spaces or = that may be between
150             quoted = !quoted;
151             line++; continue;
152         }
153         if(isspace(*line) && !quoted){
154             *bg++ = 0;
155             if(strlen(start)){
156                 //printf("start='%s'\n", start);
157                 if(concat){
158                     word = (char*)mempool->alloc(strlen(words.back())+strlen(start)+1);
159                     strcpy(word, words.back());
160                     strcat(word, start);
161                     words.pop_back();
162                     concat = false;
163                 } else {
164                     word = mempool->strdup(start);
165                 }
166                 words.push_back(word);
167             }
168             start = bg;
169             while(isspace(*++line)) {};
170             continue;
171         }
172         *bg++ = *line++;
173     }    
174
175     if(quoted && !multiline){
176         error(curLine, fileName, "unterminated quote");
177         return -1;
178     }
179
180     return multiline?1:0;
181 }
182
183 int DOTCONFDocument::parseLine()
184 {
185     char * word = NULL;
186     char * nodeName = NULL;
187     char * nodeValue = NULL;
188     DOTCONFDocumentNode * tagNode = NULL;
189     bool newNode = false;
190
191     for(std::list<char*>::iterator i = words.begin(); i != words.end(); ++i) {
192         word = *i;
193
194         if(*word == '<'){
195             newNode = true;
196         }
197
198         if(newNode){
199             nodeValue = NULL;
200             nodeName = NULL;
201             newNode = false;
202         }
203
204         size_t wordLen = strlen(word);
205         if(word[wordLen-1] == '>'){
206             word[wordLen-1] = 0;
207             newNode = true;
208         }
209
210         if(nodeName == NULL){
211             nodeName = word;
212             bool closed = true; //if this not <> node then it is closed by default
213             if(*nodeName == '<'){
214                 if(*(nodeName+1) != '/'){ //opening tag
215                     nodeName++;
216                     closed = false;
217                 } else { //closing tag
218                     nodeName+=2;
219                     std::list<DOTCONFDocumentNode*>::reverse_iterator i=nodeTree.rbegin();
220                     for(; i!=nodeTree.rend(); ++i){
221                         if(!cmp_func(nodeName, (*i)->name) && !(*i)->closed){
222                             (*i)->closed = true;
223                             curParent = (*i)->parentNode;
224                             curPrev = *i;
225                             break;
226                         }
227                     }
228                     if(i==nodeTree.rend()){
229                         error(curLine, fileName, "not matched closing tag </%s>", nodeName);
230                         return -1;
231                     }
232                     continue;
233                 }
234             }
235             tagNode = new DOTCONFDocumentNode;
236             tagNode->name = strdup(nodeName);
237             tagNode->document = this;
238             tagNode->fileName = processedFiles.back();
239             tagNode->lineNum = curLine;
240             tagNode->closed = closed;
241             if(!nodeTree.empty()){
242                 DOTCONFDocumentNode * prev = nodeTree.back();
243                 if(prev->closed){
244
245                     curPrev->nextNode = tagNode;
246                     tagNode->previousNode = curPrev;
247                     tagNode->parentNode = curParent;
248
249                 } else {
250                     prev->childNode = tagNode;
251                     tagNode->parentNode = prev;
252                     curParent = prev;
253                 }
254             }
255             nodeTree.push_back(tagNode);
256             curPrev = tagNode;
257         } else {
258             nodeValue = word;
259             tagNode->pushValue(nodeValue);
260         }
261     }
262     
263     return 0;
264 }
265 int DOTCONFDocument::parseFile(DOTCONFDocumentNode * _parent)
266 {
267     char str[512];
268     int ret = 0;
269     curLine = 0;
270     curParent = _parent;
271
272     quoted = false;
273
274     while(fgets(str, 511, file)){
275         curLine++;
276         size_t slen = strlen(str);
277         if( slen >= 510 ){
278             error(curLine, fileName, "warning: line too long");
279         }
280         if(str[slen-1] != '\n'){
281             str[slen] = '\n';
282             str[slen+1] = 0;
283         }
284         if((ret = cleanupLine(str)) == -1){
285             break;
286         }
287         if(ret == 0){
288             if(!words.empty()){
289                 ret = parseLine();
290                 mempool->free();
291                 words.clear();
292                 if(ret == -1){
293                     break;
294                 }
295             }            
296         }
297     }
298
299     return ret;
300 }
301
302 int DOTCONFDocument::checkConfig(const std::list<DOTCONFDocumentNode*>::iterator & from)
303 {
304     int ret = 0;
305
306     for(std::list<DOTCONFDocumentNode*>::iterator i = from; i != nodeTree.end(); ++i){
307         DOTCONFDocumentNode * tagNode = *i;
308         if(!tagNode->closed){
309             error(tagNode->lineNum, tagNode->fileName, "unclosed tag %s", tagNode->name);
310             ret = -1;
311             break;
312         }
313         int vi = 0;
314         while( vi < tagNode->valuesCount ){
315             //if((tagNode->values[vi])[0] == '$' && (tagNode->values[vi])[1] == '{' && strchr(tagNode->values[vi], '}') ){
316             if(strstr(tagNode->values[vi], "${") && strchr(tagNode->values[vi], '}') ){
317                 ret = macroSubstitute(tagNode, vi );
318                 mempool->free();
319                 if(ret == -1){
320                     break;
321                 }
322             }
323             vi++;
324         }
325         if(ret == -1){
326             break;
327         }
328     }
329
330     return ret;
331 }
332
333 int DOTCONFDocument::setContent(const char * _fileName)
334 {    
335     int ret = 0;
336     char realpathBuf[PATH_MAX];
337
338     if(realpath(_fileName, realpathBuf) == NULL){
339         error(0, _fileName, "%s", strerror(errno));
340         return -1;
341     }
342
343     fileName = strdup(realpathBuf);
344
345     char * forPathName = strdup(realpathBuf);
346
347     if (forPathName == NULL) {
348         error(0, NULL, "Not enought memory to duplicate realpath");
349         return -1;
350     }
351
352     char * _pathName = dirname(forPathName);
353
354     std::string pathName(_pathName);
355
356     free(forPathName); // From strdup
357
358     processedFiles.push_back(strdup(realpathBuf));
359
360     if(( file = fopen(fileName, "r")) == NULL){
361         error(0, NULL, "failed to open file '%s': %s", fileName, strerror(errno));
362         return -1;
363     }
364
365     ret = parseFile();
366     
367     (void) fclose(file);
368
369     if(!ret){
370     
371         if( (ret = checkConfig(nodeTree.begin())) == -1){
372             return -1;
373         }
374
375         std::list<DOTCONFDocumentNode*>::iterator from;
376         DOTCONFDocumentNode * tagNode = NULL;
377         int vi = 0;
378         for(std::list<DOTCONFDocumentNode*>::iterator i = nodeTree.begin(); i!=nodeTree.end(); ++i){
379             tagNode = *i;
380             if(!cmp_func("IncludeFile", tagNode->name)){
381                 vi = 0;
382                 while( vi < tagNode->valuesCount ){
383                     glob_t globBuf;
384                     std::string nodeFilePath;
385                     if (*tagNode->values[vi] != '/') {
386                         // Relative path
387                         nodeFilePath = pathName + "/" + tagNode->values[vi];
388                     } else {
389                         // Absolute path
390                        nodeFilePath = tagNode->values[vi];
391                     }
392                     int res = glob(nodeFilePath.c_str(), 0, NULL, &globBuf);
393                     if (res) {
394                         switch (res) {
395                             case GLOB_NOSPACE:
396                                 error(tagNode->lineNum, tagNode->fileName, "glob call failed for '%s': no free space", nodeFilePath.c_str());
397                                 return -1;
398 #ifndef FREE_BSD
399                             case GLOB_ABORTED:
400                                 // printf("Read error\n");
401                                 // Ignore that error
402                                 break;
403                             case GLOB_NOMATCH:
404                                 // printf("No match\n");
405                                 // Ignore that error
406                                 break;
407 #endif
408                             default:
409                                 error(tagNode->lineNum, tagNode->fileName, "glob call failed for '%s': unknown error", nodeFilePath.c_str());
410                                 return -1;
411                         }
412                     }
413                     if (!res) {
414                         for (size_t i = 0; i < globBuf.gl_pathc; ++i) {
415                             std::string nodeFilePath(globBuf.gl_pathv[i]);
416                             if(access(nodeFilePath.c_str(), R_OK) == -1){
417                                 error(tagNode->lineNum, tagNode->fileName, "%s: %s", nodeFilePath.c_str(), strerror(errno));
418                                 continue;
419                             }
420                             if(realpath(nodeFilePath.c_str(), realpathBuf) == NULL){
421                                 error(tagNode->lineNum, tagNode->fileName, "realpath(%s) failed: %s", nodeFilePath.c_str(), strerror(errno));
422                                 continue;
423                             }
424
425                             bool processed = false;
426                             for(std::list<char*>::const_iterator itInode = processedFiles.begin(); itInode != processedFiles.end(); ++itInode){
427                                 if(!strcmp(*itInode, realpathBuf)){
428                                     processed = true;
429                                     break;
430                                 }
431                             }
432                             if(processed){
433                                 break;
434                             }
435
436                             processedFiles.push_back(strdup(realpathBuf));
437
438                             file = fopen(nodeFilePath.c_str(), "r");
439                             if(file == NULL){
440                                 error(tagNode->lineNum, fileName, "failed to open file '%s': %s", nodeFilePath.c_str(), strerror(errno));
441                                 continue;
442                             }
443                             //free(fileName);
444                             fileName = strdup(realpathBuf);
445                             from = nodeTree.end(); --from;
446                             
447                             if(tagNode->parentNode){
448                                 DOTCONFDocumentNode * nd = tagNode->parentNode->childNode;
449                                 while(nd){
450                                     if(!nd->nextNode)
451                                         break;
452                                     nd = nd->nextNode;
453                                 }
454
455                                 curPrev = nd;
456                             }
457                             ret = parseFile(tagNode->parentNode);
458                             
459                             //ret = parseFile(tagNode->parentNode);
460                             (void) fclose(file);
461                             if(ret == -1)
462                                 continue;
463                             if(checkConfig(++from) == -1){
464                                 continue;
465                             }
466                         }
467                     }
468                     globfree(&globBuf);
469                     vi++;
470                 }
471             }
472         }
473         /*
474         if( (ret = checkConfig(nodeTree.begin())) == -1){
475             return -1;
476         }
477         */
478
479         if(!requiredOptions.empty())
480             ret = checkRequiredOptions();
481     }
482
483     return ret;
484 }
485
486 int DOTCONFDocument::checkRequiredOptions()
487 {
488     for(std::list<char*>::const_iterator ci = requiredOptions.begin(); ci != requiredOptions.end(); ++ci){
489         bool matched = false;
490         for(std::list<DOTCONFDocumentNode*>::iterator i = nodeTree.begin(); i!=nodeTree.end(); ++i){            
491             if(!cmp_func((*i)->name, *ci)){
492                 matched = true;
493                 break;
494             }
495         }
496         if(!matched){
497             error(0, NULL, "required option '%s' not specified", *ci);
498             return -1;
499         }
500     }
501     return 0;
502 }
503
504 void DOTCONFDocument::error(int lineNum, const char * fileName, const char * fmt, ...)
505 {
506     va_list args;
507     va_start(args, fmt);
508
509     char msg[256];
510
511     vsnprintf(msg, 256, fmt, args);
512
513     size_t len = (lineNum!=0?strlen(fileName):0) + strlen(msg) + 50;
514     char * buf = (char*)mempool->alloc(len);
515
516     if(lineNum)
517         (void) snprintf(buf, len, "File '%s', line %d: %s\n", fileName, lineNum, msg);
518     else
519         (void) snprintf(buf, len, "File '%s':  %s\n", fileName, msg);
520
521     if (errorCallback) {
522         errorCallback(errorCallbackData, buf);
523     } else {
524         (void) vfprintf(stderr, buf, args);
525     }
526
527     va_end(args);
528 }
529
530 char * DOTCONFDocument::getSubstitution(char * macro, int lineNum)
531 {
532     char * buf = NULL;
533     char * variable = macro+2;
534
535     char * endBr = strchr(macro, '}');
536
537     if(!endBr){
538         error(lineNum, fileName, "unterminated '{'");
539         return NULL;
540     }
541     *endBr = 0;
542
543     char * defaultValue = strchr(variable, ':');
544
545     if(defaultValue){
546         *defaultValue++ = 0;
547         if(*defaultValue != '-'){
548             error(lineNum, fileName, "incorrect macro substitution syntax");
549             return NULL;
550         }
551         defaultValue++;
552         if(*defaultValue == '"' || *defaultValue == '\''){
553             defaultValue++;
554             defaultValue[strlen(defaultValue)-1] = 0;
555         }
556     } else {
557         defaultValue = NULL;
558     }
559
560     char * subs = getenv(variable);
561     if( subs ){
562         buf = mempool->strdup(subs);
563     } else {
564         std::list<DOTCONFDocumentNode*>::iterator i = nodeTree.begin();
565         for(; i!=nodeTree.end(); ++i){            
566             DOTCONFDocumentNode * tagNode = *i;
567             if(!cmp_func(tagNode->name, variable)){
568                 if(tagNode->valuesCount != 0){
569                     buf = mempool->strdup(tagNode->values[0]);
570                     break;
571                 }
572             }
573         }
574         if( i == nodeTree.end() ){
575             if( defaultValue ){
576                 buf = mempool->strdup(defaultValue);
577             } else {
578                 error(lineNum, fileName, "substitution not found and default value not given");
579                 return NULL;
580             }
581         }
582     }
583     return buf;
584 }
585
586 int DOTCONFDocument::macroSubstitute(DOTCONFDocumentNode * tagNode, int valueIndex)
587 {
588     int ret = 0;
589     char * macro = tagNode->values[valueIndex];
590     size_t valueLen = strlen(tagNode->values[valueIndex])+1;
591     char * value = (char*)mempool->alloc(valueLen);
592     char * v = value;
593     char * subs = NULL;
594
595     while(*macro){
596         if(*macro == '$' && *(macro+1) == '{'){
597             char * m = strchr(macro, '}');
598             subs = getSubstitution(macro, tagNode->lineNum);
599             if(subs == NULL){
600                 ret = -1;
601                 break;
602             }
603             macro = m + 1;
604             *v = 0;
605             v = (char*)mempool->alloc(strlen(value)+strlen(subs)+valueLen);
606             strcpy(v, value);
607             value = strcat(v, subs);
608             v = value + strlen(value);
609             continue;
610         }
611         *v++ = *macro++;
612     }
613     *v = 0;
614
615     free(tagNode->values[valueIndex]);
616     tagNode->values[valueIndex] = strdup(value);
617     return ret;
618 }
619
620 const DOTCONFDocumentNode * DOTCONFDocument::getFirstNode() const
621 {
622     if ( !nodeTree.empty() ) {
623         return *nodeTree.begin();
624     } else {
625         return NULL;
626     }
627 }
628
629 const DOTCONFDocumentNode * DOTCONFDocument::findNode(const char * nodeName, const DOTCONFDocumentNode * parentNode, const DOTCONFDocumentNode * startNode) const
630 {
631     //printf("nodeName=%s, cont=%s, start=%s\n", nodeName, containingNode!=NULL?containingNode->name:"NULL", startNode!=NULL?startNode->name:"NULL");
632     
633     std::list<DOTCONFDocumentNode*>::const_iterator i = nodeTree.begin();
634
635     if(startNode == NULL)
636         startNode = parentNode;
637
638     if(startNode != NULL){
639         while( i != nodeTree.end() && (*i) != startNode ){
640             ++i;
641         }
642         if( i != nodeTree.end() ) ++i;
643     }
644
645     for(; i!=nodeTree.end(); ++i){
646         //if(parentNode != NULL && (*i)->parentNode != parentNode){
647         if((*i)->parentNode != parentNode){
648             continue;
649         }
650         if(!cmp_func(nodeName, (*i)->name)){
651             return *i;
652         }
653     }
654     return NULL;
655 }
656
657 void DOTCONFDocument::setRequiredOptionNames(const char ** requiredOptionNames)
658 {
659     while(*requiredOptionNames){
660         requiredOptions.push_back(strdup( *requiredOptionNames ));
661         requiredOptionNames++;
662     }
663 }
664