Line data    Source code

       1             : #include "burp.h"
       2             : #include "alloc.h"
       3             : #include "log.h"
       4             : #include "pathcmp.h"
       5             : #include "regexp.h"
       6             : #include "strlist.h"
       7             : 
       8             : // Maybe rename this stuff to 'struct pathlist'.
       9             : 
      10         520 : static void strlist_free(struct strlist *strlist)
      11             : {
      12        1040 :         if(!strlist) return;
      13         520 :         regex_free(&strlist->re);
      14         520 :         free_w(&strlist->path);
      15         520 :         free_v((void **)&strlist);
      16             : }
      17             : 
      18        8681 : void strlists_free(struct strlist **strlist)
      19             : {
      20             :         struct strlist *s;
      21             :         struct strlist *shead;
      22       17362 :         if(!strlist) return;
      23        8669 :         shead=*strlist;
      24       17857 :         while(shead)
      25             :         {
      26         519 :                 s=shead;
      27         519 :                 shead=shead->next;
      28         519 :                 strlist_free(s);
      29             :         }
      30        8669 :         *strlist=NULL;
      31             : }
      32             : 
      33         520 : static struct strlist *strlist_alloc(const char *path, long flag)
      34             : {
      35         520 :         struct strlist *slnew=NULL;
      36         520 :         if(!path)
      37             :         {
      38           0 :                 logp("%s called with NULL path!\n", __func__);
      39           0 :                 return NULL;
      40             :         }
      41         520 :         if(!(slnew=(struct strlist *)
      42             :                 calloc_w(1, sizeof(struct strlist), __func__))
      43         520 :           || !(slnew->path=strdup_w(path, __func__)))
      44             :                 return NULL;
      45         520 :         slnew->flag=flag;
      46         520 :         return slnew;
      47             : }
      48             : 
      49         520 : static int do_strlist_add(struct strlist **strlist,
      50             :         const char *path, long flag, int sorted, int uniq)
      51             : {
      52         520 :         struct strlist *s=NULL;
      53         520 :         struct strlist *slast=NULL;
      54         520 :         struct strlist *slnew=NULL;
      55             : 
      56         520 :         if(!(slnew=strlist_alloc(path, flag))) return -1;
      57             : 
      58             :         // Insert into a sorted position in the list, or if the sorted flag
      59             :         // was zero, add to the end of the list.
      60             :         // FIX THIS: Unsorted means that it goes through the whole list to
      61             :         // find the last entry. Can this be made better?
      62         912 :         for(s=*strlist; s; s=s->next)
      63             :         {
      64         408 :                 if(uniq && !pathcmp(path, s->path))
      65             :                 {
      66           1 :                         strlist_free(slnew);
      67           1 :                         return 0;
      68             :                 }
      69         407 :                 if(sorted && pathcmp(path, s->path)<0) break;
      70         392 :                 slast=s;
      71             :         }
      72         519 :         if(slast)
      73             :         {
      74         227 :                 slnew->next=slast->next;
      75         227 :                 slast->next=slnew;
      76             :         }
      77             :         else
      78             :         {
      79         292 :                 *strlist=slnew;
      80         292 :                 slnew->next=s;
      81             :         }
      82             : 
      83             :         return 0;
      84             : }
      85             : 
      86         379 : int strlist_add(struct strlist **strlist,
      87             :         const char *path, long flag)
      88             : {
      89         379 :         return do_strlist_add(strlist, path, flag, 0 /* unsorted */, 0 /* not uniq */);
      90             : }
      91             : 
      92         138 : int strlist_add_sorted(struct strlist **strlist,
      93             :         const char *path, long flag)
      94             : {
      95         138 :         return do_strlist_add(strlist, path, flag, 1 /* sorted */, 0 /* not uniq */);
      96             : }
      97             : 
      98           3 : int strlist_add_sorted_uniq(struct strlist **strlist,
      99             :         const char *path, long flag)
     100             : {
     101           3 :         return do_strlist_add(strlist, path, flag, 1 /* sorted */, 1 /* uniq */);
     102             : }
     103             : 
     104         228 : int strlist_compile_regexes(struct strlist *strlist)
     105             : {
     106             :         struct strlist *l;
     107             :         // FIX THIS: when the regex does not compile, should remove the
     108             :         // strlist entry completely.
     109         230 :         for(l=strlist; l; l=l->next)
     110           2 :                 if(!(l->re=regex_compile(l->path)))
     111           0 :                         logp("unable to compile regex: %s\n", l->path);
     112         228 :         return 0;
     113             : }
     114             : 
     115           6 : int strlist_find(struct strlist *strlist, const char *path, long flag)
     116             : {
     117             :         struct strlist *s;
     118          12 :         for(s=strlist; s; s=s->next)
     119           6 :                 if(!strcmp(path, s->path) && flag==s->flag)
     120             :                         return 1;
     121             :         return 0;
     122             : }