rubbos/app/httpd-2.0.64/modules/aaa/mod_access.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  * Security options etc.
  19  *
  20  * Module derived from code originally written by Rob McCool
  21  *
  22  */
  23
  24 #include "apr_strings.h"
  25 #include "apr_network_io.h"
  26 #include "apr_lib.h"
  27
  28 #define APR_WANT_STRFUNC
  29 #define APR_WANT_BYTEFUNC
  30 #include "apr_want.h"
  31
  32 #include "ap_config.h"
  33 #include "httpd.h"
  34 #include "http_core.h"
  35 #include "http_config.h"
  36 #include "http_log.h"
  37 #include "http_request.h"
  38
  39 #if APR_HAVE_NETINET_IN_H
  40 #include <netinet/in.h>
  41 #endif
  42
  43 enum allowdeny_type {
  44     T_ENV,
  45     T_ALL,
  46     T_IP,
  47     T_HOST,
  48     T_FAIL
  49 };
  50
  51 typedef struct {
  52     apr_int64_t limited;
  53     union {
  54         char *from;
  55         apr_ipsubnet_t *ip;
  56     } x;
  57     enum allowdeny_type type;
  58 } allowdeny;
  59
  60 /* things in the 'order' array */
  61 #define DENY_THEN_ALLOW 0
  62 #define ALLOW_THEN_DENY 1
  63 #define MUTUAL_FAILURE 2
  64
  65 typedef struct {
  66     int order[METHODS];
  67     apr_array_header_t *allows;
  68     apr_array_header_t *denys;
  69 } access_dir_conf;
  70
  71 module AP_MODULE_DECLARE_DATA access_module;
  72
  73 static void *create_access_dir_config(apr_pool_t *p, char *dummy)
  74 {
  75     int i;
  76     access_dir_conf *conf =
  77         (access_dir_conf *)apr_pcalloc(p, sizeof(access_dir_conf));
  78
  79     for (i = 0; i < METHODS; ++i) {
  80         conf->order[i] = DENY_THEN_ALLOW;
  81     }
  82     conf->allows = apr_array_make(p, 1, sizeof(allowdeny));
  83     conf->denys = apr_array_make(p, 1, sizeof(allowdeny));
  84
  85     return (void *)conf;
  86 }
  87
  88 static const char *order(cmd_parms *cmd, void *dv, const char *arg)
  89 {
  90     access_dir_conf *d = (access_dir_conf *) dv;
  91     int i, o;
  92
  93     if (!strcasecmp(arg, "allow,deny"))
  94         o = ALLOW_THEN_DENY;
  95     else if (!strcasecmp(arg, "deny,allow"))
  96         o = DENY_THEN_ALLOW;
  97     else if (!strcasecmp(arg, "mutual-failure"))
  98         o = MUTUAL_FAILURE;
  99     else
 100         return "unknown order";
 101
 102     for (i = 0; i < METHODS; ++i)
 103         if (cmd->limited & (AP_METHOD_BIT << i))
 104             d->order[i] = o;
 105
 106     return NULL;
 107 }
 108
 109 static const char *allow_cmd(cmd_parms *cmd, void *dv, const char *from,
 110                              const char *where_c)
 111 {
 112     access_dir_conf *d = (access_dir_conf *) dv;
 113     allowdeny *a;
 114     char *where = apr_pstrdup(cmd->pool, where_c);
 115     char *s;
 116     char msgbuf[120];
 117     apr_status_t rv;
 118
 119     if (strcasecmp(from, "from"))
 120         return "allow and deny must be followed by 'from'";
 121
 122     a = (allowdeny *) apr_array_push(cmd->info ? d->allows : d->denys);
 123     a->x.from = where;
 124     a->limited = cmd->limited;
 125
 126     if (!strncasecmp(where, "env=", 4)) {
 127         a->type = T_ENV;
 128         a->x.from += 4;
 129
 130     }
 131     else if (!strcasecmp(where, "all")) {
 132         a->type = T_ALL;
 133     }
 134     else if ((s = strchr(where, '/'))) {
 135         *s++ = '\0';
 136         rv = apr_ipsubnet_create(&a->x.ip, where, s, cmd->pool);
 137         if(APR_STATUS_IS_EINVAL(rv)) {
 138             /* looked nothing like an IP address */
 139             return "An IP address was expected";
 140         }
 141         else if (rv != APR_SUCCESS) {
 142             apr_strerror(rv, msgbuf, sizeof msgbuf);
 143             return apr_pstrdup(cmd->pool, msgbuf);
 144         }
 145         a->type = T_IP;
 146     }
 147     else if (!APR_STATUS_IS_EINVAL(rv = apr_ipsubnet_create(&a->x.ip, where, NULL, cmd->pool))) {
 148         if (rv != APR_SUCCESS) {
 149             apr_strerror(rv, msgbuf, sizeof msgbuf);
 150             return apr_pstrdup(cmd->pool, msgbuf);
 151         }
 152         a->type = T_IP;
 153     }
 154     else { /* no slash, didn't look like an IP address => must be a host */
 155         a->type = T_HOST;
 156     }
 157
 158     return NULL;
 159 }
 160
 161 static char its_an_allow;
 162
 163 static const command_rec access_cmds[] =
 164 {
 165     AP_INIT_TAKE1("order", order, NULL, OR_LIMIT,
 166                   "'allow,deny', 'deny,allow', or 'mutual-failure'"),
 167     AP_INIT_ITERATE2("allow", allow_cmd, &its_an_allow, OR_LIMIT,
 168                      "'from' followed by hostnames or IP-address wildcards"),
 169     AP_INIT_ITERATE2("deny", allow_cmd, NULL, OR_LIMIT,
 170                      "'from' followed by hostnames or IP-address wildcards"),
 171     {NULL}
 172 };
 173
 174 static int in_domain(const char *domain, const char *what)
 175 {
 176     int dl = strlen(domain);
 177     int wl = strlen(what);
 178
 179     if ((wl - dl) >= 0) {
 180         if (strcasecmp(domain, &what[wl - dl]) != 0)
 181             return 0;
 182
 183         /* Make sure we matched an *entire* subdomain --- if the user
 184          * said 'allow from good.com', we don't want people from nogood.com
 185          * to be able to get in.
 186          */
 187
 188         if (wl == dl)
 189             return 1;           /* matched whole thing */
 190         else
 191             return (domain[0] == '.' || what[wl - dl - 1] == '.');
 192     }
 193     else
 194         return 0;
 195 }
 196
 197 static int find_allowdeny(request_rec *r, apr_array_header_t *a, int method)
 198 {
 199
 200     allowdeny *ap = (allowdeny *) a->elts;
 201     apr_int64_t mmask = (AP_METHOD_BIT << method);
 202     int i;
 203     int gothost = 0;
 204     const char *remotehost = NULL;
 205
 206     for (i = 0; i < a->nelts; ++i) {
 207         if (!(mmask & ap[i].limited))
 208             continue;
 209
 210         switch (ap[i].type) {
 211         case T_ENV:
 212             if (apr_table_get(r->subprocess_env, ap[i].x.from)) {
 213                 return 1;
 214             }
 215             break;
 216
 217         case T_ALL:
 218             return 1;
 219
 220         case T_IP:
 221             if (apr_ipsubnet_test(ap[i].x.ip, r->connection->remote_addr)) {
 222                 return 1;
 223             }
 224             break;
 225
 226         case T_HOST:
 227             if (!gothost) {
 228                 int remotehost_is_ip;
 229
 230                 remotehost = ap_get_remote_host(r->connection, r->per_dir_config,
 231                                                 REMOTE_DOUBLE_REV, &remotehost_is_ip);
 232
 233                 if ((remotehost == NULL) || remotehost_is_ip)
 234                     gothost = 1;
 235                 else
 236                     gothost = 2;
 237             }
 238
 239             if ((gothost == 2) && in_domain(ap[i].x.from, remotehost))
 240                 return 1;
 241             break;
 242
 243         case T_FAIL:
 244             /* do nothing? */
 245             break;
 246         }
 247     }
 248
 249     return 0;
 250 }
 251
 252 static int check_dir_access(request_rec *r)
 253 {
 254     int method = r->method_number;
 255     int ret = OK;
 256     access_dir_conf *a = (access_dir_conf *)
 257         ap_get_module_config(r->per_dir_config, &access_module);
 258
 259     if (a->order[method] == ALLOW_THEN_DENY) {
 260         ret = HTTP_FORBIDDEN;
 261         if (find_allowdeny(r, a->allows, method))
 262             ret = OK;
 263         if (find_allowdeny(r, a->denys, method))
 264             ret = HTTP_FORBIDDEN;
 265     }
 266     else if (a->order[method] == DENY_THEN_ALLOW) {
 267         if (find_allowdeny(r, a->denys, method))
 268             ret = HTTP_FORBIDDEN;
 269         if (find_allowdeny(r, a->allows, method))
 270             ret = OK;
 271     }
 272     else {
 273         if (find_allowdeny(r, a->allows, method)
 274             && !find_allowdeny(r, a->denys, method))
 275             ret = OK;
 276         else
 277             ret = HTTP_FORBIDDEN;
 278     }
 279
 280     if (ret == HTTP_FORBIDDEN
 281         && (ap_satisfies(r) != SATISFY_ANY || !ap_some_auth_required(r))) {
 282         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 283             "client denied by server configuration: %s",
 284             r->filename);
 285     }
 286
 287     return ret;
 288 }
 289
 290 static void register_hooks(apr_pool_t *p)
 291 {
 292     ap_hook_access_checker(check_dir_access,NULL,NULL,APR_HOOK_MIDDLE);
 293 }
 294
 295 module AP_MODULE_DECLARE_DATA access_module =
 296 {
 297     STANDARD20_MODULE_STUFF,
 298     create_access_dir_config,   /* dir config creater */
 299     NULL,                       /* dir merger --- default is to override */
 300     NULL,                       /* server config */
 301     NULL,                       /* merge server config */
 302     access_cmds,
 303     register_hooks              /* register hooks */
 304 };