From 5bacce5236385ec4958e7aa12d91bd25009b2969 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Thu, 26 May 2022 12:46:26 -0400
Subject: [PATCH] libply: Add support for syslog

Sometimes plymouth is used along-side other programs. Those
programs may use syslog for logging, and so it would be useful
if plymouth had the ability to use syslog, too. Then message
ordering would be more coherent.

This commit adds such support by adding plymouth.debug=syslog
to the kernel command line.
---
 src/libply/ply-logger.c | 45 +++++++++++++++++++++++++++++++++++++++++
 src/libply/ply-logger.h |  2 ++
 src/main.c              | 15 +++++++++++++-
 3 files changed, 61 insertions(+), 1 deletion(-)

diff --git a/src/libply/ply-logger.c b/src/libply/ply-logger.c
index 749c9da5..e83bd1d4 100644
--- a/src/libply/ply-logger.c
+++ b/src/libply/ply-logger.c
@@ -73,6 +73,9 @@ struct _ply_logger
 
         uint32_t                  is_enabled : 1;
         uint32_t                  tracing_is_enabled : 1;
+        uint32_t                  syslog_is_enabled : 1;
+        uint32_t                  is_error_default : 1;
+        uint32_t                  is_default : 1;
 };
 
 static bool ply_text_is_loggable (const char *string,
@@ -117,6 +120,13 @@ ply_logger_write_exception (ply_logger_t *logger,
 
         assert (message != NULL);
 
+        if (logger->syslog_is_enabled) {
+                syslog (LOG_WARNING,
+                        "%.*s",
+                        message,
+                        number_of_bytes);
+        }
+
         ply_logger_write (logger, message, number_of_bytes, false);
         free (message);
 }
@@ -155,6 +165,23 @@ ply_logger_flush_buffer (ply_logger_t *logger)
         if (logger->buffer_size == 0)
                 return true;
 
+        if (logger->syslog_is_enabled) {
+                int log_priority;
+
+                if (logger->tracing_is_enabled) {
+                        log_priority = LOG_DEBUG;
+                } else if (logger->is_default) {
+                        log_priority = LOG_INFO;
+                } else if (logger->is_error_default) {
+                        log_priority = LOG_WARNING;
+                }
+
+                syslog (log_priority,
+                        "%.*s",
+                        logger->buffer_size,
+                        logger->buffer);
+        }
+
         if (!ply_logger_write (logger, logger->buffer, logger->buffer_size, true))
                 return false;
 
@@ -252,6 +279,7 @@ ply_logger_get_default (void)
         if (logger == NULL) {
                 logger = ply_logger_new ();
                 ply_logger_set_output_fd (logger, STDOUT_FILENO);
+                logger->is_default = true;
         }
 
         return logger;
@@ -267,6 +295,7 @@ ply_logger_get_error_default (void)
                 ply_logger_set_output_fd (logger, STDERR_FILENO);
                 ply_logger_set_flush_policy (logger,
                                              PLY_LOGGER_FLUSH_POLICY_EVERY_TIME);
+                logger->is_error_default = true;
         }
 
         return logger;
@@ -304,6 +333,10 @@ ply_logger_free (ply_logger_t *logger)
                 close (logger->output_fd);
         }
 
+        if (logger->syslog_is_enabled) {
+                ply_logger_close_syslog (logger);
+        }
+
         ply_logger_free_filters (logger);
 
         free (logger->filename);
@@ -358,6 +391,18 @@ ply_logger_close_file (ply_logger_t *logger)
         ply_logger_set_output_fd (logger, -1);
 }
 
+void
+ply_logger_open_syslog (ply_logger_t *logger)
+{
+        openlog (NULL, 0, LOG_DAEMON);
+}
+
+void
+ply_logger_close_syslog (ply_logger_t *logger)
+{
+        closelog ();
+}
+
 void
 ply_logger_set_output_fd (ply_logger_t *logger,
                           int           fd)
diff --git a/src/libply/ply-logger.h b/src/libply/ply-logger.h
index 8d8ee871..768a541d 100644
--- a/src/libply/ply-logger.h
+++ b/src/libply/ply-logger.h
@@ -49,6 +49,8 @@ void ply_logger_free (ply_logger_t *logger);
 bool ply_logger_open_file (ply_logger_t *logger,
                            const char   *filename);
 void ply_logger_close_file (ply_logger_t *logger);
+bool ply_logger_open_syslog (ply_logger_t *logger);
+void ply_logger_close_syslog (ply_logger_t *logger);
 void ply_logger_set_output_fd (ply_logger_t *logger,
                                int           fd);
 int ply_logger_get_output_fd (ply_logger_t *logger);
diff --git a/src/main.c b/src/main.c
index daf25243..ff700c3d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1857,6 +1857,8 @@ static void
 check_verbosity (state_t *state)
 {
         char *stream;
+        char *syslog;
+        bool found_output_target = false;
 
         ply_trace ("checking if tracing should be enabled");
 
@@ -1906,7 +1908,18 @@ check_verbosity (state_t *state)
 
                         free (file);
                 }
-        } else {
+
+                found_output_target = true;
+        }
+
+        syslog = ply_kernel_command_line_get_key_value ("plymouth.debug=syslog");
+
+        if (syslog != NULL) {
+                ply_logger_open_syslog (ply_logger_get_error_default ());
+                found_output_target = true;
+        }
+
+        if (!found_output_target) {
                 ply_trace ("tracing shouldn't be enabled!");
         }
 
-- 
2.47.2