rpi/domo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Bump version 2017.01.15

Browse Source
This commit is contained in:
NADAL Jean-Baptiste
2017-03-18 22:40:12 +01:00
parent 113c97d07a
commit a08515f4a7
8 changed files with 60 additions and 973 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
bsp/buildroot_external/package/ubox/ubox.mk
View File

@@ -4,7 +4,7 @@
#
################################################################################
UBOX_VERSION:= 2016.07.19
UBOX_VERSION:= 2017.01.15
UBOX_SITE = $(TOPDIR)/../../src/3P/ubox/builders/cmake
UBOX_SITE_METHOD = local

2
src/3P/ubox/getrandom.c
View File

@@ -55,4 +55,6 @@ int main(int argc, char *argv[])
ERROR_EXIT("write() failed: %s\n", strerror(errno));
nbtot -= sizeof(buf);
}
return 0;
}

7
src/3P/ubox/kmodloader.c
View File

@@ -12,7 +12,7 @@
* GNU General Public License for more details.
*/
//#define _GNU_SOURCE
#define _GNU_SOURCE
#include <sys/syscall.h>
#include <sys/mman.h>
#include <sys/utsname.h>
@@ -609,7 +609,10 @@ static int main_insmod(int argc, char **argv)
cur += sprintf(cur, "%s", argv[i]);
}
init_module_folders();
if (init_module_folders()) {
fprintf(stderr, "falied to find the folder holding the modules\n");
return -1;
}
if (get_module_path(argv[1])) {
name = argv[1];

202
src/3P/ubox/log/logd.c
View File

@@ -1,202 +0,0 @@
/*
* Copyright (C) 2013 John Crispin <blogic@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <syslog.h>
#include <unistd.h>
#include <linux/types.h>
#include <libubox/uloop.h>
#include <libubox/blobmsg.h>
#include <libubox/list.h>
#include <libubox/ustream.h>
#include <ubus/libubus.h>
#include "syslog.h"
int debug = 0;
static struct blob_buf b;
static struct ubus_auto_conn conn;
static LIST_HEAD(clients);
static const struct blobmsg_policy read_policy =
{ .name = "lines", .type = BLOBMSG_TYPE_INT32 };
static const struct blobmsg_policy write_policy =
{ .name = "event", .type = BLOBMSG_TYPE_STRING };
struct client {
struct list_head list;
struct ustream_fd s;
int fd;
};
static void
client_close(struct ustream *s)
{
struct client *cl = container_of(s, struct client, s.stream);
list_del(&cl->list);
ustream_free(s);
close(cl->fd);
free(cl);
}
static void client_notify_state(struct ustream *s)
{
client_close(s);
}
static int
read_log(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct client *cl;
struct blob_attr *tb;
struct log_head *l;
int count = 0;
int fds[2];
int ret;
if (msg) {
blobmsg_parse(&read_policy, 1, &tb, blob_data(msg), blob_len(msg));
if (tb)
count = blobmsg_get_u32(tb);
}
if (pipe(fds) == -1) {
fprintf(stderr, "logd: failed to create pipe: %s\n", strerror(errno));
return -1;
}
ubus_request_set_fd(ctx, req, fds[0]);
cl = calloc(1, sizeof(*cl));
cl->s.stream.notify_state = client_notify_state;
cl->fd = fds[1];
ustream_fd_init(&cl->s, cl->fd);
list_add(&cl->list, &clients);
l = log_list(count, NULL);
while ((!tb || count) && l) {
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg", l->data);
blobmsg_add_u32(&b, "id", l->id);
blobmsg_add_u32(&b, "priority", l->priority);
blobmsg_add_u32(&b, "source", l->source);
blobmsg_add_u64(&b, "time", l->ts.tv_sec * 1000LL);
l = log_list(count, l);
ret = ustream_write(&cl->s.stream, (void *) b.head, blob_len(b.head) + sizeof(struct blob_attr), false);
blob_buf_free(&b);
if (ret < 0)
break;
}
return 0;
}
static int
write_log(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb;
char *event;
if (msg) {
blobmsg_parse(&write_policy, 1, &tb, blob_data(msg), blob_len(msg));
if (tb) {
event = blobmsg_get_string(tb);
log_add(event, strlen(event) + 1, SOURCE_SYSLOG);
}
}
return 0;
}
static const struct ubus_method log_methods[] = {
{ .name = "read", .handler = read_log, .policy = &read_policy, .n_policy = 1 },
{ .name = "write", .handler = write_log, .policy = &write_policy, .n_policy = 1 },
};
static struct ubus_object_type log_object_type =
UBUS_OBJECT_TYPE("log", log_methods);
static struct ubus_object log_object = {
.name = "log",
.type = &log_object_type,
.methods = log_methods,
.n_methods = ARRAY_SIZE(log_methods),
};
void
ubus_notify_log(struct log_head *l)
{
struct client *c;
if (list_empty(&clients))
return;
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg", l->data);
blobmsg_add_u32(&b, "id", l->id);
blobmsg_add_u32(&b, "priority", l->priority);
blobmsg_add_u32(&b, "source", l->source);
blobmsg_add_u64(&b, "time", (((__u64) l->ts.tv_sec) * 1000) + (l->ts.tv_nsec / 1000000));
list_for_each_entry(c, &clients, list)
ustream_write(&c->s.stream, (void *) b.head, blob_len(b.head) + sizeof(struct blob_attr), false);
blob_buf_free(&b);
}
static void
ubus_connect_handler(struct ubus_context *ctx)
{
int ret;
ret = ubus_add_object(ctx, &log_object);
if (ret) {
fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
exit(1);
}
fprintf(stderr, "log: connected to ubus\n");
}
int
main(int argc, char **argv)
{
int ch, log_size = 16;
signal(SIGPIPE, SIG_IGN);
while ((ch = getopt(argc, argv, "S:")) != -1) {
switch (ch) {
case 'S':
log_size = atoi(optarg);
if (log_size < 1)
log_size = 16;
break;
}
}
log_size *= 1024;
uloop_init();
log_init(log_size);
conn.cb = ubus_connect_handler;
ubus_auto_connect(&conn);
uloop_run();
log_shutdown();
uloop_done();
return 0;
}

358
src/3P/ubox/log/logread.c
View File

@@ -1,358 +0,0 @@
/*
* Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
* Copyright (C) 2013 John Crispin <blogic@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#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/types.h>
#include <sys/socket.h>
#define SYSLOG_NAMES
#include <syslog.h>
#include <libubox/ustream.h>
#include <libubox/blobmsg_json.h>
#include <libubox/usock.h>
#include <libubox/uloop.h>
#include <ubus/libubus.h>
#include "syslog.h"
enum {
LOG_STDOUT,
LOG_FILE,
LOG_NET,
};
enum {
LOG_MSG,
LOG_ID,
LOG_PRIO,
LOG_SOURCE,
LOG_TIME,
__LOG_MAX
};
static const struct blobmsg_policy log_policy[] = {
[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 },
};
static struct uloop_timeout retry;
static struct uloop_fd sender;
static regex_t regexp_preg;
static const char *log_file, *log_ip, *log_port, *log_prefix, *pid_file, *hostname, *regexp_pattern;
static int log_type = LOG_STDOUT;
static int log_size, log_udp, log_follow, log_trailer_null = 0;
static const char* getcodetext(int value, CODE *codetable) {
CODE *i;
if (value >= 0)
for (i = codetable; i->c_val != -1; i++)
if (i->c_val == value)
return (i->c_name);
return "<unknown>";
};
static void log_handle_reconnect(struct uloop_timeout *timeout)
{
sender.fd = usock((log_udp) ? (USOCK_UDP) : (USOCK_TCP), log_ip, log_port);
if (sender.fd < 0) {
fprintf(stderr, "failed to connect: %s\n", strerror(errno));
uloop_timeout_set(&retry, 1000);
} else {
uloop_fd_add(&sender, ULOOP_READ);
syslog(LOG_INFO, "Logread connected to %s:%s\n", log_ip, log_port);
}
}
static void log_handle_fd(struct uloop_fd *u, unsigned int events)
{
if (u->eof) {
uloop_fd_delete(u);
close(sender.fd);
sender.fd = -1;
uloop_timeout_set(&retry, 1000);
}
}
static int log_notify(struct blob_attr *msg)
{
struct blob_attr *tb[__LOG_MAX];
struct stat s;
char buf[512];
uint32_t p;
char *str;
time_t t;
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: %s\n", log_file, strerror(errno));
exit(-1);
}
}
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;
c = ctime(&t);
p = blobmsg_get_u32(tb[LOG_PRIO]);
c[strlen(c) - 1] = '\0';
str = blobmsg_format_json(msg, true);
if (log_type == LOG_NET) {
int err;
snprintf(buf, sizeof(buf), "<%u>", p);
strncat(buf, c + 4, 16);
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\n",
c, 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));
}
free(str);
if (log_type == LOG_FILE)
fsync(sender.fd);
return ret;
}
static int usage(const char *prog)
{
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"
" -f Follow log messages\n"
" -u Use UDP as the protocol\n"
" -0 Use \\0 instead of \\n as trailer when using TCP\n"
"\n", prog);
return 1;
}
static void logread_fd_data_cb(struct ustream *s, int bytes)
{
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);
}
if (!log_follow)
uloop_end();
}
static void logread_fd_cb(struct ubus_request *req, int fd)
{
static struct ustream_fd test_fd;
test_fd.stream.notify_read = logread_fd_data_cb;
ustream_fd_init(&test_fd, fd);
}
int main(int argc, char **argv)
{
static struct ubus_request req;
struct ubus_context *ctx;
uint32_t id;
const char *ubus_socket = NULL;
int ch, ret, lines = 0;
static struct blob_buf b;
int tries = 5;
signal(SIGPIPE, SIG_IGN);
while ((ch = getopt(argc, argv, "u0fcs:l:r:F:p:S:P:h:e:")) != -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 '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;
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);
/* ugly ugly ugly ... we need a real reconnect logic */
do {
ret = ubus_lookup_id(ctx, "log", &id);
if (ret) {
fprintf(stderr, "Failed to find log object: %s\n", ubus_strerror(ret));
sleep(1);
continue;
}
blob_buf_init(&b, 0);
if (lines)
blobmsg_add_u32(&b, "lines", lines);
else if (log_follow)
blobmsg_add_u32(&b, "lines", 0);
if (log_follow) {
if (pid_file) {
FILE *fp = fopen(pid_file, "w+");
if (fp) {
fprintf(fp, "%d", getpid());
fclose(fp);
}
}
}
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: %s\n", log_file, strerror(errno));
exit(-1);
}
} else {
sender.fd = STDOUT_FILENO;
}
ubus_invoke_async(ctx, id, "read", b.head, &req);
req.fd_cb = logread_fd_cb;
ubus_complete_request_async(ctx, &req);
uloop_run();
ubus_free(ctx);
uloop_done();
} while (ret && tries--);
return ret;
}

309
src/3P/ubox/log/syslog.c
View File

@@ -1,309 +0,0 @@
/*
* Copyright (C) 2013 John Crispin <blogic@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/version.h>
#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,21)
typedef unsigned short sa_family_t;
#endif
#include <linux/un.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <regex.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <syslog.h>
#include <libubox/uloop.h>
#include <libubox/usock.h>
#include <libubox/ustream.h>
#include "syslog.h"
#define LOG_DEFAULT_SIZE (16 * 1024)
#define LOG_DEFAULT_SOCKET "/dev/log"
#define LOG_LINE_LEN 256
#define SYSLOG_PADDING 16
#define KLOG_DEFAULT_PROC "/proc/kmsg"
#define PAD(x) (x % 4) ? (((x) - (x % 4)) + 4) : (x)
static char *log_dev = LOG_DEFAULT_SOCKET;
static int log_size = LOG_DEFAULT_SIZE;
static struct log_head *log, *log_end, *oldest, *newest;
static int current_id = 0;
static regex_t pat_prio;
static regex_t pat_tstamp;
static struct log_head*
log_next(struct log_head *h, int size)
{
struct log_head *n = (struct log_head *) &h->data[PAD(sizeof(struct log_head) + size)];
return (n >= log_end) ? (log) : (n);
}
void
log_add(char *buf, int size, int source)
{
regmatch_t matches[4];
struct log_head *next;
int priority = 0;
int ret;
/* bounce out if we don't have init'ed yet (regmatch etc will blow) */
if (!log) {
fprintf(stderr, "%s", buf);
return;
}
/* strip trailing newline */
if (buf[size - 2] == '\n') {
buf[size - 2] = '\0';
size -= 1;
}
/* strip the priority */
ret = regexec(&pat_prio, buf, 3, matches, 0);
if (!ret) {
priority = atoi(&buf[matches[1].rm_so]);
size -= matches[2].rm_so;
buf += matches[2].rm_so;
}
#if 0
/* strip kernel timestamp */
ret = regexec(&pat_tstamp,buf, 4, matches, 0);
if ((source == SOURCE_KLOG) && !ret) {
size -= matches[3].rm_so;
buf += matches[3].rm_so;
}
#endif
/* strip syslog timestamp */
if ((source == SOURCE_SYSLOG) && (size > SYSLOG_PADDING) && (buf[SYSLOG_PADDING - 1] == ' ')) {
size -= SYSLOG_PADDING;
buf += SYSLOG_PADDING;
}
//fprintf(stderr, "-> %d - %s\n", priority, buf);
/* find new oldest entry */
next = log_next(newest, size);
if (next > newest) {
while ((oldest > newest) && (oldest <= next) && (oldest != log))
oldest = log_next(oldest, oldest->size);
} else {
//fprintf(stderr, "Log wrap\n");
newest->size = 0;
next = log_next(log, size);
for (oldest = log; oldest <= next; oldest = log_next(oldest, oldest->size))
;
newest = log;
}
/* add the log message */
newest->size = size;
newest->id = current_id++;
newest->priority = priority;
newest->source = source;
clock_gettime(CLOCK_REALTIME, &newest->ts);
strcpy(newest->data, buf);
ubus_notify_log(newest);
newest = next;
}
static void
slog_cb(struct ustream *s, int bytes)
{
struct ustream_buf *buf = s->r.head;
char *str;
int len;
do {
str = ustream_get_read_buf(s, NULL);
if (!str)
break;
len = strlen(buf->data);
if (!len) {
bytes -= 1;
ustream_consume(s, 1);
continue;
}
log_add(buf->data, len + 1, SOURCE_SYSLOG);
ustream_consume(s, len);
bytes -= len;
} while (bytes > 0);
}
static void
klog_cb(struct ustream *s, int bytes)
{
struct ustream_buf *buf = s->r.head;
char *newline, *str;
int len;
do {
str = ustream_get_read_buf(s, NULL);
if (!str)
break;
newline = strchr(buf->data, '\n');
if (!newline)
break;
*newline = 0;
len = newline + 1 - str;
log_add(buf->data, len, SOURCE_KLOG);
ustream_consume(s, len);
} while (1);
}
struct ustream_fd slog = {
.stream.string_data = true,
.stream.notify_read = slog_cb,
};
struct ustream_fd klog = {
.stream.string_data = true,
.stream.notify_read = klog_cb,
};
static int
klog_open(void)
{
int fd;
fd = open(KLOG_DEFAULT_PROC, O_RDONLY | O_NONBLOCK);
if (fd < 0) {
fprintf(stderr, "Failed to open %s\n", KLOG_DEFAULT_PROC);
return -1;
}
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
ustream_fd_init(&klog, fd);
return 0;
}
static int
syslog_open(void)
{
int fd;
unlink(log_dev);
fd = usock(USOCK_UNIX | USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK, log_dev, NULL);
if (fd < 0) {
fprintf(stderr,"Failed to open %s\n", log_dev);
return -1;
}
chmod(log_dev, 0666);
ustream_fd_init(&slog, fd);
return 0;
}
struct log_head*
log_list(int count, struct log_head *h)
{
unsigned int min = count;
if (count)
min = (count < current_id) ? (current_id - count) : (0);
if (!h && oldest->id >= min)
return oldest;
if (!h)
h = oldest;
while (h != newest) {
h = log_next(h, h->size);
if (!h->size && (h > newest))
h = log;
if (h->id >= min && (h != newest))
return h;
}
return NULL;
}
int
log_buffer_init(int size)
{
struct log_head *_log = malloc(size);
if (!_log) {
fprintf(stderr, "Failed to initialize log buffer with size %d\n", log_size);
return -1;
}
memset(_log, 0, size);
if (log && ((log_size + sizeof(struct log_head)) < size)) {
struct log_head *start = _log;
struct log_head *end = ((void*) _log) + size;
struct log_head *l;
l = log_list(0, NULL);
while ((start < end) && l && l->size) {
memcpy(start, l, PAD(sizeof(struct log_head) + l->size));
start = (struct log_head *) &l->data[PAD(l->size)];
l = log_list(0, l);
}
free(log);
newest = start;
newest->size = 0;
oldest = log = _log;
log_end = ((void*) log) + size;
} else {
oldest = newest = log = _log;
log_end = ((void*) log) + size;
}
log_size = size;
return 0;
}
void
log_init(int _log_size)
{
if (_log_size > 0)
log_size = _log_size;
regcomp(&pat_prio, "^<([0-9]*)>(.*)", REG_EXTENDED);
regcomp(&pat_tstamp, "^\[[ 0]*([0-9]*).([0-9]*)] (.*)", REG_EXTENDED);
if (log_buffer_init(log_size)) {
fprintf(stderr, "Failed to allocate log memory\n");
exit(-1);
}
syslog_open();
klog_open();
openlog("sysinit", LOG_CONS, LOG_DAEMON);
}
void
log_shutdown(void)
{
ustream_free(&slog.stream);
ustream_free(&klog.stream);
close(slog.fd.fd);
close(klog.fd.fd);
free(log);
}

42
src/3P/ubox/log/syslog.h
View File

@@ -1,42 +0,0 @@
/*
* Copyright (C) 2013 John Crispin <blogic@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __SYSLOG_H
#define __SYSLOG_H
enum {
SOURCE_KLOG = 0,
SOURCE_SYSLOG = 1,
SOURCE_INTERNAL = 2,
SOURCE_ANY = 0xff,
};
struct log_head {
unsigned int size;
unsigned int id;
int priority;
int source;
struct timespec ts;
char data[];
};
void log_init(int log_size);
void log_shutdown(void);
typedef void (*log_list_cb)(struct log_head *h);
struct log_head* log_list(int count, struct log_head *h);
int log_buffer_init(int size);
void log_add(char *buf, int size, int source);
void ubus_notify_log(struct log_head *l);
#endif

59
src/3P/ubox/validate/cli.c
View File

@@ -109,39 +109,28 @@ static int
validate_value(struct uci_ptr *ptr, const char *expr, const char *def)
{
int i = 0;
bool empty = true, first = true;
bool empty = true;
enum dt_type type = DT_INVALID;
struct uci_element *e;
struct uci_option *opt = ptr->o;
struct uci_option *opt = NULL;
if (opt->type == UCI_TYPE_LIST)
if ((ptr->flags & UCI_LOOKUP_COMPLETE) &&
(ptr->last->type == UCI_TYPE_OPTION))
opt = ptr->o;
if (opt && opt->type == UCI_TYPE_LIST)
{
uci_foreach_element(&opt->v.list, e)
{
if (!e->name || !*e->name)
continue;
empty = false;
break;
}
if (empty)
{
export_value(DT_STRING, ptr->option, def);
return 0;
}
uci_foreach_element(&opt->v.list, e)
{
if (!e->name || !*e->name)
continue;
if (first)
printf("%s=", ptr->option);
else
printf("\\ ");
first = false;
empty = false;
type = dt_parse(expr, e->name);
if (type != DT_INVALID)
@@ -152,16 +141,12 @@ validate_value(struct uci_ptr *ptr, const char *expr, const char *def)
expr, type ? "true" : "false");
}
if (!empty)
printf("; ");
}
else
else if (opt && opt->v.string && *opt->v.string)
{
if (!opt->v.string || !*opt->v.string)
{
export_value(DT_STRING, ptr->option, def);
return 0;
}
empty = false;
type = dt_parse(expr, opt->v.string);
export_value(type, ptr->option, opt->v.string);
@@ -169,6 +154,20 @@ validate_value(struct uci_ptr *ptr, const char *expr, const char *def)
ptr->package, ptr->section, ptr->option, opt->v.string,
expr, type ? "true" : "false");
}
if (empty)
{
type = dt_parse(expr, def);
if (type == DT_INVALID)
type = DT_STRING;
export_value(type, ptr->option, def);
fprintf(stderr, "%s.%s.%s is unset and defaults to %s %s\n",
ptr->package, ptr->section, ptr->option, expr, def);
}
return type ? 0 : -1;
}
@@ -188,13 +187,7 @@ validate_option(struct uci_context *ctx, char *package, char *section, char *opt
ptr.section = section;
ptr.option = opt;
if (uci_lookup_ptr(ctx, &ptr, NULL, false) ||
!(ptr.flags & UCI_LOOKUP_COMPLETE) ||
(ptr.last->type != UCI_TYPE_OPTION))
{
export_value(DT_STRING, opt, def);
return 0;
}
uci_lookup_ptr(ctx, &ptr, NULL, false);
return validate_value(&ptr, expr, def);
}