feat: Support attaching bytes

Author: jpnurmi

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 **Features**:
 
-- The `sentry_attach_file`, `sentry_scope_attach_file` (and their wide-string variants), and `sentry_remove_attachment` have been added to modify the list of attachments that are sent along with sentry events after a call to `sentry_init`. ([#1266](https://github.com/getsentry/sentry-native/pull/1266))
+- The `sentry_attach_file/bytes`, `sentry_scope_attach_file/bytes` (and their wide-string variants), and `sentry_remove_attachment` have been added to modify the list of attachments that are sent along with sentry events after a call to `sentry_init`. ([#1266](https://github.com/getsentry/sentry-native/pull/1266), [#1275](https://github.com/getsentry/sentry-native/pull/1275))
   - NOTE: When using the `crashpad` backend on macOS, the list of attachments that will be added at the time of a hard crash will be frozen at the time of `sentry_init`, and later modifications will not be reflected.
 - Add `sentry_attachment_set_content_type` to allow specifying the content type of attachments. ([#1276](https://github.com/getsentry/sentry-native/pull/1276))
 

external/crashpad

@@ -1793,15 +1793,15 @@ struct sentry_attachment_s;
 typedef struct sentry_attachment_s sentry_attachment_t;
 
 /**
- * Adds a new attachment to be sent along.
+ * Attaches a file to be sent along with events.
  *
  * `path` is assumed to be in platform-specific filesystem path encoding.
  * API Users on windows are encouraged to use `sentry_attach_filew` or
  * `sentry_scope_attach_filew` instead.
  *
  * The returned `sentry_attachment_t` is owned by the SDK and will remain valid
  * until the attachment is removed with `sentry_remove_attachment` or
- * `sentry_close` is called
+ * `sentry_close` is called.
  *
  * See the NOTE on attachments above for restrictions of this API.
  */
@@ -1813,6 +1813,29 @@ SENTRY_API sentry_attachment_t *sentry_scope_attach_file(
 SENTRY_API sentry_attachment_t *sentry_scope_attach_file_n(
     sentry_scope_t *scope, const char *path, size_t path_len);
 
+/**
+ * Attaches bytes to be sent along with events.
+ *
+ * `filename` is assumed to be in platform-specific filesystem path encoding.
+ * API Users on windows are encouraged to use `sentry_attach_bytesw` or
+ * `sentry_scope_attach_bytesw` instead.
+ *
+ * The returned `sentry_attachment_t` is owned by the SDK and will remain valid
+ * until the attachment is removed with `sentry_remove_attachment` or
+ * `sentry_close` is called.
+ *
+ * See the NOTE on attachments above for restrictions of this API.
+ */
+SENTRY_API sentry_attachment_t *sentry_attach_bytes(
+    const char *buf, size_t buf_len, const char *filename);
+SENTRY_API sentry_attachment_t *sentry_attach_bytes_n(
+    const char *buf, size_t buf_len, const char *filename, size_t filename_len);
+SENTRY_API sentry_attachment_t *sentry_scope_attach_bytes(sentry_scope_t *scope,
+    const char *buf, size_t buf_len, const char *filename);
+SENTRY_API sentry_attachment_t *sentry_scope_attach_bytes_n(
+    sentry_scope_t *scope, const char *buf, size_t buf_len,
+    const char *filename, size_t filename_len);
+
 /**
  * Removes and frees a previously added attachment.
  *
@@ -1831,6 +1854,20 @@ SENTRY_API sentry_attachment_t *sentry_scope_attach_filew(
     sentry_scope_t *scope, const wchar_t *path);
 SENTRY_API sentry_attachment_t *sentry_scope_attach_filew_n(
     sentry_scope_t *scope, const wchar_t *path, size_t path_len);
+
+/**
+ * Wide char versions of `sentry_attach_bytes` and `sentry_scope_attach_bytes`.
+ */
+SENTRY_API sentry_attachment_t *sentry_attach_bytesw(
+    const char *buf, size_t buf_len, const wchar_t *filename);
+SENTRY_API sentry_attachment_t *sentry_attach_bytesw_n(const char *buf,
+    size_t buf_len, const wchar_t *filename, size_t filename_len);
+SENTRY_API sentry_attachment_t *sentry_scope_attach_bytesw(
+    sentry_scope_t *scope, const char *buf, size_t buf_len,
+    const wchar_t *filename);
+SENTRY_API sentry_attachment_t *sentry_scope_attach_bytesw_n(
+    sentry_scope_t *scope, const char *buf, size_t buf_len,
+    const wchar_t *filename, size_t filename_len);
 #endif
 
 SENTRY_API void sentry_attachment_set_content_type(

include/sentry.h

@@ -2,6 +2,7 @@ extern "C" {
 #include "sentry_boot.h"
 
 #include "sentry_alloc.h"
+#include "sentry_attachment.h"
 #include "sentry_backend.h"
 #include "sentry_core.h"
 #include "sentry_database.h"
@@ -169,8 +170,8 @@ breakpad_backend_callback(const google_breakpad::MinidumpDescriptor &descriptor,
                 sentry_path_t *screenshot_path
                     = sentry__screenshot_get_path(options);
                 if (sentry__screenshot_capture(screenshot_path)) {
-                    sentry__envelope_add_attachment(
-                        envelope, screenshot_path, ATTACHMENT, nullptr);
+                    sentry__envelope_add_attachment(envelope,
+                        sentry__attachment_from_path(screenshot_path));
                 }
                 sentry__path_free(screenshot_path);
             }

src/backends/sentry_backend_breakpad.cpp

@@ -662,26 +662,52 @@ crashpad_backend_prune_database(sentry_backend_t *backend)
 }
 
 #if defined(SENTRY_PLATFORM_WINDOWS) || defined(SENTRY_PLATFORM_LINUX)
+static crashpad::UUID
+to_crashpad_uuid(const sentry_uuid_t *uuid)
+{
+    char str[37];
+    sentry_uuid_as_string(uuid, str);
+
+    crashpad::UUID rv;
+    rv.InitializeFromString(str);
+    return rv;
+}
+
+static crashpad::Attachment
+to_crashpad_attachment(const sentry_attachment_t *attachment)
+{
+    if (attachment->buf) {
+        uint8_t *buf = reinterpret_cast<uint8_t *>(attachment->buf);
+        return crashpad::Attachment(
+            std::vector<uint8_t>(buf, buf + attachment->buf_len),
+            base::FilePath(attachment->path->path),
+            to_crashpad_uuid(&attachment->uuid));
+    }
+
+    return crashpad::Attachment(base::FilePath(attachment->path->path),
+        to_crashpad_uuid(&attachment->uuid));
+}
+
 static void
 crashpad_backend_add_attachment(
-    sentry_backend_t *backend, const sentry_path_t *attachment)
+    sentry_backend_t *backend, const sentry_attachment_t *attachment)
 {
     auto *data = static_cast<crashpad_state_t *>(backend->data);
     if (!data || !data->client) {
         return;
     }
-    data->client->AddAttachment(base::FilePath(attachment->path));
+    data->client->AddAttachment(to_crashpad_attachment(attachment));
 }
 
 static void
 crashpad_backend_remove_attachment(
-    sentry_backend_t *backend, const sentry_path_t *attachment)
+    sentry_backend_t *backend, const sentry_attachment_t *attachment)
 {
     auto *data = static_cast<crashpad_state_t *>(backend->data);
     if (!data || !data->client) {
         return;
     }
-    data->client->RemoveAttachment(base::FilePath(attachment->path));
+    data->client->RemoveAttachment(to_crashpad_uuid(&attachment->uuid));
 }
 #endif
 

src/backends/sentry_backend_crashpad.cpp

@@ -1,3 +1,4 @@
+#include "sentry_attachment.h"
 #include "sentry_boot.h"
 
 #include "sentry_alloc.h"
@@ -601,8 +602,8 @@ handle_ucontext(const sentry_ucontext_t *uctx)
                 sentry_path_t *screenshot_path
                     = sentry__screenshot_get_path(options);
                 if (sentry__screenshot_capture(screenshot_path)) {
-                    sentry__envelope_add_attachment(
-                        envelope, screenshot_path, ATTACHMENT, NULL);
+                    sentry__envelope_add_attachment(envelope,
+                        sentry__attachment_from_path(screenshot_path));
                 }
                 sentry__path_free(screenshot_path);
             }

src/backends/sentry_backend_inproc.c

@@ -3,6 +3,8 @@
 #include "sentry_path.h"
 #include "sentry_string.h"
 
+#include <string.h>
+
 void
 sentry_attachment_set_content_type(
     sentry_attachment_t *attachment, const char *content_type)
@@ -24,13 +26,49 @@ sentry_attachment_set_content_type_n(sentry_attachment_t *attachment,
         = sentry__string_clone_n(content_type, content_type_len);
 }
 
+sentry_attachment_t *
+sentry__attachment_from_path(sentry_path_t *path)
+{
+    if (!path) {
+        return NULL;
+    }
+    sentry_attachment_t *attachment = SENTRY_MAKE(sentry_attachment_t);
+    if (!attachment) {
+        sentry__path_free(path);
+        return NULL;
+    }
+    memset(attachment, 0, sizeof(sentry_attachment_t));
+    attachment->path = path;
+    attachment->uuid = sentry_uuid_new_v4();
+    return attachment;
+}
+
+sentry_attachment_t *
+sentry__attachment_from_buffer(
+    const char *buf, size_t buf_len, sentry_path_t *filename)
+{
+    if (!buf || !buf_len || !filename) {
+        sentry__path_free(filename);
+        return NULL;
+    }
+    sentry_attachment_t *attachment = sentry__attachment_from_path(filename);
+    if (!attachment) {
+        return NULL;
+    }
+    attachment->buf = sentry_malloc(buf_len * sizeof(char));
+    memcpy(attachment->buf, buf, buf_len * sizeof(char));
+    attachment->buf_len = buf_len;
+    return attachment;
+}
+
 static void
 attachment_free(sentry_attachment_t *attachment)
 {
     if (!attachment) {
         return;
     }
     sentry__path_free(attachment->path);
+    sentry_free(attachment->buf);
     sentry_free(attachment->content_type);
     sentry_free(attachment);
 }
@@ -47,28 +85,34 @@ sentry__attachments_free(sentry_attachment_t *attachments)
     }
 }
 
+static bool
+attachment_eq(const sentry_attachment_t *a, const sentry_attachment_t *b)
+{
+    if (a == b) {
+        return true;
+    }
+    if (!a || !b || !a->path || !b->path || a->type != b->type
+        || a->content_type != b->content_type) {
+        return false;
+    }
+    return sentry__path_eq(a->path, b->path);
+}
+
 sentry_attachment_t *
 sentry__attachments_add(sentry_attachment_t **attachments_ptr,
-    sentry_path_t *path, sentry_attachment_type_t attachment_type,
+    sentry_attachment_t *attachment, sentry_attachment_type_t attachment_type,
     const char *content_type)
 {
-    if (!path) {
-        return NULL;
-    }
-    sentry_attachment_t *attachment = SENTRY_MAKE(sentry_attachment_t);
     if (!attachment) {
-        sentry__path_free(path);
         return NULL;
     }
-    attachment->path = path;
-    attachment->next = NULL;
     attachment->type = attachment_type;
     attachment->content_type = sentry__string_clone(content_type);
 
     sentry_attachment_t **next_ptr = attachments_ptr;
 
     for (sentry_attachment_t *it = *attachments_ptr; it; it = it->next) {
-        if (sentry__path_eq(it->path, path)) {
+        if (attachment_eq(it, attachment)) {
             attachment_free(attachment);
             return it;
         }
@@ -91,7 +135,7 @@ sentry__attachments_remove(
     sentry_attachment_t **next_ptr = attachments_ptr;
 
     for (sentry_attachment_t *it = *attachments_ptr; it; it = it->next) {
-        if (it == attachment || sentry__path_eq(it->path, attachment->path)) {
+        if (attachment_eq(it, attachment)) {
             *next_ptr = it->next;
             attachment_free(it);
             return;
@@ -101,12 +145,44 @@ sentry__attachments_remove(
     }
 }
 
+static sentry_attachment_t *
+attachment_clone(const sentry_attachment_t *attachment)
+{
+    if (!attachment) {
+        return NULL;
+    }
+
+    sentry_attachment_t *clone = SENTRY_MAKE(sentry_attachment_t);
+    if (!clone) {
+        return NULL;
+    }
+    memset(clone, 0, sizeof(sentry_attachment_t));
+
+    if (attachment->path) {
+        clone->path = sentry__path_clone(attachment->path);
+    }
+    if (attachment->buf_len > 0) {
+        clone->buf_len = attachment->buf_len;
+        clone->buf = sentry_malloc(attachment->buf_len * sizeof(char));
+        if (!clone->buf) {
+            attachment_free(clone);
+            return NULL;
+        }
+        memcpy(clone->buf, attachment->buf, attachment->buf_len * sizeof(char));
+    }
+    clone->type = attachment->type;
+    clone->content_type = attachment->content_type;
+    clone->uuid = attachment->uuid;
+
+    return clone;
+}
+
 void
 sentry__attachments_extend(
     sentry_attachment_t **attachments_ptr, sentry_attachment_t *attachments)
 {
     for (sentry_attachment_t *it = attachments; it; it = it->next) {
-        sentry__attachments_add(attachments_ptr, sentry__path_clone(it->path),
-            it->type, it->content_type);
+        sentry__attachments_add(
+            attachments_ptr, attachment_clone(it), it->type, it->content_type);
     }
 }

src/sentry_attachment.c

@@ -20,11 +20,18 @@ typedef enum {
  */
 struct sentry_attachment_s {
     sentry_path_t *path;
+    char *buf;
+    size_t buf_len;
     sentry_attachment_type_t type;
     char *content_type;
+    sentry_uuid_t uuid;
     sentry_attachment_t *next;
 };
 
+sentry_attachment_t *sentry__attachment_from_path(sentry_path_t *path);
+sentry_attachment_t *sentry__attachment_from_buffer(
+    const char *buf, size_t buf_len, sentry_path_t *filename);
+
 /**
  * Frees the linked list of `attachments`.
  */
@@ -34,7 +41,7 @@ void sentry__attachments_free(sentry_attachment_t *attachments);
  * Adds an attachment to the attachments list at `attachments_ptr`.
  */
 sentry_attachment_t *sentry__attachments_add(
-    sentry_attachment_t **attachments_ptr, sentry_path_t *path,
+    sentry_attachment_t **attachments_ptr, sentry_attachment_t *attachment,
     sentry_attachment_type_t attachment_type, const char *content_type);
 
 /**

src/sentry_attachment.h

@@ -25,8 +25,10 @@ struct sentry_backend_s {
     void (*user_consent_changed_func)(sentry_backend_t *);
     uint64_t (*get_last_crash_func)(sentry_backend_t *);
     void (*prune_database_func)(sentry_backend_t *);
-    void (*add_attachment_func)(sentry_backend_t *, const sentry_path_t *);
-    void (*remove_attachment_func)(sentry_backend_t *, const sentry_path_t *);
+    void (*add_attachment_func)(
+        sentry_backend_t *, const sentry_attachment_t *);
+    void (*remove_attachment_func)(
+        sentry_backend_t *, const sentry_attachment_t *);
     void *data;
     // Whether this backend still runs after shutdown_func was called.
     bool can_capture_after_shutdown;