src/python.c

Go to the documentation of this file.

/*
 * Author: Thomas Wouters <thomas@xs4all.net>
 *
 * Copyright (c) 2001-2002 Thomas Wouters
 *   All rights reserved.
 *
 * Loosely based on Markus Stenberg's python-patch to TinyMUSH 3.0.
 */

#include "config.h"
#include "db.h"
#include "externs.h"
#include "mudconf.h"
#include "config.h"

#ifdef USE_PYTHON
#include "Python.h"

static dbref cause = -1;
static dbref who = -1;

static long last_sec;
static long last_run;

static PyObject *MakeFakeStdout(dbref i);

static PyObject *sysmod = NULL;
static PyObject *muxmod = NULL;
static PyObject *maindict = NULL;

/* 0 = not started
  -1 = not functional (something severe happened)
   1 = started and ready to serve
*/
static int MUXPy_State = 0;

extern void raw_notify_raw(dbref, char *, char *);
static void init_muxmodule(void);

void MUXPy_ReportError(dbref who, int clearerr)
{
        /* XXX report the traceback, somehow */
        if(clearerr)
                PyErr_Clear();
}

void MUXPy_Abort(char *message)
{
        /* Something went massively wrong. Disable the python runtime
           and report the error. */

        MUXPy_State = -1;
        STARTLOG(LOG_PROBLEMS, "PYTHON", NULL) {
                log_text("Python Runtime disabled: ");
                log_text(message);
                ENDLOG;
        }
        if(PyErr_Occurred()) {
                MUXPy_ReportError(-1, 1);
        }
        Py_XDECREF(maindict);
        Py_XDECREF(sysmod);
        Py_XDECREF(muxmod);
}

void MUXPy_Init(void)
{

        PyObject *sys_path, *muxpy_path, *mainmod;

        if(MUXPy_State != 0)
                return;

        Py_SetProgramName("netmux");
        Py_Initialize();

        init_muxmodule();

        if((mainmod = PyImport_ImportModule("__main__")) == NULL) {
                MUXPy_Abort("Can't import '__main__' module");
                return;
        }

        if((maindict = PyModule_GetDict(mainmod)) == NULL) {
                MUXPy_Abort("Can't get module dict for '__main__'");
                return;
        }
        Py_INCREF(maindict);

        if((sysmod = PyImport_ImportModule("sys")) == NULL) {
                MUXPy_Abort("Can't import 'sys' module");
                return;
        }

        sys_path = PyObject_GetAttrString(sysmod, "path");
        if(sys_path == NULL) {
                MUXPy_Abort("Can't find sys.path to update!");
                return;
        }
        muxpy_path = PyString_FromString("muxpy-lib");
        if(muxpy_path == NULL) {
                Py_DECREF(sys_path);
                MUXPy_Abort("Can't create muxpy-lib path string");
                return;
        }
        if(PyList_Append(sys_path, muxpy_path) == -1) {
                Py_DECREF(sys_path);
                Py_DECREF(muxpy_path);
                MUXPy_Abort("Can't append muxpy-lib path string to sys.path");
                return;
        }

        if((muxmod = PyImport_ImportModule("mux")) == NULL) {
                MUXPy_Abort("Can't import 'mux' module");
                return;
        }

        STARTLOG(LOG_PROBLEMS, "PYTHON", NULL) {
                log_text("Python Runtime Started.");
                ENDLOG;
        }
        MUXPy_State = 1;
}

#define MAX_UPDATE_PER_SEC 3
#define TICK(x) ((x) / (1000000/MAX_UPDATE_PER_SEC))

static int shouldupdate()
{
        struct timeval tv;
        struct timezone tz;
        int tick;

        if(gettimeofday(&tv, &tz) < 0)
                return 0;
        if(tv.tv_sec == last_sec) {
                tick = TICK(tv.tv_usec);
                if(tick == last_run)
                        return 0;
        } else
                tick = TICK(tv.tv_usec);
        last_sec = tv.tv_sec;
        last_run = tick;
        return 1;
}

void runPythonHook(char *hook)
{
        PyObject *hookobj, *arglist, *result;

        if(MUXPy_State != 1)
                return;
        hookobj = PyObject_GetAttrString(muxmod, hook);
        if(hookobj) {
                if(PyCallable_Check(hookobj)) {
                        if((arglist = PyTuple_New(0)) == NULL) {
                                /* Can't create/reuse empty tuple -- serious error. */
                                MUXPy_Abort("Can't create empty tuple");
                                return;
                        }
                        result = PyEval_CallObject(hookobj, arglist);
                        /* XXX use result */
                } else {
                        MUXPy_ReportError(-1, 1);
                }
        } else {
                /* attr not found, possibly log it ? */
                MUXPy_ReportError(-1, 1);
        }
}

void updatePython(void)
{
        if(!shouldupdate())
                return;
        runPythonHook("update");
}

void endPython(int result)
{
        MUXPy_State = 0;
        Py_Exit(result);
        /* XXX: Insert this, instead of regular exit, to all places (ugh) */
        /* NOTREACHED */
}

static PyObject *setStdout(dbref player)
{
        PyObject *stdout = MakeFakeStdout(player);

        if(stdout == NULL)
                return NULL;
        if(PySys_SetObject("stdout", stdout) == -1) {
                MUXPy_ReportError(player, 1);
                return NULL;
        }
        if(PySys_SetObject("stderr", stdout) == -1) {
                MUXPy_ReportError(player, 1);
                return NULL;
        }
        return stdout;
}

static PyObject *evalString(char *runstring)
{
        /* Run eval() on the code, and print result */
        PyObject *result = PyRun_String(runstring, Py_single_input,
                                                                        maindict, maindict);

        return result;
}

int update_whocause(void)
{
        PyObject *tmp;

        if((tmp = PyInt_FromLong((long) who)) == NULL)
                return -1;

        if(PyDict_SetItemString(maindict, "who", tmp) == -1) {
                Py_DECREF(tmp);
                return -1;
        }
        Py_DECREF(tmp);

        if((tmp = PyInt_FromLong((long) cause)) == NULL)
                return -1;
        if(PyDict_SetItemString(maindict, "cause", tmp) == -1) {
                Py_DECREF(tmp);
                return -1;
        }
        Py_DECREF(tmp);
        return 0;
}

void do_python(dbref cwho, dbref ccause, int key, char *target)
{
        PyObject *stdout, *result;
        dbref prev_cause = cause;
        dbref prev_who = who;

        if(MUXPy_State != 1)
                return;
        if(!target)
                return;
        if(*target == ',')
                target++;                               /* one-letter start */
        while (*target && isspace(*target))
                target++;

        stdout = setStdout(cwho);
        if(stdout == NULL) {
                PyErr_Print();
                MUXPy_ReportError(who, 1);
                return;
        }

        cause = ccause;
        who = cwho;
        if(cause != prev_cause || who != prev_who)
                update_whocause();

        result = PyRun_String(target, Py_single_input, maindict, maindict);
        if(result == NULL) {
                if(PyErr_Occurred()) {
                        PyErr_Print();
                        PyErr_Clear();
                }
        }
        if(result != NULL && result != Py_None) {
                PyObject *str = PyObject_Repr(result);

                if(str != NULL) {
                        raw_notify_raw(cwho, PyString_AsString(str), "\r\n");
                        Py_DECREF(str);
                }
        }

        Py_XDECREF(result);
        Py_DECREF(stdout);
        cause = prev_cause;
        who = prev_who;
}

void fun_python(char *buff, char **bufc, dbref cwho, dbref ccause,
                                char *fargs[], int nfargs, char *cargs[], int ncargs)
{
        char buf[LBUF_SIZE];            /* XXX: Overflow check */
        PyObject *stdout, *t;
        int eval = 1;
        char *c, *target = fargs[0];
        dbref prev_cause = cause;
        dbref prev_who = who;

        if(MUXPy_State != 1)
                return;
        if(!target)
                return;
        while (*target && isspace(*target))
                target++;
        if(!*target)
                return;

        stdout = setStdout(cwho);
        if(stdout == NULL) {
                MUXPy_ReportError(who, 1);
                return;
        }

        who = cwho;
        cause = ccause;
        if(cause != prev_cause || who != prev_who)
                update_whocause();

        if((t = evalString(target))) {
                if(t != Py_None) {
                        PyObject *str;

                        if((str = PyObject_Str(t))) {
                                safe_str(PyString_AsString(str), buff, bufc);
                                Py_DECREF(str);
                        } else {
                                MUXPy_ReportError(who, 1);
                        }
                }
        } else {
                MUXPy_ReportError(who, 1);
        }
        Py_DECREF(stdout);
        cause = prev_cause;
        who = prev_who;
}

void fun_pythoncall(char *buff, char **bufc,
                                        dbref cwho, dbref ccause,
                                        char *fargs[], int nfargs, char *cargs[], int ncargs)
{
        char buf[LBUF_SIZE];
        char *myfargs[2];
        char *to, c;
        int i;

        /* Conveniency function that converts arguments and calls fun_python() */

        if(MUXPy_State != 1)
                return;

        if(nfargs < 1) {
                safe_str("#-1 AT LEAST ONE ARGUMENT IS REQUIRED", buff, bufc);
                return;
        }

        strcpy(buf, fargs[0]);
        to = buf + strlen(buf);
        *to++ = '(';
        for(i = 1; i < nfargs; i++) {
                char *fr = fargs[i];

                if(i > 1)
                        *to++ = ',';

                *to++ = '"';
                while (*fr && (to - buf) < (LBUF_SIZE - 10)) {
                        c = *fr++;
                        if(c == '"')
                                c = '\'';
                        *to++ = c;
                }
                if((to - buf) >= (LBUF_SIZE - 10)) {
                        safe_str("#-1 ARGUMENTS TOO LONG", buff, bufc);
                        return;
                }
                *to++ = '"';
        }
        *to++ = ')';
        *to = 0;
        myfargs[0] = buf;
        myfargs[1] = NULL;
        fun_python(buff, bufc, cwho, ccause, myfargs, 1, cargs, ncargs);
}

/* Fake stdout, prints to player-dbref. */

staticforward PyTypeObject PyFakeStdout_Type;
typedef struct {
        PyObject_HEAD;
        dbref dbref;
} fakestdout;

static PyObject *fakestdout_write(fakestdout * self, PyObject * args)
{
        char *str;

        if(!PyArg_ParseTuple(args, "s:write", &str))
                return NULL;
        raw_notify_raw(self->dbref, str, NULL);
        Py_INCREF(Py_None);
        return Py_None;
}

static PyObject *MakeFakeStdout(dbref dbref)
{
        fakestdout *mo = PyObject_NEW(fakestdout, &PyFakeStdout_Type);

        if(mo == NULL)
                return NULL;
        mo->dbref = dbref;
        return (PyObject *) mo;
}

static PyMethodDef fakestdout_methods[] = {
        {"write", (PyCFunction) fakestdout_write, METH_VARARGS},
        {NULL, NULL}                            /* Sentinel */
};

static PyObject *fakestdout_getattr(PyObject * self, char *name)
{
        return Py_FindMethod(fakestdout_methods, self, name);
}

static void fakestdout_dealloc(fakestdout * self)
{
        PyMem_DEL(self);
}

static PyTypeObject PyFakeStdout_Type = {

        PyObject_HEAD_INIT(&PyType_Type) 0,     /*ob_size */
        "fakestdout",                           /*tp_name */
        sizeof(fakestdout),                     /*tp_size */
        0,                                                      /*tp_itemsize */
        /* methods */
        (destructor) fakestdout_dealloc,        /*tp_dealloc */
        0,                                                      /*tp_print */
        (getattrfunc) fakestdout_getattr,       /*tp_getattr */
        0,                                                      /*tp_setattr */
        0,                                                      /*tp_compare */
        0,                                                      /*tp_repr */
};

/* MUXObject */

staticforward PyTypeObject PyMUXObject_Type;

typedef struct {
        PyObject_HEAD;
        dbref dbref;
} MUXObject;

static PyObject *MUXObject_New(dbref dbref)
{
        MUXObject *mo;

        mo = PyObject_NEW(MUXObject, &PyMUXObject_Type);
        if(mo == NULL)
                return NULL;
        mo->dbref = dbref;
        return (PyObject *) mo;
}

static void MUXObject_Del(MUXObject * self)
{
        PyMem_DEL(self);
}

static PyObject *MUXObject_keys(MUXObject * self, PyObject * args)
{
        PyObject *p;
        int ca;
        char *as;
        ATTR *attr;

        if(!PyArg_ParseTuple(args, ":keys"))
                return NULL;
        p = PyList_New(0);
        PyList_Append(p, PyString_FromString("Dbref"));
        PyList_Append(p, PyString_FromString("Location"));
        for(ca = atr_head(self->dbref, &as); ca; ca = atr_next(&as)) {
                attr = atr_num(ca);
                PyList_Append(p, PyString_FromString(attr->name));
        }
        return p;
}

static PyMethodDef MUXObject_methods[] = {
        {"keys", (PyCFunction) MUXObject_keys, METH_VARARGS},
        {NULL, NULL}                            /* Sentinel */
};

static PyObject *MUXObject_GetAttr(MUXObject * self, char *name)
{
        char *ptr;
        int len;
        ATTR *a;
        char *buf;
        int ao, af;                                     /* Attribute owner, attribute flags */
        PyObject *p;
        PyObject *v = NULL;

        if(strcasecmp(name, "location") == 0)
                return PyInt_FromLong(Location(self->dbref));

        if(strcasecmp(name, "dbref") == 0)
                return PyInt_FromLong(self->dbref);

        if(!(a = atr_str(name)))
                return Py_FindMethod(MUXObject_methods, (PyObject *) self, name);

        buf = alloc_lbuf("python_getattr");     /* XXX: Overflow check */
        atr_get_str(buf, self->dbref, a->number, &ao, &af);
        p = PyString_FromString(buf);
        free_lbuf(buf);
        return p;
}

static int MUXObject_SetAttr(MUXObject * self, char *name, PyObject * v)
{
        ATTR *atr;
        int attnum;

        atr = atr_str(name);
        if(v == NULL) {
                /* delAttr */
                if(atr) {
                        atr_clr(self->dbref, atr->number);
                        return 0;
                }
                PyErr_SetString(PyExc_AttributeError, "Nonexistent attribute");
                return -1;
        }
        if(!PyString_Check(v)) {
                PyErr_SetString(PyExc_ValueError,
                                                "Invalid value: only string accepted");
                return -1;
        }
        attnum = atr ? atr->number : mkattr(name);
        atr_add_raw(self->dbref, attnum, PyString_AsString(v));
        return 0;
}

/* Functions in MUX module */
static PyObject *muxc_getobject(PyObject * self, PyObject * args)
{
        dbref dbref;

        if(!PyArg_ParseTuple(args, "i:getobject", &dbref))
                return NULL;
        return MUXObject_New(dbref);
}

static PyObject *mux_eval(dbref dbref, char *str)
{
        char *buf = alloc_lbuf("objeval");
        char *endMarker = buf;
        PyObject *rv;

        exec(buf, &endMarker, 0, dbref, cause,
                 EV_FCHECK | EV_STRIP | EV_EVAL, &str, NULL, 0);
        *endMarker = 0;
        if(*buf)
                rv = PyString_FromString(buf);
        else {
                Py_INCREF(Py_None);
                rv = Py_None;
        }
        free_lbuf(buf);
        return rv;
}

static PyObject *muxc_muxeval(PyObject * self, PyObject * args)
{
        dbref dbref;
        char *str;

        if(!PyArg_ParseTuple(args, "is:muxeval", &dbref, &str))
                return NULL;
        return mux_eval(dbref, str);
}

static PyObject *muxc_notify(PyObject * self, PyObject * args)
{
        dbref dbref;
        char *str;

        if(!PyArg_ParseTuple(args, "is:notify", &dbref, &str))
                return NULL;
        notify(dbref, str);
        Py_INCREF(Py_None);
        return Py_None;
}

/* Initialization */ static PyTypeObject PyMUXObject_Type = {
        PyObject_HEAD_INIT(&PyType_Type) 0,     /*ob_size */
        "MUXobject",                            /*tp_name */
        sizeof(MUXObject),                      /*tp_basicsize */
        0,                                                      /*tp_itemsize */
        /* methods */
        (destructor) MUXObject_Del,     /*tp_dealloc */
        0,                                                      /*tp_print */
        (getattrfunc) MUXObject_GetAttr,        /*tp_getattr */
        (setattrfunc) MUXObject_SetAttr,        /*tp_setattr */
        0,                                                      /*tp_compare */
        0,                                                      /*tp_repr */
        0,                                                      /*tp_hash (=as_number) */
};

static PyMethodDef MUXMethods[] = {
        {"getobject", muxc_getobject, METH_VARARGS},
        {"muxeval", muxc_muxeval, METH_VARARGS},
        {"notify", muxc_notify, METH_VARARGS},
        {NULL, NULL}                            /* Sentinel */
};

static void init_muxmodule()
{
        PyImport_AddModule("muxc");
        Py_InitModule("muxc", MUXMethods);
}
#endif /* USE_PYTHON */

---