src/python/pysss_nss_idmap.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Configuration settings for the SAMA5D3 Xplained board.
 *
 * Copyright (C) 2014 Atmel Corporation
 *		      Bo Shen <voice.shen@atmel.com>
 */

#ifndef __CONFIG_H
#define __CONFIG_H

#include "at91-sama5_common.h"

/*
 * This needs to be defined for the OHCI code to work but it is defined as
 * ATMEL_ID_UHPHS in the CPU specific header files.
 */
#define ATMEL_ID_UHP			32

/*
 * Specify the clock enable bit in the PMC_SCER register.
 */
#define ATMEL_PMC_UHP			(1 <<  6)

/* SDRAM */
#define CONFIG_SYS_SDRAM_BASE           0x20000000
#define CONFIG_SYS_SDRAM_SIZE		0x10000000

#ifdef CONFIG_SPL_BUILD
#define CONFIG_SYS_INIT_SP_ADDR		0x318000
#else
#define CONFIG_SYS_INIT_SP_ADDR \
	(CONFIG_SYS_SDRAM_BASE + 16 * 1024 - GENERATED_GBL_DATA_SIZE)
#endif

/* NAND flash */
#ifdef CONFIG_CMD_NAND
#define CONFIG_SYS_MAX_NAND_DEVICE	1
#define CONFIG_SYS_NAND_BASE		0x60000000
/* our ALE is AD21 */
#define CONFIG_SYS_NAND_MASK_ALE	(1 << 21)
/* our CLE is AD22 */
#define CONFIG_SYS_NAND_MASK_CLE	(1 << 22)
#define CONFIG_SYS_NAND_ONFI_DETECTION
#endif

/* USB */
#ifdef CONFIG_CMD_USB
#define CONFIG_USB_ATMEL
#define CONFIG_USB_ATMEL_CLK_SEL_UPLL
#define CONFIG_USB_OHCI_NEW
#define CONFIG_SYS_USB_OHCI_CPU_INIT
#define CONFIG_SYS_USB_OHCI_REGS_BASE		0x00600000
#define CONFIG_SYS_USB_OHCI_SLOT_NAME		"SAMA5D3 Xplained"
#define CONFIG_SYS_USB_OHCI_MAX_ROOT_PORTS	2
#endif

#define CONFIG_SYS_LOAD_ADDR			0x22000000 /* load address */

/* SPL */
#define CONFIG_SPL_MAX_SIZE		0x18000
#define CONFIG_SPL_BSS_START_ADDR	0x20000000
#define CONFIG_SPL_BSS_MAX_SIZE		0x80000
#define CONFIG_SYS_SPL_MALLOC_START	0x20080000
#define CONFIG_SYS_SPL_MALLOC_SIZE	0x80000

#define CONFIG_SYS_MONITOR_LEN		(512 << 10)

#ifdef CONFIG_SD_BOOT
#define CONFIG_SYS_MMCSD_FS_BOOT_PARTITION	1
#define CONFIG_SPL_FS_LOAD_PAYLOAD_NAME	"u-boot.img"

#elif CONFIG_NAND_BOOT
#define CONFIG_SPL_NAND_DRIVERS
#define CONFIG_SPL_NAND_BASE
#endif
#define CONFIG_SYS_NAND_U_BOOT_OFFS	0x40000
#define CONFIG_SYS_NAND_5_ADDR_CYCLE
#define CONFIG_SYS_NAND_PAGE_SIZE	0x800
#define CONFIG_SYS_NAND_PAGE_COUNT	64
#define CONFIG_SYS_NAND_OOBSIZE		64
#define CONFIG_SYS_NAND_BLOCK_SIZE	0x20000
#define CONFIG_SYS_NAND_BAD_BLOCK_POS	0x0

#endif
/*
    Authors:
        Sumit Bose <sbose@redhat.com>
        Alexander Bokovoy <abokovoy@redhat.com>

    Copyright (C) 2013 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 <Python.h>
#include "util/sss_python.h"

#include "sss_client/idmap/sss_nss_idmap.h"

#define SSS_NAME_KEY "name"
#define SSS_SID_KEY "sid"
#define SSS_ID_KEY "id"
#define SSS_TYPE_KEY "type"

enum lookup_type {
    SIDBYNAME,
    SIDBYID,
    NAMEBYSID,
    IDBYSID
};

static int add_dict(PyObject *py_result, PyObject *key, PyObject *res_type,
                    PyObject *res, PyObject *id_type)
{
    int ret;
    PyObject *py_dict;

    py_dict =  PyDict_New();
    if (py_dict == NULL) {
        return ENOMEM;
    }

    ret = PyDict_SetItem(py_dict, res_type, res);
    if (ret != 0) {
        Py_XDECREF(py_dict);
        return ret;
    }

    ret = PyDict_SetItem(py_dict, PyString_FromString(SSS_TYPE_KEY), id_type);
    if (ret != 0) {
        Py_XDECREF(py_dict);
        return ret;
    }

    ret = PyDict_SetItem(py_result, key, py_dict);

    return ret;
}

static char *py_string_or_unicode_as_string(PyObject *inp)
{
    PyObject *py_str = NULL;

    if (PyUnicode_Check(inp)) {
        py_str = PyUnicode_AsUTF8String(inp);
    } else if (PyString_Check(inp)) {
        py_str = inp;
    } else {
        PyErr_Format(PyExc_TypeError, "input must be unicode or a string");
        return NULL;
    }

    return PyString_AS_STRING(py_str);
}

static int do_getsidbyname(PyObject *py_result, PyObject *py_name)
{
    int ret;
    const char *name;
    char *sid = NULL;
    enum sss_id_type id_type;

    name = py_string_or_unicode_as_string(py_name);
    if (name == NULL) {
        return EINVAL;
    }

    ret = sss_nss_getsidbyname(name, &sid, &id_type);
    if (ret == 0) {
        ret = add_dict(py_result, py_name, PyString_FromString(SSS_SID_KEY),
                       PyUnicode_FromString(sid), PyInt_FromLong(id_type));
    }
    free(sid);

    return ret;
}

static int do_getnamebysid(PyObject *py_result, PyObject *py_sid)
{
    int ret;
    const char *sid;
    char *name = NULL;
    enum sss_id_type id_type;

    sid = py_string_or_unicode_as_string(py_sid);
    if (sid == NULL) {
        return EINVAL;
    }

    ret = sss_nss_getnamebysid(sid, &name, &id_type);
    if (ret == 0) {
        ret = add_dict(py_result, py_sid, PyString_FromString(SSS_NAME_KEY),
                       PyUnicode_FromString(name), PyInt_FromLong(id_type));
    }
    free(name);

    return ret;
}

static int do_getsidbyid(PyObject *py_result, PyObject *py_id)
{
    long id;
    const char *id_str;
    char *endptr;
    char *sid = NULL;
    int ret;
    enum sss_id_type id_type;

    if (PyInt_Check(py_id)) {
        id = PyInt_AS_LONG(py_id);
    } else if (PyLong_Check(py_id)) {
        id = PyLong_AsLong(py_id);
    } else {
        id_str = py_string_or_unicode_as_string(py_id);
        if (id_str == NULL) {
            return EINVAL;
        }
        errno = 0;
        id = strtol(id_str, &endptr, 10);
        if (errno != 0 || *endptr != '\0') {
            return EINVAL;
        }
    }

    if (id < 0 || id > UINT32_MAX) {
        return EINVAL;
    }

    ret = sss_nss_getsidbyid((uint32_t) id, &sid, &id_type);
    if (ret == 0) {
        ret = add_dict(py_result, py_id, PyString_FromString(SSS_SID_KEY),
                       PyUnicode_FromString(sid), PyInt_FromLong(id_type));
    }
    free(sid);

    return ret;
}

static int do_getidbysid(PyObject *py_result, PyObject *py_sid)
{
    const char *sid;
    uint32_t id;
    enum sss_id_type id_type;
    int ret;

    sid = py_string_or_unicode_as_string(py_sid);
    if (sid == NULL) {
        return EINVAL;
    }

    ret = sss_nss_getidbysid(sid, &id, &id_type);
    if (ret == 0) {
        ret = add_dict(py_result, py_sid, PyString_FromString(SSS_ID_KEY),
                       PyInt_FromLong(id), PyInt_FromLong(id_type));
    }

    return ret;
}

static int do_lookup(enum lookup_type type, PyObject *py_result,
                     PyObject *py_inp)
{
    switch(type) {
    case SIDBYNAME:
        return do_getsidbyname(py_result, py_inp);
        break;
    case NAMEBYSID:
        return do_getnamebysid(py_result, py_inp);
        break;
    case SIDBYID:
        return do_getsidbyid(py_result, py_inp);
        break;
    case IDBYSID:
        return do_getidbysid(py_result, py_inp);
        break;
    default:
        return ENOSYS;
    }

    return ENOSYS;
}

static PyObject *check_args(enum lookup_type type, PyObject *args)
{
    PyObject *obj, *py_value;
    int ret;
    Py_ssize_t len, i;
    PyObject *py_result;

    if (!PyArg_ParseTuple(args, sss_py_const_p(char, "O"), &obj)) {
        PyErr_Format(PyExc_ValueError, "Unable to retrieve argument\n");
        return NULL;
    }

    if (!(PyList_Check(obj) || PyTuple_Check(obj) ||
          PyString_Check(obj) || PyUnicode_Check(obj) ||
          (type == SIDBYID && (PyInt_Check(obj) || PyLong_Check(obj))))) {
        PyErr_Format(PyExc_ValueError,
                     "Only string, long or list or tuples of them " \
                     "are accepted\n");
        return NULL;
    }

    py_result = PyDict_New();
    Py_XINCREF(py_result);
    if (py_result == NULL) {
        PyErr_Format(PyExc_MemoryError,
                     "Unable to allocate resulting dictionary\n");
        return NULL;
    }

    if (PyList_Check(obj) || PyTuple_Check(obj)) {
        len = PySequence_Size(obj);
        for(i=0; i < len; i++) {
            py_value = PySequence_GetItem(obj, i);
            if ((py_value != NULL) &&
                (PyString_Check(py_value) || PyUnicode_Check(py_value) ||
                 (type == SIDBYID &&
                  (PyInt_Check(py_value) || PyLong_Check(py_value))))) {
                ret = do_lookup(type, py_result, py_value);
                if (ret != 0) {
                    /* Skip this name */
                    continue;
                }
            }
        }
    } else {
        ret = do_lookup(type, py_result, obj);
        switch (ret) {
        case 0:
        case ENOENT: /* nothing found, return empty dict */
            break;
        case EINVAL:
            PyErr_Format(PyExc_ValueError, "Unable to retrieve argument\n");
            Py_XDECREF(py_result);
            return NULL;
            break;
        default:
            PyErr_Format(PyExc_IOError, "Operation not supported\n");
            Py_XDECREF(py_result);
            return NULL;
        }
    }

    Py_XDECREF(py_result);
    return py_result;

}

PyDoc_STRVAR(getsidbyname_doc,
"getsidbyname(name or list/tuple of names) -> dict(name => dict(results))\n\
\n\
Returns a dictionary with a dictonary of results for each given name.\n\
The result dictonary contain the SID and the type of the object which can be\n\
accessed with the key constants SID_KEY and TYPE_KEY, respectively.\n\
\n\
The return type can be one of the following constants:\n\
- ID_NOT_SPECIFIED\n\
- ID_USER\n\
- ID_GROUP\n\
- ID_BOTH"
);

static PyObject * py_getsidbyname(PyObject *module, PyObject *args)
{
    return check_args(SIDBYNAME, args);
}

PyDoc_STRVAR(getsidbyid_doc,
"getsidbyid(id or list/tuple of id) -> dict(id => dict(results))\n\
\n\
Returns a dictionary with a dictonary of results for each given POSIX ID.\n\
The result dictonary contain the SID and the type of the object which can be\n\
accessed with the key constants SID_KEY and TYPE_KEY, respectively."
);

static PyObject * py_getsidbyid(PyObject *module, PyObject *args)
{
    return check_args(SIDBYID, args);
}

PyDoc_STRVAR(getnamebysid_doc,
"getnamebysid(sid or list/tuple of sid) -> dict(sid => dict(results))\n\
\n\
Returns a dictionary with a dictonary of results for each given SID.\n\
The result dictonary contain the name and the type of the object which can be\n\
accessed with the key constants NAME_KEY and TYPE_KEY, respectively."
);

static PyObject * py_getnamebysid(PyObject *module, PyObject *args)
{
    return check_args(NAMEBYSID, args);
}

PyDoc_STRVAR(getidbysid_doc,
"getidbysid(sid) -> POSIX ID\n\
\n\
Returns the POSIX ID of the object with the given SID."
"getidbysid(sid or list/tuple of sid) -> dict(sid => dict(results))\n\
\n\
Returns a dictionary with a dictonary of results for each given SID.\n\
The result dictonary contain the POSIX ID and the type of the object which\n\
can be accessed with the key constants ID_KEY and TYPE_KEY, respectively."
);

static PyObject * py_getidbysid(PyObject *module, PyObject *args)
{
    return check_args(IDBYSID, args);
}

static PyMethodDef methods[] = {
    { sss_py_const_p(char, "getsidbyname"), (PyCFunction) py_getsidbyname,
      METH_VARARGS, getsidbyname_doc },
    { sss_py_const_p(char, "getsidbyid"), (PyCFunction) py_getsidbyid,
      METH_VARARGS, getsidbyid_doc },
    { sss_py_const_p(char, "getnamebysid"), (PyCFunction) py_getnamebysid,
      METH_VARARGS, getnamebysid_doc },
    { sss_py_const_p(char, "getidbysid"), (PyCFunction) py_getidbysid,
      METH_VARARGS, getidbysid_doc },
    { NULL,NULL, 0, NULL }
};


PyMODINIT_FUNC
initpysss_nss_idmap(void)
{
    PyObject *module;

    module = Py_InitModule3(sss_py_const_p(char, "pysss_nss_idmap"),
                            methods,
                            sss_py_const_p(char, "SSSD ID-mapping functions"));

    PyModule_AddIntConstant(module, "ID_NOT_SPECIFIED",
                            SSS_ID_TYPE_NOT_SPECIFIED);
    PyModule_AddIntConstant(module, "ID_USER", SSS_ID_TYPE_UID);
    PyModule_AddIntConstant(module, "ID_GROUP", SSS_ID_TYPE_GID);
    PyModule_AddIntConstant(module, "ID_BOTH", SSS_ID_TYPE_BOTH);

    PyModule_AddStringConstant(module, "SID_KEY", SSS_SID_KEY);
    PyModule_AddStringConstant(module, "NAME_KEY", SSS_NAME_KEY);
    PyModule_AddStringConstant(module, "ID_KEY", SSS_ID_KEY);
    PyModule_AddStringConstant(module, "TYPE_KEY", SSS_TYPE_KEY);
}