2 * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
3 * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License version 2.1
7 * as published by the Free Software Foundation
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 #include <sys/types.h>
23 #include <sys/types.h>
24 #include <sys/socket.h>
29 #include <libubox/ustream.h>
30 #include <libubox/blobmsg_json.h>
31 #include <libubox/usock.h>
32 #include <libubox/uloop.h>
36 #define LOGD_CONNECT_RETRY 10
53 static const struct blobmsg_policy log_policy
[] = {
54 [LOG_MSG
] = { .name
= "msg", .type
= BLOBMSG_TYPE_STRING
},
55 [LOG_ID
] = { .name
= "id", .type
= BLOBMSG_TYPE_INT32
},
56 [LOG_PRIO
] = { .name
= "priority", .type
= BLOBMSG_TYPE_INT32
},
57 [LOG_SOURCE
] = { .name
= "source", .type
= BLOBMSG_TYPE_INT32
},
58 [LOG_TIME
] = { .name
= "time", .type
= BLOBMSG_TYPE_INT64
},
61 static struct uloop_timeout retry
;
62 static struct uloop_fd sender
;
63 static regex_t regexp_preg
;
64 static const char *log_file
, *log_ip
, *log_port
, *log_prefix
, *pid_file
, *hostname
, *regexp_pattern
;
65 static int log_type
= LOG_STDOUT
;
66 static int log_size
, log_udp
, log_follow
, log_trailer_null
= 0;
67 static int log_timestamp
;
68 static int logd_conn_tries
= LOGD_CONNECT_RETRY
;
69 static int facility_include
;
70 static int facility_exclude
;
72 /* check for facility filter; return 0 if message shall be dropped */
73 static int check_facility_filter(int f
)
76 return !!(facility_include
& (1 << f
));
78 return !(facility_exclude
& (1 << f
));
82 static const char* getcodetext(int value
, CODE
*codetable
) {
86 for (i
= codetable
; i
->c_val
!= -1; i
++)
87 if (i
->c_val
== value
)
92 static void log_handle_reconnect(struct uloop_timeout
*timeout
)
94 sender
.fd
= usock((log_udp
) ? (USOCK_UDP
) : (USOCK_TCP
), log_ip
, log_port
);
96 fprintf(stderr
, "failed to connect: %m\n");
97 uloop_timeout_set(&retry
, 1000);
99 uloop_fd_add(&sender
, ULOOP_READ
);
100 syslog(LOG_INFO
, "Logread connected to %s:%s\n", log_ip
, log_port
);
104 static void log_handle_fd(struct uloop_fd
*u
, unsigned int events
)
110 uloop_timeout_set(&retry
, 1000);
114 static int log_notify(struct blob_attr
*msg
)
116 struct blob_attr
*tb
[__LOG_MAX
];
118 char buf
[LOG_LINE_SIZE
+ 128];
129 blobmsg_parse(log_policy
, ARRAY_SIZE(log_policy
), tb
, blob_data(msg
), blob_len(msg
));
130 if (!tb
[LOG_ID
] || !tb
[LOG_PRIO
] || !tb
[LOG_SOURCE
] || !tb
[LOG_TIME
] || !tb
[LOG_MSG
])
133 if ((log_type
== LOG_FILE
) && log_size
&& (!stat(log_file
, &s
)) && (s
.st_size
> log_size
)) {
134 char *old
= malloc(strlen(log_file
) + 5);
138 sprintf(old
, "%s.old", log_file
);
139 rename(log_file
, old
);
142 sender
.fd
= open(log_file
, O_CREAT
| O_WRONLY
| O_APPEND
, 0600);
144 fprintf(stderr
, "failed to open %s: %m\n", log_file
);
148 p
= blobmsg_get_u32(tb
[LOG_PRIO
]);
150 if (!check_facility_filter(LOG_FAC(p
)))
153 m
= blobmsg_get_string(tb
[LOG_MSG
]);
154 if (regexp_pattern
&&
155 regexec(®exp_preg
, m
, 0, NULL
, 0) == REG_NOMATCH
)
157 t
= blobmsg_get_u64(tb
[LOG_TIME
]) / 1000;
159 t_ms
= blobmsg_get_u64(tb
[LOG_TIME
]) % 1000;
160 snprintf(buf_ts
, sizeof(buf_ts
), "[%lu.%03u] ",
161 (unsigned long)t
, t_ms
);
164 c
[strlen(c
) - 1] = '\0';
166 if (log_type
== LOG_NET
) {
169 snprintf(buf
, sizeof(buf
), "<%u>", p
);
170 strncat(buf
, c
+ 4, 16);
172 strncat(buf
, buf_ts
, sizeof(buf
) - strlen(buf
) - 1);
175 strncat(buf
, hostname
, sizeof(buf
) - strlen(buf
) - 1);
176 strncat(buf
, " ", sizeof(buf
) - strlen(buf
) - 1);
179 strncat(buf
, log_prefix
, sizeof(buf
) - strlen(buf
) - 1);
180 strncat(buf
, ": ", sizeof(buf
) - strlen(buf
) - 1);
182 if (blobmsg_get_u32(tb
[LOG_SOURCE
]) == SOURCE_KLOG
)
183 strncat(buf
, "kernel: ", sizeof(buf
) - strlen(buf
) - 1);
184 strncat(buf
, m
, sizeof(buf
) - strlen(buf
) - 1);
186 err
= write(sender
.fd
, buf
, strlen(buf
));
188 size_t buflen
= strlen(buf
);
189 if (!log_trailer_null
)
191 err
= send(sender
.fd
, buf
, buflen
+ 1, 0);
195 syslog(LOG_INFO
, "failed to send log data to %s:%s via %s\n",
196 log_ip
, log_port
, (log_udp
) ? ("udp") : ("tcp"));
197 uloop_fd_delete(&sender
);
200 uloop_timeout_set(&retry
, 1000);
203 snprintf(buf
, sizeof(buf
), "%s %s%s.%s%s %s\n",
204 c
, log_timestamp
? buf_ts
: "",
205 getcodetext(LOG_FAC(p
) << 3, facilitynames
),
206 getcodetext(LOG_PRI(p
), prioritynames
),
207 (blobmsg_get_u32(tb
[LOG_SOURCE
])) ? ("") : (" kernel:"), m
);
208 ret
= write(sender
.fd
, buf
, strlen(buf
));
211 if (log_type
== LOG_FILE
)
217 static int usage(const char *prog
)
219 fprintf(stderr
, "Usage: %s [options]\n"
221 " -s <path> Path to ubus socket\n"
222 " -l <count> Got only the last 'count' messages\n"
223 " -e <pattern> Filter messages with a regexp\n"
224 " -r <server> <port> Stream message to a server\n"
225 " -F <file> Log file\n"
226 " -S <bytes> Log size\n"
227 " -p <file> PID file\n"
228 " -h <hostname> Add hostname to the message\n"
229 " -P <prefix> Prefix custom text to streamed messages\n"
230 " -z <facility> handle only messages with given facility (0-23), repeatable\n"
231 " -Z <facility> ignore messages with given facility (0-23), repeatable\n"
232 " -f Follow log messages\n"
233 " -u Use UDP as the protocol\n"
234 " -t Add an extra timestamp\n"
235 " -0 Use \\0 instead of \\n as trailer when using TCP\n"
240 static void logread_fd_data_cb(struct ustream
*s
, int bytes
)
246 a
= (void*) ustream_get_read_buf(s
, &len
);
247 if (len
< sizeof(*a
))
250 cur_len
= blob_len(a
) + sizeof(*a
);
255 ustream_consume(s
, cur_len
);
259 static void logread_fd_state_cb(struct ustream
*s
)
262 logd_conn_tries
= LOGD_CONNECT_RETRY
;
266 static void logread_fd_cb(struct ubus_request
*req
, int fd
)
268 static struct ustream_fd test_fd
;
270 memset(&test_fd
, 0, sizeof(test_fd
));
272 test_fd
.stream
.notify_read
= logread_fd_data_cb
;
273 test_fd
.stream
.notify_state
= logread_fd_state_cb
;
274 ustream_fd_init(&test_fd
, fd
);
277 static void logread_setup_output(void)
279 if (sender
.fd
|| sender
.cb
)
282 if (log_ip
&& log_port
) {
283 openlog("logread", LOG_PID
, LOG_DAEMON
);
285 sender
.cb
= log_handle_fd
;
286 retry
.cb
= log_handle_reconnect
;
287 uloop_timeout_set(&retry
, 1000);
288 } else if (log_file
) {
290 sender
.fd
= open(log_file
, O_CREAT
| O_WRONLY
| O_APPEND
, 0600);
292 fprintf(stderr
, "failed to open %s: %m\n", log_file
);
296 sender
.fd
= STDOUT_FILENO
;
300 int main(int argc
, char **argv
)
302 struct ubus_context
*ctx
;
304 const char *ubus_socket
= NULL
;
305 int ch
, ret
, lines
= 0;
306 static struct blob_buf b
;
308 signal(SIGPIPE
, SIG_IGN
);
310 while ((ch
= getopt(argc
, argv
, "u0fcs:l:z:Z:r:F:p:S:P:h:e:t")) != -1) {
316 log_trailer_null
= 1;
319 ubus_socket
= optarg
;
323 log_port
= argv
[optind
++];
338 lines
= atoi(optarg
);
341 id
= strtoul(optarg
, NULL
, 0) & 0x1f;
342 facility_include
|= (1 << id
);
345 id
= strtoul(optarg
, NULL
, 0) & 0x1f;
346 facility_exclude
|= (1 << id
);
349 log_size
= atoi(optarg
);
358 if (!regcomp(®exp_preg
, optarg
, REG_NOSUB
)) {
359 regexp_pattern
= optarg
;
371 ctx
= ubus_connect(ubus_socket
);
373 fprintf(stderr
, "Failed to connect to ubus\n");
378 if (log_follow
&& pid_file
) {
379 FILE *fp
= fopen(pid_file
, "w+");
381 fprintf(fp
, "%d", getpid());
386 blob_buf_init(&b
, 0);
387 blobmsg_add_u8(&b
, "stream", 1);
388 blobmsg_add_u8(&b
, "oneshot", !log_follow
);
390 blobmsg_add_u32(&b
, "lines", lines
);
392 blobmsg_add_u32(&b
, "lines", 0);
394 /* ugly ugly ugly ... we need a real reconnect logic */
396 struct ubus_request req
= { 0 };
398 ret
= ubus_lookup_id(ctx
, "log", &id
);
400 fprintf(stderr
, "Failed to find log object: %s\n", ubus_strerror(ret
));
405 logread_setup_output();
407 ubus_invoke_async(ctx
, id
, "read", b
.head
, &req
);
408 req
.fd_cb
= logread_fd_cb
;
409 ubus_complete_request_async(ctx
, &req
);
413 } while (logd_conn_tries
--);
418 if (log_follow
&& pid_file
)