summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorusa <usa@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2004-08-19 00:11:12 +0000
committerusa <usa@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2004-08-19 00:11:12 +0000
commit3f673a27e0e3cdffdbb33286c0b61a32f72d39b4 (patch)
treede9acf8d5982a00a35efb94c20c5991ef0b30a6f
parentb0e7e0d285baffadd33f9377d5bdf62309cbfc5b (diff)
2004-08-19
git-svn-id: http://svn.ruby-lang.org/repos/ruby/branches/ruby_1_8@6790 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat
-rw-r--r--version.h6
1 files changed, 3 insertions, 3 deletions
diff --git a/version.h b/version.h
index f4baf3104..baccf64dd 100644
--- a/version.h
+++ b/version.h
@@ -1,14 +1,14 @@
#define RUBY_VERSION "1.8.2"
-#define RUBY_RELEASE_DATE "2004-08-18"
+#define RUBY_RELEASE_DATE "2004-08-19"
#define RUBY_VERSION_CODE 182
-#define RUBY_RELEASE_CODE 20040818
+#define RUBY_RELEASE_CODE 20040819
#define RUBY_VERSION_MAJOR 1
#define RUBY_VERSION_MINOR 8
#define RUBY_VERSION_TEENY 2
#define RUBY_RELEASE_YEAR 2004
#define RUBY_RELEASE_MONTH 8
-#define RUBY_RELEASE_DAY 18
+#define RUBY_RELEASE_DAY 19
RUBY_EXTERN const char ruby_version[];
RUBY_EXTERN const char ruby_release_date[];
generated by cgit (git 2.34.1) at 2026-03-03 02:37:42 +0000
'>111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 
/*
    SSSD

    LDAP Identity Backend Module - Netgroup support

    Authors:
        Sumit Bose <sbose@redhat.com>

    Copyright (C) 2010 Red Hat

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <errno.h>

#include "util/util.h"
#include "db/sysdb.h"
#include "providers/ldap/ldap_common.h"
#include "providers/ldap/sdap_async.h"


struct ldap_netgroup_get_state {
    struct tevent_context *ev;
    struct sdap_id_ctx *ctx;
    struct sdap_id_op *op;
    struct sdap_id_conn_ctx *conn;
    struct sysdb_ctx *sysdb;
    struct sss_domain_info *domain;

    const char *name;
    int timeout;

    char *filter;
    const char **attrs;

    size_t count;
    struct sysdb_attrs **netgroups;

    int dp_error;
};

static int ldap_netgroup_get_retry(struct tevent_req *req);
static void ldap_netgroup_get_connect_done(struct tevent_req *subreq);
static void ldap_netgroup_get_done(struct tevent_req *subreq);

struct tevent_req *ldap_netgroup_get_send(TALLOC_CTX *memctx,
                                          struct tevent_context *ev,
                                          struct sdap_id_ctx *ctx,
                                          struct sdap_id_conn_ctx *conn,
                                          const char *name)
{
    struct tevent_req *req;
    struct ldap_netgroup_get_state *state;
    char *clean_name;
    int ret;

    req = tevent_req_create(memctx, &state, struct ldap_netgroup_get_state);
    if (!req) return NULL;

    state->ev = ev;
    state->ctx = ctx;
    state->conn = conn;
    state->dp_error = DP_ERR_FATAL;

    state->op = sdap_id_op_create(state, state->conn->conn_cache);
    if (!state->op) {
        DEBUG(2, ("sdap_id_op_create failed\n"));
        ret = ENOMEM;
        goto fail;
    }

    state->sysdb = ctx->be->domain->sysdb;
    state->domain = state->ctx->be->domain;
    state->name = name;
    state->timeout = dp_opt_get_int(ctx->opts->basic, SDAP_SEARCH_TIMEOUT);

    ret = sss_filter_sanitize(state, name, &clean_name);
    if (ret != EOK) {
        goto fail;
    }

    state->filter = talloc_asprintf(state, "(&(%s=%s)(objectclass=%s))",
                            ctx->opts->netgroup_map[SDAP_AT_NETGROUP_NAME].name,
                            clean_name,
                            ctx->opts->netgroup_map[SDAP_OC_NETGROUP].name);
    if (!state->filter) {
        DEBUG(2, ("Failed to build filter\n"));
        ret = ENOMEM;
        goto fail;
    }
    talloc_zfree(clean_name);

    ret = build_attrs_from_map(state, ctx->opts->netgroup_map, SDAP_OPTS_NETGROUP,
                               NULL, &state->attrs, NULL);
    if (ret != EOK) goto fail;

    ret = ldap_netgroup_get_retry(req);
    if (ret != EOK) {
        goto fail;
    }

    return req;

fail:
    tevent_req_error(req, ret);
    tevent_req_post(req, ev);
    return req;
}

static int ldap_netgroup_get_retry(struct tevent_req *req)
{
    struct ldap_netgroup_get_state *state = tevent_req_data(req,
                                                    struct ldap_netgroup_get_state);
    struct tevent_req *subreq;
    int ret = EOK;

    subreq = sdap_id_op_connect_send(state->op, state, &ret);
    if (!subreq) {
        return ret;
    }

    tevent_req_set_callback(subreq, ldap_netgroup_get_connect_done, req);
    return EOK;
}

static void ldap_netgroup_get_connect_done(struct tevent_req *subreq)
{
    struct tevent_req *req = tevent_req_callback_data(subreq,
                                                      struct tevent_req);
    struct ldap_netgroup_get_state *state = tevent_req_data(req,
                                                    struct ldap_netgroup_get_state);
    int dp_error = DP_ERR_FATAL;
    int ret;

    ret = sdap_id_op_connect_recv(subreq, &dp_error);
    talloc_zfree(subreq);

    if (ret != EOK) {
        state->dp_error = dp_error;
        tevent_req_error(req, ret);
        return;
    }

    subreq = sdap_get_netgroups_send(state, state->ev,
                                     state->domain, state->sysdb,
                                     state->ctx->opts,
                                     state->ctx->opts->netgroup_search_bases,
                                     sdap_id_op_handle(state->op),
                                     state->attrs, state->filter,
                                     state->timeout);
    if (!subreq) {
        tevent_req_error(req, ENOMEM);
        return;
    }
    tevent_req_set_callback(subreq, ldap_netgroup_get_done, req);

    return;
}

static void ldap_netgroup_get_done(struct tevent_req *subreq)
{
    struct tevent_req *req = tevent_req_callback_data(subreq,
                                                      struct tevent_req);
    struct ldap_netgroup_get_state *state = tevent_req_data(req,
                                                    struct ldap_netgroup_get_state);
    int dp_error = DP_ERR_FATAL;
    int ret;

    ret = sdap_get_netgroups_recv(subreq, state, NULL, &state->count,
                                  &state->netgroups);
    talloc_zfree(subreq);
    ret = sdap_id_op_done(state->op, ret, &dp_error);

    if (dp_error == DP_ERR_OK && ret != EOK) {
        /* retry */
        ret = ldap_netgroup_get_retry(req);
        if (ret != EOK) {
            tevent_req_error(req, ret);
            return;
        }

        return;
    }

    if (ret && ret != ENOENT) {
        state->dp_error = dp_error;
        tevent_req_error(req, ret);
        return;
    }

    if (ret == EOK && state->count > 1) {
        DEBUG(1, ("Found more than one netgroup with the name [%s].\n",
                  state->name));
        tevent_req_error(req, EINVAL);
        return;
    }

    if (ret == ENOENT) {
        ret = sysdb_delete_netgroup(state->sysdb, state->domain, state->name);
        if (ret != EOK && ret != ENOENT) {
            tevent_req_error(req, ret);
            return;
        }
    }

    state->dp_error = DP_ERR_OK;
    tevent_req_done(req);
    return;
}

int ldap_netgroup_get_recv(struct tevent_req *req, int *dp_error_out)
{
    struct ldap_netgroup_get_state *state = tevent_req_data(req,
                                                    struct ldap_netgroup_get_state);

    if (dp_error_out) {
        *dp_error_out = state->dp_error;
    }

    TEVENT_REQ_RETURN_ON_ERROR(req);

    return EOK;
}
generated by cgit (git 2.34.1) at 2026-03-03 02:37:42 +0000