ARROW-10071: [R] segfault with ArrowObject from previous session, or saved

cpp/src/arrow/util/nameof.h

@@ -0,0 +1,86 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <string>
+
+namespace arrow {
+namespace util {
+namespace detail {
+
+#ifdef _MSC_VER
+#define ARROW_PRETTY_FUNCTION __FUNCSIG__
+#else
+#define ARROW_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#endif
+
+template <typename T>
+const char* raw() {
+  return ARROW_PRETTY_FUNCTION;
+}
+
+template <typename T>
+size_t raw_sizeof() {
+  return sizeof(ARROW_PRETTY_FUNCTION);
+}
+
+#undef ARROW_PRETTY_FUNCTION
+
+constexpr bool starts_with(char const* haystack, char const* needle) {
+  return needle[0] == '\0' ||
+         (haystack[0] == needle[0] && starts_with(haystack + 1, needle + 1));
+}
+
+constexpr size_t search(char const* haystack, char const* needle) {
+  return haystack[0] == '\0' || starts_with(haystack, needle)
+             ? 0
+             : search(haystack + 1, needle) + 1;
+}
+
+const size_t typename_prefix = search(raw<void>(), "void");
+
+template <typename T>
+size_t struct_class_prefix() {
+#ifdef _MSC_VER
+  return starts_with(raw<T>() + typename_prefix, "struct ")
+             ? 7
+             : starts_with(raw<T>() + typename_prefix, "class ") ? 6 : 0;
+#else
+  return 0;
+#endif
+}
+
+template <typename T>
+size_t typename_length() {
+  // raw_sizeof<T>() - raw_sizeof<void>() == (length of T's name) - strlen("void")
+  // (length of T's name) == raw_sizeof<T>() - raw_sizeof<void>() + strlen("void")
+  return raw_sizeof<T>() - raw_sizeof<void>() + 4;
+}
+
+template <typename T>
+const char* typename_begin() {
+  return raw<T>() + struct_class_prefix<T>() + typename_prefix;
+}
+
+}  // namespace detail
+
+template <typename T>
+std::string nameof() {
+  return {detail::typename_begin<T>(), detail::typename_length<T>()};
+}
+
+}  // namespace util
+}  // namespace arrow

r/src/arrow_cpp11.h

@@ -22,6 +22,8 @@
 #include <vector>
 #undef Free
 
+#include "arrow/util/nameof.h"
+
 namespace cpp11 {
 
 template <typename T>
@@ -157,8 +159,17 @@ struct ns {
 
 template <typename Pointer>
 Pointer r6_to_pointer(SEXP self) {
-  return reinterpret_cast<Pointer>(
-      R_ExternalPtrAddr(Rf_findVarInFrame(self, arrow::r::symbols::xp)));
+  if (!Rf_inherits(self, "ArrowObject")) {
+    std::string type_name =
+        arrow::util::nameof<typename std::remove_pointer<Pointer>::type>();
+    cpp11::stop("Invalid R object for %s, must be an ArrowObject", type_name.c_str());
+  }
+  void* p = R_ExternalPtrAddr(Rf_findVarInFrame(self, arrow::r::symbols::xp));
+  if (p == nullptr) {
+    SEXP klass = Rf_getAttrib(self, R_ClassSymbol);
+    cpp11::stop("Invalid <%s>, external pointer to null", CHAR(STRING_ELT(klass, 0)));
+  }
+  return reinterpret_cast<Pointer>(p);
 }
 
 // T is either std::shared_ptr<U> or std::unique_ptr<U>

r/tests/testthat/test-arrow.R

@@ -47,3 +47,16 @@ r_only({
     )
   })
 })
+
+test_that("arrow gracefully fails to load objects from other sessions (ARROW-10071)", {
+  a <- Array$create(1:10)
+  tf <- tempfile(); on.exit(unlink(tf))
+  saveRDS(a, tf)
+
+  b <- readRDS(tf)
+  expect_error(b$length(), "Invalid <Array>")
+})
+
+test_that("check for an ArrowObject in functions use std::shared_ptr", {
+  expect_error(Array__length(1), "Invalid R object")
+})