dmq_usrloc: init vars earlier to avoid invalid value cleanup on error handling
[sip-router] / modules / permissions / rule.c
1 /*
2  * PERMISSIONS module
3  *
4  * Copyright (C) 2003 Miklós Tirpák (mtirpak@sztaki.hu)
5  *
6  * This file is part of Kamailio, a free SIP server.
7  *
8  * Kamailio is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * Kamailio is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <sys/types.h>
27 #include <regex.h>
28 #include "../../mem/mem.h"
29 #include "../../sr_module.h"
30 #include "../../mem/mem.h"
31 #include "rule.h"
32
33
34 /*
35  * allocate memory for a new rule
36  */
37 rule *new_rule(void)
38 {
39         rule    *r;
40
41         r = (rule *)pkg_malloc(sizeof(rule));
42         if (!r) {
43                 LM_ERR("not enough pkg memory\n");
44                 return 0;
45         }
46
47         memset(r, 0, sizeof(rule));
48         return r;
49 }
50
51
52 /*
53  * free memory allocated by a rule
54  */
55 void free_rule(rule *r)
56 {
57         if (!r) return;
58
59         if (r->left) free_expression(r->left);
60         if (r->left_exceptions) free_expression(r->left_exceptions);
61         if (r->right) free_expression(r->right);
62         if (r->right_exceptions) free_expression(r->right_exceptions);
63
64         if (r->next) free_rule(r->next);
65         pkg_free(r);
66 }
67
68
69 /*
70  * list rules
71  */
72 void print_rule(rule *r)
73 {
74         if (!r) return;
75
76         printf("\nNEW RULE:\n");
77         printf("\n\tLEFT: ");
78         if (r->left) print_expression(r->left);  else printf("ALL");
79         if (r->left_exceptions) {
80                 printf("\n\tLEFT EXCEPTIONS: ");
81                 print_expression(r->left_exceptions);
82         }
83         printf("\n\tRIGHT: ");
84         if (r->right) print_expression(r->right);  else printf("ALL");
85         if (r->right_exceptions) {
86                 printf("\n\tRIGHT EXCEPTIONS: ");
87                 print_expression(r->right_exceptions);
88         }
89         printf("\n");
90         if (r->next) print_rule(r->next);
91 }
92
93
94 /*
95  * look for a proper rule matching with left:right
96  */
97 int search_rule(rule *r, char *left, char *right)
98 {
99         rule    *r1;
100
101         r1 = r;
102         while (r1) {
103                 if (( (!r1->left) || (search_expression(r1->left, left)) )
104                 && (!search_expression(r1->left_exceptions, left))
105                 && ( (!r1->right) || (search_expression(r1->right, right)) )
106                 && (!search_expression(r1->right_exceptions, right))) return 1;
107
108                 r1 = r1->next;
109         }
110
111         return 0;
112 }
113
114
115 /*
116  * allocate memory for a new expression
117  * str is saved in vale, and compiled to POSIX regexp (reg_value)
118  */
119 expression *new_expression(char *str)
120 {
121         expression      *e;
122
123         if (!str) return 0;
124
125         e = (expression *)pkg_malloc(sizeof(expression));
126         if (!e) {
127                 LM_ERR("not enough pkg memory\n");
128                 return 0;
129         }
130
131         strcpy(e->value, str);
132
133         e->reg_value = (regex_t*)pkg_malloc(sizeof(regex_t));
134         if (!e->reg_value) {
135                 LM_ERR("not enough pkg memory\n");
136                 pkg_free(e);
137                 return 0;
138         }
139
140         if (regcomp(e->reg_value, str, REG_EXTENDED|REG_NOSUB|REG_ICASE) ) {
141                 LM_ERR("bad regular expression: %s\n", str);
142                 pkg_free(e->reg_value);
143                 pkg_free(e);
144                 return NULL;
145         }
146
147         e->next = 0;
148         return e;
149 }
150
151
152 /*
153  * free memory allocated by an expression
154  */
155 void free_expression(expression *e)
156 {
157         if (!e) return;
158
159         if (e->next) free_expression(e->next);
160         regfree(e->reg_value);
161         pkg_free(e);
162 }
163
164
165 /*
166  * list expressions
167  */
168 void print_expression(expression *e)
169 {
170         if (!e) return;
171
172         printf("%s, ", e->value);
173         if (e->next) print_expression(e->next);
174 }
175
176
177 /*
178  * look for matching expression
179  */
180 int search_expression(expression *e, char *value)
181 {
182         expression      *e1;
183
184         e1 = e;
185         while (e1) {
186                 if (regexec(e1->reg_value, value, 0, 0, 0) == 0)        return 1;
187                 e1 = e1->next;
188         }
189         return 0;
190 }