src/logd_grabber/journal-reader.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <systemd/sd-journal.h>
   4
   5 #include "core/log.h"
   6 #include "event.h"
   7 #include "journal-reader.h"
   8 #include "logd-grabber.h"
   9 #include "macro.h"
  10
  11 #define GET_ACTION_FROM_EVENT_TYPE(eventType) ((eventType) >> 16)
  12 #define GET_OBJECT_FROM_EVENT_TYPE(eventType) ((eventType) & 0xffff)
  13
  14 static sd_journal *journal;
  15
  16 int jr_init(void)
  17 {
  18         int ret = 0;
  19
  20         ret = sd_journal_open(&journal, SD_JOURNAL_LOCAL_ONLY);
  21         CHECK_RET(ret, "sd_journal_open");
  22
  23         ret = sd_journal_add_match(journal, "CODE_FUNC=logd_event", 0);
  24         CHECK_RET(ret, "sd_journal_add_match");
  25
  26         ret = sd_journal_seek_tail(journal);
  27         CHECK_RET(ret, "sd_journal_seek_tail");
  28
  29         ret = sd_journal_previous(journal);
  30         CHECK_RET(ret, "sd_journal_previous");
  31
  32         return 0;
  33 }
  34
  35 int jr_exit(void)
  36 {
  37         if (journal)
  38                 sd_journal_close(journal);
  39
  40         return 0;
  41 }
  42
  43 int jr_get_socket(void)
  44 {
  45         return sd_journal_get_fd(journal);
  46 }
  47
  48 int get_next_event(struct logd_grabber_event *event)
  49 {
  50         const char type_field[] = "LOGD_EVENT_TYPE";
  51         const char message_field[] = "MESSAGE";
  52         const char application_field[] = "SYSLOG_IDENTIFIER";
  53         char *event_type;
  54         char *event_message;
  55         char *event_application;
  56         int ret;
  57
  58         while (1) {
  59                 uint64_t event_date;
  60                 size_t len;
  61
  62                 if (!sd_journal_next(journal)) {
  63                         ret = sd_journal_process(journal);
  64                         if (ret < 0) {
  65                                 _E("sd_journal_process failed");
  66                                 return ret;
  67                         }
  68
  69                         return 1;
  70                 }
  71                 ret = sd_journal_get_realtime_usec(journal, &event_date);
  72                 CHECK_RET(ret, "sd_journal_get_realtime_usec");
  73                 event->date = event_date / USEC_PER_SEC;
  74
  75                 ret = sd_journal_get_data(journal, type_field,
  76                         (const void**)&event_type, &len);
  77                 CHECK_RET(ret, "sd_journal_get_data");
  78
  79                 if (event_type) {
  80                         event_type = strdup(event_type + sizeof(type_field));
  81                         ret = sd_journal_get_data(journal, message_field,
  82                                 (const void**)&event_message, &len);
  83                         if (event_message) {
  84                                 event_message = strdup(event_message +
  85                                         sizeof(message_field));
  86                         }
  87
  88                         ret = sd_journal_get_data(journal, application_field,
  89                                 (const void**)&event_application, &len);
  90                         if (event_application) {
  91                                 event_application = strdup(event_application +
  92                                         sizeof(application_field));
  93                         }
  94                         break;
  95                 }
  96         }
  97
  98         event->application = event_application;
  99         event->message = event_message;
 100         event->type = atoi(event_type);
 101         free(event_type);
 102         event->object = GET_OBJECT_FROM_EVENT_TYPE(event->type);
 103         event->action = GET_ACTION_FROM_EVENT_TYPE(event->type);
 104
 105         return 0;
 106 }