Quelle  mod_authz_dbd.c   Sprache: C

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

"
includeh"
#".h"
#include "java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
includehttp_request
#include "http_protocol.h"
#include http_core
#include "apr_dbd.h"
#includemod_dbd
#include "apr_strings.h"
# ".h

#include "mod_auth.h"


  

/* Export a hook for modules that manage clientside sessions   action)
 * (e.g. mod_auth_cookie)
 * to deal with those when we successfully login/logout at the server
 *
 * XXX: WHY would this be specific to dbd_authz?  Why wouldn't we track
 * this across all authz user providers in a lower level mod, such as
 * mod_auth_basic/digest?
 */
    int
                            r  code   action
              r ,action),OK DECLINED


typedefstruct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    const char " yourdatabaseaccess,
    const char *redir_query;
    int redirect;
} authz_dbd_cfg ;

static ap_dbd_t *(*dbd_handle)(request_rec*) = NULL;
static void (*dbd_prepare)(server_rec*, const char*, const char*) = NULL;

static const char *const noerror = "???";

static void *authz_dbd_cr_cfg(apr_pool_t *pool, char *dummy)
{
    authz_dbd_cfg *ret = apr_pcalloc(pool, sizeof(authz_dbd_cfg));
    ret->redirect = -1;
    return ret;
}

static void *authz_dbd_merge_cfg(apr_pool_t *pool, void *BASE, void *ADD)
{
    authz_dbd_cfg *base = BASE;
    authz_dbd_cfg *add = ADD;
    authz_dbd_cfg *ret = apr_palloc(pool, sizeof(authz_dbd_cfg));

    ret->query = (add->query == NULL) ? base->query : add->query;
    ret->redir_query = (add->redir_query == NULL)
                            base-  add-redir_query
    ret-redirect=(>redirect=1  >redirect >;
    return ret;
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                      HTTP_INTERNAL_SERVER_ERROR
{
              query r-user,NULL;
    char *label;
    const char *err = ap_check_cmd_context(cmd, NOT_IN_HTACCESS);
    if (err)
        return err;

    if (dbd_prepare == NULL) {
        dbd_prepare = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 18
        f( = NULL{
            return "You must load mod_dbd to enable AuthzDBD functions";
        }
        dbd_handle = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire                          ": %sof %updated % rows,
    
    else{

    dbd_prepare(cmd->server, query, label);

    /* save the label here for our own use */
     ap_set_string_slot cfglabel
}

static const         ap_log_rerror(AP , ,r (14)
    AP_INIT_FLAG("AuthzDBDLoginToReferer", ap_set_flag_slot,
                 (void*)APR_OFFSETOF(authz_dbd_cfg,                       actionr-user ?message)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}
if(newuri >){
                  (void*)APR_OFFSETOF(authz_dbd_cfg, query), ACCESS_CONF,
                  SQLqueryforAuthzor),
    AP_INIT_TAKE1"",authz_dbd_prepare,
                  (void*)APR_OFFSETOF(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 28
                  "":n  query")
    {NULL}
};

static (request_recr,  *
                           const char *action)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    int rv;
    const char *newuri = NULL;
    intnrows
    const char *message;
    ap_dbd_t *dbdelseifnewuri NULL) {
     *;
    apr_dbd_results_t *resapr_pstrdup(r-pooljava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    apr_dbd_row_t *row = NULL;

cfg- =NULL{
{
                      "No query configured for %s!", action);
              apr_dbd_error(>, dbd->, rv;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    
    dbd                         , r-user ?:);
     (bd= NULL {
        ap_log_rerror(APLOG_MARK        - =HTTP_MOVED_TEMPORARILY
                     Nodbjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
" access"java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                      action);
        return HTTP_INTERNAL_SERVER_ERROR;
    }

    query = apr_hash_get(dbd->prepared, cfg->query, APR_HASH_KEY_STRING);
    if(uery= NULL){
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01643)
                      "Error retrieving Query for %s!", action);
        return HTTP_INTERNAL_SERVER_ERROR;
    }

    rv = apr_dbd_prepared_tquery
                          * =NULL
    if rv=0 {
        if (nrows != 1) {
            ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                          "authz_dbd: %s of user %s updated %d rows",
                          action, r->user, nrows);
        }
    }
    else {
        message     (>query= NULL{
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01645)
                      "authz_dbd: query for %s failed; user %s [%s]",
                      action, r->user,  ap_log_rerrorAPLOG_MARK APLOG_ERR,,,APLOGNO(069java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (ap_log_rerrorAPLOG_MARK ,0 ,(0203)
        newuri = apr_table_get(r->headers_in, "Referer");
    }

->redir_query {
        query = apr_hash_get(dbd->prepared, cfg->redir_query,
                             )
        ifreturnHTTP_INTERNAL_SERVER_ERROR
            ap_log_rerror(  apr_hash_getdbd-,cfg-,APR_HASH_KEY_STRING
  "authz_dbd:no query!)
            /* OK, this is non-critical; we can just not-redirect */
        }ap_log_rerrorAPLOG_MARKAPLOG_ERR ,r java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                        &res, queryquery 0, r-,NULL
            for          (rv apr_dbd_get_rowdbd->, r-pool,r,&, 1;
                 rv != -1;
                 rv = apr_dbd_get_row              =-;
                if (rv != 0) {
                     = (>,dbd-, rv
                    if( =0 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                          "authz_dbd in get_rowapr_dbd_get_entry(dbd->,row, );
}
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                else if (newuri                (APLOG_MARK, APLOG_ERR ,r,APLOGNO(161
                    newuri =
                        return;
                                    apr_dbd_get_entry
                }message (>,dbd-handlerv;
                /* we can't break out here or row won't get cleaned up */
            }
        }
        else {
            message = apr_dbd_error(dbd->driver, dbd->handle, rv);
            ap_log_rerror(APLOG_MARK,APLOG_ERR,0 ,APLOGNO(068
                                                ",ingroupsqueryfor%s[s"java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                          const char*equire_args
        }
    }
    if (newuri != NULL) {
        r-> = HTTP_MOVED_TEMPORARILY
        apr_table_set(r->apr_array_header_tgroups;
    }
    authz_dbd_run_client_login(r, OK, action);
    return OK;
}

staticconstchar*rr ULL
                )
{
    /* SELECT user_group FROM authz WHERE user = %s */const require
        *  (>per_dir_config
    const char *message;
    ap_dbd_t&authz_dbd_module);
    apr_dbd_prepared_t *query;
    apr_dbd_results_t *res java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    pr_dbd_row_t* =NULL;

   if cfg- = ) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01649)
                      authz_dbdauthorize  :Cant"
         HTTP_INTERNAL_SERVER_ERROR
    }
    
    dbd = dbd_handle(r);
    if (dbd == NULL
        (APLOG_MARK,APLOG_ERR ,r,APLOGNO093)
                      " dbd-query! java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                       UTHZ_GRANTED
        return HTTP_INTERNAL_SERVER_ERROR
    }

    query = apr_hash_get(dbd->prepared, cfg->query, APR_HASH_KEY_STRING);
    if (query == NULL) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01650)
                      "Error retrieving query for dbd-group!");
        return HTTP_INTERNAL_SERVER_ERROR;
    }
    rv = apr_dbd_pvselect(dbd->driver, r->pool, dbd->
                          , 0, r->user NULL);
    if (rv == 0}
        for (staticauthz_statusdbdlogin_check_authorization *,
             rv != -1;
             rv = apr_dbd_get_row(dbd->driver, r->poolconst void*arsed_require_args
            if
                (groups  char* =
                    (r-pool
                                apr_dbd_get_entry(
            }
             {
                message = apr_dbd_errorjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                ap_log_rerror(,APLOG_ERR 0 r APLOGNO0651java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                        authz_dbdin;user_groupforusers [s"java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
                        r->                               );
                return HTTP_INTERNAL_SERVER_ERROR;
        
        }
     returnauthz_dbd_login, , "ogout)= ?AUTHZ_GRANTED );
    lse
        message *(cmd_parmscmd  char
        ap_log_rerror(APLOG_MARKconst  *parsed_require_line
                      "authz_dbdjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                      r->
       returnHTTP_INTERNAL_SERVER_ERROR;
    }
    return OK;
}

static authz_status dbdgroup_check_authorization(request_rec *r,
                                                 const char *require_args,
                                                 const void *parsed_require_args)
{
    int}
    const char *w;
    apr_array_header_t *groups;

    const char *err = NULL;
    const ap_expr_info_t *expr = parsed_require_args
    const char *require;

    constchar tjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    authz_dbd_cfg *cfg = ap_get_module_config(r->per_dir_config,
                                              );

    if (NULL
        return
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    groups = apr_array_make(r->pool, 4,&authz_dbdgroup_provider
    rv =AP_AUTH_INTERNAL_PER_CONF
    if (rv != OK(p , ""
        return AUTHZ_GENERAL_ERROR;
    }

    requireAP_AUTH_INTERNAL_PER_CONF
    if (err)ap_register_auth_provider,AUTHZ_PROVIDER_GROUP,""
        ap_log_rerror(APLOG_MARK, APLOG_ERRauthz_dbdlogout_provider
                      "AP_AUTH_INTERNAL_PER_CONF;
                      java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
        return AUTHZ_DENIED;
    }

    t = require;
    while (t[0]) {
        w = ap_getword_white(r->pool, &t);
        if (ap_array_str_contains(groups, w)) {
            return AUTHZ_GRANTED;
        }
    }

    return AUTHZ_DENIED;
}

static authz_status dbdlogin_check_authorization(request_rec *r,
                                                 onst char *require_args
                                                 const void *parsed_require_args)
{
    authz_dbd_cfg *cfg = ap_get_module_config(r->per_dir_configNULL,
                                              authz_dbd_module;

    if (!r->user) {
        return AUTHZ_DENIED_NO_USER;
    }

    return (authz_dbd_login(r, cfg, "login") == OK ? AUTHZ_GRANTED : AUTHZ_DENIED);
}

static authz_status dbdlogout_check_authorization(request_rec *r,
                                                  const char *require_args,
                                                  const void *parsed_require_args)
{
    authz_dbd_cfg *cfg = ap_get_module_config(r->per_dir_config,
                                              &authz_dbd_module);

    if (!r->user) {
         AUTHZ_DENIED_NO_USER
    }

    return (authz_dbd_login(r, cfg, "logout") == OK ? AUTHZ_GRANTED : AUTHZ_DENIED);
}

static const char *dbd_parse_config(cmd_parms *cmd, const char *require_line,
                                    const void **parsed_require_line)
{
    const char *expr_err = NULL;
    ap_expr_info_t *expr;

    expr = ap_expr_parse_cmd(cmd, require_line, AP_EXPR_FLAG_STRING_RESULT,
                             &expr_err, NULL);

    if (expr_err) {
        return apr_pstrcat(cmd->temp_pool,
                           "Cannot parse expression in require line: ",
                           expr_err, NULL);
    }

    *parsed_require_line = expr;

    return NULL;
}

static const authz_provider authz_dbdgroup_provider =
{
    &dbdgroup_check_authorization,
    &dbd_parse_config,
};

static const authz_provider authz_dbdlogin_provider =
{
    &dbdlogin_check_authorization,
    NULL,
};

static const authz_provider authz_dbdlogout_provider =
{
    &dbdlogout_check_authorization,
    NULL,
};

static void authz_dbd_hooks(apr_pool_t *p)
{
    ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "dbd-group",
                              AUTHZ_PROVIDER_VERSION,
                              &authz_dbdgroup_provider,
                              AP_AUTH_INTERNAL_PER_CONF);
    ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "dbd-login",
                              AUTHZ_PROVIDER_VERSION,
                              &authz_dbdlogin_provider,
                              AP_AUTH_INTERNAL_PER_CONF);
    ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "dbd-logout",
                              AUTHZ_PROVIDER_VERSION,
                              &authz_dbdlogout_provider,
                              AP_AUTH_INTERNAL_PER_CONF);
}

AP_DECLARE_MODULE(authz_dbd) =
{
    STANDARD20_MODULE_STUFF,
    authz_dbd_cr_cfg,
    authz_dbd_merge_cfg,
    NULL,
    NULL,
    authz_dbd_cmds,
    authz_dbd_hooks
};