Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include <fcntl.h>
       4                 :            : #include <sys/stat.h>
       5                 :            : #include <sys/types.h>
       6                 :            : 
       7                 :            : #include "alloc-util.h"
       8                 :            : #include "fd-util.h"
       9                 :            : #include "io-util.h"
      10                 :            : #include "parse-util.h"
      11                 :            : #include "show-status.h"
      12                 :            : #include "string-table.h"
      13                 :            : #include "string-util.h"
      14                 :            : #include "terminal-util.h"
      15                 :            : #include "util.h"
      16                 :            : 
      17                 :            : static const char* const show_status_table[_SHOW_STATUS_MAX] = {
      18                 :            :         [SHOW_STATUS_NO]        = "no",
      19                 :            :         [SHOW_STATUS_AUTO]      = "auto",
      20                 :            :         [SHOW_STATUS_TEMPORARY] = "temporary",
      21                 :            :         [SHOW_STATUS_YES]       = "yes",
      22                 :            : };
      23                 :            : 
      24   [ +  +  +  +  :         48 : DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(show_status, ShowStatus, SHOW_STATUS_YES);
                   +  + ]
      25                 :            : 
      26                 :          0 : int parse_show_status(const char *v, ShowStatus *ret) {
      27                 :            :         ShowStatus s;
      28                 :            : 
      29         [ #  # ]:          0 :         assert(ret);
      30                 :            : 
      31                 :          0 :         s = show_status_from_string(v);
      32   [ #  #  #  # ]:          0 :         if (s < 0 || s == SHOW_STATUS_TEMPORARY)
      33                 :          0 :                 return -EINVAL;
      34                 :            : 
      35                 :          0 :         *ret = s;
      36                 :          0 :         return 0;
      37                 :            : }
      38                 :            : 
      39                 :          0 : int status_vprintf(const char *status, ShowStatusFlags flags, const char *format, va_list ap) {
      40                 :            :         static const char status_indent[] = "         "; /* "[" STATUS "] " */
      41                 :          0 :         _cleanup_free_ char *s = NULL;
      42                 :          0 :         _cleanup_close_ int fd = -1;
      43                 :          0 :         struct iovec iovec[7] = {};
      44                 :          0 :         int n = 0;
      45                 :            :         static bool prev_ephemeral;
      46                 :            : 
      47         [ #  # ]:          0 :         assert(format);
      48                 :            : 
      49                 :            :         /* This is independent of logging, as status messages are
      50                 :            :          * optional and go exclusively to the console. */
      51                 :            : 
      52         [ #  # ]:          0 :         if (vasprintf(&s, format, ap) < 0)
      53                 :          0 :                 return log_oom();
      54                 :            : 
      55                 :            :         /* Before you ask: yes, on purpose we open/close the console for each status line we write individually. This
      56                 :            :          * is a good strategy to avoid PID 1 getting killed by the kernel's SAK concept (it doesn't fix this entirely,
      57                 :            :          * but minimizes the time window the kernel might end up killing PID 1 due to SAK). It also makes things easier
      58                 :            :          * for us so that we don't have to recover from hangups and suchlike triggered on the console. */
      59                 :            : 
      60                 :          0 :         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
      61         [ #  # ]:          0 :         if (fd < 0)
      62                 :          0 :                 return fd;
      63                 :            : 
      64         [ #  # ]:          0 :         if (FLAGS_SET(flags, SHOW_STATUS_ELLIPSIZE)) {
      65                 :            :                 char *e;
      66                 :            :                 size_t emax, sl;
      67                 :            :                 int c;
      68                 :            : 
      69                 :          0 :                 c = fd_columns(fd);
      70         [ #  # ]:          0 :                 if (c <= 0)
      71                 :          0 :                         c = 80;
      72                 :            : 
      73         [ #  # ]:          0 :                 sl = status ? sizeof(status_indent)-1 : 0;
      74                 :            : 
      75                 :          0 :                 emax = c - sl - 1;
      76         [ #  # ]:          0 :                 if (emax < 3)
      77                 :          0 :                         emax = 3;
      78                 :            : 
      79                 :          0 :                 e = ellipsize(s, emax, 50);
      80         [ #  # ]:          0 :                 if (e)
      81                 :          0 :                         free_and_replace(s, e);
      82                 :            :         }
      83                 :            : 
      84         [ #  # ]:          0 :         if (prev_ephemeral)
      85                 :          0 :                 iovec[n++] = IOVEC_MAKE_STRING(ANSI_REVERSE_LINEFEED "\r" ANSI_ERASE_TO_END_OF_LINE);
      86                 :            : 
      87         [ #  # ]:          0 :         if (status) {
      88         [ #  # ]:          0 :                 if (!isempty(status)) {
      89                 :          0 :                         iovec[n++] = IOVEC_MAKE_STRING("[");
      90                 :          0 :                         iovec[n++] = IOVEC_MAKE_STRING(status);
      91                 :          0 :                         iovec[n++] = IOVEC_MAKE_STRING("] ");
      92                 :            :                 } else
      93                 :          0 :                         iovec[n++] = IOVEC_MAKE_STRING(status_indent);
      94                 :            :         }
      95                 :            : 
      96                 :          0 :         iovec[n++] = IOVEC_MAKE_STRING(s);
      97                 :          0 :         iovec[n++] = IOVEC_MAKE_STRING("\n");
      98                 :            : 
      99   [ #  #  #  # ]:          0 :         if (prev_ephemeral && !FLAGS_SET(flags, SHOW_STATUS_EPHEMERAL))
     100                 :          0 :                 iovec[n++] = IOVEC_MAKE_STRING(ANSI_ERASE_TO_END_OF_LINE);
     101                 :          0 :         prev_ephemeral = FLAGS_SET(flags, SHOW_STATUS_EPHEMERAL) ;
     102                 :            : 
     103         [ #  # ]:          0 :         if (writev(fd, iovec, n) < 0)
     104                 :          0 :                 return -errno;
     105                 :            : 
     106                 :          0 :         return 0;
     107                 :            : }
     108                 :            : 
     109                 :          0 : int status_printf(const char *status, ShowStatusFlags flags, const char *format, ...) {
     110                 :            :         va_list ap;
     111                 :            :         int r;
     112                 :            : 
     113         [ #  # ]:          0 :         assert(format);
     114                 :            : 
     115                 :          0 :         va_start(ap, format);
     116                 :          0 :         r = status_vprintf(status, flags, format, ap);
     117                 :          0 :         va_end(ap);
     118                 :            : 
     119                 :          0 :         return r;
     120                 :            : }
     121                 :            : 
     122                 :            : static const char* const status_unit_format_table[_STATUS_UNIT_FORMAT_MAX] = {
     123                 :            :         [STATUS_UNIT_FORMAT_NAME]        = "name",
     124                 :            :         [STATUS_UNIT_FORMAT_DESCRIPTION] = "description",
     125                 :            : };
     126                 :            : 
     127   [ #  #  #  # ]:          0 : DEFINE_STRING_TABLE_LOOKUP(status_unit_format, StatusUnitFormat);