feat: add linux distributions to os context (#963)

* feat: add linux distributions to os context

* Clean up test-allocations like a good boy

* separate os-dependent unit-test sources

* platform-specfic testing is decided in the translation-units

* Exclude Android too

* Add documented fallback

* Ensure we exhausted the snapshot

* DeMorgan

* format

* add valgrind exception for false positive when memmove is an ifunc resolving to memcpy

* Make sure that distributions are only added in Linux not any Unix

* Make sure we don't leak in the error paths

* Clean up the fall-back from /etc/os-release to /usr/lib/os-release

* attribute derivative work

* apply PR feedback

* Extract slice to buffer handling in a new sentry_slice_t function.

* Make sure we can read a full line of max value and max key.

This is a hugely hypothetical target, since the max values are far
beyond all the test data we currently observed, but still.

* fix classic buffer continuity bug.

* extract parse_line_into_object...

...to separate parsing/output from buffer management.

* ensure line update if we hit the buffer-end correctly.

* add support for os-release files that don't end with a newline.

* Add comments to the subtler buffer management aspects.

* Add a list of tested distribution names for documentation

* Add back eof-newline to valgrind exceptions.

* Adapt test to new entry in fixture.

* include sentry_utils in sentry_os only on Linux

* Ensure we find close() in unistd.h by including it explicitly.

* include sentry_utils in sentry_os on Windows too

* use unistd.h in sentry_os only for Linux

* flattened distribution payload fields

* format

* incref for get_by_key calls

* decref no longer copied os_dist

---------

Co-authored-by: JoshuaMoelans <60878493+JoshuaMoelans@users.noreply.github.com>

Author: supervacuus

CHANGELOG.md

@@ -115,6 +115,7 @@
 
 **Features**:
 
+- Add Linux distributions to the OS context. [#963](https://github.com/getsentry/sentry-native/pull/963)
 - Change the timestamp resolution to microseconds. ([#995](https://github.com/getsentry/sentry-native/pull/995))
 
 **Internal**:

src/modulefinder/sentry_modulefinder_linux.c

@@ -7,6 +7,7 @@
 #include "sentry_path.h"
 #include "sentry_string.h"
 #include "sentry_sync.h"
+#include "sentry_utils.h"
 #include "sentry_value.h"
 
 #include <arpa/inet.h>
@@ -31,8 +32,6 @@ process_vm_readv(pid_t __pid, const struct iovec *__local_iov,
 }
 #endif
 
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-
 #define ENSURE(Ptr)                                                            \
     if (!Ptr)                                                                  \
     goto fail

src/sentry_os.c

@@ -1,6 +1,12 @@
 #include "sentry_os.h"
+#include "sentry_slice.h"
 #include "sentry_string.h"
-#include "sentry_utils.h"
+#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS)
+#    include "sentry_utils.h"
+#endif
+#ifdef SENTRY_PLATFORM_LINUX
+#    include <unistd.h>
+#endif
 
 #ifdef SENTRY_PLATFORM_WINDOWS
 
@@ -256,8 +262,123 @@ sentry__get_os_context(void)
 }
 #elif defined(SENTRY_PLATFORM_UNIX)
 
+#    include <fcntl.h>
 #    include <sys/utsname.h>
 
+#    if defined(SENTRY_PLATFORM_LINUX)
+#        define OS_RELEASE_MAX_LINE_SIZE 256
+#        define OS_RELEASE_MAX_KEY_SIZE 64
+#        define OS_RELEASE_MAX_VALUE_SIZE 128
+
+static int
+parse_os_release_line(const char *line, char *key, char *value)
+{
+    const char *equals = strchr(line, '=');
+    if (equals == NULL)
+        return 1;
+
+    unsigned long key_length = MIN(equals - line, OS_RELEASE_MAX_KEY_SIZE - 1);
+    strncpy(key, line, key_length);
+    key[key_length] = '\0';
+
+    sentry_slice_t value_slice
+        = { .ptr = equals + 1, .len = strlen(equals + 1) };
+
+    // some values are wrapped in double quotes
+    if (value_slice.ptr[0] == '\"') {
+        value_slice.ptr++;
+        value_slice.len -= 2;
+    }
+
+    sentry__slice_to_buffer(value_slice, value, OS_RELEASE_MAX_VALUE_SIZE);
+
+    return 0;
+}
+
+static void
+parse_line_into_object(const char *line, sentry_value_t os_dist)
+{
+    char value[OS_RELEASE_MAX_VALUE_SIZE];
+    char key[OS_RELEASE_MAX_KEY_SIZE];
+
+    if (parse_os_release_line(line, key, value) == 0) {
+        if (strcmp(key, "ID") == 0) {
+            sentry_value_set_by_key(
+                os_dist, "name", sentry_value_new_string(value));
+        }
+
+        if (strcmp(key, "VERSION_ID") == 0) {
+            sentry_value_set_by_key(
+                os_dist, "version", sentry_value_new_string(value));
+        }
+
+        if (strcmp(key, "PRETTY_NAME") == 0) {
+            sentry_value_set_by_key(
+                os_dist, "pretty_name", sentry_value_new_string(value));
+        }
+    }
+}
+
+#        ifndef SENTRY_UNITTEST
+static
+#        endif
+    sentry_value_t
+    get_linux_os_release(const char *os_rel_path)
+{
+    const int fd = open(os_rel_path, O_RDONLY);
+    if (fd == -1) {
+        return sentry_value_new_null();
+    }
+
+    sentry_value_t os_dist = sentry_value_new_object();
+    char buffer[OS_RELEASE_MAX_LINE_SIZE];
+    ssize_t bytes_read;
+    ssize_t buffer_rest = 0;
+    const char *line = buffer;
+    while ((bytes_read = read(
+                fd, buffer + buffer_rest, sizeof(buffer) - buffer_rest - 1))
+        > 0) {
+        ssize_t buffer_end = buffer_rest + bytes_read;
+        buffer[buffer_end] = '\0';
+
+        // extract all lines from the valid buffer-range and parse them
+        for (char *p = buffer; *p; ++p) {
+            if (*p != '\n') {
+                continue;
+            }
+            *p = '\0';
+            parse_line_into_object(line, os_dist);
+            line = p + 1;
+        }
+
+        if (line < buffer + buffer_end) {
+            // move the remaining partial line to the start of the buffer
+            buffer_rest = buffer + buffer_end - line;
+            memmove(buffer, line, buffer_rest);
+        } else {
+            // reset buffer_rest: the line-end coincided with the buffer-end
+            buffer_rest = 0;
+        }
+        line = buffer;
+    }
+
+    if (bytes_read == -1) {
+        // read() failed and we can't assume to have valid data
+        sentry_value_decref(os_dist);
+        os_dist = sentry_value_new_null();
+    } else if (buffer_rest > 0) {
+        // the file ended w/o a new-line; we still have a line left to parse
+        buffer[buffer_rest] = '\0';
+        parse_line_into_object(line, os_dist);
+    }
+
+    close(fd);
+
+    return os_dist;
+}
+
+#    endif // defined(SENTRY_PLATFORM_LINUX)
+
 sentry_value_t
 sentry__get_os_context(void)
 {
@@ -298,6 +419,35 @@ sentry__get_os_context(void)
     sentry_value_set_by_key(
         os, "version", sentry_value_new_string(uts.release));
 
+#    if defined(SENTRY_PLATFORM_LINUX)
+    /**
+     * The file /etc/os-release takes precedence over /usr/lib/os-release.
+     * Applications should check for the former, and exclusively use its data if
+     * it exists, and only fall back to /usr/lib/os-release if it is missing.
+     * Applications should not read data from both files at the same time.
+     *
+     * From:
+     * https://www.freedesktop.org/software/systemd/man/latest/os-release.html#Description
+     */
+    sentry_value_t os_dist = get_linux_os_release("/etc/os-release");
+    if (sentry_value_is_null(os_dist)) {
+        os_dist = get_linux_os_release("/usr/lib/os-release");
+        if (sentry_value_is_null(os_dist)) {
+            return os;
+        }
+    }
+    sentry_value_set_by_key(
+        os, "distribution_name", sentry_value_get_by_key(os_dist, "name"));
+    sentry_value_set_by_key(os, "distribution_version",
+        sentry_value_get_by_key(os_dist, "version"));
+    sentry_value_set_by_key(os, "distribution_pretty_name",
+        sentry_value_get_by_key(os_dist, "pretty_name"));
+    sentry_value_incref(sentry_value_get_by_key(os_dist, "name"));
+    sentry_value_incref(sentry_value_get_by_key(os_dist, "version"));
+    sentry_value_incref(sentry_value_get_by_key(os_dist, "pretty_name"));
+    sentry_value_decref(os_dist);
+#    endif // defined(SENTRY_PLATFORM_LINUX)
+
     return os;
 
 fail:

src/sentry_slice.c

@@ -1,5 +1,6 @@
 #include "sentry_slice.h"
 #include "sentry_string.h"
+#include "sentry_utils.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -18,6 +19,14 @@ sentry__slice_to_owned(sentry_slice_t slice)
     return sentry__string_clone_n_unchecked(slice.ptr, slice.len);
 }
 
+void
+sentry__slice_to_buffer(sentry_slice_t slice, char *buffer, size_t buffer_len)
+{
+    size_t copy_len = MIN(slice.len, buffer_len - 1);
+    strncpy(buffer, slice.ptr, copy_len);
+    buffer[copy_len] = 0;
+}
+
 bool
 sentry__slice_eq(sentry_slice_t a, sentry_slice_t b)
 {

src/sentry_slice.h

@@ -20,6 +20,14 @@ typedef struct {
  */
 sentry_slice_t sentry__slice_from_str(const char *str);
 
+/**
+ * Copies a slice to a pre-allocated buffer. The resulting buffer will contain a
+ * zero-terminated string. `buffer_len` is expected to be the full length of the
+ * buffer, so the resulting string can at maximum be `buffer_len - 1` long.
+ */
+void sentry__slice_to_buffer(
+    sentry_slice_t slice, char *buffer, size_t buffer_len);
+
 /**
  * Creates an owned copy from a slice.
  */

src/sentry_utils.h

@@ -15,6 +15,9 @@
 #    include <time.h>
 #endif
 
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
 /**
  * This represents a URL parsed into its different parts.
  */

tests/assertions.py

@@ -114,6 +114,8 @@ def assert_event_meta(
                 event["contexts"]["os"],
                 {"name": "Linux", "version": version, "build": build},
             )
+            assert "distribution_name" in event["contexts"]["os"]
+            assert "distribution_version" in event["contexts"]["os"]
         elif sys.platform == "darwin":
             version = platform.mac_ver()[0].split(".")
             if len(version) < 3: