[BUG] Server crashes with segfault after "Database Manager Loaded" message (v0.2.35-with-runtimes)

[weirens]

SwiftlyS2 Version

v0.2.35-with-runtimes

Game

Counter-Strike 2

Operating System

Linux

Bug Description

Server crashes with segmentation fault immediately after Database Manager initialization. The crash occurs during .NET runtime initialization before any plugin code executes.

GDB Backtrace:
#0 __strlen_avx2_rtm at sysdeps/x86_64/multiarch/strlen-avx2.S:76
#1 0x00007fffa13176cc in ?? from libhostfxr.so
#2 0x00007fffa1317a02 in hostfxr_initialize_for_runtime_config from libhostfxr.so
#3 0x00007fff638fd781 in InitializeHostFXR at src/core/managed/host/host.cpp:85
#4 0x00007fff6390781b in SwiftlyCore::Load at src/core/entrypoint.cpp:204
#5 0x00007fff638fcdaf in SwiftlyMMBridge::Load at src/core/bridge/metamod.cpp:44

Steps to Reproduce

1. Install swiftlys2-linux-v0.2.35-with-runtimes in csgo/addons/swiftlys2/
2. Start server: ./cs2 -dedicated -maxplayers 10 -console +map de_dust2
3. Server crashes after Database Manager Loaded 2 database credentials

Expected Behavior

Normal operation

Actual Behavior

Swiftly INFO Database Manager Loaded 2 database credentials. Default Connection: host
Segmentation fault core dumped

Logs/Console Output

Plugin Information

Swiftly Version: swiftlys2-linux-v0.2.35-with-runtimes
CS2 Server: Latest via SteamCMD
OS: Ubuntu Server
Metamod: Latest CS2 version

Additional Context

No response

[weirens]

Fix for the Dangling Pointer Issue

I debugged this crash with GDB and identified the root cause: dangling pointer from temporary string objects.

The issue occurs when passing (string_expr + string_expr).c_str() directly to functions. The temporary object is destroyed immediately, leaving an invalid pointer.

Verified Fix

I've fixed and tested the src/core/managed/host/host.cpp file. Server now starts successfully without crashes.

Complete fixed file:

#include "host.h"
#include "dynlib.h"
#include "strconv.h"

#include <string.h>
#include <iostream>

hostfxr_initialize_for_runtime_config_fn _initialize_for_runtime_config = nullptr;
hostfxr_get_runtime_delegate_fn _get_runtime_delegate = nullptr;
hostfxr_close_fn _close = nullptr;
load_assembly_and_get_function_pointer_fn _load_assembly_and_get_function_pointer = nullptr;
hostfxr_set_runtime_property_value_fn _set_runtime_prop_value = nullptr;
hostfxr_handle fxrcxt;

void* GetDotnetPointer(int kind);

typedef int(CORECLR_DELEGATE_CALLTYPE* load_file_fn)(void* context, const char* filePath, int len);
typedef void(CORECLR_DELEGATE_CALLTYPE* remove_file_fn)(void* context);
typedef void(CORECLR_DELEGATE_CALLTYPE* interpret_as_string_fn)(void* object, int type, const char* out, int len);
typedef void* (CORECLR_DELEGATE_CALLTYPE* allocate_pointer_fn)(int size, int count);
typedef uint64_t(CORECLR_DELEGATE_CALLTYPE* get_plugin_memory_fn)(void* context);
typedef void(CORECLR_DELEGATE_CALLTYPE* execute_function_fn)(void* ctx, void* pctx);
typedef void(CORECLR_DELEGATE_CALLTYPE* state_fn)(int state);

load_file_fn loadFile = nullptr;
interpret_as_string_fn interpretAsString = nullptr;
remove_file_fn removeFile = nullptr;
allocate_pointer_fn allocatePointer = nullptr;
get_plugin_memory_fn getMemory = nullptr;
execute_function_fn execFunction = nullptr;
state_fn set_state = nullptr;

void* hostfxr_lib = nullptr;

#ifdef _WIN32
char_t dotnet_path[1024];
#else
char dotnet_path[1024];
#endif

#ifdef _WIN32
std::wstring widenedOriginPath;
#else
std::string widenedOriginPath;
#endif

std::string original_path;

bool InitializeHostFXR(std::string origin_path) {
  original_path = origin_path;

#ifdef _WIN32
  widenedOriginPath = StringWide(origin_path);
#else
  widenedOriginPath = origin_path;
#endif

  // Construct hostfxr library path
#ifdef _WIN32
  std::wstring hostfxr_path = widenedOriginPath + L"bin\\win64\\hostfxr.dll";
#else
  std::string hostfxr_path = widenedOriginPath + "bin/linuxsteamrt64/libhostfxr.so";
#endif

  hostfxr_lib = load_library(hostfxr_path.c_str());
  if (!hostfxr_lib) {
    std::cerr << "[Swiftly] Error: Failed to load hostfxr library from: " << original_path << std::endl;
    return false;
  }

  _initialize_for_runtime_config = (hostfxr_initialize_for_runtime_config_fn)get_export(hostfxr_lib, "hostfxr_initialize_for_runtime_config");
  if (!_initialize_for_runtime_config) return false;

  _get_runtime_delegate = (hostfxr_get_runtime_delegate_fn)get_export(hostfxr_lib, "hostfxr_get_runtime_delegate");
  if (!_get_runtime_delegate) return false;

  _close = (hostfxr_close_fn)get_export(hostfxr_lib, "hostfxr_close");
  if (!_close) return false;

  _set_runtime_prop_value = (hostfxr_set_runtime_property_value_fn)get_export(hostfxr_lib, "hostfxr_set_runtime_property_value");
  if (!_set_runtime_prop_value) return false;

  // Initialize params structure completely
  hostfxr_initialize_parameters params;
  memset(&params, 0, sizeof(params));
  params.size = sizeof(hostfxr_initialize_parameters);

#ifdef _WIN32
  std::wstring dotnet_root_path = widenedOriginPath + L"bin\\managed\\dotnet";
  std::wstring runtime_config_path = widenedOriginPath + L"bin\\managed\\SwiftlyS2.CS2.runtimeconfig.json";
#else
  std::string dotnet_root_path = widenedOriginPath + "bin/managed/dotnet";
  std::string runtime_config_path = widenedOriginPath + "bin/managed/SwiftlyS2.CS2.runtimeconfig.json";
#endif

  // Validate origin path
  if (widenedOriginPath.empty()) {
    std::cerr << "[Swiftly] Error: Origin path is empty!" << std::endl;
    return false;
  }

  // Validate constructed paths
  if (dotnet_root_path.empty() || runtime_config_path.empty()) {
    std::cerr << "[Swiftly] Error: Runtime paths are empty. Origin path: " << original_path << std::endl;
    return false;
  }

  // Clear and copy dotnet root path to buffer with bounds checking
  memset(dotnet_path, 0, sizeof(dotnet_path));
  size_t copy_size = std::min(dotnet_root_path.size(), sizeof(dotnet_path) - 1);
  memcpy(dotnet_path, dotnet_root_path.c_str(), copy_size);

  params.dotnet_root = dotnet_path;

  // Initialize .NET runtime (using local variable to avoid dangling pointer)
  int returnCode = _initialize_for_runtime_config(runtime_config_path.c_str(), &params, &fxrcxt);
  if (returnCode != 0) {
    std::cerr << "[Swiftly] Error: Failed to initialize .NET runtime (code: " << returnCode << ")" << std::endl;
    std::cerr << "[Swiftly] Config path: " << original_path << std::endl;
    _close(fxrcxt);
    return false;
  }

  _set_runtime_prop_value(fxrcxt, WIN_LIN(L"APP_CONTEXT_BASE_DIRECTORY", "APP_CONTEXT_BASE_DIRECTORY"), dotnet_path);

  returnCode = _get_runtime_delegate(fxrcxt, hdt_load_assembly_and_get_function_pointer, (void**)&_load_assembly_and_get_function_pointer);
  if (returnCode != 0 || (void*)_load_assembly_and_get_function_pointer == nullptr) {
    _close(fxrcxt);
    return false;
  }

  return true;
}

bool InitializeDotNetAPI(void* scripting_table, int scripting_table_size) {
  typedef void(CORECLR_DELEGATE_CALLTYPE* custom_loader_fn)(void*, int, const char*);
  static custom_loader_fn custom_loader = nullptr;

  if (custom_loader == nullptr) {
    // Construct DLL path as local variable to avoid dangling pointer
#ifdef _WIN32
    std::wstring dll_path = widenedOriginPath + L"bin\\managed\\SwiftlyS2.CS2.dll";
#else
    std::string dll_path = widenedOriginPath + "bin/managed/SwiftlyS2.CS2.dll";
#endif

    int returnCode = _load_assembly_and_get_function_pointer(
        dll_path.c_str(),
        STR("SwiftlyS2.Entrypoint, SwiftlyS2.CS2"), 
        STR("Start"), 
        UNMANAGEDCALLERSONLY_METHOD, 
        nullptr, 
        (void**)&custom_loader
    );

    if (returnCode != 0 || (void*)custom_loader == nullptr) {
      std::cerr << "[Swiftly] Error: Failed to load .NET assembly (code: " << returnCode << ")" << std::endl;
      return false;
    }

    custom_loader(scripting_table, scripting_table_size, original_path.c_str());
  }

  return true;
}


void CloseHostFXR() {
  if (fxrcxt && _close) _close(fxrcxt);
  unload_library(hostfxr_lib);
}

Key Changes

1. Fixed dangling pointers: Store concatenated strings in local variables before calling .c_str()
2. Added validation: Check for empty paths before use
3. Improved safety: Initialize params structure with memset, fix buffer copy bounds checking
4. Better error messages: Include error codes and paths for debugging

Verification

Tested on Ubuntu Server with CS2 latest. Server starts successfully and runs stably.

[skuzzis]

Understood, will look into it asap