[lldb] Fix Scripted ProcessLaunchInfo Argument nullptr deref

[mib]

Summary

This patch adds a new StructuredData::Dictionary constructor that
takes a StructuredData::ObjectSP as an argument. This is used to pass
the opaque_ptr from the SBStructuredData used to initialize a
ScriptedProcess, to the ProcessLaunchInfo class.

This also updates SBLaunchInfo::SetScriptedProcessDictionary to
reflect the for-mentioned changes which solves the nullptr dereference.

[JDevlieghere]

This LGTM but it would be nice if the commit message could be a bit more specific about the motivation and explain the relationship between an ObjectSP and DictionarySP.

[mib]

Address @JDevlieghere comments from D112109

[JDevlieghere]

Thanks. This LGTM!

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

36

A shared pointer is default constructed with a nullptr so you can omit that here.

lldb/include/lldb/Core/StructuredDataImpl.h

size_t GetStringValue(char *dst, size_t dst_len) const {
 
     if (!dst || !dst_len) {
       char s[1];
       return (::snprintf(s, 1, "%s", result.data()));
     }
     return (::snprintf(dst, dst_len, "%s", result.data()));
   }
 
+  StructuredData::ObjectSP GetObjectSP() const { return m_data_sp; }
+
 private:
   lldb::StructuredDataPluginWP m_plugin_wp;
   StructuredData::ObjectSP m_data_sp;
 };
 } // namespace lldb_private
 #endif

lldb/include/lldb/Utility/StructuredData.h

public:
   protected:
     std::string m_value;
   };
 
   class Dictionary : public Object {
   public:
     Dictionary() : Object(lldb::eStructuredDataTypeDictionary), m_dict() {}
 
+    Dictionary(ObjectSP obj_sp)
+        : Object(lldb::eStructuredDataTypeDictionary), m_dict() {
+      if (!obj_sp || obj_sp->GetType() != lldb::eStructuredDataTypeDictionary) {
+        SetType(lldb::eStructuredDataTypeInvalid);
+        return;
+      }
+
+      Dictionary *dict = obj_sp->GetAsDictionary();
+      m_dict = dict->m_dict;
+    }
+
     ~Dictionary() override = default;
 
     size_t GetSize() const { return m_dict.size(); }
 
     void ForEach(std::function<bool(ConstString key, Object *object)> const
                      &callback) const {
       for (const auto &pair : m_dict) {
         if (!callback(pair.first, pair.second.get()))

lldb/source/API/SBLaunchInfo.cpp

lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
   data.m_impl_up->SetObjectSP(dict_sp);
 
   return LLDB_RECORD_RESULT(data);
 }
 
 void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) {
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary,
                      (lldb::SBStructuredData), dict);
+  if (!dict.IsValid() || !dict.m_impl_up)
+    return;
 
-  SBStream stream;
-  SBError error = dict.GetAsJSON(stream);
+  StructuredData::ObjectSP obj_sp = dict.m_impl_up->GetObjectSP();
 
-  if (error.Fail())
+  if (!obj_sp)
     return;
 
-  StructuredData::DictionarySP dict_sp;
-  llvm::json::OStream s(stream.ref().AsRawOstream());
-  dict_sp->Serialize(s);
+  StructuredData::DictionarySP dict_sp =
+      std::make_shared<StructuredData::Dictionary>(obj_sp);
+  if (!dict_sp || dict_sp->GetType() == lldb::eStructuredDataTypeInvalid)
+    return;
 
   m_opaque_sp->SetScriptedProcessDictionarySP(dict_sp);
 }
 
 namespace lldb_private {
 namespace repro {
 
 template <>

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

 namespace lldb_private {
 
 class ScriptedProcess : public Process {
 protected:
   class ScriptedProcessInfo {
   public:
     ScriptedProcessInfo(const ProcessLaunchInfo &launch_info) {
       m_class_name = launch_info.GetScriptedProcessClassName();
-      m_dictionary_sp = launch_info.GetScriptedProcessDictionarySP();
+      m_args_sp = launch_info.GetScriptedProcessDictionarySP();
     }
 
     std::string GetClassName() const { return m_class_name; }
-    StructuredData::DictionarySP GetDictionarySP() const {
-      return m_dictionary_sp;
-    }
+    StructuredData::DictionarySP GetArgsSP() const { return m_args_sp; }
 
   private:
     std::string m_class_name;
-    StructuredData::DictionarySP m_dictionary_sp;
+    StructuredData::DictionarySP m_args_sp;
   };
 
 public:
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
                                         const FileSpec *crash_file_path,
                                         bool can_connect);
 

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    "Debugger has no Script Interpreter");
     return;
   }
 
   ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
 
   StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
       m_scripted_process_info.GetClassName().c_str(), exe_ctx,
-      m_scripted_process_info.GetDictionarySP());
+      m_scripted_process_info.GetArgsSP());
 
   if (!object_sp || !object_sp->IsValid()) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Failed to create valid script object");
     return;
   }
 

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

if (!class_name || class_name->empty()) {
     return;
   }
 
   ExecutionContext exe_ctx(process);
 
   StructuredData::GenericSP object_sp =
       scripted_thread_interface->CreatePluginObject(
           class_name->c_str(), exe_ctx,
-          process.m_scripted_process_info.GetDictionarySP());
+          process.m_scripted_process_info.GetArgsSP());
   if (!object_sp || !object_sp->IsValid()) {
     error.SetErrorString("Failed to create valid script object");
     return;
   }
 
   m_script_object_sp = object_sp;
 
   SetID(scripted_thread_interface->GetThreadID());