@arms/rum-reactnative 0.1.2 → 0.1.3-beta.0

package/android/src/main/jni/rum_module_info.c

@@ -0,0 +1,316 @@
+#include "rum_module_info.h"
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <elf.h>
+#include <link.h>
+
+/*
+ * async-signal-safe 的 /proc/self/maps 解析与 ELF build-id 提取。
+ *
+ * 约束：不分配内存、不加锁、不使用 stdio / sscanf。仅用 open/read/close/memcmp
+ * 及手写解析，可在 signal handler 中安全调用。
+ */
+
+#ifndef NT_GNU_BUILD_ID
+#define NT_GNU_BUILD_ID 3
+#endif
+
+#define RUM_MAPS_RAW_CAP (256 * 1024)  // maps 原始文本缓冲（超出部分截断）
+#define RUM_MAX_SEGS 512               // 最多解析段数
+#define RUM_MAX_MODULES 256            // 去重后最多模块数
+
+typedef struct {
+    uintptr_t start;
+    uintptr_t end;
+    uintptr_t offset;
+    const char *path;  // 指向 g_maps_raw，非 null 结尾
+    int path_len;
+} rum_seg_t;
+
+typedef struct {
+    uintptr_t image_addr;  // ELF 基址（= start - file_offset）
+    uintptr_t image_size;  // 覆盖所有段的镜像大小
+    const char *path;
+    int path_len;
+} rum_mod_t;
+
+static char g_maps_raw[RUM_MAPS_RAW_CAP];
+static size_t g_maps_len;
+
+static rum_seg_t g_segs[RUM_MAX_SEGS];
+static int g_seg_count;
+static int g_parsed;
+
+static rum_mod_t g_mods[RUM_MAX_MODULES];
+static int g_mod_count;
+
+static int is_hex(char c) {
+    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+           (c >= 'A' && c <= 'F');
+}
+
+static uintptr_t hex_val(char c) {
+    if (c >= '0' && c <= '9') return (uintptr_t)(c - '0');
+    if (c >= 'a' && c <= 'f') return (uintptr_t)(c - 'a' + 10);
+    if (c >= 'A' && c <= 'F') return (uintptr_t)(c - 'A' + 10);
+    return 0;
+}
+
+int rum_modules_parse(void) {
+    if (g_parsed) {
+        return g_seg_count;
+    }
+    g_parsed = 1;
+    g_seg_count = 0;
+
+    int fd = open("/proc/self/maps", O_RDONLY);
+    if (fd < 0) {
+        return 0;
+    }
+
+    size_t total = 0;
+    while (total < sizeof(g_maps_raw)) {
+        ssize_t n = read(fd, g_maps_raw + total, sizeof(g_maps_raw) - total);
+        if (n <= 0) {
+            break;
+        }
+        total += (size_t)n;
+    }
+    close(fd);
+    g_maps_len = total;
+
+    size_t i = 0;
+    while (i < g_maps_len && g_seg_count < RUM_MAX_SEGS) {
+        uintptr_t start = 0, end = 0, offset = 0;
+
+        // start hex
+        while (i < g_maps_len && is_hex(g_maps_raw[i])) {
+            start = start * 16 + hex_val(g_maps_raw[i]);
+            i++;
+        }
+        if (i < g_maps_len && g_maps_raw[i] == '-') {
+            i++;
+        }
+        // end hex
+        while (i < g_maps_len && is_hex(g_maps_raw[i])) {
+            end = end * 16 + hex_val(g_maps_raw[i]);
+            i++;
+        }
+        // space + perms 字段（跳过）
+        while (i < g_maps_len && g_maps_raw[i] == ' ') i++;
+        while (i < g_maps_len && g_maps_raw[i] != ' ' && g_maps_raw[i] != '\n') i++;
+        // space + offset hex
+        while (i < g_maps_len && g_maps_raw[i] == ' ') i++;
+        while (i < g_maps_len && is_hex(g_maps_raw[i])) {
+            offset = offset * 16 + hex_val(g_maps_raw[i]);
+            i++;
+        }
+        // dev 字段（跳过）
+        while (i < g_maps_len && g_maps_raw[i] == ' ') i++;
+        while (i < g_maps_len && g_maps_raw[i] != ' ' && g_maps_raw[i] != '\n') i++;
+        // inode 字段（跳过）
+        while (i < g_maps_len && g_maps_raw[i] == ' ') i++;
+        while (i < g_maps_len && g_maps_raw[i] != ' ' && g_maps_raw[i] != '\n') i++;
+        // 空白 + pathname 直到行尾
+        while (i < g_maps_len && g_maps_raw[i] == ' ') i++;
+        size_t path_start = i;
+        while (i < g_maps_len && g_maps_raw[i] != '\n') i++;
+        size_t path_end = i;
+        if (i < g_maps_len && g_maps_raw[i] == '\n') {
+            i++;
+        }
+
+        // 仅保留以 '/' 开头的 file-backed 段（跳过 [anon] / [stack] 等）
+        if (path_end > path_start && g_maps_raw[path_start] == '/') {
+            rum_seg_t *s = &g_segs[g_seg_count++];
+            s->start = start;
+            s->end = end;
+            s->offset = offset;
+            s->path = &g_maps_raw[path_start];
+            s->path_len = (int)(path_end - path_start);
+        }
+    }
+
+    return g_seg_count;
+}
+
+int rum_module_index_for_addr(uintptr_t addr) {
+    for (int i = 0; i < g_seg_count; i++) {
+        if (addr >= g_segs[i].start && addr < g_segs[i].end) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+uintptr_t rum_seg_load_base(int seg_index) {
+    if (seg_index < 0 || seg_index >= g_seg_count) {
+        return 0;
+    }
+    return g_segs[seg_index].start - g_segs[seg_index].offset;
+}
+
+const char *rum_seg_path(int seg_index, int *out_len) {
+    if (seg_index < 0 || seg_index >= g_seg_count) {
+        if (out_len) *out_len = 0;
+        return NULL;
+    }
+    if (out_len) *out_len = g_segs[seg_index].path_len;
+    return g_segs[seg_index].path;
+}
+
+int rum_module_build_distinct(void) {
+    g_mod_count = 0;
+    for (int s = 0; s < g_seg_count; s++) {
+        uintptr_t base = g_segs[s].start - g_segs[s].offset;
+
+        int found = -1;
+        for (int m = 0; m < g_mod_count; m++) {
+            if (g_mods[m].path_len == g_segs[s].path_len &&
+                memcmp(g_mods[m].path, g_segs[s].path,
+                       (size_t)g_segs[s].path_len) == 0) {
+                found = m;
+                break;
+            }
+        }
+
+        if (found < 0) {
+            if (g_mod_count >= RUM_MAX_MODULES) {
+                continue;
+            }
+            found = g_mod_count++;
+            g_mods[found].path = g_segs[s].path;
+            g_mods[found].path_len = g_segs[s].path_len;
+            g_mods[found].image_addr = base;
+            g_mods[found].image_size = g_segs[s].end - base;
+        } else {
+            if (base < g_mods[found].image_addr) {
+                g_mods[found].image_addr = base;
+            }
+            uintptr_t span = g_segs[s].end - g_mods[found].image_addr;
+            if (span > g_mods[found].image_size) {
+                g_mods[found].image_size = span;
+            }
+        }
+    }
+    return g_mod_count;
+}
+
+uintptr_t rum_module_image_addr(int mod_index) {
+    if (mod_index < 0 || mod_index >= g_mod_count) {
+        return 0;
+    }
+    return g_mods[mod_index].image_addr;
+}
+
+uintptr_t rum_module_image_size(int mod_index) {
+    if (mod_index < 0 || mod_index >= g_mod_count) {
+        return 0;
+    }
+    return g_mods[mod_index].image_size;
+}
+
+const char *rum_module_name(int mod_index, int *out_len) {
+    if (mod_index < 0 || mod_index >= g_mod_count) {
+        if (out_len) *out_len = 0;
+        return NULL;
+    }
+    if (out_len) *out_len = g_mods[mod_index].path_len;
+    return g_mods[mod_index].path;
+}
+
+int rum_module_build_id_hex(uintptr_t load_base, char *out, int out_cap) {
+    if (load_base == 0 || out == NULL || out_cap <= 0) {
+        return 0;
+    }
+
+    // 验证 load_base 落在已映射的段范围内。
+    // load_base = start - offset 可能指向未映射的内存区域（例如段 file_offset
+    // 不为零时，start - offset 可能落在该段之前的空洞中）。直接读取该地址
+    // 会触发二次 SIGSEGV，导致信号处理器重入保护将信号设为 SIG_DFL 后进程
+    // 立即终止，缓冲区中的崩溃数据从未刷新到磁盘。
+    // rum_module_index_for_addr() 仅做静态数组遍历比较，async-signal-safe。
+    if (rum_module_index_for_addr(load_base) < 0) {
+        return 0;
+    }
+
+    const unsigned char *base = (const unsigned char *)load_base;
+    // 校验 ELF magic（双重防御：即使地址已映射，也需确认指向 ELF 头）
+    if (base[0] != 0x7f || base[1] != 'E' || base[2] != 'L' ||
+        base[3] != 'F') {
+        return 0;
+    }
+
+    const ElfW(Ehdr) *ehdr = (const ElfW(Ehdr) *)base;
+
+    // 校验 e_phnum 上限，防止损坏的值导致循环越界。
+    // 正常 ELF 的程序头表条目数极少超过几十个，256 是宽松上限。
+    if (ehdr->e_phnum > 256) {
+        return 0;
+    }
+
+    const ElfW(Phdr) *phdr = (const ElfW(Phdr) *)(base + ehdr->e_phoff);
+
+    // 验证 phdr 起始地址在已映射段范围内。
+    // 如果 e_phoff 被损坏导致 phdr 指向未映射内存，读取 phdr[i] 会触发
+    // 二次 SIGSEGV。rum_module_index_for_addr() 仅遍历静态数组做整数比较，
+    // async-signal-safe。
+    if (rum_module_index_for_addr((uintptr_t)phdr) < 0) {
+        return 0;
+    }
+
+    for (int i = 0; i < ehdr->e_phnum; i++) {
+        if (phdr[i].p_type != PT_NOTE) {
+            continue;
+        }
+        // 对 PIE / 共享库，PT_NOTE 内容运行时地址 = base + p_vaddr
+        const unsigned char *note = base + phdr[i].p_vaddr;
+        const unsigned char *note_end = note + phdr[i].p_memsz;
+
+        // 验证 note section 起始地址在已映射段范围内。
+        // p_vaddr 可能指向模块文件中未被映射到内存的区域（如 SHT_NOTE
+        // 类型段在某些构建配置下不在可加载段内），直接读取同样会触发二次
+        // SIGSEGV。
+        if (rum_module_index_for_addr((uintptr_t)note) < 0) {
+            continue;
+        }
+
+        // 验证 note section 末尾地址也在已映射段范围内。
+        // 如果 note 数据跨越映射段末尾页边界，读取 nhdr->n_namesz、name、
+        // desc[b] 等可能触发二次 SIGSEGV。p_memsz 为 0 时跳过该段。
+        if (phdr[i].p_memsz == 0) {
+            continue;
+        }
+        if (rum_module_index_for_addr((uintptr_t)(note_end - 1)) < 0) {
+            continue;
+        }
+
+        while (note + sizeof(ElfW(Nhdr)) <= note_end) {
+            const ElfW(Nhdr) *nhdr = (const ElfW(Nhdr) *)note;
+            uint32_t namesz = nhdr->n_namesz;
+            uint32_t descsz = nhdr->n_descsz;
+            uint32_t type = nhdr->n_type;
+
+            const unsigned char *name = note + sizeof(ElfW(Nhdr));
+            const unsigned char *desc = name + ((namesz + 3u) & ~3u);
+
+            if (type == NT_GNU_BUILD_ID && namesz == 4 &&
+                memcmp(name, "GNU", 4) == 0) {
+                static const char hexc[] = "0123456789abcdef";
+                int written = 0;
+                for (uint32_t b = 0;
+                     b < descsz && written + 2 <= out_cap; b++) {
+                    out[written++] = hexc[(desc[b] >> 4) & 0xF];
+                    out[written++] = hexc[desc[b] & 0xF];
+                }
+                return written;
+            }
+
+            note = desc + ((descsz + 3u) & ~3u);
+        }
+    }
+
+    return 0;
+}

package/android/src/main/jni/rum_module_info.h

@@ -0,0 +1,54 @@
+#ifndef RUM_MODULE_INFO_H
+#define RUM_MODULE_INFO_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * 已加载模块信息（async-signal-safe）。
+ *
+ * 在信号处理器中解析 /proc/self/maps，为崩溃栈帧提供：
+ *  - 每帧所属模块（library 名）与模块内相对偏移（供后端符号化）；
+ *  - binary_images 列表：每个 .so 的 GNU build-id、加载基址、大小
+ *    （build-id 用于后端精确匹配符号文件，等价于 iOS 的 image uuid）。
+ *
+ * 所有函数均不分配内存、不加锁，可在 signal handler 中调用。
+ */
+
+/** 解析 /proc/self/maps 到内部静态表（幂等）。返回段数量。 */
+int rum_modules_parse(void);
+
+/** 返回包含 addr 的段索引，未命中返回 -1。 */
+int rum_module_index_for_addr(uintptr_t addr);
+
+/** 段的加载基址（= start - file_offset）。索引非法返回 0。 */
+uintptr_t rum_seg_load_base(int seg_index);
+
+/** 段对应的模块路径（指向内部缓冲，非 null 结尾）。out_len 输出长度。 */
+const char *rum_seg_path(int seg_index, int *out_len);
+
+/**
+ * 构建去重后的 file-backed 模块列表（按路径去重）。返回模块数量。
+ * 必须在 rum_modules_parse() 之后调用。
+ */
+int rum_module_build_distinct(void);
+
+/** 去重模块的加载基址。 */
+uintptr_t rum_module_image_addr(int mod_index);
+
+/** 去重模块的镜像大小（覆盖所有段的范围）。 */
+uintptr_t rum_module_image_size(int mod_index);
+
+/** 去重模块的路径（指向内部缓冲，非 null 结尾）。 */
+const char *rum_module_name(int mod_index, int *out_len);
+
+/**
+ * 提取模块的 GNU build-id 并写入 out（小写 hex，不含 null）。
+ * @param load_base 模块加载基址（ELF header 所在地址）
+ * @param out       输出缓冲
+ * @param out_cap   输出缓冲容量
+ * @return 写入的 hex 字符数；无 build-id 或读取失败返回 0。
+ */
+int rum_module_build_id_hex(uintptr_t load_base, char *out, int out_cap);
+
+#endif  // RUM_MODULE_INFO_H

package/android/src/main/jni/rum_test_crash.cpp

@@ -0,0 +1,55 @@
+#include <jni.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <stdexcept>
+
+// 无限递归触发栈溢出
+static void infinite_recursion(void) {
+    volatile char buf[4096];
+    buf[0] = 0;
+    infinite_recursion();
+}
+
+extern "C" {
+
+JNIEXPORT void JNICALL
+Java_com_rumsdkreactnative_RumSdkReactnativeModule_nativeTriggerCrash(
+    JNIEnv *env, jobject thiz, jint type) {
+    (void)env;
+    (void)thiz;
+
+    switch (type) {
+        case 0: {
+            // SIGSEGV - null pointer dereference
+            volatile int *p = NULL;
+            *p = 42;
+            break;
+        }
+        case 1: {
+            // SIGABRT
+            abort();
+            break;
+        }
+        case 2: {
+            // SIGFPE - division by zero
+            volatile int x = 0;
+            volatile int y = 1 / x;
+            (void)y;
+            break;
+        }
+        case 3: {
+            // Unhandled C++ exception
+            throw std::runtime_error("RUM SDK Test: Unhandled C++ Exception");
+            break;
+        }
+        case 4: {
+            // Stack overflow
+            infinite_recursion();
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+} // extern "C"

package/app.plugin.js

@@ -0,0 +1,11 @@
+/**
+ * Expo config plugin entry point.
+ *
+ * Discovered automatically by `expo prebuild` / EAS Build when this package is listed
+ * in the consumer's app.config `plugins` array:
+ *   plugins: [['@arms/rum-reactnative', { endpoint: '...', env: 'prod' }]]
+ *
+ * Delegates to the built CommonJS module (lib/commonjs/expoConfigPlugin.js).
+ */
+const mod = require('./lib/commonjs/expoConfigPlugin');
+module.exports = mod.default || mod;