Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : #ifndef foosdjournalhfoo
       3             : #define foosdjournalhfoo
       4             : 
       5             : /***
       6             :   systemd is free software; you can redistribute it and/or modify it
       7             :   under the terms of the GNU Lesser General Public License as published by
       8             :   the Free Software Foundation; either version 2.1 of the License, or
       9             :   (at your option) any later version.
      10             : 
      11             :   systemd is distributed in the hope that it will be useful, but
      12             :   WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
      14             :   Lesser General Public License for more details.
      15             : 
      16             :   You should have received a copy of the GNU Lesser General Public License
      17             :   along with systemd; If not, see <http://www.gnu.org/licenses/>.
      18             : ***/
      19             : 
      20             : #include <inttypes.h>
      21             : #include <stdarg.h>
      22             : #include <sys/types.h>
      23             : #include <sys/uio.h>
      24             : #include <syslog.h>
      25             : 
      26             : #include "sd-id128.h"
      27             : 
      28             : #include "_sd-common.h"
      29             : 
      30             : /* Journal APIs. See sd-journal(3) for more information. */
      31             : 
      32             : _SD_BEGIN_DECLARATIONS;
      33             : 
      34             : /* Write to daemon */
      35             : int sd_journal_print(int priority, const char *format, ...) _sd_printf_(2, 3);
      36             : int sd_journal_printv(int priority, const char *format, va_list ap) _sd_printf_(2, 0);
      37             : int sd_journal_send(const char *format, ...) _sd_printf_(1, 0) _sd_sentinel_;
      38             : int sd_journal_sendv(const struct iovec *iov, int n);
      39             : int sd_journal_perror(const char *message);
      40             : 
      41             : /* Used by the macros below. You probably don't want to call this directly. */
      42             : int sd_journal_print_with_location(int priority, const char *file, const char *line, const char *func, const char *format, ...) _sd_printf_(5, 6);
      43             : int sd_journal_printv_with_location(int priority, const char *file, const char *line, const char *func, const char *format, va_list ap) _sd_printf_(5, 0);
      44             : int sd_journal_send_with_location(const char *file, const char *line, const char *func, const char *format, ...) _sd_printf_(4, 0) _sd_sentinel_;
      45             : int sd_journal_sendv_with_location(const char *file, const char *line, const char *func, const struct iovec *iov, int n);
      46             : int sd_journal_perror_with_location(const char *file, const char *line, const char *func, const char *message);
      47             : 
      48             : /* implicitly add code location to messages sent, if this is enabled */
      49             : #ifndef SD_JOURNAL_SUPPRESS_LOCATION
      50             : 
      51             : #define sd_journal_print(priority, ...) sd_journal_print_with_location(priority, "CODE_FILE=" __FILE__, "CODE_LINE=" _SD_STRINGIFY(__LINE__), __func__, __VA_ARGS__)
      52             : #define sd_journal_printv(priority, format, ap) sd_journal_printv_with_location(priority, "CODE_FILE=" __FILE__, "CODE_LINE=" _SD_STRINGIFY(__LINE__), __func__, format, ap)
      53             : #define sd_journal_send(...) sd_journal_send_with_location("CODE_FILE=" __FILE__, "CODE_LINE=" _SD_STRINGIFY(__LINE__), __func__, __VA_ARGS__)
      54             : #define sd_journal_sendv(iovec, n) sd_journal_sendv_with_location("CODE_FILE=" __FILE__, "CODE_LINE=" _SD_STRINGIFY(__LINE__), __func__, iovec, n)
      55             : #define sd_journal_perror(message) sd_journal_perror_with_location("CODE_FILE=" __FILE__, "CODE_LINE=" _SD_STRINGIFY(__LINE__), __func__, message)
      56             : 
      57             : #endif
      58             : 
      59             : int sd_journal_stream_fd(const char *identifier, int priority, int level_prefix);
      60             : 
      61             : /* Browse journal stream */
      62             : 
      63             : typedef struct sd_journal sd_journal;
      64             : 
      65             : /* Open flags */
      66             : enum {
      67             :         SD_JOURNAL_LOCAL_ONLY   = 1 << 0,
      68             :         SD_JOURNAL_RUNTIME_ONLY = 1 << 1,
      69             :         SD_JOURNAL_SYSTEM       = 1 << 2,
      70             :         SD_JOURNAL_CURRENT_USER = 1 << 3,
      71             :         SD_JOURNAL_OS_ROOT      = 1 << 4,
      72             : 
      73             :         SD_JOURNAL_SYSTEM_ONLY = SD_JOURNAL_SYSTEM /* deprecated name */
      74             : };
      75             : 
      76             : /* Wakeup event types */
      77             : enum {
      78             :         SD_JOURNAL_NOP,
      79             :         SD_JOURNAL_APPEND,
      80             :         SD_JOURNAL_INVALIDATE
      81             : };
      82             : 
      83             : int sd_journal_open(sd_journal **ret, int flags);
      84             : int sd_journal_open_directory(sd_journal **ret, const char *path, int flags);
      85             : int sd_journal_open_directory_fd(sd_journal **ret, int fd, int flags);
      86             : int sd_journal_open_files(sd_journal **ret, const char **paths, int flags);
      87             : int sd_journal_open_files_fd(sd_journal **ret, int fds[], unsigned n_fds, int flags);
      88             : int sd_journal_open_container(sd_journal **ret, const char *machine, int flags); /* deprecated */
      89             : void sd_journal_close(sd_journal *j);
      90             : 
      91             : int sd_journal_previous(sd_journal *j);
      92             : int sd_journal_next(sd_journal *j);
      93             : 
      94             : int sd_journal_previous_skip(sd_journal *j, uint64_t skip);
      95             : int sd_journal_next_skip(sd_journal *j, uint64_t skip);
      96             : 
      97             : int sd_journal_get_realtime_usec(sd_journal *j, uint64_t *ret);
      98             : int sd_journal_get_monotonic_usec(sd_journal *j, uint64_t *ret, sd_id128_t *ret_boot_id);
      99             : 
     100             : int sd_journal_set_data_threshold(sd_journal *j, size_t sz);
     101             : int sd_journal_get_data_threshold(sd_journal *j, size_t *sz);
     102             : 
     103             : int sd_journal_get_data(sd_journal *j, const char *field, const void **data, size_t *l);
     104             : int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t *l);
     105             : void sd_journal_restart_data(sd_journal *j);
     106             : 
     107             : int sd_journal_add_match(sd_journal *j, const void *data, size_t size);
     108             : int sd_journal_add_disjunction(sd_journal *j);
     109             : int sd_journal_add_conjunction(sd_journal *j);
     110             : void sd_journal_flush_matches(sd_journal *j);
     111             : 
     112             : int sd_journal_seek_head(sd_journal *j);
     113             : int sd_journal_seek_tail(sd_journal *j);
     114             : int sd_journal_seek_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t usec);
     115             : int sd_journal_seek_realtime_usec(sd_journal *j, uint64_t usec);
     116             : int sd_journal_seek_cursor(sd_journal *j, const char *cursor);
     117             : 
     118             : int sd_journal_get_cursor(sd_journal *j, char **cursor);
     119             : int sd_journal_test_cursor(sd_journal *j, const char *cursor);
     120             : 
     121             : int sd_journal_get_cutoff_realtime_usec(sd_journal *j, uint64_t *from, uint64_t *to);
     122             : int sd_journal_get_cutoff_monotonic_usec(sd_journal *j, const sd_id128_t boot_id, uint64_t *from, uint64_t *to);
     123             : 
     124             : int sd_journal_get_usage(sd_journal *j, uint64_t *bytes);
     125             : 
     126             : int sd_journal_query_unique(sd_journal *j, const char *field);
     127             : int sd_journal_enumerate_unique(sd_journal *j, const void **data, size_t *l);
     128             : void sd_journal_restart_unique(sd_journal *j);
     129             : 
     130             : int sd_journal_enumerate_fields(sd_journal *j, const char **field);
     131             : void sd_journal_restart_fields(sd_journal *j);
     132             : 
     133             : int sd_journal_get_fd(sd_journal *j);
     134             : int sd_journal_get_events(sd_journal *j);
     135             : int sd_journal_get_timeout(sd_journal *j, uint64_t *timeout_usec);
     136             : int sd_journal_process(sd_journal *j);
     137             : int sd_journal_wait(sd_journal *j, uint64_t timeout_usec);
     138             : int sd_journal_reliable_fd(sd_journal *j);
     139             : 
     140             : int sd_journal_get_catalog(sd_journal *j, char **text);
     141             : int sd_journal_get_catalog_for_message_id(sd_id128_t id, char **text);
     142             : 
     143             : int sd_journal_has_runtime_files(sd_journal *j);
     144             : int sd_journal_has_persistent_files(sd_journal *j);
     145             : 
     146             : /* The inverse condition avoids ambiguity of dangling 'else' after the macro */
     147             : #define SD_JOURNAL_FOREACH(j)                                           \
     148             :         if (sd_journal_seek_head(j) < 0) { }                            \
     149             :         else while (sd_journal_next(j) > 0)
     150             : 
     151             : /* The inverse condition avoids ambiguity of dangling 'else' after the macro */
     152             : #define SD_JOURNAL_FOREACH_BACKWARDS(j)                                 \
     153             :         if (sd_journal_seek_tail(j) < 0) { }                            \
     154             :         else while (sd_journal_previous(j) > 0)
     155             : 
     156             : /* Iterate through the data fields of the current journal entry */
     157             : #define SD_JOURNAL_FOREACH_DATA(j, data, l)                             \
     158             :         for (sd_journal_restart_data(j); sd_journal_enumerate_data((j), &(data), &(l)) > 0; )
     159             : 
     160             : /* Iterate through the all known values of a specific field */
     161             : #define SD_JOURNAL_FOREACH_UNIQUE(j, data, l)                           \
     162             :         for (sd_journal_restart_unique(j); sd_journal_enumerate_unique((j), &(data), &(l)) > 0; )
     163             : 
     164             : /* Iterate through all known field names */
     165             : #define SD_JOURNAL_FOREACH_FIELD(j, field) \
     166             :         for (sd_journal_restart_fields(j); sd_journal_enumerate_fields((j), &(field)) > 0; )
     167             : 
     168         531 : _SD_DEFINE_POINTER_CLEANUP_FUNC(sd_journal, sd_journal_close);
     169             : 
     170             : _SD_END_DECLARATIONS;
     171             : 
     172             : #endif