index : kernel.git	f32-user-thl-vanilla-fedora f33-user-thl-vanilla-fedora f34-user-thl-vanilla-fedora f35-user-thl-vanilla-fedora f36-user-thl-vanilla-fedora f37-user-thl-vanilla-fedora rawhide rawhide-user-thl-vanilla-fedora stabilization-user-thl-vanilla-fedora transition-user-thl-vanilla-fedora
	Linux vanilla kernels for Fedora – https://fedoraproject.org/wiki/Kernel_Vanilla_Repositories	Thorsten Leemhuis

summaryrefslogtreecommitdiffstats

log msg author committer range

path: root/0001-iommu-arm-smmu-workaround-DMA-mode-issues.patch

	Commit message (Expand)	Author	Age	Files	Lines
*	kernel-5.7.0-1	Justin M. Forbes	2020-06-01	1	-1/+1
*	kernel-5.7.0-0.rc6.20200520git115a54162a6c.1	Justin M. Forbes	2020-05-20	1	-2/+2
*	kernel-5.7.0-0.rc4.20200508git79dede78c057.1	Justin M. Forbes	2020-05-08	1	-1/+1
*	kernel-5.7.0-0.rc4.20200507gita811c1fa0a02.1	Justin M. Forbes	2020-05-07	1	-1/+1
*	kernel-5.7.0-0.rc4.20200505git47cf1b422e60.1	Justin M. Forbes	2020-05-05	1	-1/+1
*	kernel-5.7.0-0.rc4.1	Justin M. Forbes	2020-05-04	1	-3/+3
*	kernel-5.7.0-0.rc3.20200501gitc45e8bccecaf.1	Justin M. Forbes	2020-05-01	1	-1/+1
*	kernel-5.7.0-0.rc3.20200429git1d2cc5ac6f66.1	Justin M. Forbes	2020-04-29	1	-1/+1
*	* Wed Apr 29 2020 Justin M. Forbes <jforbes@fedoraproject.org> 5.7.0-0.rc3.20...	Justin M. Forbes	2020-04-29	1	-1/+1
*	kernel-5.7.0-0.rc3.1	Justin M. Forbes	2020-04-26	1	-3/+3
*	kernel-5.7.0-0.rc2.20200423git7adc4b399952.1	Jeremy Cline	2020-04-23	1	-0/+98

generated by cgit (git 2.34.1) at 2024-05-01 21:45:34 +0000

/*
    SSSD

    LDAP Backend Module -- child helpers

    Authors:
        Jakub Hrozek <jhrozek@redhat.com>

    Copyright (C) 2009 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 <sys/types.h>
#include <sys/wait.h>
#include <pwd.h>
#include <unistd.h>
#include <fcntl.h>

#include "util/util.h"
#include "providers/ldap/ldap_common.h"
#include "providers/child_common.h"

#ifndef SSSD_LIBEXEC_PATH
#error "SSSD_LIBEXEC_PATH not defined"
#else
#define LDAP_CHILD SSSD_LIBEXEC_PATH"/ldap_child"
#endif

#ifndef LDAP_CHILD_USER
#define LDAP_CHILD_USER  "nobody"
#endif

struct sdap_child_req {
    /* child info */
    pid_t child_pid;
    int read_from_child_fd;
    int write_to_child_fd;

    /* for handling timeout */
    struct tevent_context *ev;
    int timeout;
    struct tevent_timer *timeout_handler;
    struct tevent_req *req;

    /* parameters */
    const char *realm_str;
    const char *princ_str;
    const char *keytab_name;
};

static int sdap_child_req_destructor(void *ptr)
{
    struct sdap_child_req *cr = talloc_get_type(ptr, struct sdap_child_req);

    if (cr == NULL) return EOK;

    child_cleanup(cr->read_from_child_fd, cr->write_to_child_fd);
    memset(cr, 0, sizeof(struct sdap_child_req));

    return EOK;
}

static void sdap_child_timeout(struct tevent_context *ev,
                               struct tevent_timer *te,
                               struct timeval tv, void *pvt)
{
    struct sdap_child_req *lr = talloc_get_type(pvt, struct sdap_child_req);
    int ret;

    if (lr->timeout_handler == NULL) {
        return;
    }

    DEBUG(9, ("timeout for ldap child [%d] reached.\n", lr->child_pid));

    ret = kill(lr->child_pid, SIGKILL);
    if (ret == -1) {
        DEBUG(1, ("kill failed [%d][%s].\n", errno, strerror(errno)));
    }

    tevent_req_error(lr->req, EIO);
}

static errno_t activate_child_timeout_handler(struct sdap_child_req *child_req)
{
    struct timeval tv;

    tv = tevent_timeval_current();
    tv = tevent_timeval_add(&tv,
                            child_req->timeout,
                            0);
    child_req->timeout_handler = tevent_add_timer(child_req->ev, child_req, tv,
                                                  sdap_child_timeout, child_req);
    if (child_req->timeout_handler == NULL) {
        DEBUG(1, ("tevent_add_timer failed.\n"));
        return ENOMEM;
    }

    return EOK;
}

static errno_t fork_ldap_child(struct sdap_child_req *child_req)
{
    int pipefd_to_child[2];
    int pipefd_from_child[2];
    pid_t pid;
    int ret;
    errno_t err;

    ret = pipe(pipefd_from_child);
    if (ret == -1) {
        err = errno;
        DEBUG(1, ("pipe failed [%d][%s].\n", err, strerror(err)));
        return err;
    }
    ret = pipe(pipefd_to_child);
    if (ret == -1) {
        err = errno;
        DEBUG(1, ("pipe failed [%d][%s].\n", err, strerror(err)));
        return err;
    }

    pid = fork();

    if (pid == 0) { /* child */
        err = exec_child(child_req,
                         pipefd_to_child, pipefd_from_child,
                         LDAP_CHILD, ldap_child_debug_fd);
        if (err != EOK) {
            DEBUG(1, ("Could not exec LDAP child: [%d][%s].\n",
                      err, strerror(err)));
            return err;
        }
    } else if (pid > 0) { /* parent */
        child_req->child_pid = pid;
        child_req->read_from_child_fd = pipefd_from_child[0];
        close(pipefd_from_child[1]);
        child_req->write_to_child_fd = pipefd_to_child[1];
        close(pipefd_to_child[0]);
        fd_nonblocking(child_req->read_from_child_fd);
        fd_nonblocking(child_req->write_to_child_fd);

    } else { /* error */
        err = errno;
        DEBUG(1, ("fork failed [%d][%s].\n", err, strerror(err)));
        return err;
    }

    return EOK;
}

static errno_t create_ldap_send_buffer(struct sdap_child_req *child_req, struct io_buffer **io_buf)
{
    struct io_buffer *buf;
    size_t rp;

    buf = talloc(child_req, struct io_buffer);
    if (buf == NULL) {
        DEBUG(1, ("talloc failed.\n"));
        return ENOMEM;
    }

    buf->size = 3*sizeof(int);
    if (child_req->realm_str)
        buf->size += strlen(child_req->realm_str);
    if (child_req->princ_str)
        buf->size += strlen(child_req->princ_str);
    if (child_req->keytab_name)
        buf->size += strlen(child_req->keytab_name);
    DEBUG(7, ("buffer size: %d\n", buf->size));

    buf->data = talloc_size(child_req, buf->size);
    if (buf->data == NULL) {
        DEBUG(1, ("talloc_size failed.\n"));
        talloc_free(buf);
        return ENOMEM;
    }

    rp = 0;
    /* realm */
    ((uint32_t *)(&buf->data[rp]))[0] =
                        (uint32_t) (child_req->realm_str ?
                                   strlen(child_req->realm_str) : 0);
    rp += sizeof(uint32_t);
    if (child_req->realm_str) {
        memcpy(&buf->data[rp], child_req->realm_str, strlen(child_req->realm_str));
        rp += strlen(child_req->realm_str);
    }

    /* principal */
    ((uint32_t *)(&buf->data[rp]))[0] =
                        (uint32_t) (child_req->princ_str ?
                                   strlen(child_req->princ_str) : 0);
    rp += sizeof(uint32_t);
    if (child_req->princ_str) {
        memcpy(&buf->data[rp], child_req->princ_str, strlen(child_req->princ_str));
        rp += strlen(child_req->princ_str);
    }

    /* keytab */
    ((uint32_t *)(&buf->data[rp]))[0] =
                        (uint32_t) (child_req->keytab_name ?
                                   strlen(child_req->keytab_name) : 0);
    rp += sizeof(uint32_t);
    if (child_req->keytab_name) {
        memcpy(&buf->data[rp], child_req->keytab_name, strlen(child_req->keytab_name));
        rp += strlen(child_req->keytab_name);
    }

    *io_buf = buf;
    return EOK;
}

static int parse_child_response(TALLOC_CTX *mem_ctx,
                                uint8_t *buf, ssize_t size,
                                int  *result,
                                char **ccache)
{
    size_t p = 0;
    uint32_t *len;
    uint32_t *res;
    char *ccn;

    /* ccache size the ccache itself*/
    if ((p + sizeof(uint32_t)) > size) return EINVAL;
    res = ((uint32_t *)(buf+p));
    p += sizeof(uint32_t);

    /* ccache size the ccache itself*/
    if ((p + sizeof(uint32_t)) > size) return EINVAL;
    len = ((uint32_t *)(buf+p));
    p += sizeof(uint32_t);

    if ((p + *len ) > size) return EINVAL;

    ccn = talloc_size(mem_ctx, sizeof(char) * (*len + 1));
    if (ccn == NULL) {
        DEBUG(1, ("talloc_size failed.\n"));
        return ENOMEM;
    }
    memcpy(ccn, buf+p, sizeof(char) * (*len + 1));
    ccn[*len] = '\0';

    *result = *res;
    *ccache = ccn;
    return EOK;
}

/* ==The-public-async-interface============================================*/

struct sdap_krb5_get_tgt_state {
    struct sdap_child_req *lr;
    ssize_t len;
    uint8_t *buf;
};

static void sdap_krb5_get_tgt_done(struct tevent_req *subreq);

struct tevent_req *sdap_krb5_get_tgt_send(TALLOC_CTX *mem_ctx,
                                          struct tevent_context *ev,
                                          int timeout,
                                          const char *realm_str,
                                          const char *princ_str,
                                          const char *keytab_name)
{
    struct sdap_child_req *child_req = NULL;
    struct sdap_krb5_get_tgt_state *state = NULL;
    int ret;
    struct io_buffer *buf = NULL;
    struct tevent_req *req = NULL;
    struct tevent_req *subreq = NULL;

    /* prepare the data to pass to child */
    child_req = talloc_zero(mem_ctx, struct sdap_child_req);
    if (!child_req) goto fail;

    child_req->ev = ev;
    child_req->read_from_child_fd = -1;
    child_req->write_to_child_fd = -1;
    child_req->realm_str = realm_str;
    child_req->princ_str = princ_str;
    child_req->keytab_name = keytab_name;
    child_req->timeout = timeout;
    talloc_set_destructor((TALLOC_CTX *) child_req, sdap_child_req_destructor);

    ret = create_ldap_send_buffer(child_req, &buf);
    if (ret != EOK) {
        DEBUG(1, ("create_ldap_send_buffer failed.\n"));
        return NULL;
    }

    ret = fork_ldap_child(child_req);
    if (ret != EOK) {
        DEBUG(1, ("fork_ldap_child failed.\n"));
        goto fail;
    }

    ret = write(child_req->write_to_child_fd, buf->data, buf->size);
    close(child_req->write_to_child_fd);
    child_req->write_to_child_fd = -1;
    if (ret == -1) {
        ret = errno;
        DEBUG(1, ("write failed [%d][%s].\n", ret, strerror(ret)));
        return NULL;
    }

    req = tevent_req_create(mem_ctx, &state, struct sdap_krb5_get_tgt_state);
    if (req == NULL) {
        return NULL;
    }

    state->lr = child_req;

    child_req->req = req;
    ret = activate_child_timeout_handler(child_req);
    if (ret != EOK) {
        DEBUG(1, ("activate_child_timeout_handler failed.\n"));
        return NULL;
    }

    subreq = read_pipe_send(state, ev, child_req->read_from_child_fd);
    if (tevent_req_nomem(subreq, req)) {
        return tevent_req_post(req, ev);
    }
    tevent_req_set_callback(subreq, sdap_krb5_get_tgt_done, req);

    return req;
fail:
    return NULL;
}

static void sdap_krb5_get_tgt_done(struct tevent_req *subreq)
{
    struct tevent_req *req = tevent_req_callback_data(subreq,
                                                      struct tevent_req);
    struct sdap_krb5_get_tgt_state *state = tevent_req_data(req,
                                                       struct sdap_krb5_get_tgt_state);
    int ret;

    ret = read_pipe_recv(subreq, state, &state->buf, &state->len);
    talloc_zfree(subreq);
    talloc_zfree(state->lr->timeout_handler);
    close(state->lr->read_from_child_fd);
    state->lr->read_from_child_fd = -1;
    if (ret != EOK) {
        tevent_req_error(req, ret);
        return;
    }

    tevent_req_done(req);
    return;
}

int sdap_krb5_get_tgt_recv(struct tevent_req *req,
                           TALLOC_CTX *mem_ctx,
                           int  *result,
                           char **ccname)
{
    struct sdap_krb5_get_tgt_state *state = tevent_req_data(req,
                                                            struct sdap_krb5_get_tgt_state);
    char *ccn;
    int  res;
    int ret;

    TEVENT_REQ_RETURN_ON_ERROR(req);

    ret = parse_child_response(mem_ctx, state->buf, state->len, &res, &ccn);
    if (ret != EOK) {
        DEBUG(1, ("Cannot parse child response: [%d][%s]\n", ret, strerror(ret)));
        return ret;
    }

    DEBUG(6, ("Child responded: %d [%s]\n", res, ccn));
    *result = res;
    *ccname = ccn;
    return EOK;
}

/* Setup child logging */
int setup_child(struct sdap_id_ctx *ctx)
{
    int ret;
    const char *mech;
    struct tevent_signal *sige;
    unsigned v;
    FILE *debug_filep;

    mech = dp_opt_get_string(ctx->opts->basic,
                             SDAP_SASL_MECH);
    if (!mech) {
        return EOK;
    }

    sige = tevent_add_signal(ctx->be->ev, ctx, SIGCHLD, SA_SIGINFO,
                             child_sig_handler, NULL);
    if (sige == NULL) {
        DEBUG(1, ("tevent_add_signal failed.\n"));
        return ENOMEM;
    }

    if (debug_to_file != 0 && ldap_child_debug_fd == -1) {
        ret = open_debug_file_ex("ldap_child", &debug_filep);
        if (ret != EOK) {
            DEBUG(0, ("Error setting up logging (%d) [%s]\n",
                        ret, strerror(ret)));
            return ret;
        }

        ldap_child_debug_fd = fileno(debug_filep);
        if (ldap_child_debug_fd == -1) {
            DEBUG(0, ("fileno failed [%d][%s]\n", errno, strerror(errno)));
            ret = errno;
            return ret;
        }

        v = fcntl(ldap_child_debug_fd, F_GETFD, 0);
        fcntl(ldap_child_debug_fd, F_SETFD, v & ~FD_CLOEXEC);
    }

    return EOK;
}