/*
_reader - Python module that reads systemd journal similar to journalctl
Copyright (C) 2012  Steven Hiscocks

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
*/
#include <systemd/sd-journal.h>

#include <Python.h>
#include <structmember.h>
#include <datetime.h>

typedef struct {
    PyObject_HEAD
    sd_journal *j;
    PyObject *default_call;
    PyObject *call_dict;
} Journal;
static PyTypeObject JournalType;

static void
Journal_dealloc(Journal* self)
{
    sd_journal_close(self->j);
    Py_XDECREF(self->default_call);
    Py_XDECREF(self->call_dict);
    Py_TYPE(self)->tp_free((PyObject*)self);
}

static PyObject *
Journal_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    Journal *self;

    self = (Journal *)type->tp_alloc(type, 0);
    if (self != NULL) {
        PyObject *globals, *temp;

        globals = PyEval_GetBuiltins();
        temp = PyImport_ImportModule("functools");
        PyDict_SetItemString(globals, "functools", temp);
        Py_DECREF(temp);
        temp = PyImport_ImportModule("datetime");
        PyDict_SetItemString(globals, "datetime", temp);
        Py_DECREF(temp);

#if PY_MAJOR_VERSION >=3
        self->default_call = PyRun_String("functools.partial(str, encoding='utf-8')", Py_eval_input, globals, NULL);
#else
        self->default_call = PyRun_String("functools.partial(unicode, encoding='utf-8')", Py_eval_input, globals, NULL);
#endif

        self->call_dict = PyRun_String("{"
            "'PRIORITY': int,"
            "'LEADER': int,"
            "'SESSION_ID': int,"
            "'USERSPACE_USEC': int,"
            "'INITRD_USEC': int,"
            "'KERNEL_USEC': int,"
            "'_UID': int,"
            "'_GID': int,"
            "'_PID': int,"
            "'SYSLOG_FACILITY': int,"
            "'SYSLOG_PID': int,"
            "'_AUDIT_SESSION': int,"
            "'_AUDIT_LOGINUID': int,"
            "'_SYSTEMD_SESSION': int,"
            "'_SYSTEMD_OWNER_UID': int,"
            "'CODE_LINE': int,"
            "'ERRNO': int,"
            "'EXIT_STATUS': int,"
            "'_SOURCE_REALTIME_TIMESTAMP': lambda x: datetime.datetime.fromtimestamp(float(x)/1E6),"
            "'__REALTIME_TIMESTAMP': lambda x: datetime.datetime.fromtimestamp(float(x)/1E6),"
            "'_SOURCE_MONOTONIC_TIMESTAMP': lambda x: datetime.timedelta(microseconds=float(x)),"
            "'__MONOTONIC_TIMESTAMP': lambda x: datetime.timedelta(microseconds=float(x)),"
#if PY_MAJOR_VERSION >=3
            "'COREDUMP': bytes,"
#else
            "'COREDUMP': str,"
#endif
            "'COREDUMP_PID': int,"
            "'COREDUMP_UID': int,"
            "'COREDUMP_GID': int,"
            "'COREDUMP_SESSION': int,"
            "'COREDUMP_SIGNAL': int,"
            "'COREDUMP_TIMESTAMP': lambda x: datetime.datetime.fromtimestamp(float(x)/1E6),"
            "}", Py_eval_input, globals, NULL);
    }

    return (PyObject *) self;
}

PyDoc_STRVAR(Journal__doc__,
"Journal([flags][, default_call][, call_dict][,path]) -> ...\n"
"Journal instance\n\n"
"Returns instance of Journal, which allows filtering and return\n"
"of journal entries.\n"
"Argument `flags` sets open flags of the journal, which can be one\n"
"of, or ORed combination of constants: LOCAL_ONLY (default) opens\n"
"journal on local machine only; RUNTIME_ONLY opens only\n"
"volatile journal files; and SYSTEM_ONLY opens only\n"
"journal files of system services and the kernel.\n"
"Argument `default_call` must be a callable that accepts one\n"
"argument which is string/bytes value of a field and returns\n"
"python object.\n"
"Argument `call_dict` is a dictionary where the key represents\n"
"a field name, and value is a callable as per `default_call`.\n"
"A set of sane defaults for `default_call` and `call_dict` are\n"
"present.\n"
"Argument `path` is the directory of journal files. Note that\n"
"currently flags are ignored when `path` is present as they are\n"
" not relevant.");
static int
Journal_init(Journal *self, PyObject *args, PyObject *keywds)
{
    int flags=SD_JOURNAL_LOCAL_ONLY;
    char *path=NULL;
    PyObject *default_call=NULL, *call_dict=NULL;

    static char *kwlist[] = {"flags", "default_call", "call_dict", "path", NULL};
    if (! PyArg_ParseTupleAndKeywords(args, keywds, "|iOOs", kwlist,
                                      &flags, &default_call, &call_dict, &path))
        return 1;

    if (default_call) {
        if (PyCallable_Check(default_call) || default_call == Py_None) {
            Py_DECREF(self->default_call);
            self->default_call = default_call;
            Py_INCREF(self->default_call);
        }else{
            PyErr_SetString(PyExc_TypeError, "Default call not callable");
            return 1;
        }
    }

    if (call_dict) {
        if (PyDict_Check(call_dict)) {
            Py_DECREF(self->call_dict);
            self->call_dict = call_dict;
            Py_INCREF(self->call_dict);
        }else if (call_dict == Py_None) {
            Py_DECREF(self->call_dict);
            self->call_dict = PyDict_New();
        }else{
            PyErr_SetString(PyExc_TypeError, "Call dictionary must be dict type");
            return 1;
        }
    }

    int r;
    if (path) {
        r = sd_journal_open_directory(&self->j, path, 0);
    }else{
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_open(&self->j, flags);
        Py_END_ALLOW_THREADS
    }
    if (r == -EINVAL) {
        PyErr_SetString(PyExc_ValueError, "Invalid flags or path");
        return -1;
    }else if (r == -ENOMEM) {
        PyErr_SetString(PyExc_MemoryError, "Not enough memory");
        return 1;
    }else if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error opening journal");
        return 1;
    }

    return 0;
}

static PyObject *
Journal___process_field(Journal *self, PyObject *key, const void *value, ssize_t value_len)
{
    PyObject *callable=NULL, *return_value=NULL;
    if (PyDict_Check(self->call_dict))
        callable = PyDict_GetItem(self->call_dict, key);

    if (PyCallable_Check(callable)) {
#if PY_MAJOR_VERSION >=3
        return_value = PyObject_CallFunction(callable, "y#", value, value_len);
#else
        return_value = PyObject_CallFunction(callable, "s#", value, value_len);
#endif
        if (!return_value)
            PyErr_Clear();
    }
    if (!return_value && PyCallable_Check(self->default_call))
#if PY_MAJOR_VERSION >=3
        return_value = PyObject_CallFunction(self->default_call, "y#", value, value_len);
#else
        return_value = PyObject_CallFunction(self->default_call, "s#", value, value_len);
#endif
    if (!return_value) {
        PyErr_Clear();
#if PY_MAJOR_VERSION >=3
        return_value = PyBytes_FromStringAndSize(value, value_len);
#else
        return_value = PyString_FromStringAndSize(value, value_len);
#endif
    }
    if (!return_value) {
        return_value = Py_None;
    }
    return return_value;
}

PyDoc_STRVAR(Journal_get_next__doc__,
"get_next([skip]) -> dict\n\n"
"Return dictionary of the next log entry. Optional skip value will\n"
"return the `skip`th log entry.");
static PyObject *
Journal_get_next(Journal *self, PyObject *args)
{
    int64_t skip=1LL;
    if (! PyArg_ParseTuple(args, "|L", &skip))
        return NULL;

    int r;
    if (skip == 1LL) {
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_next(self->j);
        Py_END_ALLOW_THREADS
    }else if (skip == -1LL) {
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_previous(self->j);
        Py_END_ALLOW_THREADS
    }else if (skip > 1LL) {
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_next_skip(self->j, skip);
        Py_END_ALLOW_THREADS
    }else if (skip < -1LL) {
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_previous_skip(self->j, -skip);
        Py_END_ALLOW_THREADS
    }else{
        PyErr_SetString(PyExc_ValueError, "Skip number must positive/negative integer");
        return NULL;
    }

    if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error getting next message");
        return NULL;
    }else if ( r == 0) { //EOF
        return PyDict_New();
    }

    PyObject *dict;
    dict = PyDict_New();

    const void *msg;
    size_t msg_len;
    const char *delim_ptr;
    PyObject *key, *value, *cur_value, *tmp_list;

    SD_JOURNAL_FOREACH_DATA(self->j, msg, msg_len) {
        delim_ptr = memchr(msg, '=', msg_len);
#if PY_MAJOR_VERSION >=3
        key = PyUnicode_FromStringAndSize(msg, delim_ptr - (const char*) msg);
#else
        key = PyString_FromStringAndSize(msg, delim_ptr - (const char*) msg);
#endif
        value = Journal___process_field(self, key, delim_ptr + 1, (const char*) msg + msg_len - (delim_ptr + 1) );
        if (PyDict_Contains(dict, key)) {
            cur_value = PyDict_GetItem(dict, key);
            if (PyList_CheckExact(cur_value) && PyList_Size(cur_value) > 1) {
                PyList_Append(cur_value, value);
            }else{
                tmp_list = PyList_New(0);
                PyList_Append(tmp_list, cur_value);
                PyList_Append(tmp_list, value);
                PyDict_SetItem(dict, key, tmp_list);
                Py_DECREF(tmp_list);
            }
        }else{
            PyDict_SetItem(dict, key, value);
        }
        Py_DECREF(key);
        Py_DECREF(value);
    }

    uint64_t realtime;
    if (sd_journal_get_realtime_usec(self->j, &realtime) == 0) {
        char realtime_str[20];
        sprintf(realtime_str, "%llu", (long long unsigned) realtime);

#if PY_MAJOR_VERSION >=3
        key = PyUnicode_FromString("__REALTIME_TIMESTAMP");
#else
        key = PyString_FromString("__REALTIME_TIMESTAMP");
#endif
        value = Journal___process_field(self, key, realtime_str, strlen(realtime_str));
        PyDict_SetItem(dict, key, value);
        Py_DECREF(key);
        Py_DECREF(value);
    }

    sd_id128_t sd_id;
    uint64_t monotonic;
    if (sd_journal_get_monotonic_usec(self->j, &monotonic, &sd_id) == 0) {
        char monotonic_str[20];
        sprintf(monotonic_str, "%llu", (long long unsigned) monotonic);
#if PY_MAJOR_VERSION >=3
        key = PyUnicode_FromString("__MONOTONIC_TIMESTAMP");
#else
        key = PyString_FromString("__MONOTONIC_TIMESTAMP");
#endif
        value = Journal___process_field(self, key, monotonic_str, strlen(monotonic_str));

        PyDict_SetItem(dict, key, value);
        Py_DECREF(key);
        Py_DECREF(value);
    }

    char *cursor;
    if (sd_journal_get_cursor(self->j, &cursor) > 0) { //Should return 0...
#if PY_MAJOR_VERSION >=3
        key = PyUnicode_FromString("__CURSOR");
#else
        key = PyString_FromString("__CURSOR");
#endif
        value = Journal___process_field(self, key, cursor, strlen(cursor));
        PyDict_SetItem(dict, key, value);
        free(cursor);
        Py_DECREF(key);
        Py_DECREF(value);
    }

    return dict;
}

PyDoc_STRVAR(Journal_get_previous__doc__,
"get_previous([skip]) -> dict\n\n"
"Return dictionary of the previous log entry. Optional skip value\n"
"will return the -`skip`th log entry. Equivalent to get_next(-skip).");
static PyObject *
Journal_get_previous(Journal *self, PyObject *args)
{
    int64_t skip=1LL;
    if (! PyArg_ParseTuple(args, "|L", &skip))
        return NULL;

    PyObject *dict, *arg;
    arg = Py_BuildValue("(L)", -skip);
    dict = Journal_get_next(self, arg);
    Py_DECREF(arg);
    return dict;
}

PyDoc_STRVAR(Journal_add_match__doc__,
"add_match(match, ..., field=value, ...) -> None\n\n"
"Add a match to filter journal log entries. All matches of different\n"
"field are combined in logical AND, and matches of the same field\n"
"are automatically combined in logical OR.\n"
"Matches can be passed as strings \"field=value\", or keyword\n"
"arguments field=\"value\".");
static PyObject *
Journal_add_match(Journal *self, PyObject *args, PyObject *keywds)
{
    Py_ssize_t arg_match_len;
    char *arg_match;
    int i, r;
    for (i = 0; i < PySequence_Size(args); i++) {
#if PY_MAJOR_VERSION >=3
        PyObject *arg;
        arg = PySequence_Fast_GET_ITEM(args, i);
        if (PyUnicode_Check(arg)) {
#if PY_MINOR_VERSION >=3
            arg_match = PyUnicode_AsUTF8AndSize(arg, &arg_match_len);
#else
            PyObject *temp;
            temp = PyUnicode_AsUTF8String(arg);
            PyBytes_AsStringAndSize(temp, &arg_match, &arg_match_len);
            Py_DECREF(temp);
#endif
        }else if (PyBytes_Check(arg)) {
            PyBytes_AsStringAndSize(arg, &arg_match, &arg_match_len);
        }else{
            PyErr_SetString(PyExc_TypeError, "expected bytes or string");
        }
#else
        PyString_AsStringAndSize(PySequence_Fast_GET_ITEM(args, i), &arg_match, &arg_match_len);
#endif
        if (PyErr_Occurred())
            return NULL;
        r = sd_journal_add_match(self->j, arg_match, arg_match_len);
        if (r == -EINVAL) {
            PyErr_SetString(PyExc_ValueError, "Invalid match");
            return NULL;
        }else if (r == -ENOMEM) {
            PyErr_SetString(PyExc_MemoryError, "Not enough memory");
            return NULL;
        }else if (r < 0) {
            PyErr_SetString(PyExc_RuntimeError, "Error adding match");
            return NULL;
        }
    }

    if (! keywds)
        Py_RETURN_NONE;

    PyObject *key, *value;
    Py_ssize_t pos=0, match_key_len, match_value_len;
    int match_len;
    char *match_key, *match_value;
    void *match;
    while (PyDict_Next(keywds, &pos, &key, &value)) {
#if PY_MAJOR_VERSION >=3
        if (PyUnicode_Check(key)) {
#if PY_MINOR_VERSION >=3
            match_key = PyUnicode_AsUTF8AndSize(key, &match_key_len);
#else
            PyObject *temp2;
            temp2 = PyUnicode_AsUTF8String(key);
            PyBytes_AsStringAndSize(temp2, &match_key, &match_key_len);
            Py_DECREF(temp2);
#endif
        }else if (PyBytes_Check(key)) {
            PyBytes_AsStringAndSize(key, &match_key, &match_key_len);
        }else{
            PyErr_SetString(PyExc_TypeError, "expected bytes or string");
        }
        if (PyUnicode_Check(value)) {
#if PY_MINOR_VERSION >=3
            match_value = PyUnicode_AsUTF8AndSize(value, &match_value_len);
#else
            PyObject *temp3;
            temp3 = PyUnicode_AsUTF8String(value);
            PyBytes_AsStringAndSize(temp3, &match_value, &match_value_len);
            Py_DECREF(temp3);
#endif
        }else if (PyBytes_Check(value)) {
            PyBytes_AsStringAndSize(value, &match_value, &match_value_len);
        }else{
            PyErr_SetString(PyExc_TypeError, "expected bytes or string");
        }
#else
        PyString_AsStringAndSize(key, &match_key, &match_key_len);
        PyString_AsStringAndSize(value, &match_value, &match_value_len);
#endif
        if (PyErr_Occurred())
            return NULL;

        match_len = match_key_len + 1 + match_value_len;
        match = malloc(match_len);
        memcpy(match, match_key, match_key_len);
        memcpy(match + match_key_len, "=", 1);
        memcpy(match + match_key_len + 1, match_value, match_value_len);

        r = sd_journal_add_match(self->j, match, match_len);
        free(match);
        if (r == -EINVAL) {
            PyErr_SetString(PyExc_ValueError, "Invalid match");
            return NULL;
        }else if (r == -ENOMEM) {
            PyErr_SetString(PyExc_MemoryError, "Not enough memory");
            return NULL;
        }else if (r < 0) {
            PyErr_SetString(PyExc_RuntimeError, "Error adding match");
            return NULL;
        }
    }

    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_add_disjunction__doc__,
"add_disjunction() -> None\n\n"
"Once called, all matches before and after are combined in logical\n"
"OR.");
static PyObject *
Journal_add_disjunction(Journal *self, PyObject *args)
{
    int r;
    r = sd_journal_add_disjunction(self->j);
    if (r == -ENOMEM) {
        PyErr_SetString(PyExc_MemoryError, "Not enough memory");
        return NULL;
    }else if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error adding disjunction");
        return NULL;
    }
    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_flush_matches__doc__,
"flush_matches() -> None\n\n"
"Clears all current match filters.");
static PyObject *
Journal_flush_matches(Journal *self, PyObject *args)
{
    sd_journal_flush_matches(self->j);
    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_seek__doc__,
"seek(offset[, whence]) -> None\n\n"
"Seek through journal by `offset` number of entries. Argument\n"
"`whence` defines what the offset is relative to:\n"
"os.SEEK_SET (default) from first match in journal;\n"
"os.SEEK_CUR from current position in journal;\n"
"and os.SEEK_END is from last match in journal.");
static PyObject *
Journal_seek(Journal *self, PyObject *args, PyObject *keywds)
{
    int64_t offset;
    int whence=SEEK_SET;
    static char *kwlist[] = {"offset", "whence", NULL};

    if (! PyArg_ParseTupleAndKeywords(args, keywds, "L|i", kwlist,
                                      &offset, &whence))
        return NULL;

    PyObject *arg;
    if (whence == SEEK_SET){
        int r;
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_seek_head(self->j);
        Py_END_ALLOW_THREADS
        if (r < 0) {
            PyErr_SetString(PyExc_RuntimeError, "Error seeking to head");
            return NULL;
        }
        if (offset > 0LL) {
            arg = Py_BuildValue("(L)", offset);
            Py_DECREF(Journal_get_next(self, arg));
            Py_DECREF(arg);
        }
    }else if (whence == SEEK_CUR){
        arg = Py_BuildValue("(L)", offset);
        Py_DECREF(Journal_get_next(self, arg));
        Py_DECREF(arg);
    }else if (whence == SEEK_END){
        int r;
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_seek_tail(self->j);
        Py_END_ALLOW_THREADS
        if (r < 0) {
            PyErr_SetString(PyExc_RuntimeError, "Error seeking to tail");
            return NULL;
        }
        arg = Py_BuildValue("(L)", -1LL);
        Py_DECREF(Journal_get_next(self, arg));
        Py_DECREF(arg);
        if (offset < 0LL) {
            arg = Py_BuildValue("(L)", offset);
            Py_DECREF(Journal_get_next(self, arg));
            Py_DECREF(arg);
        }
    }else{
        PyErr_SetString(PyExc_ValueError, "Invalid value for whence");
        return NULL;
    }
    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_seek_realtime__doc__,
"seek_realtime(realtime) -> None\n\n"
"Seek to nearest matching journal entry to `realtime`. Argument\n"
"`realtime` can be an integer unix timestamp in usecs or a "
"datetime instance.");
static PyObject *
Journal_seek_realtime(Journal *self, PyObject *args)
{
    PyObject *arg;
    if (! PyArg_ParseTuple(args, "O", &arg))
        return NULL;

    uint64_t timestamp=-1LL;
    if (PyDateTime_Check(arg)) {
        PyObject *temp;
        char *timestamp_str;
        temp = PyObject_CallMethod(arg, "strftime", "s", "%s%f");
#if PY_MAJOR_VERSION >=3
        PyObject *temp2;
        temp2 = PyUnicode_AsUTF8String(temp);
        timestamp_str = PyBytes_AsString(temp2);
        Py_DECREF(temp2);
#else
        timestamp_str = PyString_AsString(temp);
#endif
        Py_DECREF(temp);
        timestamp = strtoull(timestamp_str, NULL, 10);
    }else if (PyLong_Check(arg)) {
        timestamp = PyLong_AsUnsignedLongLong(arg);
#if PY_MAJOR_VERSION <3
    }else if (PyInt_Check(arg)) {
        timestamp = PyInt_AsUnsignedLongLongMask(arg);
#endif
    }
    if ((int64_t) timestamp < 0LL) {
        PyErr_SetString(PyExc_ValueError, "Time must be positive integer or datetime instance");
        return NULL;
    }

    int r;
    Py_BEGIN_ALLOW_THREADS
    r = sd_journal_seek_realtime_usec(self->j, timestamp);
    Py_END_ALLOW_THREADS
    if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error seek to time");
        return NULL;
    }
    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_seek_monotonic__doc__,
"seek_monotonic(monotonic[, bootid]) -> None\n\n"
"Seek to nearest matching journal entry to `monotonic`. Argument\n"
"`monotonic` is an timestamp from boot in secs, or a\n"
"timedelta instance.\n"
"Argument `bootid` is a string representing which boot the\n"
"monotonic time is reference to. Defaults to current bootid.");
static PyObject *
Journal_seek_monotonic(Journal *self, PyObject *args)
{
    PyObject *arg;
    char *bootid=NULL;
    if (! PyArg_ParseTuple(args, "O|s", &arg, &bootid))
        return NULL;

    uint64_t timestamp=-1LL;
    if PyDelta_Check(arg) {
        PyObject *temp;
        temp = PyObject_CallMethod(arg, "total_seconds", NULL);
        timestamp = (uint64_t) (PyFloat_AsDouble(temp) * 1E6);
        Py_DECREF(temp);
    }else if (PyFloat_Check(arg)) {
        timestamp = (uint64_t) (PyFloat_AsDouble(arg) * 1E6);
    }else if (PyLong_Check(arg)) {
        timestamp = PyLong_AsUnsignedLongLong(arg) * (uint64_t) 1E6;
#if PY_MAJOR_VERSION <3
    }else if (PyInt_Check(arg)) {
        timestamp = PyInt_AsUnsignedLongLongMask(arg) * (uint64_t) 1E6;
#endif

    }

    if ((int64_t) timestamp < 0LL) {
        PyErr_SetString(PyExc_ValueError, "Time must be positive number or timedelta instance");
        return NULL;
    }

    sd_id128_t sd_id;
    int r;
    if (bootid) {
        r = sd_id128_from_string(bootid, &sd_id);
        if (r == -EINVAL) {
            PyErr_SetString(PyExc_ValueError, "Invalid bootid");
            return NULL;
        } else if (r < 0) {
            PyErr_SetString(PyExc_RuntimeError, "Error processing bootid");
            return NULL;
        }
    }else{
        r = sd_id128_get_boot(&sd_id);
        if (r == -EIO) {
            PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
            return NULL;
        } else if (r < 0) {
            PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID");
            return NULL;
        }
    }

    Py_BEGIN_ALLOW_THREADS
    r = sd_journal_seek_monotonic_usec(self->j, sd_id, timestamp);
    Py_END_ALLOW_THREADS
    if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error seek to time");
        return NULL;
    }
    Py_RETURN_NONE;
}
 
PyDoc_STRVAR(Journal_wait__doc__,
"wait([timeout]) -> Change state (integer)\n\n"
"Waits until there is a change in the journal. Argument `timeout`\n"
"is the maximum number of seconds to wait before returning\n"
"regardless if journal has changed. If `timeout` is not given or is\n"
"0, then it will block forever.\n"
"Will return constants: NOP if no change; APPEND if new\n"
"entries have been added to the end of the journal; and\n"
"INVALIDATE if journal files have been added or removed.");
static PyObject *
Journal_wait(Journal *self, PyObject *args, PyObject *keywds)
{
    int64_t timeout=0LL;
    if (! PyArg_ParseTuple(args, "|L", &timeout))
        return NULL;

    int r;
    if ( timeout == 0LL) {
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_wait(self->j, (uint64_t) -1);
        Py_END_ALLOW_THREADS
    }else{
        Py_BEGIN_ALLOW_THREADS
        r = sd_journal_wait(self->j, timeout * 1E6);
        Py_END_ALLOW_THREADS
    }
#if PY_MAJOR_VERSION >=3
    return PyLong_FromLong(r);
#else
    return PyInt_FromLong(r);
#endif
}

PyDoc_STRVAR(Journal_seek_cursor__doc__,
"seek_cursor(cursor) -> None\n\n"
"Seeks to journal entry by given unique reference `cursor`.");
static PyObject *
Journal_seek_cursor(Journal *self, PyObject *args)
{
    const char *cursor;
    if (! PyArg_ParseTuple(args, "s", &cursor))
        return NULL;

    int r;
    Py_BEGIN_ALLOW_THREADS
    r = sd_journal_seek_cursor(self->j, cursor);
    Py_END_ALLOW_THREADS
    if (r == -EINVAL) {
        PyErr_SetString(PyExc_ValueError, "Invalid cursor");
        return NULL;
    }else if (r == -ENOMEM) {
        PyErr_SetString(PyExc_MemoryError, "Not enough memory");
        return NULL;
    }else if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error seeking to cursor");
        return NULL;
    }
    Py_RETURN_NONE;
}

static PyObject *
Journal_iter(PyObject *self)
{
    Py_INCREF(self);
    return self;
}

static PyObject *
Journal_iternext(PyObject *self)
{
    Journal *iter = (Journal *)self;
    PyObject *dict, *arg;
    Py_ssize_t dict_size;

    arg =  Py_BuildValue("()");
    dict = Journal_get_next(iter, arg);
    Py_DECREF(arg);
    dict_size = PyDict_Size(dict);
    if ((int64_t) dict_size > 0LL) {
        return dict;
    }else{
        Py_DECREF(dict);
        PyErr_SetNone(PyExc_StopIteration);
        return NULL;
    }
}

#ifdef SD_JOURNAL_FOREACH_UNIQUE
PyDoc_STRVAR(Journal_query_unique__doc__,
"query_unique(field) -> a set of values\n\n"
"Returns a set of unique values in journal for given `field`.\n"
"Note this does not respect any journal matches.");
static PyObject *
Journal_query_unique(Journal *self, PyObject *args)
{
    char *query;
    if (! PyArg_ParseTuple(args, "s", &query))
        return NULL;

    int r;
    Py_BEGIN_ALLOW_THREADS
    r = sd_journal_query_unique(self->j, query);
    Py_END_ALLOW_THREADS
    if (r == -EINVAL) {
        PyErr_SetString(PyExc_ValueError, "Invalid field name");
        return NULL;
    } else if (r == -ENOMEM) {
        PyErr_SetString(PyExc_MemoryError, "Not enough memory");
        return NULL;
    } else if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error querying journal");
        return NULL;
    }

    const void *uniq;
    size_t uniq_len;
    const char *delim_ptr;
    PyObject *value_set, *key, *value;
    value_set = PySet_New(0);

#if PY_MAJOR_VERSION >=3
    key = PyUnicode_FromString(query);
#else
    key = PyString_FromString(query);
#endif

    SD_JOURNAL_FOREACH_UNIQUE(self->j, uniq, uniq_len) {
        delim_ptr = memchr(uniq, '=', uniq_len);
        value = Journal___process_field(self, key, delim_ptr + 1, (const char*) uniq + uniq_len - (delim_ptr + 1));
        PySet_Add(value_set, value);
        Py_DECREF(value);
    }
    Py_DECREF(key);
    return value_set;
}
#endif //def SD_JOURNAL_FOREACH_UNIQUE

PyDoc_STRVAR(Journal_log_level__doc__,
"log_level(level) -> None\n\n"
"Sets maximum log level by setting matches for PRIORITY.");
static PyObject *
Journal_log_level(Journal *self, PyObject *args)
{
    int level;
    if (! PyArg_ParseTuple(args, "i", &level))
        return NULL;

    if (level < 0 || level > 7) {
        PyErr_SetString(PyExc_ValueError, "Log level should be 0 <= level <= 7");
        return NULL;
    }
    int i;
    char level_str[2];
    PyObject *arg, *keywds;
    for(i = 0; i <= level; i++) {
        sprintf(level_str, "%i", i);
        arg = PyTuple_New(0);
        keywds = Py_BuildValue("{s:s}", "PRIORITY", level_str);
        Journal_add_match(self, arg, keywds);
        Py_DECREF(arg);
        Py_DECREF(keywds);
        if (PyErr_Occurred())
            return NULL;
    }
    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_this_boot__doc__,
"this_boot() -> None\n\n"
"Sets match filter for the current _BOOT_ID.");
static PyObject *
Journal_this_boot(Journal *self, PyObject *args)
{
    sd_id128_t sd_id;
    int r;
    r = sd_id128_get_boot(&sd_id);
    if (r == -EIO) {
        PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
        return NULL;
    } else if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID");
        return NULL;
    }

    char bootid[33];
    sd_id128_to_string(sd_id, bootid);

    PyObject *arg, *keywds;
    arg = PyTuple_New(0);
    keywds = Py_BuildValue("{s:s}", "_BOOT_ID", bootid);
    Journal_add_match(self, arg, keywds);
    Py_DECREF(arg);
    Py_DECREF(keywds);
    if (PyErr_Occurred())
        return NULL;

    Py_RETURN_NONE;
}

PyDoc_STRVAR(Journal_this_machine__doc__,
"this_machine() -> None\n\n"
"Sets match filter for the current _MACHINE_ID.");
static PyObject *
Journal_this_machine(Journal *self, PyObject *args)
{
    sd_id128_t sd_id;
    int r;
    r = sd_id128_get_machine(&sd_id);
    if (r == -EIO) {
        PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
        return NULL;
    } else if (r < 0) {
        PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID");
        return NULL;
    }

    char machineid[33];
    sd_id128_to_string(sd_id, machineid);

    PyObject *arg, *keywds;
    arg = PyTuple_New(0);
    keywds = Py_BuildValue("{s:s}", "_MACHINE_ID", machineid);
    Journal_add_match(self, arg, keywds);
    Py_DECREF(arg);
    Py_DECREF(keywds);
    if (PyErr_Occurred())
        return NULL;

    Py_RETURN_NONE;
}

static PyObject *
Journal_get_default_call(Journal *self, void *closure)
{
    Py_INCREF(self->default_call);
    return self->default_call;
}

static int
Journal_set_default_call(Journal *self, PyObject *value, void *closure)
{
    if (value == NULL) {
        PyErr_SetString(PyExc_TypeError, "Cannot delete default_call");
        return -1;
    }
    if (! PyCallable_Check(value)) {
        PyErr_SetString(PyExc_TypeError, "default_call must be callable");
        return -1;
    }
    Py_DECREF(self->default_call);
    Py_INCREF(value);
    self->default_call = value;

    return 0;
}

static PyObject *
Journal_get_call_dict(Journal *self, void *closure)
{
    Py_INCREF(self->call_dict);
    return self->call_dict;
}

static int
Journal_set_call_dict(Journal *self, PyObject *value, void *closure)
{
    if (value == NULL) {
        PyErr_SetString(PyExc_TypeError, "Cannot delete call_dict");
        return -1;
    }
    if (! PyDict_Check(value)) {
        PyErr_SetString(PyExc_TypeError, "call_dict must be dict type");
        return -1;
    }
    Py_DECREF(self->call_dict);
    Py_INCREF(value);
    self->call_dict = value;

    return 0;
}

static PyObject *
Journal_get_data_threshold(Journal *self, void *closure)
{
    size_t cvalue;
    PyObject *value;
    int r;

    r = sd_journal_get_data_threshold(self->j, &cvalue);
    if (r < 0){
        PyErr_SetString(PyExc_RuntimeError, "Error getting data threshold");
        return NULL;
    }

#if PY_MAJOR_VERSION >=3
    value = PyLong_FromSize_t(cvalue);
#else
    value = PyInt_FromSize_t(cvalue);
#endif
    return value;
}

static int
Journal_set_data_threshold(Journal *self, PyObject *value, void *closure)
{
    if (value == NULL) {
        PyErr_SetString(PyExc_TypeError, "Cannot delete data threshold");
        return -1;
    }
#if PY_MAJOR_VERSION >=3
    if (! PyLong_Check(value)){
#else
    if (! PyInt_Check(value)){
#endif
        PyErr_SetString(PyExc_TypeError, "Data threshold must be int");
        return -1;
    }
    int r;
#if PY_MAJOR_VERSION >=3
    r = sd_journal_set_data_threshold(self->j, (size_t) PyLong_AsLong(value));
#else
    r = sd_journal_set_data_threshold(self->j, (size_t) PyInt_AsLong(value));
#endif
    if (r < 0){
        PyErr_SetString(PyExc_RuntimeError, "Error setting data threshold");
        return -1;
    }
    return 0;
}

static PyGetSetDef Journal_getseters[] = {
    {"data_threshold",
    (getter)Journal_get_data_threshold,
    (setter)Journal_set_data_threshold,
    "data threshold",
    NULL},
    {"call_dict",
    (getter)Journal_get_call_dict,
    (setter)Journal_set_call_dict,
    "dictionary of calls for each field",
    NULL},
    {"default_call",
    (getter)Journal_get_default_call,
    (setter)Journal_set_default_call,
    "default call for values for fields",
    NULL},
    {NULL}
};

static PyMethodDef Journal_methods[] = {
    {"get_next", (PyCFunction)Journal_get_next, METH_VARARGS,
    Journal_get_next__doc__},
    {"get_previous", (PyCFunction)Journal_get_previous, METH_VARARGS,
    Journal_get_previous__doc__},
    {"add_match", (PyCFunction)Journal_add_match, METH_VARARGS|METH_KEYWORDS,
    Journal_add_match__doc__},
    {"add_disjunction", (PyCFunction)Journal_add_disjunction, METH_NOARGS,
    Journal_add_disjunction__doc__},
    {"flush_matches", (PyCFunction)Journal_flush_matches, METH_NOARGS,
    Journal_flush_matches__doc__},
    {"seek", (PyCFunction)Journal_seek, METH_VARARGS | METH_KEYWORDS,
    Journal_seek__doc__},
    {"seek_realtime", (PyCFunction)Journal_seek_realtime, METH_VARARGS,
    Journal_seek_realtime__doc__},
    {"seek_monotonic", (PyCFunction)Journal_seek_monotonic, METH_VARARGS,
    Journal_seek_monotonic__doc__},
    {"wait", (PyCFunction)Journal_wait, METH_VARARGS,
    Journal_wait__doc__},
    {"seek_cursor", (PyCFunction)Journal_seek_cursor, METH_VARARGS,
    Journal_seek_cursor__doc__},
#ifdef SD_JOURNAL_FOREACH_UNIQUE
    {"query_unique", (PyCFunction)Journal_query_unique, METH_VARARGS,
    Journal_query_unique__doc__},
#endif
    {"log_level", (PyCFunction)Journal_log_level, METH_VARARGS,
    Journal_log_level__doc__},
    {"this_boot", (PyCFunction)Journal_this_boot, METH_NOARGS,
    Journal_this_boot__doc__},
    {"this_machine", (PyCFunction)Journal_this_machine, METH_NOARGS,
    Journal_this_machine__doc__},
    {NULL}  /* Sentinel */
};

static PyTypeObject JournalType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_reader.Journal",           /*tp_name*/
    sizeof(Journal),                  /*tp_basicsize*/
    0,                                /*tp_itemsize*/
    (destructor)Journal_dealloc,      /*tp_dealloc*/
    0,                                /*tp_print*/
    0,                                /*tp_getattr*/
    0,                                /*tp_setattr*/
    0,                                /*tp_compare*/
    0,                                /*tp_repr*/
    0,                                /*tp_as_number*/
    0,                                /*tp_as_sequence*/
    0,                                /*tp_as_mapping*/
    0,                                /*tp_hash */
    0,                                /*tp_call*/
    0,                                /*tp_str*/
    0,                                /*tp_getattro*/
    0,                                /*tp_setattro*/
    0,                                /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,/*tp_flags*/
    Journal__doc__,                   /* tp_doc */
    0,                                /* tp_traverse */
    0,                                /* tp_clear */
    0,                                /* tp_richcompare */
    0,                                /* tp_weaklistoffset */
    Journal_iter,                     /* tp_iter */
    Journal_iternext,                 /* tp_iternext */
    Journal_methods,                  /* tp_methods */
    0,                                /* tp_members */
    Journal_getseters,                /* tp_getset */
    0,                                /* tp_base */
    0,                                /* tp_dict */
    0,                                /* tp_descr_get */
    0,                                /* tp_descr_set */
    0,                                /* tp_dictoffset */
    (initproc)Journal_init,           /* tp_init */
    0,                                /* tp_alloc */
    Journal_new,                      /* tp_new */
};

#if PY_MAJOR_VERSION >= 3
static PyModuleDef _reader_module = {
    PyModuleDef_HEAD_INIT,
    "_reader",
    "Module that reads systemd journal similar to journalctl.",
    -1,
    NULL, NULL, NULL, NULL, NULL
};
#endif

PyMODINIT_FUNC
#if PY_MAJOR_VERSION >= 3
PyInit__reader(void)
#else
init_reader(void) 
#endif
{
    PyObject* m;

    PyDateTime_IMPORT;

    if (PyType_Ready(&JournalType) < 0)
#if PY_MAJOR_VERSION >= 3
        return NULL;
#else
        return;
#endif

#if PY_MAJOR_VERSION >= 3
    m = PyModule_Create(&_reader_module);
    if (m == NULL)
        return NULL;
#else
    m = Py_InitModule3("_reader", NULL,
                   "Module that reads systemd journal similar to journalctl.");
    if (m == NULL)
        return;
#endif

    Py_INCREF(&JournalType);
    PyModule_AddObject(m, "Journal", (PyObject *)&JournalType);
    PyModule_AddIntConstant(m, "NOP", SD_JOURNAL_NOP);
    PyModule_AddIntConstant(m, "APPEND", SD_JOURNAL_APPEND);
    PyModule_AddIntConstant(m, "INVALIDATE", SD_JOURNAL_INVALIDATE);
    PyModule_AddIntConstant(m, "LOCAL_ONLY", SD_JOURNAL_LOCAL_ONLY);
    PyModule_AddIntConstant(m, "RUNTIME_ONLY", SD_JOURNAL_RUNTIME_ONLY);
    PyModule_AddIntConstant(m, "SYSTEM_ONLY", SD_JOURNAL_SYSTEM_ONLY);

#if PY_MAJOR_VERSION >= 3
    return m;
#endif
}