Catcrafts/imsd
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

imsd 0.2.7 — initial public snapshot

Browse source 
Userspace VoLTE/IMS daemon for mainline Linux phones (developed on the
Fairphone 6): a GLib-free core (SIP, SDP, USIM AKA, IPsec SA setup, RTP
media, call engine) behind a GDBus control daemon, a standalone AMR-WB
media leg, and a Plasma Dialer backend. C++26 modules built with Crafter
Build; the tree is clean under the project's house-style linter
(crafter-build lint) across all three build products.

Assisted-by: Claude:claude-fable-5
Signed-off-by: Jorijn van der Graaf <jorijnvdgraaf@catcrafts.net>
This commit is contained in:
Jorijn van der Graaf 2026-07-22 22:53:28 +02:00
commit 6e77823933
31 changed files with 8761 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

164
project.cpp Normal file
View file

@ -0,0 +1,164 @@
// SPDX-License-Identifier: GPL-3.0-only
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
// lint-disable-file no-char-pointer
import std;
import Crafter.Build;
#include "lint-rules.h"
namespace fs = std::filesystem;
using namespace Crafter;
// pkg-config wrapper (std-only: no popen in import std). Returns the flags
// split on whitespace, or empty if pkg-config is unavailable — callers
// provide a fallback for that case.
static std::vector<std::string> PkgConfig(std::string_view args) {
fs::path tmp = fs::temp_directory_path() /
std::format("imsd-pkgconfig-{}.txt", std::hash<std::string_view>{}(args));
std::string cmd = std::format("pkg-config {} > {} 2>/dev/null", args, tmp.string());
std::vector<std::string> flags;
if (std::system(cmd.c_str()) == 0) {
std::ifstream f(tmp);
std::string flag;
while (f >> flag)
flags.push_back(flag);
}
std::error_code ec;
fs::remove(tmp, ec);
return flags;
}
// GDBus (gio-2.0) — bus layer for the two daemons; chosen over sd-bus because
// the platform stack (ModemManager, libqmi for the future direct-AKA port) is
// GLib, so they want a GMainLoop regardless.
static void ApplyGioFlags(Configuration& cfg) {
if (!cfg.sysroot.empty()) {
// cross build (e.g. --target=aarch64-alpine-linux-musl
// --sysroot=<packaging/make-sysroot.sh output>): the host's
// pkg-config would answer for the wrong architecture. glib's
// include layout is stable across distros; the `-I=` form makes
// clang resolve the paths inside the sysroot.
cfg.compileFlags.push_back("-I=/usr/include/glib-2.0");
cfg.compileFlags.push_back("-I=/usr/lib/glib-2.0/include");
for (const char* l : { "-lgio-2.0", "-lgobject-2.0", "-lglib-2.0" })
cfg.linkFlags.push_back(l);
} else {
// native build: ask pkg-config. Only -I/-D flags pass through:
// pkg-config also emits -pthread, which would config-mismatch the
// shared prebuilt std.pcm (and pthread lives in libc on every
// platform we target).
for (std::string& f : PkgConfig("--cflags gio-2.0"))
if (f.starts_with("-I") || f.starts_with("-D")) cfg.compileFlags.push_back(std::move(f));
std::vector<std::string> libs;
for (std::string& f : PkgConfig("--libs gio-2.0"))
if (f.starts_with("-l") || f.starts_with("-L")) libs.push_back(std::move(f));
if (libs.empty()) libs = { "-lgio-2.0", "-lgobject-2.0", "-lglib-2.0" };
for (std::string& f : libs)
cfg.linkFlags.push_back(std::move(f));
}
}
extern "C" Configuration CrafterBuildProject(std::span<const std::string_view> args) {
// Three executables come out of this repo; which one a build produces is
// chosen by `--product=`:
// daemon (default) — imsd, the control-plane daemon (GDBus + engine),
// and the unit tests, which link imsd-core.
// media — imsd-media, the standalone RTP/AMR-WB data plane
// the daemon spawns per call (pure std + POSIX, no
// core, no GLib). Built with `-- --product=media`.
// dialerd — imsd-dialerd, the session-bus Plasma Dialer
// backend (org.kde.telephony.*) bridging to imsd
// (pure GDBus translation, no core).
bool wantMedia = false;
bool wantDialerd = false;
for (std::string_view a : args) {
if (a == "--product=media") wantMedia = true;
if (a == "--product=dialerd") wantDialerd = true;
}
if (wantDialerd) {
Configuration dialerd;
dialerd.path = "./";
dialerd.name = "imsd-dialerd";
dialerd.outputName = "imsd-dialerd";
ApplyStandardArgs(dialerd, args);
dialerd.type = ConfigurationType::Executable;
{
std::array<fs::path, 0> ifaces = {};
std::array<fs::path, 1> impls = { "implementations/dialerd" };
dialerd.GetInterfacesAndImplementations(ifaces, impls);
}
ApplyGioFlags(dialerd);
ProjectLint::AddProjectLintRules(dialerd);
return dialerd;
}
if (wantMedia) {
Configuration media;
media.path = "./";
media.name = "imsd-media";
media.outputName = "imsd-media";
ApplyStandardArgs(media, args);
media.type = ConfigurationType::Executable;
{
std::array<fs::path, 0> ifaces = {};
std::array<fs::path, 1> impls = { "implementations/media" };
media.GetInterfacesAndImplementations(ifaces, impls);
}
media.linkFlags.push_back("-ldl"); // dlopen the AMR-WB codecs
media.linkFlags.push_back("-lpthread"); // std::jthread playout/mic
ProjectLint::AddProjectLintRules(media);
return media;
}
// imsd-core — the engine as a static library of pure C++ modules (SIP,
// SDP, later AKA/IPsec/media/engine). Deliberately GLib-free so every
// piece is unit-testable without a bus or a phone.
static auto Core = std::make_unique<Configuration>();
Core->path = "./";
Core->name = "imsd-core";
Core->outputName = "imsd-core";
ApplyStandardArgs(*Core, args);
Core->type = ConfigurationType::LibraryStatic;
{
std::array<fs::path, 8> ifaces = {
"interfaces/Imsd",
"interfaces/Imsd-Util",
"interfaces/Imsd-Aka",
"interfaces/Imsd-Ipsec",
"interfaces/Imsd-Sip",
"interfaces/Imsd-Sdp",
"interfaces/Imsd-Messages",
"interfaces/Imsd-Engine",
};
std::array<fs::path, 0> impls = {};
Core->GetInterfacesAndImplementations(ifaces, impls);
}
// imsd — the daemon executable: GLib main loop + GDBus service
// (net.catcrafts.IMS1, same ABI as the Python imsd.py) around the core.
Configuration cfg;
cfg.path = "./";
cfg.name = "imsd";
cfg.outputName = "imsd";
ApplyStandardArgs(cfg, args);
cfg.type = ConfigurationType::Executable;
cfg.dependencies = { Core.get() };
{
std::array<fs::path, 0> ifaces = {};
std::array<fs::path, 1> impls = { "implementations/main" };
cfg.GetInterfacesAndImplementations(ifaces, impls);
}
ApplyGioFlags(cfg);
cfg.linkFlags.push_back("-lpthread"); // std::thread engine loop
cfg.AddTest("Util").Dependencies({ Core.get() });
cfg.AddTest("Aka").Dependencies({ Core.get() });
cfg.AddTest("Ipsec").Dependencies({ Core.get() });
cfg.AddTest("Messages").Dependencies({ Core.get() });
cfg.AddTest("Engine").Dependencies({ Core.get() });
cfg.AddTest("Sip").Dependencies({ Core.get() });
cfg.AddTest("Sdp").Dependencies({ Core.get() });
ProjectLint::AddProjectLintRules(cfg);
return cfg;
}