heimdal: update to lorikeet-heimdal rev 801
[sfrench/samba-autobuild/.git] / source4 / heimdal / lib / hx509 / sel.c
1 /*
2  * Copyright (c) 2008 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden). 
4  * All rights reserved. 
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met: 
9  *
10  * 1. Redistributions of source code must retain the above copyright 
11  *    notice, this list of conditions and the following disclaimer. 
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright 
14  *    notice, this list of conditions and the following disclaimer in the 
15  *    documentation and/or other materials provided with the distribution. 
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors 
18  *    may be used to endorse or promote products derived from this software 
19  *    without specific prior written permission. 
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
31  * SUCH DAMAGE. 
32  */
33
34 #include "hx_locl.h"
35
36 struct hx_expr *
37 _hx509_make_expr(enum hx_expr_op op, void *arg1, void *arg2)
38 {
39     struct hx_expr *expr;
40
41     expr = malloc(sizeof(*expr));
42     if (expr == NULL)
43         return NULL;
44     expr->op = op;
45     expr->arg1 = arg1;
46     expr->arg2 = arg2;
47
48     return expr;
49 }
50
51 static const char *
52 eval_word(hx509_context context, hx509_env env, struct hx_expr *word)
53 {
54     switch (word->op) {
55     case expr_STRING:
56         return word->arg1;
57     case expr_VAR:
58         if (word->arg2 == NULL)
59             return hx509_env_find(context, env, word->arg1);
60
61         env = hx509_env_find_binding(context, env, word->arg1);
62         if (env == NULL)
63             return NULL;
64
65         return eval_word(context, env, word->arg2);
66     default:
67         return NULL;
68     }
69 }
70
71 static hx509_env
72 find_variable(hx509_context context, hx509_env env, struct hx_expr *word)
73 {
74     assert(word->op == expr_VAR);
75
76     if (word->arg2 == NULL)
77         return hx509_env_find_binding(context, env, word->arg1);
78     
79     env = hx509_env_find_binding(context, env, word->arg1);
80     if (env == NULL)
81         return NULL;
82     return find_variable(context, env, word->arg2);
83 }
84
85 static int
86 eval_comp(hx509_context context, hx509_env env, struct hx_expr *expr)
87 {
88     switch (expr->op) {
89     case comp_NE:
90     case comp_EQ:
91     case comp_TAILEQ: {
92         const char *s1, *s2;
93         int ret;
94
95         s1 = eval_word(context, env, expr->arg1);
96         s2 = eval_word(context, env, expr->arg2);
97
98         if (s1 == NULL || s2 == NULL)
99             return FALSE;
100
101         if (expr->op == comp_TAILEQ) {
102             size_t len1 = strlen(s1);
103             size_t len2 = strlen(s2);
104             
105             if (len1 < len2)
106                 return 0;
107             ret = strcmp(s1 + (len1 - len2), s2) == 0;
108         } else {
109             ret = strcmp(s1, s2) == 0;
110             if (expr->op == comp_NE)
111                 ret = !ret;
112         }
113         return ret;
114     }
115     case comp_IN: {
116         struct hx_expr *subexpr;
117         const char *w, *s1;
118
119         w = eval_word(context, env, expr->arg1);
120
121         subexpr = expr->arg2;
122
123         if (subexpr->op == expr_WORDS) {
124             while (subexpr) {
125                 s1 = eval_word(context, env, subexpr->arg1);
126                 if (strcmp(w, s1) == 0)
127                     return TRUE;
128                 subexpr = subexpr->arg2;
129             }
130         } else if (subexpr->op == expr_VAR) {
131             hx509_env subenv;
132
133             subenv = find_variable(context, env, subexpr);
134             if (subenv == NULL)
135                 return FALSE;
136             
137             while (subenv) {
138                 if (subenv->type != env_string)
139                     continue;
140                 if (strcmp(w, subenv->name) == 0)
141                     return TRUE;
142                 if (strcmp(w, subenv->u.string) == 0)
143                     return TRUE;
144                 subenv = subenv->next;
145             }
146
147         } else
148             _hx509_abort("hx509 eval IN unknown op: %d", (int)subexpr->op);
149
150         return FALSE;
151     }
152     default:
153         _hx509_abort("hx509 eval expr with unknown op: %d", (int)expr->op);
154     }
155     return FALSE;
156 }
157
158 int
159 _hx509_expr_eval(hx509_context context, hx509_env env, struct hx_expr *expr)
160 {
161     switch (expr->op) {
162     case op_TRUE:
163         return 1;
164     case op_FALSE:
165         return 0;
166     case op_NOT:
167         return ! _hx509_expr_eval(context, env, expr->arg1);
168     case op_AND:
169         return _hx509_expr_eval(context, env, expr->arg1) && 
170             _hx509_expr_eval(context, env, expr->arg2);
171     case op_OR:
172         return _hx509_expr_eval(context, env, expr->arg1) ||
173             _hx509_expr_eval(context, env, expr->arg2);
174     case op_COMP:
175         return eval_comp(context, env, expr->arg1);
176     default:
177         _hx509_abort("hx509 eval expr with unknown op: %d", (int)expr->op);
178     }
179 }
180
181 void
182 _hx509_expr_free(struct hx_expr *expr)
183 {
184     switch (expr->op) {
185     case expr_STRING:
186     case expr_NUMBER:
187         free(expr->arg1);
188         break;
189     case expr_WORDS:
190     case expr_FUNCTION:
191     case expr_VAR:
192         free(expr->arg1);
193         if (expr->arg2)
194             _hx509_expr_free(expr->arg2);
195         break;
196     default:
197         if (expr->arg1)
198             _hx509_expr_free(expr->arg1);
199         if (expr->arg2)
200             _hx509_expr_free(expr->arg2);
201         break;
202     }
203     free(expr);
204 }
205
206 struct hx_expr *
207 _hx509_expr_parse(const char *buf)
208 {
209     _hx509_expr_input.buf = buf;
210     _hx509_expr_input.length = strlen(buf);
211     _hx509_expr_input.offset = 0;
212     _hx509_expr_input.expr = NULL;
213
214     if (_hx509_expr_input.error) {
215         free(_hx509_expr_input.error);
216         _hx509_expr_input.error = NULL;
217     }
218
219     yyparse();
220
221     return _hx509_expr_input.expr;
222 }
223
224 void
225 _hx509_sel_yyerror (char *s)
226 {
227      if (_hx509_expr_input.error)
228          free(_hx509_expr_input.error);
229      
230      _hx509_expr_input.error = strdup(s);
231 }
232