From f53c6620c55488e2a3bd92957b21b6b95a7a3d35 Mon Sep 17 00:00:00 2001

From: David Tardon <dtardon@redhat.com>

Date: Thu, 12 Jan 2023 15:47:09 +0100

Subject: [PATCH] coredump: put context array into a struct

[dtardon: This is based on commit f46c706bdd4316ae8ed6baf7a8c382b90b84f648 ,

but does just the minimal change to introduce the Context struct that is

needed by the following commit.]

Related: #2155520

---

 src/coredump/coredump.c | 208 +++++++++++++++++++++-------------------

 1 file changed, 108 insertions(+), 100 deletions(-)

diff --git a/src/coredump/coredump.c b/src/coredump/coredump.c

index fb3a6ecfe9..ebc56d8342 100644

--- a/src/coredump/coredump.c

+++ b/src/coredump/coredump.c

@@ -91,6 +91,10 @@ enum {

         _CONTEXT_MAX

 };

+typedef struct Context {

+        const char *meta[_CONTEXT_MAX];

+} Context;

+

 typedef enum CoredumpStorage {

         COREDUMP_STORAGE_NONE,

         COREDUMP_STORAGE_EXTERNAL,

@@ -184,7 +188,7 @@ static int fix_acl(int fd, uid_t uid) {

         return 0;

 }

-static int fix_xattr(int fd, const char *context[_CONTEXT_MAX]) {

+static int fix_xattr(int fd, const Context *context) {

         static const char * const xattrs[_CONTEXT_MAX] = {

                 [CONTEXT_PID] = "user.coredump.pid",

@@ -209,10 +213,10 @@ static int fix_xattr(int fd, const char *context[_CONTEXT_MAX]) {

         for (i = 0; i < _CONTEXT_MAX; i++) {

                 int k;

-                if (isempty(context[i]) || !xattrs[i])

+                if (isempty(context->meta[i]) || !xattrs[i])

                         continue;

-                k = fsetxattr(fd, xattrs[i], context[i], strlen(context[i]), XATTR_CREATE);

+                k = fsetxattr(fd, xattrs[i], context->meta[i], strlen(context->meta[i]), XATTR_CREATE);

                 if (k < 0 && r == 0)

                         r = -errno;

         }

@@ -230,7 +234,7 @@ static int fix_permissions(

                 int fd,

                 const char *filename,

                 const char *target,

-                const char *context[_CONTEXT_MAX],

+                const Context *context,

                 uid_t uid) {

         int r;

@@ -273,18 +277,18 @@ static int maybe_remove_external_coredump(const char *filename, uint64_t size) {

         return 1;

 }

-static int make_filename(const char *context[_CONTEXT_MAX], char **ret) {

+static int make_filename(const Context *context, char **ret) {

         _cleanup_free_ char *c = NULL, *u = NULL, *p = NULL, *t = NULL;

         sd_id128_t boot = {};

         int r;

         assert(context);

-        c = filename_escape(context[CONTEXT_COMM]);

+        c = filename_escape(context->meta[CONTEXT_COMM]);

         if (!c)

                 return -ENOMEM;

-        u = filename_escape(context[CONTEXT_UID]);

+        u = filename_escape(context->meta[CONTEXT_UID]);

         if (!u)

                 return -ENOMEM;

@@ -292,11 +296,11 @@ static int make_filename(const char *context[_CONTEXT_MAX], char **ret) {

         if (r < 0)

                 return r;

-        p = filename_escape(context[CONTEXT_PID]);

+        p = filename_escape(context->meta[CONTEXT_PID]);

         if (!p)

                 return -ENOMEM;

-        t = filename_escape(context[CONTEXT_TIMESTAMP]);

+        t = filename_escape(context->meta[CONTEXT_TIMESTAMP]);

         if (!t)

                 return -ENOMEM;

@@ -313,7 +317,7 @@ static int make_filename(const char *context[_CONTEXT_MAX], char **ret) {

 }

 static int save_external_coredump(

-                const char *context[_CONTEXT_MAX],

+                const Context *context,

                 int input_fd,

                 char **ret_filename,

                 int *ret_node_fd,

@@ -334,19 +338,19 @@ static int save_external_coredump(

         assert(ret_data_fd);

         assert(ret_size);

-        r = parse_uid(context[CONTEXT_UID], &uid);

+        r = parse_uid(context->meta[CONTEXT_UID], &uid);

         if (r < 0)

                 return log_error_errno(r, "Failed to parse UID: %m");

-        r = safe_atou64(context[CONTEXT_RLIMIT], &rlimit);

+        r = safe_atou64(context->meta[CONTEXT_RLIMIT], &rlimit);

         if (r < 0)

-                return log_error_errno(r, "Failed to parse resource limit: %s", context[CONTEXT_RLIMIT]);

+                return log_error_errno(r, "Failed to parse resource limit: %s", context->meta[CONTEXT_RLIMIT]);

         if (rlimit < page_size()) {

                 /* Is coredumping disabled? Then don't bother saving/processing the coredump.

                  * Anything below PAGE_SIZE cannot give a readable coredump (the kernel uses

                  * ELF_EXEC_PAGESIZE which is not easily accessible, but is usually the same as PAGE_SIZE. */

                 log_info("Resource limits disable core dumping for process %s (%s).",

-                         context[CONTEXT_PID], context[CONTEXT_COMM]);

+                         context->meta[CONTEXT_PID], context->meta[CONTEXT_COMM]);

                 return -EBADSLT;

         }

@@ -371,7 +375,7 @@ static int save_external_coredump(

         r = copy_bytes(input_fd, fd, max_size, 0);

         if (r < 0) {

-                log_error_errno(r, "Cannot store coredump of %s (%s): %m", context[CONTEXT_PID], context[CONTEXT_COMM]);

+                log_error_errno(r, "Cannot store coredump of %s (%s): %m", context->meta[CONTEXT_PID], context->meta[CONTEXT_COMM]);

                 goto fail;

         }

         *ret_truncated = r == 1;

@@ -659,12 +663,12 @@ static int get_process_container_parent_cmdline(pid_t pid, char** cmdline) {

         return 1;

 }

-static int change_uid_gid(const char *context[]) {

+static int change_uid_gid(const Context *context) {

         uid_t uid;

         gid_t gid;

         int r;

-        r = parse_uid(context[CONTEXT_UID], &uid);

+        r = parse_uid(context->meta[CONTEXT_UID], &uid);

         if (r < 0)

                 return r;

@@ -677,7 +681,7 @@ static int change_uid_gid(const char *context[]) {

                         uid = gid = 0;

                 }

         } else {

-                r = parse_gid(context[CONTEXT_GID], &gid;;

+                r = parse_gid(context->meta[CONTEXT_GID], &gid;;

                 if (r < 0)

                         return r;

         }

@@ -685,23 +689,23 @@ static int change_uid_gid(const char *context[]) {

         return drop_privileges(uid, gid, 0);

 }

-static bool is_journald_crash(const char *context[_CONTEXT_MAX]) {

+static bool is_journald_crash(const Context *context) {

         assert(context);

-        return streq_ptr(context[CONTEXT_UNIT], SPECIAL_JOURNALD_SERVICE);

+        return streq_ptr(context->meta[CONTEXT_UNIT], SPECIAL_JOURNALD_SERVICE);

 }

-static bool is_pid1_crash(const char *context[_CONTEXT_MAX]) {

+static bool is_pid1_crash(const Context *context) {

         assert(context);

-        return streq_ptr(context[CONTEXT_UNIT], SPECIAL_INIT_SCOPE) ||

-                streq_ptr(context[CONTEXT_PID], "1");

+        return streq_ptr(context->meta[CONTEXT_UNIT], SPECIAL_INIT_SCOPE) ||

+                streq_ptr(context->meta[CONTEXT_PID], "1");

 }

 #define SUBMIT_COREDUMP_FIELDS 4

 static int submit_coredump(

-                const char *context[_CONTEXT_MAX],

+                Context *context,

                 struct iovec *iovec,

                 size_t n_iovec_allocated,

                 size_t n_iovec,

@@ -760,11 +764,11 @@ static int submit_coredump(

         if (coredump_size <= arg_process_size_max) {

                 _cleanup_free_ char *stacktrace = NULL;

-                r = coredump_make_stack_trace(coredump_fd, context[CONTEXT_EXE], &stacktrace);

+                r = coredump_make_stack_trace(coredump_fd, context->meta[CONTEXT_EXE], &stacktrace);

                 if (r >= 0)

-                        core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID],

-                                               " (", context[CONTEXT_COMM], ") of user ",

-                                               context[CONTEXT_UID], " dumped core.",

+                        core_message = strjoin("MESSAGE=Process ", context->meta[CONTEXT_PID],

+                                               " (", context->meta[CONTEXT_COMM], ") of user ",

+                                               context->meta[CONTEXT_UID], " dumped core.",

                                                journald_crash ? "\nCoredump diverted to " : "",

                                                journald_crash ? filename : "",

                                                "\n\n", stacktrace);

@@ -779,9 +783,9 @@ static int submit_coredump(

         if (!core_message)

 #endif

 log:

-        core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID],

-                               " (", context[CONTEXT_COMM], ") of user ",

-                               context[CONTEXT_UID], " dumped core.",

+        core_message = strjoin("MESSAGE=Process ", context->meta[CONTEXT_PID],

+                               " (", context->meta[CONTEXT_COMM], ") of user ",

+                               context->meta[CONTEXT_UID], " dumped core.",

                                journald_crash && filename ? "\nCoredump diverted to " : NULL,

                                journald_crash && filename ? filename : NULL);

         if (!core_message)

@@ -826,7 +830,7 @@ log:

         return 0;

 }

-static void map_context_fields(const struct iovec *iovec, const char* context[]) {

+static void map_context_fields(const struct iovec *iovec, Context *context) {

         static const char * const context_field_names[] = {

                 [CONTEXT_PID] = "COREDUMP_PID=",

@@ -857,7 +861,7 @@ static void map_context_fields(const struct iovec *iovec, const char* context[])

                 /* Note that these strings are NUL terminated, because we made sure that a trailing NUL byte is in the

                  * buffer, though not included in the iov_len count. (see below) */

-                context[i] = p;

+                context->meta[i] = p;

                 break;

         }

 }

@@ -866,7 +870,7 @@ static int process_socket(int fd) {

         _cleanup_close_ int coredump_fd = -1;

         struct iovec *iovec = NULL;

         size_t n_iovec = 0, n_allocated = 0, i, k;

-        const char *context[_CONTEXT_MAX] = {};

+        Context context = {};

         int r;

         assert(fd >= 0);

@@ -950,7 +954,7 @@ static int process_socket(int fd) {

                 iovec[n_iovec].iov_len = (size_t) n;

                 cmsg_close_all(&mh);

-                map_context_fields(iovec + n_iovec, context);

+                map_context_fields(iovec + n_iovec, &context);

                 n_iovec++;

         }

@@ -960,24 +964,24 @@ static int process_socket(int fd) {

         }

         /* Make sure we got all data we really need */

-        assert(context[CONTEXT_PID]);

-        assert(context[CONTEXT_UID]);

-        assert(context[CONTEXT_GID]);

-        assert(context[CONTEXT_SIGNAL]);

-        assert(context[CONTEXT_TIMESTAMP]);

-        assert(context[CONTEXT_RLIMIT]);

-        assert(context[CONTEXT_HOSTNAME]);

-        assert(context[CONTEXT_COMM]);

+        assert(context.meta[CONTEXT_PID]);

+        assert(context.meta[CONTEXT_UID]);

+        assert(context.meta[CONTEXT_GID]);

+        assert(context.meta[CONTEXT_SIGNAL]);

+        assert(context.meta[CONTEXT_TIMESTAMP]);

+        assert(context.meta[CONTEXT_RLIMIT]);

+        assert(context.meta[CONTEXT_HOSTNAME]);

+        assert(context.meta[CONTEXT_COMM]);

         assert(coredump_fd >= 0);

         /* Small quirk: the journal fields contain the timestamp padded with six zeroes, so that the kernel-supplied 1s

          * granularity timestamps becomes 1µs granularity, i.e. the granularity systemd usually operates in. Since we

          * are reconstructing the original kernel context, we chop this off again, here. */

-        k = strlen(context[CONTEXT_TIMESTAMP]);

+        k = strlen(context.meta[CONTEXT_TIMESTAMP]);

         if (k > 6)

-                context[CONTEXT_TIMESTAMP] = strndupa(context[CONTEXT_TIMESTAMP], k - 6);

+                context.meta[CONTEXT_TIMESTAMP] = strndupa(context.meta[CONTEXT_TIMESTAMP], k - 6);

-        r = submit_coredump(context, iovec, n_allocated, n_iovec, coredump_fd);

+        r = submit_coredump(&context, iovec, n_allocated, n_iovec, coredump_fd);

 finish:

         for (i = 0; i < n_iovec; i++)

@@ -1062,7 +1066,7 @@ static char* set_iovec_field_free(struct iovec *iovec, size_t *n_iovec, const ch

 }

 static int gather_pid_metadata(

-                char* context[_CONTEXT_MAX],

+                Context *context,

                 char **comm_fallback,

                 struct iovec *iovec, size_t *n_iovec) {

@@ -1077,65 +1081,69 @@ static int gather_pid_metadata(

         const char *p;

         int r, signo;

-        r = parse_pid(context[CONTEXT_PID], &pid;;

+        r = parse_pid(context->meta[CONTEXT_PID], &pid;;

         if (r < 0)

-                return log_error_errno(r, "Failed to parse PID \"%s\": %m", context[CONTEXT_PID]);

+                return log_error_errno(r, "Failed to parse PID \"%s\": %m", context->meta[CONTEXT_PID]);

-        r = get_process_comm(pid, &context[CONTEXT_COMM]);

+        r = get_process_comm(pid, &t);

         if (r < 0) {

                 log_warning_errno(r, "Failed to get COMM, falling back to the command line: %m");

-                context[CONTEXT_COMM] = strv_join(comm_fallback, " ");

-                if (!context[CONTEXT_COMM])

+                context->meta[CONTEXT_COMM] = strv_join(comm_fallback, " ");

+                if (!context->meta[CONTEXT_COMM])

                         return log_oom();

-        }

+        } else

+                context->meta[CONTEXT_COMM] = t;

-        r = get_process_exe(pid, &context[CONTEXT_EXE]);

+        r = get_process_exe(pid, &t);

         if (r < 0)

                 log_warning_errno(r, "Failed to get EXE, ignoring: %m");

+        else

+                context->meta[CONTEXT_EXE] = t;

-        if (cg_pid_get_unit(pid, &context[CONTEXT_UNIT]) >= 0) {

-                if (!is_journald_crash((const char**) context)) {

+        if (cg_pid_get_unit(pid, &t) >= 0) {

+                if (!is_journald_crash(context)) {

                         /* OK, now we know it's not the journal, hence we can make use of it now. */

                         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);

                         log_open();

                 }

                 /* If this is PID 1 disable coredump collection, we'll unlikely be able to process it later on. */

-                if (is_pid1_crash((const char**) context)) {

+                if (is_pid1_crash(context)) {

                         log_notice("Due to PID 1 having crashed coredump collection will now be turned off.");

                         disable_coredumps();

                 }

-                set_iovec_string_field(iovec, n_iovec, "COREDUMP_UNIT=", context[CONTEXT_UNIT]);

-        }

+                set_iovec_string_field(iovec, n_iovec, "COREDUMP_UNIT=", context->meta[CONTEXT_UNIT]);

+        } else

+                context->meta[CONTEXT_UNIT] = t;

         if (cg_pid_get_user_unit(pid, &t) >= 0)

                 set_iovec_field_free(iovec, n_iovec, "COREDUMP_USER_UNIT=", t);

         /* The next few are mandatory */

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_PID=", context[CONTEXT_PID]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_PID=", context->meta[CONTEXT_PID]))

                 return log_oom();

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_UID=", context[CONTEXT_UID]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_UID=", context->meta[CONTEXT_UID]))

                 return log_oom();

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_GID=", context[CONTEXT_GID]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_GID=", context->meta[CONTEXT_GID]))

                 return log_oom();

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_SIGNAL=", context[CONTEXT_SIGNAL]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_SIGNAL=", context->meta[CONTEXT_SIGNAL]))

                 return log_oom();

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_RLIMIT=", context[CONTEXT_RLIMIT]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_RLIMIT=", context->meta[CONTEXT_RLIMIT]))

                 return log_oom();

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_HOSTNAME=", context[CONTEXT_HOSTNAME]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_HOSTNAME=", context->meta[CONTEXT_HOSTNAME]))

                 return log_oom();

-        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_COMM=", context[CONTEXT_COMM]))

+        if (!set_iovec_string_field(iovec, n_iovec, "COREDUMP_COMM=", context->meta[CONTEXT_COMM]))

                 return log_oom();

-        if (context[CONTEXT_EXE] &&

-            !set_iovec_string_field(iovec, n_iovec, "COREDUMP_EXE=", context[CONTEXT_EXE]))

+        if (context->meta[CONTEXT_EXE] &&

+            !set_iovec_string_field(iovec, n_iovec, "COREDUMP_EXE=", context->meta[CONTEXT_EXE]))

                 return log_oom();

         if (sd_pid_get_session(pid, &t) >= 0)

@@ -1198,11 +1206,11 @@ static int gather_pid_metadata(

         if (get_process_environ(pid, &t) >= 0)

                 set_iovec_field_free(iovec, n_iovec, "COREDUMP_ENVIRON=", t);

-        t = strjoin("COREDUMP_TIMESTAMP=", context[CONTEXT_TIMESTAMP], "000000");

+        t = strjoin("COREDUMP_TIMESTAMP=", context->meta[CONTEXT_TIMESTAMP], "000000");

         if (t)

                 iovec[(*n_iovec)++] = IOVEC_MAKE_STRING(t);

-        if (safe_atoi(context[CONTEXT_SIGNAL], &signo) >= 0 && SIGNAL_VALID(signo))

+        if (safe_atoi(context->meta[CONTEXT_SIGNAL], &signo) >= 0 && SIGNAL_VALID(signo))

                 set_iovec_string_field(iovec, n_iovec, "COREDUMP_SIGNAL_NAME=SIG", signal_to_string(signo));

         return 0; /* we successfully acquired all metadata */

@@ -1210,7 +1218,7 @@ static int gather_pid_metadata(

 static int process_kernel(int argc, char* argv[]) {

-        char* context[_CONTEXT_MAX] = {};

+        Context context = {};

         struct iovec iovec[29 + SUBMIT_COREDUMP_FIELDS];

         size_t i, n_iovec, n_to_free = 0;

         int r;

@@ -1222,15 +1230,15 @@ static int process_kernel(int argc, char* argv[]) {

                 return -EINVAL;

         }

-        context[CONTEXT_PID]       = argv[1 + CONTEXT_PID];

-        context[CONTEXT_UID]       = argv[1 + CONTEXT_UID];

-        context[CONTEXT_GID]       = argv[1 + CONTEXT_GID];

-        context[CONTEXT_SIGNAL]    = argv[1 + CONTEXT_SIGNAL];

-        context[CONTEXT_TIMESTAMP] = argv[1 + CONTEXT_TIMESTAMP];

-        context[CONTEXT_RLIMIT]    = argv[1 + CONTEXT_RLIMIT];

-        context[CONTEXT_HOSTNAME]  = argv[1 + CONTEXT_HOSTNAME];

+        context.meta[CONTEXT_PID]       = argv[1 + CONTEXT_PID];

+        context.meta[CONTEXT_UID]       = argv[1 + CONTEXT_UID];

+        context.meta[CONTEXT_GID]       = argv[1 + CONTEXT_GID];

+        context.meta[CONTEXT_SIGNAL]    = argv[1 + CONTEXT_SIGNAL];

+        context.meta[CONTEXT_TIMESTAMP] = argv[1 + CONTEXT_TIMESTAMP];

+        context.meta[CONTEXT_RLIMIT]    = argv[1 + CONTEXT_RLIMIT];

+        context.meta[CONTEXT_HOSTNAME]  = argv[1 + CONTEXT_HOSTNAME];

-        r = gather_pid_metadata(context, argv + 1 + CONTEXT_COMM, iovec, &n_to_free);

+        r = gather_pid_metadata(&context, argv + 1 + CONTEXT_COMM, iovec, &n_to_free);

         if (r < 0)

                 goto finish;

@@ -1243,8 +1251,8 @@ static int process_kernel(int argc, char* argv[]) {

         assert(n_iovec <= ELEMENTSOF(iovec));

-        if (is_journald_crash((const char**) context) || is_pid1_crash((const char**) context))

-                r = submit_coredump((const char**) context,

+        if (is_journald_crash(&context) || is_pid1_crash(&context))

+                r = submit_coredump(&context,

                                     iovec, ELEMENTSOF(iovec), n_iovec,

                                     STDIN_FILENO);

         else

@@ -1255,15 +1263,15 @@ static int process_kernel(int argc, char* argv[]) {

                 free(iovec[i].iov_base);

         /* Those fields are allocated by gather_pid_metadata */

-        free(context[CONTEXT_COMM]);

-        free(context[CONTEXT_EXE]);

-        free(context[CONTEXT_UNIT]);

+        free((char *) context.meta[CONTEXT_COMM]);

+        free((char *) context.meta[CONTEXT_EXE]);

+        free((char *) context.meta[CONTEXT_UNIT]);

         return r;

 }

 static int process_backtrace(int argc, char *argv[]) {

-        char *context[_CONTEXT_MAX] = {};

+        Context context = {};

         _cleanup_free_ char *message = NULL;

         _cleanup_free_ struct iovec *iovec = NULL;

         size_t n_iovec, n_allocated, n_to_free = 0, i;

@@ -1279,13 +1287,13 @@ static int process_backtrace(int argc, char *argv[]) {

                 return -EINVAL;

         }

-        context[CONTEXT_PID]       = argv[2 + CONTEXT_PID];

-        context[CONTEXT_UID]       = argv[2 + CONTEXT_UID];

-        context[CONTEXT_GID]       = argv[2 + CONTEXT_GID];

-        context[CONTEXT_SIGNAL]    = argv[2 + CONTEXT_SIGNAL];

-        context[CONTEXT_TIMESTAMP] = argv[2 + CONTEXT_TIMESTAMP];

-        context[CONTEXT_RLIMIT]    = argv[2 + CONTEXT_RLIMIT];

-        context[CONTEXT_HOSTNAME]  = argv[2 + CONTEXT_HOSTNAME];

+        context.meta[CONTEXT_PID]       = argv[2 + CONTEXT_PID];

+        context.meta[CONTEXT_UID]       = argv[2 + CONTEXT_UID];

+        context.meta[CONTEXT_GID]       = argv[2 + CONTEXT_GID];

+        context.meta[CONTEXT_SIGNAL]    = argv[2 + CONTEXT_SIGNAL];

+        context.meta[CONTEXT_TIMESTAMP] = argv[2 + CONTEXT_TIMESTAMP];

+        context.meta[CONTEXT_RLIMIT]    = argv[2 + CONTEXT_RLIMIT];

+        context.meta[CONTEXT_HOSTNAME]  = argv[2 + CONTEXT_HOSTNAME];

         n_allocated = 34 + COREDUMP_STORAGE_EXTERNAL;

         /* 26 metadata, 2 static, +unknown input, 4 storage, rounded up */

@@ -1293,7 +1301,7 @@ static int process_backtrace(int argc, char *argv[]) {

         if (!iovec)

                 return log_oom();

-        r = gather_pid_metadata(context, argv + 2 + CONTEXT_COMM, iovec, &n_to_free);

+        r = gather_pid_metadata(&context, argv + 2 + CONTEXT_COMM, iovec, &n_to_free);

         if (r < 0)

                 goto finish;

         if (r > 0) {

@@ -1320,10 +1328,10 @@ static int process_backtrace(int argc, char *argv[]) {

         if (journal_importer_eof(&importer)) {

                 log_warning("Did not receive a full journal entry on stdin, ignoring message sent by reporter");

-                message = strjoin("MESSAGE=Process ", context[CONTEXT_PID],

-                                  " (", context[CONTEXT_COMM], ")"

-                                  " of user ", context[CONTEXT_UID],

-                                  " failed with ", context[CONTEXT_SIGNAL]);

+                message = strjoin("MESSAGE=Process ", context.meta[CONTEXT_PID],

+                                  " (", context.meta[CONTEXT_COMM], ")"

+                                  " of user ", context.meta[CONTEXT_UID],

+                                  " failed with ", context.meta[CONTEXT_SIGNAL]);

                 if (!message) {

                         r = log_oom();

                         goto finish;

@@ -1349,9 +1357,9 @@ static int process_backtrace(int argc, char *argv[]) {

                 free(iovec[i].iov_base);

         /* Those fields are allocated by gather_pid_metadata */

-        free(context[CONTEXT_COMM]);

-        free(context[CONTEXT_EXE]);

-        free(context[CONTEXT_UNIT]);

+        free((char *) context.meta[CONTEXT_COMM]);

+        free((char *) context.meta[CONTEXT_EXE]);

+        free((char *) context.meta[CONTEXT_UNIT]);

         return r;

 }