-#include <libaudit.h>
-#include <systemd/sd-event.h>
+/*
+ * This file is a part of faultd.
+ *
+ * Copyright © 2017 Samsung Electronics
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE 1
+
#include <errno.h>
+#include <libaudit.h>
#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
#include <stdlib.h>
+#include <string.h>
+#include <systemd/sd-event.h>
+#include <unistd.h>
+
#include "audit.h"
+#include "log.h"
static struct audit_rule_data rule_data = {
.flags = AUDIT_FILTER_EXIT, /* trigger on exit from syscall */
++p;
event->timestamp = strtol(p, &p, 10);
+ event->pid = 0;
- while (p = strchr(p, ' ')) {
+ while ((p = strchr(p, ' ')) != 0) {
++p;
e = strchr(p, '=');
key = str2key(p, e - p);
ret = audit_get_reply(fd, &reply, GET_REPLY_NONBLOCKING, 0);
if (ret < 0) {
- fprintf(stderr, "Could not get reply\n");
+ log_error("Could not get reply.\n");
return ret;
}
reply.message[reply.len] = '\0';
ret = parse_event(reply.message, reply.len, &ev);
if (ret < 0) {
- fprintf(stderr, "Could not parse event\n");
+ log_error("Could not parse event\n");
return ret;
}
- printf("timestamp = %d, pid = %d\n", ev.timestamp, ev.pid);
+ log_debug("timestamp = %ld, pid = %d\n", ev.timestamp, ev.pid);
return 0;
}
fd = audit_open();
if (fd < 0) {
- fprintf(stderr, "Could not open audit socket (%d)\n", fd);
+ log_error("Could not open audit socket: %m\n");
return fd;
}
ret = audit_set_pid(fd, getpid(), WAIT_YES);
if (ret < 0) {
- fprintf(stderr, "Could not set pid (%d)\n", ret);
+ log_error("Could not set pid (%d)\n", ret);
return ret;
}
ret = sd_event_add_io(event, NULL, fd, EPOLLIN, audit_handler, NULL);
if (ret < 0) {
- fprintf(stderr, "Could not add event io (%d)\n", ret);
+ log_error_errno(ret, "Could not add io event: %m");
return ret;
}
audit_rule_syscallbyname_data(&rule_data, "all");
ret = audit_add_rule_data(fd, &rule_data, AUDIT_FILTER_EXIT, AUDIT_ALWAYS);
- if (ret < 0 && ret != -EEXIST) {
- fprintf(stderr, "Could not add rule: %d\n", ret);
+ if (ret <= 0 && ret != -EEXIST) {
+ log_error("Could not add rule (%d).", ret);
return ret;
}
ret = audit_delete_rule_data(fd, &rule_data, AUDIT_FILTER_EXIT, AUDIT_ALWAYS);
if (ret < 0 && ret != -EEXIST) {
- fprintf(stderr, "Could not add rule: %d\n", ret);
+ log_error("Could not add rule (%d)", ret);
return ret;
}
ret = audit_set_pid(fd, 0, WAIT_YES);
if (ret < 0) {
- fprintf(stderr, "Could not set pid (%d)\n", ret);
+ log_error("Could not set pid (%d)", ret);
return ret;
}
* limitations under the License.
*/
+#include <errno.h>
+#include <getopt.h>
#include <stdio.h>
#include <poll.h>
#include <systemd/sd-bus.h>
#include <systemd/sd-event.h>
#include <signal.h>
+#include <syslog.h>
+
#include "audit.h"
+#include "log.h"
#include "systemd.h"
static int terminate = 0;
return 0;
}
+static int parse_argv(int ac, char* av[]) {
+ int c, r;
+ enum {
+ ARG_LOG_LEVEL = 0x100,
+ };
+ static const struct option options[] = {
+ {"log-level", required_argument, NULL, ARG_LOG_LEVEL},
+ {}
+ };
+
+ while ((c = getopt_long(ac, av, "D", options, NULL)) >= 0) {
+ switch (c) {
+
+ case ARG_LOG_LEVEL:
+ r = log_parse_level_name(optarg);
+ if (r < 0) {
+ fprintf(stderr, "Unknown log level: \"%s\"\n", optarg);
+ return r;
+ }
+ log_set_max_level(r);
+ break;
+
+ case 'D':
+ log_set_max_level(LOG_DEBUG);
+ break;
+
+ default:
+ return -EINVAL;
+ }
+ }
+ return 0;
+}
+
int main(int ac, char* av[])
{
int aufd;
sd_event* loop;
sigset_t ss;
+ rc = parse_argv(ac, av);
+ if (rc < 0) {
+ fprintf(stderr, "Failed to parse command line options: %s\n", strerror(-rc));
+ return -1;
+ }
+
rc = sd_bus_default_system(&bus);
if (rc < 0) {
- fprintf(stderr, "Failed to acquire the defult system bus connection.\n");
+ log_error_errno(rc, "Failed to acquire the defult system bus connection: %m");
return -1;
}
rc = sd_event_new(&loop);
if (rc < 0) {
- fprintf(stderr, "Failed to allocate the event loop.\n");
+ log_error_errno(rc, "Failed to allocate the event loop.");
return -1;
}
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
+#include <string.h>
#include <syslog.h>
#include "log.h"
log_max_level = level;
}
+int log_parse_level_name(const char *name) {
+ int i;
+ static const char *levels[] = {
+ [LOG_EMERG] = "emerg",
+ [LOG_ALERT] = "alert",
+ [LOG_CRIT] = "crit",
+ [LOG_ERR] = "err",
+ [LOG_WARNING] = "warning",
+ [LOG_NOTICE] = "notice",
+ [LOG_INFO] = "info",
+ [LOG_DEBUG] = "debug",
+ };
+
+ for (i = 0; i < sizeof(levels)/sizeof(levels[0]); i++)
+ if (strcmp(levels[i], name) == 0)
+ return i;
+ return -EINVAL;
+}
+
int log_internal(int level,
int error,
const char *file,
#include <poll.h>
#include <systemd/sd-bus.h>
#include <systemd/sd-event.h>
+
#include "systemd.h"
+#include "log.h"
static int on_unit_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *ret_error);
rc = sd_bus_default_system(&bus);
if (rc < 0) {
- fprintf(stderr, "Failed to acquire the defult system bus connection.\n");
+ log_error_errno(rc, "Failed to acquire the defult system bus connection.");
return -1;
}
rc = sd_bus_attach_event(bus, loop, SD_EVENT_PRIORITY_NORMAL);
if (rc < 0) {
- fprintf(stderr, "Failed to attach the bus to the event loop.\n");
+ log_error_errno(rc, "Failed to attach the bus to the event loop.");
return -1;
}
on_unit_properties_changed,
NULL);
if (rc < 0) {
- fprintf(stderr, "Failed to add match");
+ log_error_errno(rc, "Failed to add match.");
return -1;
}
&error,
NULL, NULL);
if (rc < 0) {
- fprintf(stderr, "Failed to subscribe.\n");
+ log_error_errno(rc, "Failed to subscribe.");
return -1;
}
rc = sd_bus_default_system(&bus);
if (rc < 0) {
- fprintf(stderr, "Failed to acquire the defult system bus connection.\n");
+ log_error_errno(rc, "Failed to acquire the defult system bus connection.");
return -1;
}
&error,
NULL, NULL);
if (rc < 0) {
- fprintf(stderr, "Failed to unsubscribe.\n");
+ log_error_errno(rc, "Failed to unsubscribe.");
return -1;
}
return 0;
rc = sd_bus_message_read(m, "s", &interface);
if (rc < 0) {
- fprintf(stderr, "Invalid message format.\n");
+ log_error_errno(rc, "Invalid message format.");
goto finish;
}
if (strcmp("org.freedesktop.systemd1.Unit", interface) != 0) {
fflush(stdout);
rc = sd_bus_message_get_type(m, &type);
if (rc < 0) {
- fprintf(stderr, "Oops!\n");
+ log_error_errno(rc, "Failed to get message type.");
goto finish;
}
- fprintf(stdout, "Received a message!\n");
- fprintf(stdout, " Type: %s\n",
- type == SD_BUS_MESSAGE_METHOD_CALL ? "method call" :
- (type == SD_BUS_MESSAGE_METHOD_RETURN ? "method return" :
- (type == SD_BUS_MESSAGE_METHOD_ERROR ? "method error" :
- (type == SD_BUS_MESSAGE_SIGNAL ? "signal" : "INVALID"))));
- fprintf(stdout, " Interface: %s\n", sd_bus_message_get_interface(m));
- fprintf(stdout, " Member: %s\n", sd_bus_message_get_member(m));
- fprintf(stdout, " Path: %s\n", sd_bus_message_get_path(m));
- fprintf(stdout, " Message If: %s\n", interface);
+ log_debug("Received a message!");
+ log_debug(" Type: %s",
+ type == SD_BUS_MESSAGE_METHOD_CALL ? "method call" :
+ (type == SD_BUS_MESSAGE_METHOD_RETURN ? "method return" :
+ (type == SD_BUS_MESSAGE_METHOD_ERROR ? "method error" :
+ (type == SD_BUS_MESSAGE_SIGNAL ? "signal" : "INVALID"))));
+ log_debug(" Interface: %s", sd_bus_message_get_interface(m));
+ log_debug(" Member: %s", sd_bus_message_get_member(m));
+ log_debug(" Path: %s", sd_bus_message_get_path(m));
+ log_debug(" Message If: %s", interface);
rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
if (rc < 0) {
rc = 0;
}
- fprintf(stdout, " Message dictionary:\n");
+ log_debug(" Message dictionary:");
while((rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
const char *key;
rc = sd_bus_message_read(m, "s", &key);
if (rc < 0) {
- fprintf(stderr, "Failed to read a DICT_ENTRY: %s.\n", strerror(-rc));
+ log_error_errno(rc, "Failed to read a DICT_ENTRY: %m.");
rc = 0;
goto finish;
}
- fprintf(stdout, " %s", key);
if (strcmp("ActiveState", key) == 0) {
const char *value;
}
rc = sd_bus_message_read(m, "s", &value);
if (rc < 0) {
- log_error_errno(rc, "Failed to read the AciveSate value: %m.\n");
+ log_error_errno(rc, "Failed to read the AciveSate value: %m.");
rc = 0;
goto finish;
}
rc = sd_bus_message_exit_container(m);
- fprintf(stdout, ":%s", value);
+ log_debug(" %s:%s", key, value);
} else {
-
+ log_debug(" %s", key);
rc = sd_bus_message_skip(m, "v");
if (rc < 0) {
fprintf(stderr, "Failed to skip a value.");
goto finish;
}
}
- fprintf(stdout,"\n");
rc = sd_bus_message_exit_container(m);
if (rc < 0) {
- fprintf(stderr, "Failed to exit a container: %s.\n", strerror(-rc));
+ log_error_errno(rc, "Failed to exit a container: %s.", strerror(-rc));
rc = 0;
goto finish;
}
projects / platform / core / system / faultd.git / commitdiff