← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source4/heimdal/lib/hx509/sel.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
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