rubbos/app/httpd-2.0.64/modules/ssl/ssl_expr_eval.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*                      _             _
  18  *  _ __ ___   ___   __| |    ___ ___| |  mod_ssl
  19  * | '_ ` _ \ / _ \ / _` |   / __/ __| |  Apache Interface to OpenSSL
  20  * | | | | | | (_) | (_| |   \__ \__ \ |
  21  * |_| |_| |_|\___/ \__,_|___|___/___/_|
  22  *                      |_____|
  23  *  ssl_expr_eval.c
  24  *  Expression Evaluation
  25  */
  26                              /* ``Make love,
  27                                   not software!''
  28                                         -- Unknown */
  29 #include "mod_ssl.h"
  30
  31 /*  _________________________________________________________________
  32 **
  33 **  Expression Evaluation
  34 **  _________________________________________________________________
  35 */
  36
  37 static BOOL  ssl_expr_eval_comp(request_rec *, ssl_expr *);
  38 static char *ssl_expr_eval_word(request_rec *, ssl_expr *);
  39 static char *ssl_expr_eval_func_file(request_rec *, char *);
  40 static int   ssl_expr_eval_strcmplex(char *, char *);
  41
  42 BOOL ssl_expr_eval(request_rec *r, ssl_expr *node)
  43 {
  44     switch (node->node_op) {
  45         case op_True: {
  46             return TRUE;
  47         }
  48         case op_False: {
  49             return FALSE;
  50         }
  51         case op_Not: {
  52             ssl_expr *e = (ssl_expr *)node->node_arg1;
  53             return (!ssl_expr_eval(r, e));
  54         }
  55         case op_Or: {
  56             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
  57             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
  58             return (ssl_expr_eval(r, e1) || ssl_expr_eval(r, e2));
  59         }
  60         case op_And: {
  61             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
  62             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
  63             return (ssl_expr_eval(r, e1) && ssl_expr_eval(r, e2));
  64         }
  65         case op_Comp: {
  66             ssl_expr *e = (ssl_expr *)node->node_arg1;
  67             return ssl_expr_eval_comp(r, e);
  68         }
  69         default: {
  70             ssl_expr_error = "Internal evaluation error: Unknown expression node";
  71             return FALSE;
  72         }
  73     }
  74 }
  75
  76 static BOOL ssl_expr_eval_comp(request_rec *r, ssl_expr *node)
  77 {
  78     switch (node->node_op) {
  79         case op_EQ: {
  80             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
  81             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
  82             return (strcmp(ssl_expr_eval_word(r, e1), ssl_expr_eval_word(r, e2)) == 0);
  83         }
  84         case op_NE: {
  85             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
  86             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
  87             return (strcmp(ssl_expr_eval_word(r, e1), ssl_expr_eval_word(r, e2)) != 0);
  88         }
  89         case op_LT: {
  90             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
  91             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
  92             return (ssl_expr_eval_strcmplex(ssl_expr_eval_word(r, e1), ssl_expr_eval_word(r, e2)) <  0);
  93         }
  94         case op_LE: {
  95             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
  96             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
  97             return (ssl_expr_eval_strcmplex(ssl_expr_eval_word(r, e1), ssl_expr_eval_word(r, e2)) <= 0);
  98         }
  99         case op_GT: {
 100             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
 101             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
 102             return (ssl_expr_eval_strcmplex(ssl_expr_eval_word(r, e1), ssl_expr_eval_word(r, e2)) >  0);
 103         }
 104         case op_GE: {
 105             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
 106             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
 107             return (ssl_expr_eval_strcmplex(ssl_expr_eval_word(r, e1), ssl_expr_eval_word(r, e2)) >= 0);
 108         }
 109         case op_IN: {
 110             ssl_expr *e1 = (ssl_expr *)node->node_arg1;
 111             ssl_expr *e2 = (ssl_expr *)node->node_arg2;
 112             ssl_expr *e3;
 113             char *w1 = ssl_expr_eval_word(r, e1);
 114             BOOL found = FALSE;
 115             do {
 116                 e3 = (ssl_expr *)e2->node_arg1;
 117                 e2 = (ssl_expr *)e2->node_arg2;
 118                 if (strcmp(w1, ssl_expr_eval_word(r, e3)) == 0) {
 119                     found = TRUE;
 120                     break;
 121                 }
 122             } while (e2 != NULL);
 123             return found;
 124         }
 125         case op_REG: {
 126             ssl_expr *e1;
 127             ssl_expr *e2;
 128             char *word;
 129             regex_t *regex;
 130
 131             e1 = (ssl_expr *)node->node_arg1;
 132             e2 = (ssl_expr *)node->node_arg2;
 133             word = ssl_expr_eval_word(r, e1);
 134             regex = (regex_t *)(e2->node_arg1);
 135             return (ap_regexec(regex, word, 0, NULL, 0) == 0);
 136         }
 137         case op_NRE: {
 138             ssl_expr *e1;
 139             ssl_expr *e2;
 140             char *word;
 141             regex_t *regex;
 142
 143             e1 = (ssl_expr *)node->node_arg1;
 144             e2 = (ssl_expr *)node->node_arg2;
 145             word = ssl_expr_eval_word(r, e1);
 146             regex = (regex_t *)(e2->node_arg1);
 147             return !(ap_regexec(regex, word, 0, NULL, 0) == 0);
 148         }
 149         default: {
 150             ssl_expr_error = "Internal evaluation error: Unknown expression node";
 151             return FALSE;
 152         }
 153     }
 154 }
 155
 156 static char *ssl_expr_eval_word(request_rec *r, ssl_expr *node)
 157 {
 158     switch (node->node_op) {
 159         case op_Digit: {
 160             char *string = (char *)node->node_arg1;
 161             return string;
 162         }
 163         case op_String: {
 164             char *string = (char *)node->node_arg1;
 165             return string;
 166         }
 167         case op_Var: {
 168             char *var = (char *)node->node_arg1;
 169             char *val = ssl_var_lookup(r->pool, r->server, r->connection, r, var);
 170             return (val == NULL ? "" : val);
 171         }
 172         case op_Func: {
 173             char *name = (char *)node->node_arg1;
 174             ssl_expr *args = (ssl_expr *)node->node_arg2;
 175             if (strEQ(name, "file"))
 176                 return ssl_expr_eval_func_file(r, (char *)(args->node_arg1));
 177             else {
 178                 ssl_expr_error = "Internal evaluation error: Unknown function name";
 179                 return "";
 180             }
 181         }
 182         default: {
 183             ssl_expr_error = "Internal evaluation error: Unknown expression node";
 184             return FALSE;
 185         }
 186     }
 187 }
 188
 189 static char *ssl_expr_eval_func_file(request_rec *r, char *filename)
 190 {
 191     apr_file_t *fp;
 192     char *buf;
 193     apr_off_t offset;
 194     apr_size_t len;
 195     apr_finfo_t finfo;
 196
 197     if (apr_file_open(&fp, filename, APR_READ|APR_BUFFERED,
 198                       APR_OS_DEFAULT, r->pool) != APR_SUCCESS) {
 199         ssl_expr_error = "Cannot open file";
 200         return "";
 201     }
 202     apr_file_info_get(&finfo, APR_FINFO_SIZE, fp);
 203     if ((finfo.size + 1) != ((apr_size_t)finfo.size + 1)) {
 204         ssl_expr_error = "Huge file cannot be read";
 205         apr_file_close(fp);
 206         return "";
 207     }
 208     len = (apr_size_t)finfo.size;
 209     if (len == 0) {
 210         buf = (char *)apr_palloc(r->pool, sizeof(char) * 1);
 211         *buf = NUL;
 212     }
 213     else {
 214         if ((buf = (char *)apr_palloc(r->pool, sizeof(char)*(len+1))) == NULL) {
 215             ssl_expr_error = "Cannot allocate memory";
 216             apr_file_close(fp);
 217             return "";
 218         }
 219         offset = 0;
 220         apr_file_seek(fp, APR_SET, &offset);
 221         if (apr_file_read(fp, buf, &len) != APR_SUCCESS) {
 222             ssl_expr_error = "Cannot read from file";
 223             apr_file_close(fp);
 224             return "";
 225         }
 226         buf[len] = NUL;
 227     }
 228     apr_file_close(fp);
 229     return buf;
 230 }
 231
 232 /* a variant of strcmp(3) which works correctly also for number strings */
 233 static int ssl_expr_eval_strcmplex(char *cpNum1, char *cpNum2)
 234 {
 235     int i, n1, n2;
 236
 237     if (cpNum1 == NULL)
 238         return -1;
 239     if (cpNum2 == NULL)
 240         return +1;
 241     n1 = strlen(cpNum1);
 242     n2 = strlen(cpNum2);
 243     if (n1 > n2)
 244         return 1;
 245     if (n1 < n2)
 246         return -1;
 247     for (i = 0; i < n1; i++) {
 248         if (cpNum1[i] > cpNum2[i])
 249             return 1;
 250         if (cpNum1[i] < cpNum2[i])
 251             return -1;
 252     }
 253     return 0;
 254 }