src/python-systemd/_reader.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Steven Hiscocks, Zbigniew Jędrzejewski-Szmek
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21 #include <systemd/sd-journal.h>
  22
  23 #include <Python.h>
  24 #include <structmember.h>
  25 #include <datetime.h>
  26
  27 typedef struct {
  28     PyObject_HEAD
  29     sd_journal *j;
  30 } Journal;
  31 static PyTypeObject JournalType;
  32
  33 static void
  34 Journal_dealloc(Journal* self)
  35 {
  36     sd_journal_close(self->j);
  37     Py_TYPE(self)->tp_free((PyObject*)self);
  38 }
  39
  40 PyDoc_STRVAR(Journal__doc__,
  41 "Journal([flags][,path]) -> ...\n"
  42 "Journal instance\n\n"
  43 "Returns instance of Journal, which allows filtering and return\n"
  44 "of journal entries.\n"
  45 "Argument `flags` sets open flags of the journal, which can be one\n"
  46 "of, or ORed combination of constants: LOCAL_ONLY (default) opens\n"
  47 "journal on local machine only; RUNTIME_ONLY opens only\n"
  48 "volatile journal files; and SYSTEM_ONLY opens only\n"
  49 "journal files of system services and the kernel.\n"
  50 "Argument `path` is the directory of journal files. Note that\n"
  51 "currently flags are ignored when `path` is present as they are\n"
  52 " not relevant.");
  53 static int
  54 Journal_init(Journal *self, PyObject *args, PyObject *keywds)
  55 {
  56     int flags=SD_JOURNAL_LOCAL_ONLY;
  57     char *path=NULL;
  58
  59     static char *kwlist[] = {"flags", "path", NULL};
  60     if (! PyArg_ParseTupleAndKeywords(args, keywds, "|is", kwlist,
  61                                       &flags, &path))
  62         return 1;
  63
  64     int r;
  65     Py_BEGIN_ALLOW_THREADS
  66     if (path) {
  67         r = sd_journal_open_directory(&self->j, path, 0);
  68     }else{
  69         r = sd_journal_open(&self->j, flags);
  70     }
  71     Py_END_ALLOW_THREADS
  72     if (r < 0) {
  73         errno = -r;
  74         PyObject *errtype = r == -EINVAL ? PyExc_ValueError :
  75                             r == -ENOMEM ? PyExc_MemoryError :
  76                             PyExc_OSError;
  77         PyErr_SetFromErrnoWithFilename(errtype, path);
  78         return -1;
  79     }
  80
  81     return 0;
  82 }
  83
  84 PyDoc_STRVAR(Journal_get_next__doc__,
  85 "get_next([skip]) -> dict\n\n"
  86 "Return dictionary of the next log entry. Optional skip value will\n"
  87 "return the `skip`th log entry.");
  88 static PyObject *
  89 Journal_get_next(Journal *self, PyObject *args)
  90 {
  91     int64_t skip=1LL;
  92     if (! PyArg_ParseTuple(args, "|L", &skip))
  93         return NULL;
  94
  95     if (skip == 0LL) {
  96         PyErr_SetString(PyExc_ValueError, "Skip number must positive/negative integer");
  97         return NULL;
  98     }
  99
 100     int r = -EINVAL;
 101     Py_BEGIN_ALLOW_THREADS
 102     if (skip == 1LL) {
 103         r = sd_journal_next(self->j);
 104     }else if (skip == -1LL) {
 105         r = sd_journal_previous(self->j);
 106     }else if (skip > 1LL) {
 107         r = sd_journal_next_skip(self->j, skip);
 108     }else if (skip < -1LL) {
 109         r = sd_journal_previous_skip(self->j, -skip);
 110     }
 111     Py_END_ALLOW_THREADS
 112
 113     if (r < 0) {
 114         errno = -r;
 115         PyErr_SetFromErrno(PyExc_OSError);
 116         return NULL;
 117     }else if ( r == 0) { //EOF
 118         return PyDict_New();
 119     }
 120
 121     PyObject *dict;
 122     dict = PyDict_New();
 123
 124     const void *msg;
 125     size_t msg_len;
 126     const char *delim_ptr;
 127     PyObject *key, *value, *cur_value, *tmp_list;
 128
 129     SD_JOURNAL_FOREACH_DATA(self->j, msg, msg_len) {
 130         delim_ptr = memchr(msg, '=', msg_len);
 131 #if PY_MAJOR_VERSION >=3
 132         key = PyUnicode_FromStringAndSize(msg, delim_ptr - (const char*) msg);
 133 #else
 134         key = PyString_FromStringAndSize(msg, delim_ptr - (const char*) msg);
 135 #endif
 136         value = PyBytes_FromStringAndSize(delim_ptr + 1, (const char*) msg + msg_len - (delim_ptr + 1) );
 137         if (PyDict_Contains(dict, key)) {
 138             cur_value = PyDict_GetItem(dict, key);
 139             if (PyList_CheckExact(cur_value)) {
 140                 PyList_Append(cur_value, value);
 141             }else{
 142                 tmp_list = PyList_New(0);
 143                 PyList_Append(tmp_list, cur_value);
 144                 PyList_Append(tmp_list, value);
 145                 PyDict_SetItem(dict, key, tmp_list);
 146                 Py_DECREF(tmp_list);
 147             }
 148         }else{
 149             PyDict_SetItem(dict, key, value);
 150         }
 151         Py_DECREF(key);
 152         Py_DECREF(value);
 153     }
 154
 155     uint64_t realtime;
 156     if (sd_journal_get_realtime_usec(self->j, &realtime) == 0) {
 157         char realtime_str[20];
 158         sprintf(realtime_str, "%llu", (long long unsigned) realtime);
 159
 160 #if PY_MAJOR_VERSION >=3
 161         key = PyUnicode_FromString("__REALTIME_TIMESTAMP");
 162 #else
 163         key = PyString_FromString("__REALTIME_TIMESTAMP");
 164 #endif
 165         value = PyBytes_FromString(realtime_str);
 166         PyDict_SetItem(dict, key, value);
 167         Py_DECREF(key);
 168         Py_DECREF(value);
 169     }
 170
 171     sd_id128_t sd_id;
 172     uint64_t monotonic;
 173     if (sd_journal_get_monotonic_usec(self->j, &monotonic, &sd_id) == 0) {
 174         char monotonic_str[20];
 175         sprintf(monotonic_str, "%llu", (long long unsigned) monotonic);
 176 #if PY_MAJOR_VERSION >=3
 177         key = PyUnicode_FromString("__MONOTONIC_TIMESTAMP");
 178 #else
 179         key = PyString_FromString("__MONOTONIC_TIMESTAMP");
 180 #endif
 181         value = PyBytes_FromString(monotonic_str);
 182
 183         PyDict_SetItem(dict, key, value);
 184         Py_DECREF(key);
 185         Py_DECREF(value);
 186     }
 187
 188     char *cursor;
 189     if (sd_journal_get_cursor(self->j, &cursor) > 0) { //Should return 0...
 190 #if PY_MAJOR_VERSION >=3
 191         key = PyUnicode_FromString("__CURSOR");
 192 #else
 193         key = PyString_FromString("__CURSOR");
 194 #endif
 195         value = PyBytes_FromString(cursor);
 196         PyDict_SetItem(dict, key, value);
 197         free(cursor);
 198         Py_DECREF(key);
 199         Py_DECREF(value);
 200     }
 201
 202     return dict;
 203 }
 204
 205 PyDoc_STRVAR(Journal_get_previous__doc__,
 206 "get_previous([skip]) -> dict\n\n"
 207 "Return dictionary of the previous log entry. Optional skip value\n"
 208 "will return the -`skip`th log entry. Equivalent to get_next(-skip).");
 209 static PyObject *
 210 Journal_get_previous(Journal *self, PyObject *args)
 211 {
 212     int64_t skip=1LL;
 213     if (! PyArg_ParseTuple(args, "|L", &skip))
 214         return NULL;
 215
 216     return PyObject_CallMethod((PyObject *)self, "get_next", "L", -skip);
 217 }
 218
 219 PyDoc_STRVAR(Journal_add_match__doc__,
 220 "add_match(match) -> None\n\n"
 221 "Add a match to filter journal log entries. All matches of different\n"
 222 "fields are combined in logical AND, and matches of the same field\n"
 223 "are automatically combined in logical OR.\n"
 224 "Match is string of form \"field=value\".");
 225 static PyObject *
 226 Journal_add_match(Journal *self, PyObject *args, PyObject *keywds)
 227 {
 228     char *match;
 229     int match_len;
 230     if (! PyArg_ParseTuple(args, "s#", &match, &match_len))
 231         return NULL;
 232
 233     int r;
 234     r = sd_journal_add_match(self->j, match, match_len);
 235     if (r < 0) {
 236         errno = -r;
 237         PyObject *errtype = r == -EINVAL ? PyExc_ValueError :
 238                             r == -ENOMEM ? PyExc_MemoryError :
 239                             PyExc_OSError;
 240         PyErr_SetFromErrno(errtype);
 241         return NULL;
 242     }
 243
 244     Py_RETURN_NONE;
 245 }
 246
 247 PyDoc_STRVAR(Journal_add_disjunction__doc__,
 248 "add_disjunction() -> None\n\n"
 249 "Once called, all matches before and after are combined in logical\n"
 250 "OR.");
 251 static PyObject *
 252 Journal_add_disjunction(Journal *self, PyObject *args)
 253 {
 254     int r;
 255     r = sd_journal_add_disjunction(self->j);
 256     if (r < 0) {
 257         errno = -r;
 258         PyObject *errtype = r == -ENOMEM ? PyExc_MemoryError :
 259                             PyExc_OSError;
 260         PyErr_SetFromErrno(errtype);
 261         return NULL;
 262     }
 263     Py_RETURN_NONE;
 264 }
 265
 266 PyDoc_STRVAR(Journal_flush_matches__doc__,
 267 "flush_matches() -> None\n\n"
 268 "Clears all current match filters.");
 269 static PyObject *
 270 Journal_flush_matches(Journal *self, PyObject *args)
 271 {
 272     sd_journal_flush_matches(self->j);
 273     Py_RETURN_NONE;
 274 }
 275
 276 PyDoc_STRVAR(Journal_seek__doc__,
 277 "seek(offset[, whence]) -> None\n\n"
 278 "Seek through journal by `offset` number of entries. Argument\n"
 279 "`whence` defines what the offset is relative to:\n"
 280 "os.SEEK_SET (default) from first match in journal;\n"
 281 "os.SEEK_CUR from current position in journal;\n"
 282 "and os.SEEK_END is from last match in journal.");
 283 static PyObject *
 284 Journal_seek(Journal *self, PyObject *args, PyObject *keywds)
 285 {
 286     int64_t offset;
 287     int whence=SEEK_SET;
 288     static char *kwlist[] = {"offset", "whence", NULL};
 289
 290     if (! PyArg_ParseTupleAndKeywords(args, keywds, "L|i", kwlist,
 291                                       &offset, &whence))
 292         return NULL;
 293
 294     PyObject *result=NULL;
 295     if (whence == SEEK_SET){
 296         int r;
 297         Py_BEGIN_ALLOW_THREADS
 298         r = sd_journal_seek_head(self->j);
 299         Py_END_ALLOW_THREADS
 300         if (r < 0) {
 301             errno = -r;
 302             PyErr_SetFromErrno(PyExc_OSError);
 303             return NULL;
 304         }
 305         if (offset > 0LL) {
 306             result = PyObject_CallMethod((PyObject *)self, "get_next", "L", offset);
 307         }
 308     }else if (whence == SEEK_CUR){
 309         result = PyObject_CallMethod((PyObject *)self, "get_next", "L", offset);
 310     }else if (whence == SEEK_END){
 311         int r;
 312         Py_BEGIN_ALLOW_THREADS
 313         r = sd_journal_seek_tail(self->j);
 314         Py_END_ALLOW_THREADS
 315         if (r < 0) {
 316             errno = -r;
 317             PyErr_SetFromErrno(PyExc_OSError);
 318             return NULL;
 319         }
 320         if (offset < 0LL) {
 321             result = PyObject_CallMethod((PyObject *)self, "get_next", "L", offset);
 322         }else{
 323             result = PyObject_CallMethod((PyObject *)self, "get_next", "L", -1LL);
 324         }
 325     }else{
 326         PyErr_SetString(PyExc_ValueError, "Invalid value for whence");
 327     }
 328
 329     if (result)
 330         Py_DECREF(result);
 331     if (PyErr_Occurred())
 332         return NULL;
 333     Py_RETURN_NONE;
 334 }
 335
 336 PyDoc_STRVAR(Journal_seek_realtime__doc__,
 337 "seek_realtime(realtime) -> None\n\n"
 338 "Seek to nearest matching journal entry to `realtime`. Argument\n"
 339 "`realtime` can must be an integer unix timestamp.");
 340 static PyObject *
 341 Journal_seek_realtime(Journal *self, PyObject *args)
 342 {
 343     double timedouble;
 344     if (! PyArg_ParseTuple(args, "d", &timedouble))
 345         return NULL;
 346
 347     uint64_t timestamp;
 348     timestamp = (uint64_t) (timedouble * 1.0E6);
 349
 350     if ((int64_t) timestamp < 0LL) {
 351         PyErr_SetString(PyExc_ValueError, "Time must be positive integer");
 352         return NULL;
 353     }
 354
 355     int r;
 356     Py_BEGIN_ALLOW_THREADS
 357     r = sd_journal_seek_realtime_usec(self->j, timestamp);
 358     Py_END_ALLOW_THREADS
 359     if (r < 0) {
 360         errno = -r;
 361         PyErr_SetFromErrno(PyExc_OSError);
 362         return NULL;
 363     }
 364     Py_RETURN_NONE;
 365 }
 366
 367 PyDoc_STRVAR(Journal_seek_monotonic__doc__,
 368 "seek_monotonic(monotonic[, bootid]) -> None\n\n"
 369 "Seek to nearest matching journal entry to `monotonic`. Argument\n"
 370 "`monotonic` is an timestamp from boot in seconds.\n"
 371 "Argument `bootid` is a string representing which boot the\n"
 372 "monotonic time is reference to. Defaults to current bootid.");
 373 static PyObject *
 374 Journal_seek_monotonic(Journal *self, PyObject *args)
 375 {
 376     double timedouble;
 377     char *bootid=NULL;
 378     if (! PyArg_ParseTuple(args, "d|z", &timedouble, &bootid))
 379         return NULL;
 380
 381     uint64_t timestamp;
 382     timestamp = (uint64_t) (timedouble * 1.0E6);
 383
 384     if ((int64_t) timestamp < 0LL) {
 385         PyErr_SetString(PyExc_ValueError, "Time must be positive number");
 386         return NULL;
 387     }
 388
 389     sd_id128_t sd_id;
 390     int r;
 391     if (bootid) {
 392         r = sd_id128_from_string(bootid, &sd_id);
 393         if (r == -EINVAL) {
 394             PyErr_SetString(PyExc_ValueError, "Invalid bootid");
 395             return NULL;
 396         }else if (r < 0) {
 397             errno = -r;
 398             PyErr_SetFromErrno(PyExc_OSError);
 399             return NULL;
 400         }
 401     }else{
 402         r = sd_id128_get_boot(&sd_id);
 403         if (r == -EIO) {
 404             PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
 405             return NULL;
 406         }else if (r < 0) {
 407             errno = -r;
 408             PyErr_SetFromErrno(PyExc_OSError);
 409             return NULL;
 410         }
 411     }
 412
 413     Py_BEGIN_ALLOW_THREADS
 414     r = sd_journal_seek_monotonic_usec(self->j, sd_id, timestamp);
 415     Py_END_ALLOW_THREADS
 416     if (r < 0) {
 417         errno = -r;
 418         PyErr_SetFromErrno(PyExc_OSError);
 419         return NULL;
 420     }
 421     Py_RETURN_NONE;
 422 }
 423
 424 PyDoc_STRVAR(Journal_wait__doc__,
 425 "wait([timeout]) -> Change state (integer)\n\n"
 426 "Waits until there is a change in the journal. Argument `timeout`\n"
 427 "is the maximum number of seconds to wait before returning\n"
 428 "regardless if journal has changed. If `timeout` is not given or is\n"
 429 "0, then it will block forever.\n"
 430 "Will return constants: NOP if no change; APPEND if new\n"
 431 "entries have been added to the end of the journal; and\n"
 432 "INVALIDATE if journal files have been added or removed.");
 433 static PyObject *
 434 Journal_wait(Journal *self, PyObject *args, PyObject *keywds)
 435 {
 436     int64_t timeout=0LL;
 437     if (! PyArg_ParseTuple(args, "|L", &timeout))
 438         return NULL;
 439
 440     int r;
 441     Py_BEGIN_ALLOW_THREADS
 442     if ( timeout == 0LL) {
 443         r = sd_journal_wait(self->j, (uint64_t) -1);
 444     }else{
 445         r = sd_journal_wait(self->j, timeout * 1E6);
 446     }
 447     Py_END_ALLOW_THREADS
 448     if (r < 0) {
 449         errno = -r;
 450         PyObject *errtype = r == -ENOMEM ? PyExc_MemoryError :
 451                             PyExc_OSError;
 452         PyErr_SetFromErrno(errtype);
 453         return NULL;
 454     }
 455 #if PY_MAJOR_VERSION >=3
 456     return PyLong_FromLong(r);
 457 #else
 458     return PyInt_FromLong(r);
 459 #endif
 460 }
 461
 462 PyDoc_STRVAR(Journal_seek_cursor__doc__,
 463 "seek_cursor(cursor) -> None\n\n"
 464 "Seeks to journal entry by given unique reference `cursor`.");
 465 static PyObject *
 466 Journal_seek_cursor(Journal *self, PyObject *args)
 467 {
 468     const char *cursor;
 469     if (! PyArg_ParseTuple(args, "s", &cursor))
 470         return NULL;
 471
 472     int r;
 473     Py_BEGIN_ALLOW_THREADS
 474     r = sd_journal_seek_cursor(self->j, cursor);
 475     Py_END_ALLOW_THREADS
 476     if (r < 0) {
 477         errno = -r;
 478         PyObject *errtype = r == -EINVAL ? PyExc_ValueError :
 479                             r == -ENOMEM ? PyExc_MemoryError :
 480                             PyExc_OSError;
 481         PyErr_SetFromErrno(errtype);
 482         return NULL;
 483     }
 484     Py_RETURN_NONE;
 485 }
 486
 487 static PyObject *
 488 Journal_iter(PyObject *self)
 489 {
 490     Py_INCREF(self);
 491     return self;
 492 }
 493
 494 static PyObject *
 495 Journal_iternext(PyObject *self)
 496 {
 497     PyObject *dict;
 498     Py_ssize_t dict_size;
 499
 500     dict = PyObject_CallMethod(self, "get_next", "");
 501     dict_size = PyDict_Size(dict);
 502     if ((int64_t) dict_size > 0LL) {
 503         return dict;
 504     }else{
 505         Py_DECREF(dict);
 506         PyErr_SetNone(PyExc_StopIteration);
 507         return NULL;
 508     }
 509 }
 510
 511 PyDoc_STRVAR(Journal_query_unique__doc__,
 512 "query_unique(field) -> a set of values\n\n"
 513 "Returns a set of unique values in journal for given `field`.\n"
 514 "Note this does not respect any journal matches.");
 515 static PyObject *
 516 Journal_query_unique(Journal *self, PyObject *args)
 517 {
 518     char *query;
 519     if (! PyArg_ParseTuple(args, "s", &query))
 520         return NULL;
 521
 522     int r;
 523     Py_BEGIN_ALLOW_THREADS
 524     r = sd_journal_query_unique(self->j, query);
 525     Py_END_ALLOW_THREADS
 526     if (r < 0) {
 527         errno = -r;
 528         PyObject *errtype = r == -EINVAL ? PyExc_ValueError :
 529                             r == -ENOMEM ? PyExc_MemoryError :
 530                             PyExc_OSError;
 531         PyErr_SetFromErrno(errtype);
 532         return NULL;
 533     }
 534
 535     const void *uniq;
 536     size_t uniq_len;
 537     const char *delim_ptr;
 538     PyObject *value_set, *key, *value;
 539     value_set = PySet_New(0);
 540
 541 #if PY_MAJOR_VERSION >=3
 542     key = PyUnicode_FromString(query);
 543 #else
 544     key = PyString_FromString(query);
 545 #endif
 546
 547     SD_JOURNAL_FOREACH_UNIQUE(self->j, uniq, uniq_len) {
 548         delim_ptr = memchr(uniq, '=', uniq_len);
 549         value = PyBytes_FromStringAndSize(delim_ptr + 1, (const char*) uniq + uniq_len - (delim_ptr + 1));
 550         PySet_Add(value_set, value);
 551         Py_DECREF(value);
 552     }
 553     Py_DECREF(key);
 554     return value_set;
 555 }
 556
 557 static PyObject *
 558 Journal_get_data_threshold(Journal *self, void *closure)
 559 {
 560     size_t cvalue;
 561     PyObject *value;
 562     int r;
 563
 564     r = sd_journal_get_data_threshold(self->j, &cvalue);
 565     if (r < 0) {
 566         errno = -r;
 567         PyErr_SetFromErrno(PyExc_OSError);
 568         return NULL;
 569     }
 570
 571 #if PY_MAJOR_VERSION >=3
 572     value = PyLong_FromSize_t(cvalue);
 573 #else
 574     value = PyInt_FromSize_t(cvalue);
 575 #endif
 576     return value;
 577 }
 578
 579 static int
 580 Journal_set_data_threshold(Journal *self, PyObject *value, void *closure)
 581 {
 582     if (value == NULL) {
 583         PyErr_SetString(PyExc_TypeError, "Cannot delete data threshold");
 584         return -1;
 585     }
 586 #if PY_MAJOR_VERSION >=3
 587     if (! PyLong_Check(value)){
 588 #else
 589     if (! PyInt_Check(value)){
 590 #endif
 591         PyErr_SetString(PyExc_TypeError, "Data threshold must be int");
 592         return -1;
 593     }
 594     int r;
 595 #if PY_MAJOR_VERSION >=3
 596     r = sd_journal_set_data_threshold(self->j, (size_t) PyLong_AsLong(value));
 597 #else
 598     r = sd_journal_set_data_threshold(self->j, (size_t) PyInt_AsLong(value));
 599 #endif
 600     if (r < 0) {
 601         errno = -r;
 602         PyErr_SetFromErrno(PyExc_OSError);
 603         return -1;
 604     }
 605     return 0;
 606 }
 607
 608 static PyGetSetDef Journal_getseters[] = {
 609     {"data_threshold",
 610     (getter)Journal_get_data_threshold,
 611     (setter)Journal_set_data_threshold,
 612     "data threshold",
 613     NULL},
 614     {NULL}
 615 };
 616
 617 static PyMethodDef Journal_methods[] = {
 618     {"get_next", (PyCFunction)Journal_get_next, METH_VARARGS,
 619     Journal_get_next__doc__},
 620     {"get_previous", (PyCFunction)Journal_get_previous, METH_VARARGS,
 621     Journal_get_previous__doc__},
 622     {"add_match", (PyCFunction)Journal_add_match, METH_VARARGS|METH_KEYWORDS,
 623     Journal_add_match__doc__},
 624     {"add_disjunction", (PyCFunction)Journal_add_disjunction, METH_NOARGS,
 625     Journal_add_disjunction__doc__},
 626     {"flush_matches", (PyCFunction)Journal_flush_matches, METH_NOARGS,
 627     Journal_flush_matches__doc__},
 628     {"seek", (PyCFunction)Journal_seek, METH_VARARGS | METH_KEYWORDS,
 629     Journal_seek__doc__},
 630     {"seek_realtime", (PyCFunction)Journal_seek_realtime, METH_VARARGS,
 631     Journal_seek_realtime__doc__},
 632     {"seek_monotonic", (PyCFunction)Journal_seek_monotonic, METH_VARARGS,
 633     Journal_seek_monotonic__doc__},
 634     {"wait", (PyCFunction)Journal_wait, METH_VARARGS,
 635     Journal_wait__doc__},
 636     {"seek_cursor", (PyCFunction)Journal_seek_cursor, METH_VARARGS,
 637     Journal_seek_cursor__doc__},
 638     {"query_unique", (PyCFunction)Journal_query_unique, METH_VARARGS,
 639     Journal_query_unique__doc__},
 640     {NULL}  /* Sentinel */
 641 };
 642
 643 static PyTypeObject JournalType = {
 644     PyVarObject_HEAD_INIT(NULL, 0)
 645     "_reader.Journal",           /*tp_name*/
 646     sizeof(Journal),                  /*tp_basicsize*/
 647     0,                                /*tp_itemsize*/
 648     (destructor)Journal_dealloc,      /*tp_dealloc*/
 649     0,                                /*tp_print*/
 650     0,                                /*tp_getattr*/
 651     0,                                /*tp_setattr*/
 652     0,                                /*tp_compare*/
 653     0,                                /*tp_repr*/
 654     0,                                /*tp_as_number*/
 655     0,                                /*tp_as_sequence*/
 656     0,                                /*tp_as_mapping*/
 657     0,                                /*tp_hash */
 658     0,                                /*tp_call*/
 659     0,                                /*tp_str*/
 660     0,                                /*tp_getattro*/
 661     0,                                /*tp_setattro*/
 662     0,                                /*tp_as_buffer*/
 663     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,/*tp_flags*/
 664     Journal__doc__,                   /* tp_doc */
 665     0,                                /* tp_traverse */
 666     0,                                /* tp_clear */
 667     0,                                /* tp_richcompare */
 668     0,                                /* tp_weaklistoffset */
 669     Journal_iter,                     /* tp_iter */
 670     Journal_iternext,                 /* tp_iternext */
 671     Journal_methods,                  /* tp_methods */
 672     0,                                /* tp_members */
 673     Journal_getseters,                /* tp_getset */
 674     0,                                /* tp_base */
 675     0,                                /* tp_dict */
 676     0,                                /* tp_descr_get */
 677     0,                                /* tp_descr_set */
 678     0,                                /* tp_dictoffset */
 679     (initproc)Journal_init,           /* tp_init */
 680     0,                                /* tp_alloc */
 681     PyType_GenericNew,                /* tp_new */
 682 };
 683
 684 #if PY_MAJOR_VERSION >= 3
 685 static PyModuleDef _reader_module = {
 686     PyModuleDef_HEAD_INIT,
 687     "_reader",
 688     "Module that reads systemd journal similar to journalctl.",
 689     -1,
 690     NULL, NULL, NULL, NULL, NULL
 691 };
 692 #endif
 693
 694 PyMODINIT_FUNC
 695 #if PY_MAJOR_VERSION >= 3
 696 PyInit__reader(void)
 697 #else
 698 init_reader(void)
 699 #endif
 700 {
 701     PyObject* m;
 702
 703     PyDateTime_IMPORT;
 704
 705     if (PyType_Ready(&JournalType) < 0)
 706 #if PY_MAJOR_VERSION >= 3
 707         return NULL;
 708 #else
 709         return;
 710 #endif
 711
 712 #if PY_MAJOR_VERSION >= 3
 713     m = PyModule_Create(&_reader_module);
 714     if (m == NULL)
 715         return NULL;
 716 #else
 717     m = Py_InitModule3("_reader", NULL,
 718                    "Module that reads systemd journal similar to journalctl.");
 719     if (m == NULL)
 720         return;
 721 #endif
 722
 723     Py_INCREF(&JournalType);
 724     PyModule_AddObject(m, "_Journal", (PyObject *)&JournalType);
 725     PyModule_AddIntConstant(m, "NOP", SD_JOURNAL_NOP);
 726     PyModule_AddIntConstant(m, "APPEND", SD_JOURNAL_APPEND);
 727     PyModule_AddIntConstant(m, "INVALIDATE", SD_JOURNAL_INVALIDATE);
 728     PyModule_AddIntConstant(m, "LOCAL_ONLY", SD_JOURNAL_LOCAL_ONLY);
 729     PyModule_AddIntConstant(m, "RUNTIME_ONLY", SD_JOURNAL_RUNTIME_ONLY);
 730     PyModule_AddIntConstant(m, "SYSTEM_ONLY", SD_JOURNAL_SYSTEM_ONLY);
 731
 732 #if PY_MAJOR_VERSION >= 3
 733     return m;
 734 #endif
 735 }