#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <regex.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <syslog.h>
#include <libubox/ustream.h>
#include <libubox/blobmsg_json.h>
#include <libubox/usock.h>
#include <libubox/uloop.h>
#include "libubus.h"

Macros
#define	SYSLOG_NAMES

#define	LOGD_CONNECT_RETRY 10

Enumerations
enum	{ LOG_STDOUT , LOG_FILE , LOG_NET }

enum	{ LOG_MSG , LOG_ID , LOG_PRIO , LOG_SOURCE , LOG_TIME , __LOG_MAX }

Functions
static int	check_facility_filter (int f)

static const char *	getcodetext (int value, CODE *codetable)

static void	log_handle_reconnect (struct uloop_timeout *timeout)

static void	log_handle_fd (struct uloop_fd *u, unsigned int events)

static int	log_notify (struct blob_attr *msg)

static int	usage (const char *prog)

static void	logread_fd_data_cb (struct ustream *s, int bytes)

static void	logread_fd_state_cb (struct ustream *s)

static void	logread_fd_cb (struct ubus_request *req, int fd)

static void	logread_setup_output (void)

int	main (int argc, char **argv)

Variables
static const struct blobmsg_policy	log_policy []

static struct uloop_timeout	retry

static struct uloop_fd	sender

static regex_t	regexp_preg

static const char *	log_file

static const char *	log_ip

static const char *	log_port

static const char *	log_prefix

static const char *	pid_file

static const char *	hostname

static const char *	regexp_pattern

static int	log_type = LOG_STDOUT

static int	log_size

static int	log_udp

static int	log_follow

static int	log_trailer_null = 0

static int	log_timestamp

static int	logd_conn_tries = 10

static int	facility_include

static int	facility_exclude

Macro Definition Documentation

◆ LOGD_CONNECT_RETRY

#define LOGD_CONNECT_RETRY 10

Definition at line 36 of file logread.c.

◆ SYSLOG_NAMES

#define SYSLOG_NAMES

Definition at line 26 of file logread.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
LOG_STDOUT
LOG_FILE
LOG_NET

Definition at line 38 of file logread.c.

      {
         LOG_STDOUT,
         LOG_FILE,
         LOG_NET,
 };

◆ anonymous enum

anonymous enum

Enumerator
LOG_MSG
LOG_ID
LOG_PRIO
LOG_SOURCE
LOG_TIME
__LOG_MAX

Definition at line 44 of file logread.c.

      {
         LOG_MSG,
         LOG_ID,
         LOG_PRIO,
         LOG_SOURCE,
         LOG_TIME,
         __LOG_MAX
 };

Function Documentation

◆ check_facility_filter()

static int check_facility_filter ( int f )

static

Definition at line 73 of file logread.c.

 {
         if (facility_include)
                 return !!(facility_include & (1 << f));
         if (facility_exclude)
                 return !(facility_exclude & (1 << f));
         return 1;
 }

Here is the caller graph for this function:

◆ getcodetext()

static const char* getcodetext	(	int	value,
		CODE *	codetable
	)

static

Definition at line 82 of file logread.c.

                                                            {
         CODE *i;
  
         if (value >= 0)
                 for (i = codetable; i->c_val != -1; i++)
                         if (i->c_val == value)
                                 return (i->c_name);
         return "<unknown>";
 };

Here is the caller graph for this function:

◆ log_handle_fd()

static void log_handle_fd	(	struct uloop_fd *	u,
		unsigned int	events
	)

static

Definition at line 110 of file logread.c.

 {
         if (u->eof) {
                 uloop_fd_delete(u);
                 close(sender.fd);
                 sender.fd = -1;
                 uloop_timeout_set(&retry, 1000);
         }
 }

Here is the caller graph for this function:

◆ log_handle_reconnect()

static void log_handle_reconnect ( struct uloop_timeout * timeout )

static

Definition at line 92 of file logread.c.

 {
         sender.fd = usock((log_udp) ? (USOCK_UDP) : (USOCK_TCP), log_ip, log_port);
         if (sender.fd < 0) {
                 fprintf(stderr, "failed to connect: %m\n");
                 uloop_timeout_set(&retry, 1000);
         } else {
                 uloop_fd_add(&sender, ULOOP_READ);
  
                 if (log_udp < 2)
                         syslog(LOG_INFO, "Logread connected to %s:%s via %s\n",
                                 log_ip, log_port, (log_udp) ? ("udp") : ("tcp"));
  
                 if (log_udp == 1)
                         ++log_udp;
         }
 }

Here is the caller graph for this function:

◆ log_notify()

static int log_notify ( struct blob_attr * msg )

static

Definition at line 120 of file logread.c.

 {
         struct blob_attr *tb[__LOG_MAX];
         struct stat s;
         char buf[LOG_LINE_SIZE + 128];
         char buf_ts[32];
         uint32_t p;
         time_t t;
         uint32_t t_ms = 0;
         char *c, *m;
         int ret = 0;
  
         if (sender.fd < 0)
                 return 0;
  
         blobmsg_parse(log_policy, ARRAY_SIZE(log_policy), tb, blob_data(msg), blob_len(msg));
         if (!tb[LOG_ID] || !tb[LOG_PRIO] || !tb[LOG_SOURCE] || !tb[LOG_TIME] || !tb[LOG_MSG])
                 return 1;
  
         if ((log_type == LOG_FILE) && log_size && (!stat(log_file, &s)) && (s.st_size > log_size)) {
                 char *old = malloc(strlen(log_file) + 5);
  
                 close(sender.fd);
                 if (old) {
                         sprintf(old, "%s.old", log_file);
                         rename(log_file, old);
                         free(old);
                 }
                 sender.fd = open(log_file, O_CREAT | O_WRONLY | O_APPEND, 0600);
                 if (sender.fd < 0) {
                         fprintf(stderr, "failed to open %s: %m\n", log_file);
                         exit(-1);
                 }
         }
         p = blobmsg_get_u32(tb[LOG_PRIO]);
  
         if (!check_facility_filter(LOG_FAC(p)))
                         return 0;
  
         m = blobmsg_get_string(tb[LOG_MSG]);
         if (regexp_pattern &&
             regexec(&regexp_preg, m, 0, NULL, 0) == REG_NOMATCH)
                 return 0;
         t = blobmsg_get_u64(tb[LOG_TIME]) / 1000;
         if (log_timestamp) {
                 t_ms = blobmsg_get_u64(tb[LOG_TIME]) % 1000;
                 snprintf(buf_ts, sizeof(buf_ts), "[%lu.%03u] ",
                                 (unsigned long)t, t_ms);
         }
         c = ctime(&t);
         c[strlen(c) - 1] = '\0';
  
         if (log_type == LOG_NET) {
                 int err;
  
                 snprintf(buf, sizeof(buf), "<%u>", p);
                 strncat(buf, c + 4, 16);
                 if (log_timestamp) {
                         strncat(buf, buf_ts, sizeof(buf) - strlen(buf) - 1);
                 }
                 if (hostname) {
                         strncat(buf, hostname, sizeof(buf) - strlen(buf) - 1);
                         strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
                 }
                 if (log_prefix) {
                         strncat(buf, log_prefix, sizeof(buf) - strlen(buf) - 1);
                         strncat(buf, ": ", sizeof(buf) - strlen(buf) - 1);
                 }
                 if (blobmsg_get_u32(tb[LOG_SOURCE]) == SOURCE_KLOG)
                         strncat(buf, "kernel: ", sizeof(buf) - strlen(buf) - 1);
                 strncat(buf, m, sizeof(buf) - strlen(buf) - 1);
                 if (log_udp)
                         err = write(sender.fd, buf, strlen(buf));
                 else {
                         size_t buflen = strlen(buf);
                         if (!log_trailer_null)
                                 buf[buflen] = '\n';
                         err = send(sender.fd, buf, buflen + 1, 0);
                 }
  
                 if (err < 0) {
                         syslog(LOG_INFO, "Failed to send log data to %s:%s via %s\n",
                                 log_ip, log_port, (log_udp) ? ("udp") : ("tcp"));
                         uloop_fd_delete(&sender);
                         close(sender.fd);
                         sender.fd = -1;
                         uloop_timeout_set(&retry, 1000);
                 }
         } else {
                 snprintf(buf, sizeof(buf), "%s %s%s.%s%s %s\n",
                         c, log_timestamp ? buf_ts : "",
                         getcodetext(LOG_FAC(p) << 3, facilitynames),
                         getcodetext(LOG_PRI(p), prioritynames),
                         (blobmsg_get_u32(tb[LOG_SOURCE])) ? ("") : (" kernel:"), m);
                 ret = write(sender.fd, buf, strlen(buf));
         }
  
         if (log_type == LOG_FILE)
                 fsync(sender.fd);
  
         return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logread_fd_cb()

static void logread_fd_cb	(	struct ubus_request *	req,
		int	fd
	)

static

Definition at line 272 of file logread.c.

 {
         static struct ustream_fd test_fd;
  
         memset(&test_fd, 0, sizeof(test_fd));
  
         test_fd.stream.notify_read = logread_fd_data_cb;
         test_fd.stream.notify_state = logread_fd_state_cb;
         ustream_fd_init(&test_fd, fd);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logread_fd_data_cb()

static void logread_fd_data_cb	(	struct ustream *	s,
		int	bytes
	)

static

Definition at line 246 of file logread.c.

 {
         while (true) {
                 struct blob_attr *a;
                 int len, cur_len;
  
                 a = (void*) ustream_get_read_buf(s, &len);
                 if (len < sizeof(*a))
                         break;
  
                 cur_len = blob_len(a) + sizeof(*a);
                 if (len < cur_len)
                         break;
  
                 log_notify(a);
                 ustream_consume(s, cur_len);
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logread_fd_state_cb()

static void logread_fd_state_cb ( struct ustream * s )

static

Definition at line 265 of file logread.c.

 {
         if (log_follow)
                 logd_conn_tries = LOGD_CONNECT_RETRY;
         uloop_end();
 }

Here is the caller graph for this function:

◆ logread_setup_output()

static void logread_setup_output ( void )

static

Definition at line 283 of file logread.c.

 {
         if (sender.fd || sender.cb)
                 return;
  
         if (log_ip && log_port) {
                 openlog("logread", LOG_PID, LOG_DAEMON);
                 log_type = LOG_NET;
                 sender.cb = log_handle_fd;
                 retry.cb = log_handle_reconnect;
                 uloop_timeout_set(&retry, 1000);
         } else if (log_file) {
                 log_type = LOG_FILE;
                 sender.fd = open(log_file, O_CREAT | O_WRONLY| O_APPEND, 0600);
                 if (sender.fd < 0) {
                         fprintf(stderr, "failed to open %s: %m\n", log_file);
                         exit(-1);
                 }
         } else {
                 sender.fd = STDOUT_FILENO;
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 306 of file logread.c.

 {
         struct ubus_context *ctx;
         uint32_t id;
         const char *ubus_socket = NULL;
         int ch, ret, lines = 0;
         static struct blob_buf b;
  
         signal(SIGPIPE, SIG_IGN);
  
         while ((ch = getopt(argc, argv, "u0fcs:l:z:Z:r:F:p:S:P:h:e:t")) != -1) {
                 switch (ch) {
                 case 'u':
                         log_udp = 1;
                         break;
                 case '0':
                         log_trailer_null = 1;
                         break;
                 case 's':
                         ubus_socket = optarg;
                         break;
                 case 'r':
                         log_ip = optarg++;
                         log_port = argv[optind++];
                         break;
                 case 'F':
                         log_file = optarg;
                         break;
                 case 'p':
                         pid_file = optarg;
                         break;
                 case 'P':
                         log_prefix = optarg;
                         break;
                 case 'f':
                         log_follow = 1;
                         break;
                 case 'l':
                         lines = atoi(optarg);
                         break;
                 case 'z':
                         id = strtoul(optarg, NULL, 0) & 0x1f;
                         facility_include |= (1 << id);
                         break;
                 case 'Z':
                         id = strtoul(optarg, NULL, 0) & 0x1f;
                         facility_exclude |= (1 << id);
                         break;
                 case 'S':
                         log_size = atoi(optarg);
                         if (log_size < 1)
                                 log_size = 1;
                         log_size *= 1024;
                         break;
                 case 'h':
                         hostname = optarg;
                         break;
                 case 'e':
                         if (!regcomp(&regexp_preg, optarg, REG_NOSUB)) {
                                 regexp_pattern = optarg;
                         }
                         break;
                 case 't':
                         log_timestamp = 1;
                         break;
                 default:
                         return usage(*argv);
                 }
         }
         uloop_init();
  
         ctx = ubus_connect(ubus_socket);
         if (!ctx) {
                 fprintf(stderr, "Failed to connect to ubus\n");
                 return -1;
         }
         ubus_add_uloop(ctx);
  
         if (log_follow && pid_file) {
                 FILE *fp = fopen(pid_file, "w+");
                 if (fp) {
                         fprintf(fp, "%d", getpid());
                         fclose(fp);
                 }
         }
  
         blob_buf_init(&b, 0);
         blobmsg_add_u8(&b, "stream", 1);
         blobmsg_add_u8(&b, "oneshot", !log_follow);
         if (lines)
                 blobmsg_add_u32(&b, "lines", lines);
         else if (log_follow)
                 blobmsg_add_u32(&b, "lines", 0);
  
         /* ugly ugly ugly ... we need a real reconnect logic */
         do {
                 struct ubus_request req = { 0 };
  
                 ret = ubus_lookup_id(ctx, "log", &id);
                 if (ret) {
                         fprintf(stderr, "Failed to find log object: %s\n", ubus_strerror(ret));
                         sleep(1);
                         continue;
                 }
                 logd_conn_tries = 0;
                 logread_setup_output();
  
                 ubus_invoke_async(ctx, id, "read", b.head, &req);
                 req.fd_cb = logread_fd_cb;
                 ubus_complete_request_async(ctx, &req);
  
                 uloop_run();
  
         } while (logd_conn_tries--);
  
         ubus_free(ctx);
         uloop_done();
  
         if (log_follow && pid_file)
                 unlink(pid_file);
  
         return ret;
 }

Here is the call graph for this function:

◆ usage()

static int usage ( const char * prog )

static

Definition at line 223 of file logread.c.

 {
         fprintf(stderr, "Usage: %s [options]\n"
                 "Options:\n"
                 "    -s <path>          Path to ubus socket\n"
                 "    -l <count>         Got only the last 'count' messages\n"
                 "    -e <pattern>       Filter messages with a regexp\n"
                 "    -r <server> <port> Stream message to a server\n"
                 "    -F <file>          Log file\n"
                 "    -S <bytes>         Log size\n"
                 "    -p <file>          PID file\n"
                 "    -h <hostname>      Add hostname to the message\n"
                 "    -P <prefix>        Prefix custom text to streamed messages\n"
                 "    -z <facility>      handle only messages with given facility (0-23), repeatable\n"
                 "    -Z <facility>      ignore messages with given facility (0-23), repeatable\n"
                 "    -f                 Follow log messages\n"
                 "    -u                 Use UDP as the protocol\n"
                 "    -t                 Add an extra timestamp\n"
                 "    -0                 Use \\0 instead of \\n as trailer when using TCP\n"
                 "\n", prog);
         return 1;
 }

Here is the caller graph for this function:

Variable Documentation

◆ facility_exclude

int facility_exclude

static

Definition at line 70 of file logread.c.

◆ facility_include

int facility_include

static

Definition at line 69 of file logread.c.

◆ hostname

const char * hostname

static

Definition at line 64 of file logread.c.

◆ log_file

const char* log_file

static

Definition at line 64 of file logread.c.

◆ log_follow

int log_follow

static

Definition at line 66 of file logread.c.

◆ log_ip

const char * log_ip

static

Definition at line 64 of file logread.c.

◆ log_policy

const struct blobmsg_policy log_policy[]

static

Initial value:

= {
        [LOG_MSG] = { .name = "msg", .type = BLOBMSG_TYPE_STRING },
        [LOG_ID] = { .name = "id", .type = BLOBMSG_TYPE_INT32 },
        [LOG_PRIO] = { .name = "priority", .type = BLOBMSG_TYPE_INT32 },
        [LOG_SOURCE] = { .name = "source", .type = BLOBMSG_TYPE_INT32 },
        [LOG_TIME] = { .name = "time", .type = BLOBMSG_TYPE_INT64 },
}

Definition at line 1 of file logread.c.

◆ log_port

const char * log_port

static

Definition at line 64 of file logread.c.

◆ log_prefix

const char * log_prefix

static

Definition at line 64 of file logread.c.

◆ log_size

int log_size

static

Definition at line 66 of file logread.c.

◆ log_timestamp

int log_timestamp

static

Definition at line 67 of file logread.c.

◆ log_trailer_null

int log_trailer_null = 0

static

Definition at line 66 of file logread.c.

◆ log_type

int log_type = LOG_STDOUT

static

Definition at line 65 of file logread.c.

◆ log_udp

int log_udp

static

Definition at line 66 of file logread.c.

◆ logd_conn_tries

int logd_conn_tries = 10

static

Definition at line 68 of file logread.c.

◆ pid_file

const char * pid_file

static

Definition at line 64 of file logread.c.

◆ regexp_pattern

const char * regexp_pattern

static

Definition at line 64 of file logread.c.

◆ regexp_preg

regex_t regexp_preg

static

Definition at line 63 of file logread.c.

◆ retry

struct uloop_timeout retry

static

Definition at line 1 of file logread.c.

◆ sender

struct uloop_fd sender

static

Definition at line 1 of file logread.c.

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ LOGD_CONNECT_RETRY

◆ SYSLOG_NAMES

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ check_facility_filter()

◆ getcodetext()

◆ log_handle_fd()

◆ log_handle_reconnect()

◆ log_notify()

◆ logread_fd_cb()

◆ logread_fd_data_cb()

◆ logread_fd_state_cb()

◆ logread_setup_output()

◆ main()

◆ usage()

Variable Documentation

◆ facility_exclude

◆ facility_include

◆ hostname

◆ log_file

◆ log_follow

◆ log_ip

◆ log_policy

◆ log_port

◆ log_prefix

◆ log_size

◆ log_timestamp

◆ log_trailer_null

◆ log_type

◆ log_udp

◆ logd_conn_tries

◆ pid_file

◆ regexp_pattern

◆ regexp_preg

◆ retry

◆ sender