/*

 * Open Vulnerability and Assessment Language

 * (http://oval.mitre.org/)

 */

/*

 * Copyright 2009--2014 Red Hat Inc., Durham, North Carolina.

 * All Rights Reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 *

 * Authors:

 *      Maros Barabas   <mbarabas@redhat.com>

 *

 */

/* Define OSCAP_API as an empty string */

/* Prevents 'Syntax error in input(1).' message */

#define OSCAP_API

/* Convert a tuple element to a C array */

/* SWIG can't understand __attribute__(x), so we make it go away */

#define __attribute__(x)

#if defined(SWIGPYTHON)

/* Definitions for PYTHON */

%exception xccdf_policy_evaluate {

    Py_BEGIN_ALLOW_THREADS

    $action

    Py_END_ALLOW_THREADS

}

%typemap(in) time_t

{

    if (PyLong_Check($input))

        $1 = (time_t) PyLong_AsLong($input);

    else if (PyInt_Check($input))

        $1 = (time_t) PyInt_AsLong($input);

    else if (PyFloat_Check($input))

        $1 = (time_t) PyFloat_AsDouble($input);

    else {

        PyErr_SetString(PyExc_TypeError,"Expected a large number");

        SWIG_fail;

    }

}

%typemap(out) time_t

{

    $result = PyLong_FromLong((long)$1);

}

%typemap(in) void * {

    $result = SWIG_ConvertPtr($input,%as_voidptrptr(&$1), 0, $disown);

    if (!SWIG_IsOK($result)) {

        %argument_fail($result, "$type", $symname, $argnum);

    }

}

%module openscap

%typemap(in) char ** {

  if (PyList_Check($input)) {

    int size = PyList_Size($input);

    int i = 0;

    $1 = (char **) malloc((size+1)*sizeof(char *));

    for (i = 0; i < size; i++) {

      PyObject *o = PyList_GetItem($input,i);

      /*if (PyString_Check(o))*/

        $1[i] = PyString_AsString(PyList_GetItem($input,i));

      /*else {

        PyErr_SetString(PyExc_TypeError,"list must contain strings");

        free($1);

        return NULL;

      }*/

    }

    $1[i] = 0;

  } else {

    PyErr_SetString(PyExc_TypeError,"not a list");

    SWIG_fail;

  }

}

%typemap(freearg) char ** {

  free((char *) $1);

}

%typemap(in) struct cpe_name ** {

    int i;

    int a_size = 0;

    int res_o = 0;

    a_size = (int) PySequence_Length($input);

    if (!PySequence_Check($input)) {

        PyErr_SetString(PyExc_ValueError,"Expected a sequence");

        SWIG_fail;

    }

    if (a_size <= 0) {

        PyErr_SetString(PyExc_ValueError,"Expected not empty sequence");

        SWIG_fail;

    }

    $1 = (struct cpe_name **) malloc(a_size*sizeof(struct cpe_name *));

    for (i = 0; i < a_size; i++) {

        void *arg = 0;

        PyObject *obj = PySequence_GetItem($input,i);

        if (obj == NULL) {

            SWIG_exception_fail(SWIG_ArgError(res_o), "in argument '" "cpe_name" "' substitution '" "', can't access sequence");

            SWIG_fail; /*5956*/

        }

        res_o = SWIG_ConvertPtr(obj, &arg, SWIGTYPE_p_cpe_name, 0 );

        if (!SWIG_IsOK(res_o)) {

            SWIG_exception_fail(SWIG_ArgError(res_o), "in argument '" "cpe_name" "' substitution invalid types");

            SWIG_fail;

        }

        $1[i] = (struct cpe_name *) arg;

    }

}

%typemap(in) struct oval_syschar_model ** {

    int i;

    int a_size = 0;

    int res_o = 0;

    a_size = (int) PySequence_Length($input);

    if (!PySequence_Check($input)) {

        PyErr_SetString(PyExc_ValueError,"Expected a sequence");

        SWIG_fail;

    }

    if (a_size <= 0) {

        PyErr_SetString(PyExc_ValueError,"Expected not empty sequence");

        SWIG_fail;

    }

    $1 = (struct oval_syschar_model **) malloc(a_size*sizeof(struct oval_syschar_model *));

    for (i = 0; i < a_size; i++) {

        void *arg = 0;

        PyObject *obj = PySequence_GetItem($input,i);

        if (obj == NULL) {

            SWIG_exception_fail(SWIG_ArgError(res_o), "in argument '" "oval_syschar_model" "' substitution '" "', can't access sequence");

            SWIG_fail;

        }

        res_o = SWIG_ConvertPtr(obj, &arg, SWIGTYPE_p_oval_syschar_model, 0 );

        if (!SWIG_IsOK(res_o)) {

            SWIG_exception_fail(SWIG_ArgError(res_o), "in argument '" "oval_syschar_model" "' substitution invalid types");

            SWIG_fail;

        }

        $1[i] = (struct oval_syschar_model *) arg;

    }

}

%typemap(freearg) struct oval_syschar_model ** {

    free($1);

}

#elif defined(SWIGPERL)

/* Definitions for PERL */

#endif

%module openscap

%{

 #include "../../src/common/public/oscap.h"

 #include "../../src/common/public/oscap_error.h"

 #include "../../src/common/public/oscap_text.h"

 #include "../../src/DS/public/scap_ds.h"

%}

%include "../../src/common/public/oscap.h"

%include "../../src/common/public/oscap_error.h"

%include "../../src/common/public/oscap_text.h"

%include "../../src/common/public/oscap_reference.h"

%include "../../src/DS/public/scap_ds.h"

%module openscap

%{

 #include "../../src/CPE/public/cpe_name.h"

 #include "../../src/CPE/public/cpe_dict.h"

 #include "../../src/CPE/public/cpe_lang.h"

%}

%include "../../src/CPE/public/cpe_name.h"

%include "../../src/CPE/public/cpe_dict.h"

%include "../../src/CPE/public/cpe_lang.h"

%module openscap

%{

 #include "../../src/CVE/public/cve_nvd.h"

%}

%include "../../src/CVE/public/cve_nvd.h"

%module openscap

%{

 #include "../../src/CVSS/public/cvss_score.h"

%}

%include "../../src/CVSS/public/cvss_score.h"

%module openscap

%{

 #include "../../src/DS/public/ds_rds_session.h"

 #include "../../src/DS/public/ds_sds_session.h"

 #include "../../src/DS/public/scap_ds.h"

%}

%include "../../src/DS/public/ds_rds_session.h"

%include "../../src/DS/public/ds_sds_session.h"

%include "../../src/DS/public/scap_ds.h"

%module openscap

%{

 #include "../../src/XCCDF/public/xccdf_benchmark.h"

 #include "../../src/XCCDF/public/xccdf_session.h"

 #include "../../src/XCCDF_POLICY/public/xccdf_policy.h"

%}

%include "../../src/XCCDF/public/xccdf_benchmark.h"

%include "../../src/XCCDF/public/xccdf_session.h"

%include "../../src/XCCDF_POLICY/public/xccdf_policy.h"

%module openscap

%{

 #include "../../src/OVAL/public/oval_adt.h"

 #include "../../src/OVAL/public/oval_agent_api.h"

 #include "../../src/OVAL/public/oval_definitions.h"

 #include "../../src/OVAL/public/oval_directives.h"

 #include "../../src/OVAL/public/oval_system_characteristics.h"

 #include "../../src/OVAL/public/oval_results.h"

 #include "../../src/OVAL/public/oval_schema_version.h"

 #include "../../src/OVAL/public/oval_session.h"

 #include "../../src/OVAL/public/oval_types.h"

 #include "../../src/OVAL/public/oval_variables.h"

 #include "../../src/OVAL/public/oval_probe.h"

 #include "../../src/OVAL/public/oval_probe_session.h"

%}

%include "../../src/OVAL/public/oval_adt.h"

%include "../../src/OVAL/public/oval_agent_api.h"

%include "../../src/OVAL/public/oval_definitions.h"

%include "../../src/OVAL/public/oval_directives.h"

%include "../../src/OVAL/public/oval_system_characteristics.h"

%include "../../src/OVAL/public/oval_results.h"

%include "../../src/OVAL/public/oval_schema_version.h"

%include "../../src/OVAL/public/oval_session.h"

%include "../../src/OVAL/public/oval_types.h"

%include "../../src/OVAL/public/oval_variables.h"

#if defined(ENABLE_PROBES)

%include "../../src/OVAL/public/oval_probe.h"

%include "../../src/OVAL/public/oval_probe_session.h"

#endif

%module openscap

%{

 #include "../../src/OVAL/public/oval_agent_xccdf_api.h"

%}

%include "../../src/OVAL/public/oval_agent_xccdf_api.h"

%module openscap

%{

 #include "../../src/source/public/oscap_source.h"

%}

%include "../../src/source/public/oscap_source.h"

/*%typemap(in) value[ANY] {

    int i;

    PyErr_SetString(PyExc_ValueError,"Expected a sequence");

    return NULL;

    if (!PySequence_Check($input)) {

        PyErr_SetString(PyExc_ValueError,"Expected a sequence");

        return NULL;

    }

    if (PySequence_Length($input) != $1_dim0) {

            PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements");

            return NULL;

    }

    $1 = (void **) malloc($1_dim0*sizeof( Py_TYPE(PySequence_GetItem($input, 0)) ));

    for (i = 0; i < $1_dim0; i++) {

        PyObject *o = PySequence_GetItem($input,i);

        if (Py_TYPE(PySequence_GetItem($input,i)) != Py_TYPE(PySequence_GetItem($input,0)) {

                PyErr_SetString(PyExc_ValueError,"Type mismatch");

                free($1);

                return NULL;

        }

        $1[i] = (PyTYPE(PySequence_GetItem($input, i))) o;

    }

}

*/

#if defined(SWIGPYTHON)

%{

struct internal_usr {

    PyObject *func;

    PyObject *usr;

};

int rule_result_output_callback_wrapper(struct xccdf_rule_result* rule_result, void *arg)

{

    PyGILState_STATE state;

    PyObject *py_rule_result;

    PyObject *arglist;

    PyObject *func, *usrdata;

    struct internal_usr *data;

    PyObject *result;

    double    dres = 0;

    state = PyGILState_Ensure();

    py_rule_result = SWIG_NewPointerObj(rule_result, SWIGTYPE_p_xccdf_rule_result, 1);

    data = (struct internal_usr *) arg;

    func = data->func;

    usrdata = data->usr;

    arglist = Py_BuildValue("OO", py_rule_result, usrdata);

    if (!PyCallable_Check(func)) {

      PyGILState_Release(state);

      return 1;

    }

    result = PyEval_CallObject(func,arglist);

    if (result == NULL) {

        if (PyErr_Occurred() != NULL)

            PyErr_PrintEx(0);

        PyErr_Print();

        Py_DECREF(arglist);

        Py_XDECREF(result);

        PyGILState_Release(state);

        return -1;

    }

    Py_DECREF(arglist);

    dres = PyInt_AsLong(result);

    Py_XDECREF(result);

    PyGILState_Release(state);

    return dres;

}

int rule_start_callback_wrapper(struct xccdf_rule* rule, void *arg)

{

    PyGILState_STATE state;

    PyObject *py_rule;

    PyObject *arglist;

    PyObject *func, *usrdata;

    struct internal_usr *data;

    PyObject *result;

    double    dres = 0;

    state = PyGILState_Ensure();

    py_rule = SWIG_NewPointerObj(rule, SWIGTYPE_p_xccdf_rule, 1);

    data = (struct internal_usr *) arg;

    func = data->func;

    usrdata = data->usr;

    arglist = Py_BuildValue("OO", py_rule, usrdata);

    if (!PyCallable_Check(func)) {

      PyGILState_Release(state);

      return 1;

    }

    result = PyEval_CallObject(func,arglist);

    if (result == NULL) {

        if (PyErr_Occurred() != NULL)

            PyErr_PrintEx(0);

        PyErr_Print();

        Py_DECREF(arglist);

        Py_XDECREF(result);

        PyGILState_Release(state);

        return -1;

    }

    Py_DECREF(arglist);

    dres = PyInt_AsLong(result);

    Py_XDECREF(result);

    PyGILState_Release(state);

    return dres;

}

int agent_reporter_callback_wrapper(const struct oval_result_definition* res_def, void *arg)

{

    PyGILState_STATE state;

    PyObject *py_res_def;

    PyObject *arglist;

    PyObject *func, *usrdata;

    struct internal_usr *data;

    PyObject *result;

    double    dres = 0;

    state = PyGILState_Ensure();

    py_res_def = SWIG_NewPointerObj(res_def, SWIGTYPE_p_oval_result_definition, 1);

    data = (struct internal_usr *) arg;

    func = data->func;

    usrdata = data->usr;

    arglist = Py_BuildValue("OO", py_res_def, usrdata);

    if (!PyCallable_Check(func)) {

      PyGILState_Release(state);

      return 1;

    }

    result = PyEval_CallObject(func,arglist);

    if (result == NULL) {

        if (PyErr_Occurred() != NULL)

            PyErr_PrintEx(0);

        PyErr_Print();

        Py_DECREF(arglist);

        Py_XDECREF(result);

        PyGILState_Release(state);

        return -1;

    }

    Py_DECREF(arglist);

    dres = PyInt_AsLong(result);

    Py_XDECREF(result);

    PyGILState_Release(state);

    return dres;

}

int validate_callback_wrapper(const char* file, int line, const char* msg, void *arg)

{

    PyGILState_STATE state;

    PyObject *arglist;

    PyObject *func, *usrdata;

    struct internal_usr *data;

    PyObject *result;

    double    dres = 0;

    state = PyGILState_Ensure();

    data = (struct internal_usr *) arg;

    func = data->func;

    usrdata = data->usr;

    arglist = Py_BuildValue("sisO", file, line, msg, usrdata);

    if (!PyCallable_Check(func)) {

      PyGILState_Release(state);

      return 1;

    }

    result = PyEval_CallObject(func,arglist);

    if (result == NULL) {

        if (PyErr_Occurred() != NULL)

            PyErr_PrintEx(0);

        PyErr_Print();

        Py_DECREF(arglist);

        Py_XDECREF(result);

        PyGILState_Release(state);

        return -1;

    }

    Py_DECREF(arglist);

    dres = PyInt_AsLong(result);

    Py_XDECREF(result);

    PyGILState_Release(state);

    return dres;

}

char * sub_callback_wrapper(xccdf_subst_type_t type, const char *id, void *arg)

{

    PyGILState_STATE state;

    PyObject *arglist;

    PyObject *func, *usrdata;

    struct internal_usr *data;

    PyObject *result;

    char *dres = NULL;

    state = PyGILState_Ensure();

    data = (struct internal_usr *) arg;

    func = data->func;

    usrdata = data->usr;

    arglist = Py_BuildValue("isO", type, id, usrdata);

    if (!PyCallable_Check(func)) {

      PyGILState_Release(state);

      return 1;

    }

    result = PyEval_CallObject(func, arglist);

    if (result == NULL) {

        if (PyErr_Occurred() != NULL)

            PyErr_PrintEx(0);

        PyErr_Print();

        Py_DECREF(arglist);

        Py_XDECREF(result);

        PyGILState_Release(state);

        return NULL;

    }

    Py_DECREF(arglist);

    dres = PyString_AsString(result);

    if (dres == NULL) {

        if (PyErr_Occurred() != NULL)

            PyErr_PrintEx(0);

        PyErr_Print();

        Py_DECREF(arglist);

        Py_XDECREF(result);

        PyGILState_Release(state);

        return NULL;

    }

    Py_XDECREF(result);

    PyGILState_Release(state);

    return strdup(dres);

}

%}

%inline %{

bool xccdf_policy_model_register_output_callback_py(struct xccdf_policy_model *model, PyObject *func, PyObject *usr) {

    struct internal_usr *new_usrdata;

    PyEval_InitThreads();

    Py_INCREF(func);

    Py_INCREF(usr);

    new_usrdata = malloc(sizeof(struct internal_usr));

    if (new_usrdata == NULL) return false;

    new_usrdata->func = func;

    new_usrdata->usr = usr;

    return xccdf_policy_model_register_output_callback(model, rule_result_output_callback_wrapper, (void *)new_usrdata);

}

bool xccdf_policy_model_register_start_callback_py(struct xccdf_policy_model *model, PyObject *func, PyObject *usr) {

    struct internal_usr *new_usrdata;

    PyEval_InitThreads();

    Py_INCREF(func);

    Py_INCREF(usr);

    new_usrdata = malloc(sizeof(struct internal_usr));

    if (new_usrdata == NULL) return false;

    new_usrdata->func = func;

    new_usrdata->usr = usr;

    return xccdf_policy_model_register_start_callback(model, rule_start_callback_wrapper, (void *)new_usrdata);

}

int oval_agent_eval_system_py(oval_agent_session_t * asess, PyObject * func, PyObject *usr) {

    struct internal_usr *new_usrdata;

    PyEval_InitThreads();

    Py_INCREF(func);

    Py_INCREF(usr);

    new_usrdata = malloc(sizeof(struct internal_usr));

    if (new_usrdata == NULL) return false;

    new_usrdata->func = func;

    new_usrdata->usr = usr;

    return oval_agent_eval_system(asess, agent_reporter_callback_wrapper, (void *) new_usrdata);

}

/* we only recopy the first part of the struct, in order to free the rule property

* since it's defined in xccdf_session.c and not xccdf_session.h, this struct is unknown

* and so it's not possible to access to the rule property without defining it

*/

struct xccdf_session {

        char *filename;

        char *rule;

};

void xccdf_session_set_rule_py(struct xccdf_session  *sess, char *rule) {

    char *n_rule = strdup(rule);

    xccdf_session_set_rule(sess, n_rule);

}

void xccdf_session_free_py(struct xccdf_session *sess){

    free(sess->rule);

    xccdf_session_free(sess);

}

%}

#endif