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 #ifdef SD_JOURNAL_FOREACH_UNIQUE
 512 PyDoc_STRVAR(Journal_query_unique__doc__,
 513 "query_unique(field) -> a set of values\n\n"
 514 "Returns a set of unique values in journal for given `field`.\n"
 515 "Note this does not respect any journal matches.");
 516 static PyObject *
 517 Journal_query_unique(Journal *self, PyObject *args)
 518 {
 519     char *query;
 520     if (! PyArg_ParseTuple(args, "s", &query))
 521         return NULL;
 522
 523     int r;
 524     Py_BEGIN_ALLOW_THREADS
 525     r = sd_journal_query_unique(self->j, query);
 526     Py_END_ALLOW_THREADS
 527     if (r < 0) {
 528         errno = -r;
 529         PyObject *errtype = r == -EINVAL ? PyExc_ValueError :
 530                             r == -ENOMEM ? PyExc_MemoryError :
 531                             PyExc_OSError;
 532         PyErr_SetFromErrno(errtype);
 533         return NULL;
 534     }
 535
 536     const void *uniq;
 537     size_t uniq_len;
 538     const char *delim_ptr;
 539     PyObject *value_set, *key, *value;
 540     value_set = PySet_New(0);
 541
 542 #if PY_MAJOR_VERSION >=3
 543     key = PyUnicode_FromString(query);
 544 #else
 545     key = PyString_FromString(query);
 546 #endif
 547
 548     SD_JOURNAL_FOREACH_UNIQUE(self->j, uniq, uniq_len) {
 549         delim_ptr = memchr(uniq, '=', uniq_len);
 550         value = PyBytes_FromStringAndSize(delim_ptr + 1, (const char*) uniq + uniq_len - (delim_ptr + 1));
 551         PySet_Add(value_set, value);
 552         Py_DECREF(value);
 553     }
 554     Py_DECREF(key);
 555     return value_set;
 556 }
 557 #endif //def SD_JOURNAL_FOREACH_UNIQUE
 558
 559 static PyObject *
 560 Journal_get_data_threshold(Journal *self, void *closure)
 561 {
 562     size_t cvalue;
 563     PyObject *value;
 564     int r;
 565
 566     r = sd_journal_get_data_threshold(self->j, &cvalue);
 567     if (r < 0) {
 568         errno = -r;
 569         PyErr_SetFromErrno(PyExc_OSError);
 570         return NULL;
 571     }
 572
 573 #if PY_MAJOR_VERSION >=3
 574     value = PyLong_FromSize_t(cvalue);
 575 #else
 576     value = PyInt_FromSize_t(cvalue);
 577 #endif
 578     return value;
 579 }
 580
 581 static int
 582 Journal_set_data_threshold(Journal *self, PyObject *value, void *closure)
 583 {
 584     if (value == NULL) {
 585         PyErr_SetString(PyExc_TypeError, "Cannot delete data threshold");
 586         return -1;
 587     }
 588 #if PY_MAJOR_VERSION >=3
 589     if (! PyLong_Check(value)){
 590 #else
 591     if (! PyInt_Check(value)){
 592 #endif
 593         PyErr_SetString(PyExc_TypeError, "Data threshold must be int");
 594         return -1;
 595     }
 596     int r;
 597 #if PY_MAJOR_VERSION >=3
 598     r = sd_journal_set_data_threshold(self->j, (size_t) PyLong_AsLong(value));
 599 #else
 600     r = sd_journal_set_data_threshold(self->j, (size_t) PyInt_AsLong(value));
 601 #endif
 602     if (r < 0) {
 603         errno = -r;
 604         PyErr_SetFromErrno(PyExc_OSError);
 605         return -1;
 606     }
 607     return 0;
 608 }
 609
 610 static PyGetSetDef Journal_getseters[] = {
 611     {"data_threshold",
 612     (getter)Journal_get_data_threshold,
 613     (setter)Journal_set_data_threshold,
 614     "data threshold",
 615     NULL},
 616     {NULL}
 617 };
 618
 619 static PyMethodDef Journal_methods[] = {
 620     {"get_next", (PyCFunction)Journal_get_next, METH_VARARGS,
 621     Journal_get_next__doc__},
 622     {"get_previous", (PyCFunction)Journal_get_previous, METH_VARARGS,
 623     Journal_get_previous__doc__},
 624     {"add_match", (PyCFunction)Journal_add_match, METH_VARARGS|METH_KEYWORDS,
 625     Journal_add_match__doc__},
 626     {"add_disjunction", (PyCFunction)Journal_add_disjunction, METH_NOARGS,
 627     Journal_add_disjunction__doc__},
 628     {"flush_matches", (PyCFunction)Journal_flush_matches, METH_NOARGS,
 629     Journal_flush_matches__doc__},
 630     {"seek", (PyCFunction)Journal_seek, METH_VARARGS | METH_KEYWORDS,
 631     Journal_seek__doc__},
 632     {"seek_realtime", (PyCFunction)Journal_seek_realtime, METH_VARARGS,
 633     Journal_seek_realtime__doc__},
 634     {"seek_monotonic", (PyCFunction)Journal_seek_monotonic, METH_VARARGS,
 635     Journal_seek_monotonic__doc__},
 636     {"wait", (PyCFunction)Journal_wait, METH_VARARGS,
 637     Journal_wait__doc__},
 638     {"seek_cursor", (PyCFunction)Journal_seek_cursor, METH_VARARGS,
 639     Journal_seek_cursor__doc__},
 640 #ifdef SD_JOURNAL_FOREACH_UNIQUE
 641     {"query_unique", (PyCFunction)Journal_query_unique, METH_VARARGS,
 642     Journal_query_unique__doc__},
 643 #endif
 644     {NULL}  /* Sentinel */
 645 };
 646
 647 static PyTypeObject JournalType = {
 648     PyVarObject_HEAD_INIT(NULL, 0)
 649     "_reader.Journal",           /*tp_name*/
 650     sizeof(Journal),                  /*tp_basicsize*/
 651     0,                                /*tp_itemsize*/
 652     (destructor)Journal_dealloc,      /*tp_dealloc*/
 653     0,                                /*tp_print*/
 654     0,                                /*tp_getattr*/
 655     0,                                /*tp_setattr*/
 656     0,                                /*tp_compare*/
 657     0,                                /*tp_repr*/
 658     0,                                /*tp_as_number*/
 659     0,                                /*tp_as_sequence*/
 660     0,                                /*tp_as_mapping*/
 661     0,                                /*tp_hash */
 662     0,                                /*tp_call*/
 663     0,                                /*tp_str*/
 664     0,                                /*tp_getattro*/
 665     0,                                /*tp_setattro*/
 666     0,                                /*tp_as_buffer*/
 667     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,/*tp_flags*/
 668     Journal__doc__,                   /* tp_doc */
 669     0,                                /* tp_traverse */
 670     0,                                /* tp_clear */
 671     0,                                /* tp_richcompare */
 672     0,                                /* tp_weaklistoffset */
 673     Journal_iter,                     /* tp_iter */
 674     Journal_iternext,                 /* tp_iternext */
 675     Journal_methods,                  /* tp_methods */
 676     0,                                /* tp_members */
 677     Journal_getseters,                /* tp_getset */
 678     0,                                /* tp_base */
 679     0,                                /* tp_dict */
 680     0,                                /* tp_descr_get */
 681     0,                                /* tp_descr_set */
 682     0,                                /* tp_dictoffset */
 683     (initproc)Journal_init,           /* tp_init */
 684     0,                                /* tp_alloc */
 685     PyType_GenericNew,                /* tp_new */
 686 };
 687
 688 #if PY_MAJOR_VERSION >= 3
 689 static PyModuleDef _reader_module = {
 690     PyModuleDef_HEAD_INIT,
 691     "_reader",
 692     "Module that reads systemd journal similar to journalctl.",
 693     -1,
 694     NULL, NULL, NULL, NULL, NULL
 695 };
 696 #endif
 697
 698 PyMODINIT_FUNC
 699 #if PY_MAJOR_VERSION >= 3
 700 PyInit__reader(void)
 701 #else
 702 init_reader(void)
 703 #endif
 704 {
 705     PyObject* m;
 706
 707     PyDateTime_IMPORT;
 708
 709     if (PyType_Ready(&JournalType) < 0)
 710 #if PY_MAJOR_VERSION >= 3
 711         return NULL;
 712 #else
 713         return;
 714 #endif
 715
 716 #if PY_MAJOR_VERSION >= 3
 717     m = PyModule_Create(&_reader_module);
 718     if (m == NULL)
 719         return NULL;
 720 #else
 721     m = Py_InitModule3("_reader", NULL,
 722                    "Module that reads systemd journal similar to journalctl.");
 723     if (m == NULL)
 724         return;
 725 #endif
 726
 727     Py_INCREF(&JournalType);
 728     PyModule_AddObject(m, "_Journal", (PyObject *)&JournalType);
 729     PyModule_AddIntConstant(m, "NOP", SD_JOURNAL_NOP);
 730     PyModule_AddIntConstant(m, "APPEND", SD_JOURNAL_APPEND);
 731     PyModule_AddIntConstant(m, "INVALIDATE", SD_JOURNAL_INVALIDATE);
 732     PyModule_AddIntConstant(m, "LOCAL_ONLY", SD_JOURNAL_LOCAL_ONLY);
 733     PyModule_AddIntConstant(m, "RUNTIME_ONLY", SD_JOURNAL_RUNTIME_ONLY);
 734     PyModule_AddIntConstant(m, "SYSTEM_ONLY", SD_JOURNAL_SYSTEM_ONLY);
 735
 736 #if PY_MAJOR_VERSION >= 3
 737     return m;
 738 #endif
 739 }