Jorijn van der Graaf
142adf057c
After bring-up the daemon recovered a dead protected flow by reconnecting through the existing SA and refreshing, on a 5 s → 5 min backoff, forever. That was the whole recovery: a refresh the network refused, or a P-CSCF that stopped answering, kept it in that loop on the same Call-ID and SA until someone restarted the service. O2 UK, 2026-09-24: the 30-minute refresh answered 503, 21 refusals over 70 min; after a manual restart the new registration's flow died 8 s in and no connect over its SA succeeded for 2 h 39 min; a second restart registered within two seconds (13:27:55 → 13:27:57 in the journal; ims ledger F16). Do in place the rest of what a restart does: when the refresh keeps being refused, or reconnect cycles keep ending without an answer unless the modem reports no packet service, register fresh. The fresh registration is the expensive step, so a failed one waits before the next: on a schedule (21 min, growing to 60) after a refusal or a throttle, on a backoff after silence, and a Retry-After from the network is honoured up to an hour. What the network set — a Retry-After, the schedule after a refused or throttled attempt — is kept across a restart in /run/imsd.holds, for the address it was set on. A refused initial registration at bring-up — a final from 300 up to the unprotected REGISTER (its 401 is the challenge), any final but 200 to the protected one, a second 401 (rejected credentials) included — now waits on the same schedule instead of exiting for a systemd restart every two minutes. The policy is a pure reducer in Imsd:Engine (RegRecovery), shaped like the call machine: the daemon supplies the clock and the network, the reducer holds the deadlines and names the next step, and tests/Engine pin it. tests/Engine now exits 0 or 1 instead of its failure count: with more than 255 checks a count of 256 would exit 0, and crafter-build reads 77 as a skipped suite. The bring-up's deferral is logged in the policy's form: `bring-up deferred: <why> — attempt N, next fresh registration in M min` becomes `bring-up deferred: <why>; next: fresh registration in M min`. A bring-up writes the verdict that the old registration is gone as well: a start that goes on to register fresh — its resume failed, or there was nothing to resume over — records it before the attempt, and when the attempt then fails without an answer the daemon exits with the file in place. The next start on the same address and boot does not resume, where 0.3.9 retried the resume: it registers fresh at once. On KPN, with the old registration in fact still live — a start during an outage, staged on the dev phone — that attempt was throttled, and the 21-min schedule began. A bring-up does not retry its resume through an outage the way recovery reconnects. Tested on the dev phone (KPN) in builds of this series; not every path has run there.
2139 lines
103 KiB
C++
2139 lines
103 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
// lint-disable-file fixed-width-types no-char-pointer
|
|
/*
|
|
imsd — the userspace IMS/VoLTE daemon (control plane).
|
|
|
|
Owns net.catcrafts.IMS1 on the system bus with the project's frozen D-Bus ABI
|
|
(README) and drives it with the engine core: register on the IMS PDN (USIM AKA
|
|
+ IPsec sec-agree, fresh or warm-resume, with a keepalive re-REGISTER refresh),
|
|
run outgoing and incoming calls through the Imsd:Engine call machine (inbound
|
|
INVITEs on the protected-port listeners become ringing calls a dialer answers
|
|
via Accept), and spawn one imsd-media data-plane process per answered call.
|
|
GLib/GDBus lives only here; every message, digest, SA command, and call-state
|
|
decision comes from the GLib-free core.
|
|
|
|
Threads: a dedicated engine thread runs the SIP loop (blocking framed recv,
|
|
protected-port listeners, media reaping, keepalive); the GLib main loop owns
|
|
the bus. D-Bus method calls push commands to the engine queue; engine events
|
|
reach the bus via g_idle_add, where the calls table + status snapshot live
|
|
(touched only on the main thread).
|
|
|
|
--session own the name on the session bus (development; no policy needed)
|
|
*/
|
|
|
|
#include <arpa/inet.h>
|
|
#include <fcntl.h>
|
|
#include <gio/gio.h>
|
|
#include <glib-unix.h>
|
|
#include <netinet/in.h>
|
|
#include <poll.h>
|
|
#include <pthread.h>
|
|
#include <signal.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/wait.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
import std;
|
|
import Imsd;
|
|
|
|
namespace {
|
|
|
|
// ---- static config (env-overridable, same knobs as imsd.py) ---------------
|
|
constexpr const char* Version = "0.3.9";
|
|
constexpr const char* BusName = "net.catcrafts.IMS1";
|
|
constexpr const char* ObjPath = "/net/catcrafts/IMS1";
|
|
constexpr const char* Iface = "net.catcrafts.IMS1";
|
|
constexpr int PortUc = imsd::util::PortUc;
|
|
constexpr int PortUs = imsd::util::PortUs;
|
|
constexpr int InitPort = 5060;
|
|
|
|
std::string EnvOr(const char* k, std::string d) {
|
|
const char* v = std::getenv(k);
|
|
return v ? std::string(v) : std::move(d);
|
|
}
|
|
|
|
std::string SelfDir; // dir of argv[0], for locating imsd-media
|
|
|
|
void Log(std::string_view m) { std::println("imsd: {}", m); std::fflush(stdout); }
|
|
|
|
bool Is6(std::string_view a) { return a.contains(':'); }
|
|
|
|
// ---- subprocess exec ------------------------------------------------------
|
|
|
|
struct ProcResult { int rc = -1; std::string out; };
|
|
|
|
// Run argv, capture stdout (stderr discarded), wait. No shell.
|
|
ProcResult RunCapture(const std::vector<std::string>& argv) {
|
|
int pipefd[2];
|
|
if (pipe(pipefd) != 0) return {};
|
|
pid_t pid = fork();
|
|
if (pid == 0) {
|
|
dup2(pipefd[1], STDOUT_FILENO);
|
|
close(pipefd[0]); close(pipefd[1]);
|
|
int dn = open("/dev/null", O_WRONLY);
|
|
if (dn >= 0) { dup2(dn, STDERR_FILENO); close(dn); }
|
|
std::vector<char*> c;
|
|
for (auto& s : argv) c.push_back(const_cast<char*>(s.c_str()));
|
|
c.push_back(nullptr);
|
|
execvp(c[0], c.data());
|
|
_exit(127);
|
|
}
|
|
if (pid < 0) { close(pipefd[0]); close(pipefd[1]); return {}; }
|
|
close(pipefd[1]);
|
|
std::string out;
|
|
char buf[4096];
|
|
ssize_t n;
|
|
while ((n = read(pipefd[0], buf, sizeof buf)) > 0)
|
|
out.append(buf, static_cast<std::size_t>(n));
|
|
close(pipefd[0]);
|
|
int status = 0;
|
|
waitpid(pid, &status, 0);
|
|
return {WIFEXITED(status) ? WEXITSTATUS(status) : -1, std::move(out)};
|
|
}
|
|
|
|
// Run argv, discard output, return exit code.
|
|
int RunCmd(const std::vector<std::string>& argv) { return RunCapture(argv).rc; }
|
|
|
|
// argv as one journal line with key material (the "0x…" tokens) masked.
|
|
std::string RedactKeys(const std::vector<std::string>& argv) {
|
|
std::string s;
|
|
for (const auto& a : argv) {
|
|
if (!s.empty()) s += ' ';
|
|
s += a.starts_with("0x") ? "<key>" : a;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
// ---- small text extractors (401 header params, qmicli "completed:") -------
|
|
|
|
std::optional<std::string> QuotedAfter(std::string_view text, std::string_view key) {
|
|
std::size_t at = text.find(key);
|
|
if (at == std::string_view::npos) return std::nullopt;
|
|
std::size_t start = at + key.size();
|
|
std::size_t end = text.find('"', start);
|
|
if (end == std::string_view::npos) return std::nullopt;
|
|
return std::string(text.substr(start, end - start));
|
|
}
|
|
|
|
std::optional<long> IntAfter(std::string_view text, std::string_view key) {
|
|
std::size_t at = text.find(key);
|
|
if (at == std::string_view::npos) return std::nullopt;
|
|
std::size_t i = at + key.size();
|
|
std::size_t start = i;
|
|
while (i < text.size() && text[i] >= '0' && text[i] <= '9') i++;
|
|
if (i == start) return std::nullopt;
|
|
long v = 0;
|
|
std::from_chars(text.data() + start, text.data() + i, v);
|
|
return v;
|
|
}
|
|
|
|
// value after "completed:" — integer or the hex ("AB:CD:..") token
|
|
std::optional<long> CompletedInt(std::string_view out) {
|
|
return IntAfter(out, "completed: ");
|
|
}
|
|
std::optional<std::string> CompletedHex(std::string_view out) {
|
|
std::size_t at = out.find("completed:");
|
|
if (at == std::string_view::npos) return std::nullopt;
|
|
std::size_t i = at + 10;
|
|
while (i < out.size() && (out[i] == ' ' || out[i] == '\t')) i++;
|
|
std::size_t start = i;
|
|
auto ok = [](char c) {
|
|
return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') ||
|
|
(c >= 'a' && c <= 'f') || c == ':';
|
|
};
|
|
while (i < out.size() && ok(out[i])) i++;
|
|
if (i == start) return std::nullopt;
|
|
std::string s(out.substr(start, i - start));
|
|
std::string h;
|
|
for (char c : s) if (c != ':') h.push_back(static_cast<char>(std::tolower(c)));
|
|
return h;
|
|
}
|
|
|
|
// global IPv6 on the ims PDN, from `ip -6 addr show dev <dev> scope global`.
|
|
std::optional<std::string> DetectLocal(const std::string& dev) {
|
|
auto r = RunCapture({"ip", "-6", "addr", "show", "dev", dev, "scope", "global"});
|
|
std::size_t at = r.out.find("inet6 ");
|
|
if (at == std::string_view::npos) return std::nullopt;
|
|
std::size_t start = at + 6;
|
|
std::size_t end = r.out.find('/', start);
|
|
if (end == std::string_view::npos) return std::nullopt;
|
|
return r.out.substr(start, end - start);
|
|
}
|
|
|
|
// ---- sockaddr helper ------------------------------------------------------
|
|
socklen_t MakeAddr(std::string_view ip, int port, sockaddr_storage& ss) {
|
|
std::memset(&ss, 0, sizeof ss);
|
|
std::string s(ip);
|
|
if (Is6(ip)) {
|
|
auto* a = reinterpret_cast<sockaddr_in6*>(&ss);
|
|
a->sin6_family = AF_INET6; a->sin6_port = htons(static_cast<uint16_t>(port));
|
|
inet_pton(AF_INET6, s.c_str(), &a->sin6_addr);
|
|
return sizeof(sockaddr_in6);
|
|
}
|
|
auto* a = reinterpret_cast<sockaddr_in*>(&ss);
|
|
a->sin_family = AF_INET; a->sin_port = htons(static_cast<uint16_t>(port));
|
|
inet_pton(AF_INET, s.c_str(), &a->sin_addr);
|
|
return sizeof(sockaddr_in);
|
|
}
|
|
|
|
// ---- SIP over the protected TCP flow --------------------------------------
|
|
enum class Transport { Tcp, Udp };
|
|
constexpr std::string_view TransportName(Transport t) { return t == Transport::Udp ? "UDP" : "TCP"; }
|
|
|
|
// The protected client flow: our requests to the P-CSCF's protected server
|
|
// port and their responses. TCP is the shape every carrier that works so far
|
|
// serves; UDP is the alternative for a P-CSCF that never answers the TCP
|
|
// connect (O2 UK, 2026-09-17). Both run through the same SA pair — the xfrm
|
|
// policies select on ports only — and the same Via port.
|
|
// A P-CSCF refusing a fresh security association (KPN: Security-Server
|
|
// spi-s=0 to a fresh REGISTER on an address whose registration is still
|
|
// live). Handled in-process: a
|
|
// systemd restart every RestartSec would never clear it.
|
|
struct ThrottledError : std::runtime_error { using std::runtime_error::runtime_error; };
|
|
// A REGISTER the network refused: the protected one, or a refresh, answered
|
|
// with a final other than 200 (a refresh's first 401 is its challenge); the
|
|
// unprotected initial one answered with a final from 300 up (its 401 is the
|
|
// challenge). The status and its Retry-After feed imsd::engine::RegRecovery.
|
|
struct RefusedError : std::runtime_error {
|
|
int status;
|
|
long retryAfter;
|
|
RefusedError(const std::string& what, int st, long ra) : std::runtime_error(what), status(st), retryAfter(ra) {}
|
|
};
|
|
// Bytes of SIP that fit one ESP-protected IPv6 packet at the ims PDN's
|
|
// 1280-byte MTU (40 IPv6 + 8 ESP + 16 IV + 8 UDP + padding + 12 ICV).
|
|
constexpr std::size_t UdpSinglePacketBudget = 1190;
|
|
|
|
class SipFlow {
|
|
public:
|
|
// TCP: connect up to `tries` times (12-s timeout each, 10 s apart). An
|
|
// attempt the network never answers counts towards `silentLimit` (0 =
|
|
// unlimited); an attempt refused locally — connect() itself failing:
|
|
// EADDRNOTAVAIL (the 4-tuple still in TIME_WAIT from the previous flow),
|
|
// ENETUNREACH (no route yet) — does not, so a restart within 60 s of the
|
|
// last one keeps retrying instead of concluding the P-CSCF is silent. UDP: bind the same client port and connect() the
|
|
// datagram socket to the same peer — the kernel then delivers that peer's
|
|
// datagrams here in preference to the unconnected ServerPorts socket on
|
|
// the same port. A UDP connect() cannot be refused by the peer, so it is
|
|
// one attempt.
|
|
bool Connect(const std::string& local, int lport, const std::string& pcscf, int pport, Transport t, int tries = 10, int silentLimit = 0) {
|
|
transport_ = t;
|
|
lastConnectLocal_ = false;
|
|
int fam = Is6(local) ? AF_INET6 : AF_INET;
|
|
if (t == Transport::Udp) {
|
|
int fd = socket(fam, SOCK_DGRAM, 0);
|
|
if (fd < 0) return SocketFailed();
|
|
int one = 1;
|
|
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
|
|
setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof one);
|
|
sockaddr_storage la; socklen_t ll = MakeAddr(local, lport, la);
|
|
if (!Bind(fd, la, ll, local, lport)) return false;
|
|
sockaddr_storage pa; socklen_t pl = MakeAddr(pcscf, pport, pa);
|
|
if (connect(fd, reinterpret_cast<sockaddr*>(&pa), pl) != 0) {
|
|
// a UDP connect() cannot be refused by the peer: no route
|
|
// yet, and the like — local, like the TCP path's ENETUNREACH
|
|
Log(std::format("UDP connect: {}", std::strerror(errno)));
|
|
close(fd); lastConnectLocal_ = true; return false;
|
|
}
|
|
fd_ = fd; alive_ = true; fb_ = {}; sizeWarned_ = false;
|
|
return true;
|
|
}
|
|
int silent = 0;
|
|
for (int attempt = 0; attempt < tries; attempt++) {
|
|
int fd = socket(fam, SOCK_STREAM, 0);
|
|
if (fd < 0) return SocketFailed();
|
|
int one = 1;
|
|
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
|
|
// REUSEPORT (paired with the listener's): a reconnect must bind
|
|
// the protected client port while the ServerPorts listener holds
|
|
// it in LISTEN state — REUSEADDR alone only covers TIME_WAIT.
|
|
setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof one);
|
|
sockaddr_storage la; socklen_t ll = MakeAddr(local, lport, la);
|
|
if (!Bind(fd, la, ll, local, lport)) return false;
|
|
sockaddr_storage pa; socklen_t pl = MakeAddr(pcscf, pport, pa);
|
|
// non-blocking connect + poll: Linux connect() ignores SO_SNDTIMEO,
|
|
// so bound it ourselves (a silent P-CSCF must not hang the engine).
|
|
fcntl(fd, F_SETFL, O_NONBLOCK);
|
|
int rc = connect(fd, reinterpret_cast<sockaddr*>(&pa), pl);
|
|
bool connected = (rc == 0);
|
|
bool localRefusal = (rc < 0 && errno != EINPROGRESS);
|
|
int err = localRefusal ? errno : 0;
|
|
if (rc < 0 && errno == EINPROGRESS) {
|
|
pollfd p{fd, POLLOUT, 0};
|
|
if (poll(&p, 1, 12000) > 0) {
|
|
socklen_t el = sizeof err;
|
|
getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &el);
|
|
connected = (err == 0);
|
|
} else err = ETIMEDOUT;
|
|
}
|
|
if (connected) {
|
|
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_NONBLOCK);
|
|
fd_ = fd; alive_ = true; fb_ = {}; sizeWarned_ = false;
|
|
return true;
|
|
}
|
|
close(fd);
|
|
lastConnectLocal_ = localRefusal;
|
|
if (!localRefusal) silent++;
|
|
// An answer (RST → ECONNREFUSED, ICMP → EHOSTUNREACH/ENETUNREACH)
|
|
// counts towards the silent limit like a timeout: either way the
|
|
// P-CSCF does not serve TCP on that port. The log says which.
|
|
const char* why = err == ETIMEDOUT ? "no answer" : (err == EADDRNOTAVAIL ? "TIME_WAIT?" : std::strerror(err));
|
|
if (attempt == tries - 1) {
|
|
Log(std::format("connect failed ({}) [{}/{}]", why, attempt + 1, tries));
|
|
return false;
|
|
}
|
|
if (silentLimit > 0 && silent >= silentLimit) {
|
|
Log(std::format("connect: no answer from the P-CSCF {} times ({})", silent, why));
|
|
return false;
|
|
}
|
|
Log(std::format("connect failed; retry in 10s ({}) [{}/{}]", why, attempt + 1, tries));
|
|
sleep(10);
|
|
}
|
|
return false;
|
|
}
|
|
// socket() failing is ours, not the network's: logged, and a local
|
|
// refusal like a connect() the kernel turns down.
|
|
bool SocketFailed() {
|
|
Log(std::format("connect failed: socket: {}", std::strerror(errno)));
|
|
lastConnectLocal_ = true;
|
|
return false;
|
|
}
|
|
// A bind the kernel refuses (the address is not on the link:
|
|
// EADDRNOTAVAIL) is logged and counts like the network's silence — it is
|
|
// not a transient refusal to retry every 5 s. Closes fd on failure.
|
|
bool Bind(int fd, const sockaddr_storage& la, socklen_t ll, const std::string& local, int lport) {
|
|
if (bind(fd, reinterpret_cast<const sockaddr*>(&la), ll) == 0) return true;
|
|
int err = errno;
|
|
close(fd);
|
|
lastConnectLocal_ = false;
|
|
Log(std::format("connect failed: cannot bind {} ({})", imsd::util::HostPort(local, lport), std::strerror(err)));
|
|
return false;
|
|
}
|
|
// Whether the last failed Connect() ended on a local refusal (our own
|
|
// 4-tuple still in TIME_WAIT, no route yet) rather than on the network's
|
|
// silence or answer — the recovery policy counts only the latter.
|
|
bool LastConnectLocal() const { return lastConnectLocal_; }
|
|
// MSG_NOSIGNAL: a flow the network killed (CSFB excursion, P-CSCF idle
|
|
// drop) must surface as a send error, not a SIGPIPE.
|
|
bool Send(std::string_view msg) {
|
|
if (transport_ == Transport::Udp && msg.size() > UdpSinglePacketBudget && !sizeWarned_) {
|
|
sizeWarned_ = true;
|
|
Log(std::format("UDP: {} bytes of SIP exceed the single-packet ESP budget (~{}) at MTU 1280; the kernel sends it as IPv6 fragments — a P-CSCF that cannot reassemble ESP fragments drops it silently", msg.size(), UdpSinglePacketBudget));
|
|
}
|
|
std::size_t off = 0;
|
|
while (off < msg.size()) {
|
|
ssize_t w = send(fd_, msg.data() + off, msg.size() - off, MSG_NOSIGNAL);
|
|
if (w <= 0) { alive_ = false; return false; }
|
|
off += static_cast<std::size_t>(w);
|
|
}
|
|
return true;
|
|
}
|
|
void SendKeepalive() {
|
|
if (transport_ == Transport::Udp) return; // RFC 5626 4.4.1: CRLF keepalives are for connection-oriented transports
|
|
if (send(fd_, "\r\n\r\n", 4, MSG_NOSIGNAL) <= 0) alive_ = false;
|
|
}
|
|
|
|
std::optional<std::string> RecvMsg(double timeoutSec) {
|
|
auto deadline = std::chrono::steady_clock::now() +
|
|
std::chrono::duration_cast<std::chrono::steady_clock::duration>(std::chrono::duration<double>(timeoutSec));
|
|
for (;;) {
|
|
if (auto m = fb_.TryExtract()) return m;
|
|
auto now = std::chrono::steady_clock::now();
|
|
if (now >= deadline) return std::nullopt;
|
|
int ms = static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(deadline - now).count());
|
|
pollfd p{fd_, POLLIN, 0};
|
|
int r = poll(&p, 1, ms);
|
|
if (r <= 0) { if (r == 0) return std::nullopt; if (errno == EINTR) continue; return std::nullopt; }
|
|
char buf[65535];
|
|
ssize_t n = recv(fd_, buf, sizeof buf, 0);
|
|
if (transport_ == Transport::Udp) {
|
|
// One datagram = one message (RFC 3261 18.3): never accumulated
|
|
// across datagrams. An empty datagram is not EOF. A recv error
|
|
// is the kernel relaying an ICMP for the inner (decrypted) UDP
|
|
// — port unreachable → ECONNREFUSED, prohibited/policy → EACCES
|
|
// — i.e. the peer answering "no"; an ICMP quoting the ESP
|
|
// packet itself never reaches us (esp6_err ignores all but
|
|
// PKT_TOOBIG), so UDP has no dead-flow signal beyond these and
|
|
// the refresh timeouts.
|
|
if (n < 0) {
|
|
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) continue;
|
|
Log(std::format("UDP flow: recv error: {}", std::strerror(errno)));
|
|
alive_ = false; return std::nullopt;
|
|
}
|
|
if (n == 0) continue;
|
|
std::string why;
|
|
if (auto m = imsd::sip::DatagramMessage(std::string_view(buf, static_cast<std::size_t>(n)), &why)) return m;
|
|
if (!why.empty()) Log(std::format("UDP: {} — ignored", why));
|
|
continue;
|
|
}
|
|
// EOF/RST is not a timeout: mark the flow dead so the engine's
|
|
// reconnect path notices within one loop turn instead of at the
|
|
// next (possibly 30-min-away) keepalive refresh.
|
|
if (n <= 0) { alive_ = false; return std::nullopt; }
|
|
fb_.Append(std::string_view(buf, static_cast<std::size_t>(n)));
|
|
}
|
|
}
|
|
int Fd() const { return fd_; }
|
|
bool Alive() const { return fd_ >= 0 && alive_; }
|
|
Transport CurrentTransport() const { return transport_; }
|
|
// What was read and not yet dispatched goes with the flow: nothing
|
|
// read from it can be answered once it is closed.
|
|
void Close() { if (fd_ >= 0) { close(fd_); fd_ = -1; } alive_ = false; fb_ = {}; }
|
|
private:
|
|
int fd_ = -1;
|
|
bool alive_ = false;
|
|
bool lastConnectLocal_ = false;
|
|
Transport transport_ = Transport::Tcp;
|
|
bool sizeWarned_ = false;
|
|
imsd::sip::FrameBuffer fb_;
|
|
};
|
|
|
|
// ---- protected-port listeners (terminating requests: remote BYE/UPDATE) ---
|
|
struct Inbound {
|
|
std::string msg;
|
|
std::function<void(const std::string&)> reply;
|
|
};
|
|
|
|
class ServerPorts {
|
|
public:
|
|
void Open(const std::string& local) {
|
|
int fam = Is6(local) ? AF_INET6 : AF_INET;
|
|
for (int port : {PortUc, PortUs}) {
|
|
int ls = socket(fam, SOCK_STREAM, 0);
|
|
if (ls >= 0) {
|
|
int one = 1;
|
|
setsockopt(ls, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
|
|
// paired with SipFlow::Connect's REUSEPORT (reconnect binds
|
|
// the client port while this listener holds it)
|
|
setsockopt(ls, SOL_SOCKET, SO_REUSEPORT, &one, sizeof one);
|
|
sockaddr_storage a; socklen_t l = MakeAddr(local, port, a);
|
|
if (bind(ls, reinterpret_cast<sockaddr*>(&a), l) == 0 && listen(ls, 4) == 0) {
|
|
fcntl(ls, F_SETFL, O_NONBLOCK);
|
|
listeners_.push_back(ls);
|
|
} else { close(ls); }
|
|
}
|
|
int us = socket(fam, SOCK_DGRAM, 0);
|
|
if (us >= 0) {
|
|
int one = 1;
|
|
setsockopt(us, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
|
|
sockaddr_storage a; socklen_t l = MakeAddr(local, port, a);
|
|
if (bind(us, reinterpret_cast<sockaddr*>(&a), l) == 0) {
|
|
fcntl(us, F_SETFL, O_NONBLOCK);
|
|
udp_.push_back(us);
|
|
if (port == PortUc) udpUc_ = us;
|
|
} else { close(us); }
|
|
}
|
|
Log(std::format("listening on protected port {} (TCP+UDP)", port));
|
|
}
|
|
}
|
|
|
|
std::vector<Inbound> Poll() {
|
|
std::vector<Inbound> out;
|
|
for (int ls : listeners_) {
|
|
for (;;) {
|
|
int c = accept(ls, nullptr, nullptr);
|
|
if (c < 0) break;
|
|
fcntl(c, F_SETFL, O_NONBLOCK);
|
|
conns_.push_back({c, {}});
|
|
}
|
|
}
|
|
for (int us : udp_) {
|
|
for (;;) {
|
|
char buf[65535];
|
|
sockaddr_storage src; socklen_t sl = sizeof src;
|
|
ssize_t n = recvfrom(us, buf, sizeof buf, 0, reinterpret_cast<sockaddr*>(&src), &sl);
|
|
if (n <= 0) break;
|
|
std::string_view sv(buf, static_cast<std::size_t>(n));
|
|
bool blank = sv.find_first_not_of("\r\n \t") == std::string_view::npos;
|
|
if (blank) continue;
|
|
std::string msg(sv);
|
|
if (imsd::sip::Status(msg).has_value()) {
|
|
// A response here means the P-CSCF answered to the Via port
|
|
// instead of the source port of our request (rport) — it
|
|
// never reaches the client flow. Say so.
|
|
int sp = src.ss_family == AF_INET6 ? ntohs(reinterpret_cast<sockaddr_in6*>(&src)->sin6_port) : ntohs(reinterpret_cast<sockaddr_in*>(&src)->sin_port);
|
|
Log(std::format("UDP response on server socket {} from port {} ignored: {}", us == udpUc_ ? PortUc : PortUs, sp, sv.substr(0, sv.find("\r\n"))));
|
|
continue;
|
|
}
|
|
if (!imsd::sip::Status(msg).has_value()) { // request only
|
|
sockaddr_storage s = src; socklen_t sll = sl;
|
|
int rs = us;
|
|
// RFC 3261 18.2.2: rport-less UDP requests get their
|
|
// response at the Via sent-by port, not the source
|
|
// port. KPN's P-CSCF sends in-dialog requests from its
|
|
// protected client port but silently drops responses
|
|
// sent back there (s57: every UPDATE/BYE 200 ignored,
|
|
// audit kills the call); the Via port is its protected
|
|
// server port, whose SA pairs with OUR client-port
|
|
// socket — respond from that one so the uc->ps SA
|
|
// carries it.
|
|
if (auto vp = imsd::sip::ViaResponsePort(msg)) {
|
|
if (s.ss_family == AF_INET6)
|
|
reinterpret_cast<sockaddr_in6*>(&s)->sin6_port =
|
|
htons(static_cast<uint16_t>(*vp));
|
|
else
|
|
reinterpret_cast<sockaddr_in*>(&s)->sin_port =
|
|
htons(static_cast<uint16_t>(*vp));
|
|
if (udpUc_ >= 0) rs = udpUc_;
|
|
}
|
|
out.push_back({std::move(msg), [rs, s, sll](const std::string& r) mutable {
|
|
sendto(rs, r.data(), r.size(), 0, reinterpret_cast<sockaddr*>(&s), sll);
|
|
}});
|
|
}
|
|
}
|
|
}
|
|
for (auto it = conns_.begin(); it != conns_.end();) {
|
|
bool eof = false;
|
|
for (;;) {
|
|
char buf[65535];
|
|
ssize_t n = recv(it->fd, buf, sizeof buf, 0);
|
|
if (n == 0) { eof = true; break; }
|
|
if (n < 0) break;
|
|
it->fb.Append(std::string_view(buf, static_cast<std::size_t>(n)));
|
|
}
|
|
while (auto m = it->fb.TryExtract()) {
|
|
if (!imsd::sip::Status(*m).has_value()) {
|
|
int fd = it->fd;
|
|
out.push_back({*m, [fd](const std::string& r) {
|
|
(void)!write(fd, r.data(), r.size());
|
|
}});
|
|
}
|
|
}
|
|
if (eof) { close(it->fd); it = conns_.erase(it); } else { ++it; }
|
|
}
|
|
return out;
|
|
}
|
|
|
|
void CloseAll() {
|
|
for (int f : listeners_) close(f);
|
|
for (int f : udp_) close(f);
|
|
for (auto& c : conns_) close(c.fd);
|
|
listeners_.clear(); udp_.clear(); conns_.clear();
|
|
}
|
|
private:
|
|
struct Conn { int fd; imsd::sip::FrameBuffer fb; };
|
|
int udpUc_ = -1;
|
|
std::vector<int> listeners_, udp_;
|
|
std::vector<Conn> conns_;
|
|
};
|
|
|
|
// ---- registration state ---------------------------------------------------
|
|
struct RegState {
|
|
std::string callid, ftag;
|
|
long cseq = 2;
|
|
std::uint32_t spiUc = 0;
|
|
std::uint32_t spiUs = 0;
|
|
long expiry = 0;
|
|
int slot = 0;
|
|
std::string aid;
|
|
// Contact user-part of the stored binding (UUID since the s53 oracle
|
|
// diff; empty = legacy IMSI binding from an older state file).
|
|
std::string contactUser;
|
|
};
|
|
|
|
// Writable directory for the daemon's own files: the persisted registration
|
|
// context, media stats, and optional debug dumps. Root daemon (the packaged
|
|
// service): /var/lib/imsd; --session/dev runs: the XDG state dir.
|
|
std::string StateDir() {
|
|
if (geteuid() == 0) return "/var/lib/imsd";
|
|
if (const char* x = std::getenv("XDG_STATE_HOME")) return std::format("{}/imsd", std::string(x));
|
|
return std::format("{}/.local/state/imsd", EnvOr("HOME", "/tmp"));
|
|
}
|
|
|
|
// tiny JSON reader/writer for the persisted registration context.
|
|
std::string StatePath() { return EnvOr("STATE_FILE", std::format("{}/imsreg.state", StateDir())); }
|
|
|
|
void PersistState(const RegState& r, const std::string& route, const std::string& ppi, const std::string& aor, const std::string& transport) {
|
|
std::string j = std::format(
|
|
"{{\"callid\": \"{}\", \"ftag\": \"{}\", \"cseq\": {}, \"spi_uc\": {}, "
|
|
"\"spi_us\": {}, \"expiry\": {}, \"route\": \"{}\", \"ppi\": \"{}\", "
|
|
"\"aor\": \"{}\", \"contact_user\": \"{}\", \"transport\": \"{}\"}}",
|
|
r.callid, r.ftag, r.cseq, r.spiUc, r.spiUs, r.expiry, route, ppi, aor,
|
|
r.contactUser, transport);
|
|
std::string path = StatePath();
|
|
std::error_code ec;
|
|
std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);
|
|
if (std::FILE* f = std::fopen(path.c_str(), "w")) {
|
|
std::fwrite(j.data(), 1, j.size(), f);
|
|
std::fclose(f);
|
|
}
|
|
}
|
|
|
|
// Raw dump of a received message for offline diffing against the stock-modem
|
|
// oracle (rung-5b registration-parity work). One file per message kind,
|
|
// overwritten on every registration cycle. The dumps carry the subscriber's
|
|
// IMSI/MSISDN and addresses, so they are opt-in (DUMP_SIP=1) and mode 0600.
|
|
void DumpRaw(std::string_view name, std::string_view msg) {
|
|
if (EnvOr("DUMP_SIP", "0") != "1") return;
|
|
std::string path = std::format("{}/{}", EnvOr("DUMP_DIR", StateDir()), name);
|
|
int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0600);
|
|
if (fd < 0) return;
|
|
(void)!write(fd, msg.data(), msg.size());
|
|
close(fd);
|
|
}
|
|
|
|
struct PersistedState {
|
|
std::optional<std::string> callid, ftag, route, ppi, aor, contactUser, transport;
|
|
std::optional<long> cseq, spiUc, spiUs, expiry;
|
|
};
|
|
std::optional<PersistedState> LoadState() {
|
|
std::FILE* f = std::fopen(StatePath().c_str(), "r");
|
|
if (!f) return std::nullopt;
|
|
std::string s;
|
|
char buf[1024]; std::size_t n;
|
|
while ((n = std::fread(buf, 1, sizeof buf, f)) > 0) s.append(buf, n);
|
|
std::fclose(f);
|
|
PersistedState ps;
|
|
ps.callid = QuotedAfter(s, "\"callid\": \"");
|
|
ps.ftag = QuotedAfter(s, "\"ftag\": \"");
|
|
ps.route = QuotedAfter(s, "\"route\": \"");
|
|
ps.ppi = QuotedAfter(s, "\"ppi\": \"");
|
|
ps.aor = QuotedAfter(s, "\"aor\": \"");
|
|
ps.contactUser = QuotedAfter(s, "\"contact_user\": \"");
|
|
ps.transport = QuotedAfter(s, "\"transport\": \""); // absent in pre-0.3.5 files: TCP
|
|
ps.cseq = IntAfter(s, "\"cseq\": ");
|
|
ps.spiUc = IntAfter(s, "\"spi_uc\": ");
|
|
ps.spiUs = IntAfter(s, "\"spi_us\": ");
|
|
ps.expiry = IntAfter(s, "\"expiry\": ");
|
|
return ps;
|
|
}
|
|
|
|
// ---- daemon-level shared state (main thread only) -------------------------
|
|
struct CallInfo {
|
|
std::string uni, number, state, reason;
|
|
std::int64_t startedAt = 0;
|
|
std::int64_t answeredAt = 0;
|
|
std::string direction = "outgoing";
|
|
};
|
|
struct StatusSnapshot {
|
|
bool registered = false;
|
|
std::string local, pcscf, ppi;
|
|
std::int64_t expiry = 0;
|
|
std::int64_t cseq = 0;
|
|
};
|
|
|
|
// engine -> main-loop event
|
|
struct Event {
|
|
enum class Type { Added, State, Deleted, Registration, Status, Fatal } type;
|
|
CallInfo info; // Added
|
|
std::string uni, state, reason; // State/Deleted
|
|
StatusSnapshot status; // Registration/Status
|
|
std::string text; // Fatal
|
|
};
|
|
|
|
GDBusConnection* DbusConn = nullptr;
|
|
std::map<std::string, CallInfo> Calls; // main thread only
|
|
StatusSnapshot StatusSnap; // main thread only
|
|
GMainLoop* MainLoop = nullptr;
|
|
bool FatalExit = false; // set by an engine-fatal event: main() exits non-zero so systemd restarts us
|
|
|
|
std::int64_t NowEpoch() {
|
|
return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
|
|
}
|
|
|
|
// The recovery policy's holds, kept for the next process: the network's
|
|
// word (a Retry-After, the schedule after a refused or throttled fresh
|
|
// attempt) outlives a restart of imsd. They
|
|
// are filed under the daemon's address — another one, or a reboot, starts
|
|
// clean — so the file names that address and the boot, and
|
|
// lives in /run. Seconds left at `written_at`, which is on the boot
|
|
// clock: no clock step moves it, and it runs through a suspend as the
|
|
// network's timers do. Whether the old registration is gone travels with
|
|
// them: a restart inside a hold must not resume over SAs the network has
|
|
// written off.
|
|
std::int64_t BootSeconds() {
|
|
timespec ts{};
|
|
clock_gettime(CLOCK_BOOTTIME, &ts);
|
|
return ts.tv_sec;
|
|
}
|
|
|
|
std::string BootId() {
|
|
std::string id;
|
|
if (std::FILE* f = std::fopen("/proc/sys/kernel/random/boot_id", "r")) {
|
|
char buf[64];
|
|
id.assign(buf, std::fread(buf, 1, sizeof buf, f));
|
|
std::fclose(f);
|
|
}
|
|
while (!id.empty() && std::isspace(static_cast<unsigned char>(id.back()))) id.pop_back();
|
|
return id;
|
|
}
|
|
|
|
// The recovery policy runs on the same clock: a hold in the process and
|
|
// its copy in the file age alike, through a suspend as the network's
|
|
// timers do.
|
|
double Boot() {
|
|
timespec ts{};
|
|
clock_gettime(CLOCK_BOOTTIME, &ts);
|
|
return static_cast<double>(ts.tv_sec) + static_cast<double>(ts.tv_nsec) / 1e9;
|
|
}
|
|
|
|
std::string HoldsPath() {
|
|
if (const char* o = std::getenv("HOLDS_FILE")) return o;
|
|
if (geteuid() == 0) return "/run/imsd.holds";
|
|
return std::format("{}/imsd.holds", EnvOr("XDG_RUNTIME_DIR", "/tmp"));
|
|
}
|
|
|
|
void PersistHolds(const imsd::engine::RegRecovery::Held& h, const std::string& pdn) {
|
|
std::string path = HoldsPath();
|
|
if (!h.Any()) {
|
|
// nothing to keep: the file goes — when it is ours. A device node or a
|
|
// link the HOLDS_FILE knob points at (/dev/null switches the file off) is
|
|
// emptied instead, never unlinked.
|
|
std::error_code ec;
|
|
auto st = std::filesystem::symlink_status(path, ec);
|
|
if (std::filesystem::is_regular_file(st)) std::remove(path.c_str());
|
|
else if (std::filesystem::exists(st)) { if (std::FILE* f = std::fopen(path.c_str(), "w")) std::fclose(f); }
|
|
return;
|
|
}
|
|
std::string j = std::format("{{\"pdn\": \"{}\", \"boot\": \"{}\", \"written_at\": {}, \"hold\": {}, \"fresh_hold\": {}, \"throttle_minutes\": {}, \"old_gone\": {}}}\n",
|
|
pdn, BootId(), BootSeconds(), static_cast<long>(std::ceil(h.hold)), static_cast<long>(std::ceil(h.freshHold)), h.throttleMinutes, h.oldGone ? "true" : "false");
|
|
if (std::FILE* f = std::fopen(path.c_str(), "w")) {
|
|
std::fwrite(j.data(), 1, j.size(), f);
|
|
std::fclose(f);
|
|
}
|
|
}
|
|
|
|
std::optional<imsd::engine::RegRecovery::Held> LoadHolds(const std::string& pdn) {
|
|
std::FILE* f = std::fopen(HoldsPath().c_str(), "r");
|
|
if (!f) return std::nullopt;
|
|
std::string s;
|
|
char buf[512]; std::size_t n;
|
|
while ((n = std::fread(buf, 1, sizeof buf, f)) > 0) s.append(buf, n);
|
|
std::fclose(f);
|
|
if (QuotedAfter(s, "\"pdn\": \"").value_or("") != pdn) return std::nullopt;
|
|
if (QuotedAfter(s, "\"boot\": \"").value_or("") != BootId()) return std::nullopt;
|
|
long elapsed = BootSeconds() - IntAfter(s, "\"written_at\": ").value_or(0);
|
|
imsd::engine::RegRecovery::Held h;
|
|
h.hold = std::max<long>(0, IntAfter(s, "\"hold\": ").value_or(0) - elapsed);
|
|
h.freshHold = std::max<long>(0, IntAfter(s, "\"fresh_hold\": ").value_or(0) - elapsed);
|
|
h.throttleMinutes = static_cast<int>(IntAfter(s, "\"throttle_minutes\": ").value_or(h.throttleMinutes));
|
|
h.oldGone = s.find("\"old_gone\": true") != std::string::npos;
|
|
if (!h.Any()) return std::nullopt;
|
|
return h;
|
|
}
|
|
|
|
// build an a{sv} from a CallInfo (matches imsd.py _d typing)
|
|
GVariant* CallVariant(const CallInfo& c) {
|
|
GVariantBuilder b;
|
|
g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
|
|
g_variant_builder_add(&b, "{sv}", "uni", g_variant_new_string(c.uni.c_str()));
|
|
g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string(c.number.c_str()));
|
|
g_variant_builder_add(&b, "{sv}", "state", g_variant_new_string(c.state.c_str()));
|
|
g_variant_builder_add(&b, "{sv}", "reason", g_variant_new_string(c.reason.c_str()));
|
|
g_variant_builder_add(&b, "{sv}", "startedAt", g_variant_new_int64(c.startedAt));
|
|
g_variant_builder_add(&b, "{sv}", "answeredAt", g_variant_new_int64(c.answeredAt));
|
|
g_variant_builder_add(&b, "{sv}", "direction", g_variant_new_string(c.direction.c_str()));
|
|
return g_variant_builder_end(&b);
|
|
}
|
|
|
|
void EmitSignal(const char* name, GVariant* params) {
|
|
if (!DbusConn) return;
|
|
g_dbus_connection_emit_signal(DbusConn, nullptr, ObjPath, Iface, name, params, nullptr);
|
|
}
|
|
|
|
gboolean OnIdleEvent(gpointer data) {
|
|
std::unique_ptr<Event> ev(static_cast<Event*>(data));
|
|
switch (ev->type) {
|
|
case Event::Type::Added: {
|
|
Calls[ev->info.uni] = ev->info;
|
|
EmitSignal("CallAdded", g_variant_new("(s@a{sv})", ev->info.uni.c_str(), CallVariant(ev->info)));
|
|
break;
|
|
}
|
|
case Event::Type::State: {
|
|
auto it = Calls.find(ev->uni);
|
|
if (it != Calls.end()) {
|
|
it->second.state = ev->state;
|
|
it->second.reason = ev->reason;
|
|
if (ev->state == "active" && it->second.answeredAt == 0) it->second.answeredAt = NowEpoch();
|
|
}
|
|
EmitSignal("CallStateChanged", g_variant_new("(sss)", ev->uni.c_str(), ev->state.c_str(), ev->reason.c_str()));
|
|
break;
|
|
}
|
|
case Event::Type::Deleted:
|
|
Calls.erase(ev->uni);
|
|
EmitSignal("CallDeleted", g_variant_new("(s)", ev->uni.c_str()));
|
|
break;
|
|
case Event::Type::Registration:
|
|
StatusSnap = ev->status;
|
|
EmitSignal("RegistrationChanged", g_variant_new("(b)", ev->status.registered ? TRUE : FALSE));
|
|
break;
|
|
case Event::Type::Status:
|
|
StatusSnap = ev->status;
|
|
break;
|
|
case Event::Type::Fatal:
|
|
Log(std::format("engine fatal: {} — exiting for systemd restart", ev->text));
|
|
FatalExit = true; // non-zero exit, or Restart=on-failure never fires
|
|
g_main_loop_quit(MainLoop);
|
|
break;
|
|
}
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
void PostEvent(std::unique_ptr<Event> ev) {
|
|
g_idle_add(OnIdleEvent, ev.release());
|
|
}
|
|
|
|
// ================= engine ==================================================
|
|
class Engine {
|
|
public:
|
|
Engine() {
|
|
// No baked-in default: the P-CSCF is carrier infrastructure, learned
|
|
// from the IMS PDN's PCO on a stock stack. Until PCO discovery is
|
|
// implemented, PCSCF= must be configured (see README).
|
|
pcscf_ = EnvOr("PCSCF", "");
|
|
pcscfPort_ = std::atoi(EnvOr("PCSCF_PORT", "5060").c_str());
|
|
dev_ = EnvOr("DEV", "qmapmux0.0");
|
|
outDir_ = EnvOr("OUT_DIR", StateDir());
|
|
rtpPort_ = std::atoi(EnvOr("RTP_PORT", "50004").c_str());
|
|
precond_ = EnvOr("PRECOND", "0") == "1";
|
|
ealgOffer_ = EnvOr("EALG", "aes-cbc");
|
|
// SIP_TRANSPORT: the protected leg's transport. auto (default) = TCP,
|
|
// and when the P-CSCF never answers the TCP connect, a fresh
|
|
// registration over UDP; tcp / udp force one. The challenge (first
|
|
// REGISTER) is UDP regardless.
|
|
sipPolicy_ = EnvOr("SIP_TRANSPORT", "auto");
|
|
if (sipPolicy_ != "auto" && sipPolicy_ != "tcp" && sipPolicy_ != "udp") {
|
|
Log(std::format("SIP_TRANSPORT={} unknown; using auto", sipPolicy_));
|
|
sipPolicy_ = "auto";
|
|
}
|
|
transport_ = sipPolicy_ == "udp" ? Transport::Udp : Transport::Tcp;
|
|
mediaBin_ = ResolveMediaBin();
|
|
// CODECS: restrict + reorder the codecs we offer and accept (bench
|
|
// knob — a gateway that transcodes every caller up to AMR-WB never
|
|
// lets the narrowband path run otherwise). Empty = defaults.
|
|
codecs_ = imsd::sdp::ParseCodecList(EnvOr("CODECS", ""));
|
|
if (!codecs_.empty()) {
|
|
std::string list;
|
|
for (const auto& c : codecs_) list += (list.empty() ? "" : ",") + c;
|
|
Log(std::format("CODECS override active: {}", list));
|
|
}
|
|
// EMERGENCY_NUMBERS: comma-separated additions to the builtin
|
|
// 112/911 (a lab core's advertised short code, carrier extras).
|
|
std::string extra = EnvOr("EMERGENCY_NUMBERS", "");
|
|
for (std::size_t pos = 0; pos <= extra.size();) {
|
|
std::size_t comma = extra.find(',', pos);
|
|
std::size_t end = comma == std::string::npos ? extra.size() : comma;
|
|
std::string n = extra.substr(pos, end - pos);
|
|
std::erase(n, ' ');
|
|
if (!n.empty()) emergencyExtra_.push_back(std::move(n));
|
|
if (comma == std::string::npos) break;
|
|
pos = comma + 1;
|
|
}
|
|
}
|
|
|
|
void SetLocal(std::string l) { local_ = std::move(l); }
|
|
void SetDevMode(bool d) { devMode_ = d; }
|
|
const std::string& Local() const { return local_; }
|
|
|
|
// Dial() runs on the D-Bus thread: allocate the uni, queue the work.
|
|
std::string Dial(const std::string& number) {
|
|
std::scoped_lock g(cmdLock_);
|
|
std::string uni = std::format("ims-call-{}", ++callSeq_);
|
|
cmds_.push_back({Cmd::Kind::Dial, uni, number});
|
|
return uni;
|
|
}
|
|
void HangUp(const std::string& uni) {
|
|
std::scoped_lock g(cmdLock_);
|
|
cmds_.push_back({Cmd::Kind::HangUp, uni, {}});
|
|
}
|
|
void Accept(const std::string& uni) {
|
|
std::scoped_lock g(cmdLock_);
|
|
cmds_.push_back({Cmd::Kind::Accept, uni, {}});
|
|
}
|
|
void Stop() {
|
|
{ std::scoped_lock g(cmdLock_); cmds_.push_back({Cmd::Kind::Stop, {}, {}}); }
|
|
quit_.store(true);
|
|
}
|
|
|
|
void Run() {
|
|
if (auto h = LoadHolds(local_)) {
|
|
recovery_.Restore(Boot(), *h);
|
|
auto kept = recovery_.Holds(Boot()); // what the policy took over: the file's values after the clamp
|
|
if (kept.hold > 0 || kept.freshHold > 0)
|
|
Log(std::format("a hold the network set before this start stands ({:.0f} s for any attempt, {:.0f} s for a fresh registration; the refusal schedule at {} min)", kept.hold, kept.freshHold, kept.throttleMinutes));
|
|
else if (kept.throttleMinutes > imsd::engine::RegRecovery::ThrottleMinutesMin)
|
|
Log(std::format("the refusal schedule stands at {} min from before this start: a refused or throttled fresh registration waits that long", kept.throttleMinutes));
|
|
if (kept.oldGone) Log("the old registration was gone before this start: no resume over its SAs, the fresh registration once its wait has run");
|
|
}
|
|
for (;;) {
|
|
try {
|
|
BringUp();
|
|
break;
|
|
} catch (const Stopping&) {
|
|
return;
|
|
} catch (const ThrottledError& e) {
|
|
DeferBringUp(e.what(), imsd::engine::RegRecovery::Failure::Throttled, 0);
|
|
if (quit_.load()) return;
|
|
continue;
|
|
} catch (const RefusedError& e) {
|
|
// A refused initial registration (403, 5xx) waits like a
|
|
// throttle: a fatal would restart imsd every RestartSec with an
|
|
// initial REGISTER each time.
|
|
DeferBringUp(e.what(), imsd::engine::RegRecovery::Failure::Refused, e.retryAfter);
|
|
if (quit_.load()) return;
|
|
continue;
|
|
} catch (const std::exception& e) {
|
|
if (devMode_) {
|
|
// dev/session mode (no modem): keep the ABI up, unregistered,
|
|
// so the D-Bus surface can be exercised without a phone.
|
|
Log(std::format("bring-up skipped (dev mode): {}", e.what()));
|
|
registered_ = false;
|
|
EmitStatus(true);
|
|
DevLoop();
|
|
return;
|
|
}
|
|
Log(std::format("bring-up FAILED: {}", e.what()));
|
|
auto ev = std::make_unique<Event>();
|
|
ev->type = Event::Type::Fatal; ev->text = e.what();
|
|
PostEvent(std::move(ev));
|
|
return;
|
|
}
|
|
}
|
|
try { server_.Open(local_); }
|
|
catch (...) { Log("server ports unavailable; remote hangup/incoming not seen"); }
|
|
OnRegistered();
|
|
|
|
while (!quit_.load()) {
|
|
if (auto cmd = PopCmd()) { HandleCmd(*cmd); continue; }
|
|
for (Inbound& in : server_.Poll()) {
|
|
reply_ = in.reply;
|
|
DispatchRequest(in.msg);
|
|
}
|
|
MaybeRefresh();
|
|
MaybeReconnect();
|
|
if (!call_ && sip_.Alive() && Mono() - lastKa_ > 30) { sip_.SendKeepalive(); lastKa_ = Mono(); }
|
|
ReapMedia();
|
|
if (call_ && call_->State() != imsd::engine::CallState::Active && Mono() > deadline_) {
|
|
Execute(call_->OnDeadline());
|
|
MaybeDropCall();
|
|
}
|
|
auto msg = sip_.RecvMsg(0.3);
|
|
if (!msg) continue;
|
|
auto st = imsd::sip::Status(*msg);
|
|
if (!st) { reply_ = [this](const std::string& r) { sip_.Send(r); }; DispatchRequest(*msg); continue; }
|
|
std::string cseq(imsd::sip::Header(*msg, "CSeq").value_or(""));
|
|
std::string callid(imsd::sip::Header(*msg, "Call-ID").value_or(""));
|
|
if (call_ && callid == call_->CallId() && cseq.ends_with("INVITE")) {
|
|
Execute(call_->OnInviteResponse(*msg));
|
|
MaybeDropCall();
|
|
} else if (!subCallid_.empty() && callid == subCallid_ && cseq.ends_with("SUBSCRIBE")) {
|
|
if (*st >= 300) {
|
|
Log(std::format("reg-event SUBSCRIBE refused: {}", imsd::sip::RefusalSummary(*msg)));
|
|
DumpRaw("imsd-subscribe-fail.raw", *msg);
|
|
} else {
|
|
Log(std::format("reg-event SUBSCRIBE -> {}", *st));
|
|
if (*st >= 200) DumpRaw("imsd-subscribe-200.raw", *msg);
|
|
}
|
|
}
|
|
}
|
|
// shutdown: release an active call, keep the SA/registration for resume
|
|
if (call_) { Execute(call_->OnHangup()); MaybeDropCall(); }
|
|
sip_.Close();
|
|
Log("engine stopped (SA left up for resume)");
|
|
}
|
|
|
|
private:
|
|
struct Cmd { enum class Kind { Dial, HangUp, Accept, Stop } kind; std::string uni, number; };
|
|
struct Stopping {}; // the engine was told to stop while a bring-up waited
|
|
|
|
// A bring-up the network deferred (a fresh-SA throttle) or refused: wait
|
|
// it out here, in process, on the recovery policy's schedule, then try
|
|
// the bring-up again. There is nothing to reconnect over meanwhile (the
|
|
// resume just found the stored SAs unusable, or there are none) and no
|
|
// recovery step runs from inside the wait — portPs_ says so to
|
|
// MaybeReconnect, whatever the attempt left in it — so a Dial
|
|
// meanwhile collapses at once, as in dev mode.
|
|
void DeferBringUp(std::string_view why, imsd::engine::RegRecovery::Failure f, long retryAfter) {
|
|
FreshAttemptFailed(f, retryAfter, std::format("bring-up deferred: {}", why));
|
|
portPs_ = 0;
|
|
registered_ = false;
|
|
EmitStatus(true);
|
|
WaitForPolicy();
|
|
}
|
|
|
|
// Wait until the policy's next step is due. A Dial/Accept/HangUp
|
|
// arriving meanwhile must not wait in the queue and run stale once
|
|
// registration succeeds; with no flow the call collapses to terminated
|
|
// at once (DevLoop's rule). A wait can be long (an hour on the
|
|
// schedule), so the REGISTER after one names the access network read
|
|
// after it, not before. False when the engine is stopping.
|
|
bool WaitForPolicy() {
|
|
bool waited = false;
|
|
while (!quit_.load() && recovery_.Next(Boot()).at > Boot()) {
|
|
waited = true;
|
|
if (auto cmd = PopCmd()) { HandleCmd(*cmd); MaybeDropCall(); continue; }
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
}
|
|
if (waited && !quit_.load()) RefreshPani();
|
|
return !quit_.load();
|
|
}
|
|
|
|
void KeepHolds() { PersistHolds(recovery_.Holds(Boot()), local_); }
|
|
|
|
// dev/session mode without a modem: process commands so the ABI answers,
|
|
// but there is no SIP socket — a Dial collapses to terminated/error.
|
|
void DevLoop() {
|
|
while (!quit_.load()) {
|
|
if (auto cmd = PopCmd()) { HandleCmd(*cmd); MaybeDropCall(); continue; }
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
|
}
|
|
}
|
|
|
|
// config
|
|
std::string pcscf_, dev_, outDir_, local_, ealgOffer_, mediaBin_;
|
|
std::string sipPolicy_; // SIP_TRANSPORT: auto | tcp | udp
|
|
Transport transport_ = Transport::Tcp; // the protected leg's transport in effect
|
|
void SetTransport(Transport t) { transport_ = t; ctx_.transport = std::string(TransportName(t)); }
|
|
std::vector<std::string> emergencyExtra_;
|
|
int pcscfPort_ = 5060;
|
|
int rtpPort_ = 50004;
|
|
bool precond_ = false;
|
|
std::vector<std::string> codecs_; // CODECS override; empty = defaults
|
|
|
|
// registration
|
|
imsd::msg::Context ctx_;
|
|
RegState reg_;
|
|
std::string route_, ppi_, ss_;
|
|
bool registered_ = false;
|
|
SipFlow sip_;
|
|
ServerPorts server_;
|
|
std::string subCallid_; // live reg-event subscription dialog (empty: none)
|
|
int portPs_ = 0; // P-CSCF protected server port (reconnect target)
|
|
imsd::engine::RegRecovery recovery_; // what to do when the registration stops working
|
|
bool saReplaced_ = false; // the running fresh attempt got past the SA setup (the old registration's SAs are gone)
|
|
|
|
// call
|
|
imsd::util::Rng rng_;
|
|
std::optional<imsd::engine::CallMachine> call_;
|
|
bool dropCall_ = false;
|
|
pid_t mediaPid_ = -1;
|
|
double deadline_ = 0;
|
|
// reply_ answers the inbound request being dispatched right now;
|
|
// callReply_ is the call's durable response channel — refreshed from
|
|
// reply_ on every in-dialog request, so an Accept()'s 200 OK (which
|
|
// happens outside any inbound dispatch) still reaches the caller.
|
|
std::function<void(const std::string&)> reply_;
|
|
std::function<void(const std::string&)> callReply_;
|
|
|
|
// timers
|
|
double lastRefresh_ = 0;
|
|
double lastKa_ = 0;
|
|
std::atomic<bool> quit_{false};
|
|
bool devMode_ = false;
|
|
|
|
// command queue
|
|
std::mutex cmdLock_;
|
|
std::deque<Cmd> cmds_;
|
|
// atomic: Dial (D-Bus thread) and an inbound INVITE (engine thread) both mint unis
|
|
std::atomic<std::uint64_t> callSeq_{0};
|
|
|
|
static double Mono() {
|
|
return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count();
|
|
}
|
|
|
|
std::optional<Cmd> PopCmd() {
|
|
std::scoped_lock g(cmdLock_);
|
|
if (cmds_.empty()) return std::nullopt;
|
|
Cmd c = cmds_.front(); cmds_.pop_front();
|
|
return c;
|
|
}
|
|
|
|
static std::string ResolveMediaBin() {
|
|
if (const char* e = std::getenv("IMSD_MEDIA")) return e;
|
|
if (!SelfDir.empty()) {
|
|
std::string p = std::format("{}/imsd-media", SelfDir);
|
|
if (access(p.c_str(), X_OK) == 0) return p;
|
|
}
|
|
return "/usr/libexec/imsd-media";
|
|
}
|
|
|
|
// Refresh P-Access-Network-Info from the live serving cell (mmcli 3GPP
|
|
// location). Serving cell changes as the phone moves, so this runs
|
|
// before every REGISTER/INVITE-carrying step; on failure the previous
|
|
// value (possibly empty = header omitted) stays.
|
|
void RefreshPani() {
|
|
auto loc = RunCapture({"mmcli", "-m", "any", "--location-get"});
|
|
if (auto p = imsd::aka::ParsePani(loc.out)) ctx_.panInfo = *p;
|
|
}
|
|
|
|
// ---- bring-up: warm resume if an SA + state file exist, else fresh ----
|
|
void BringUp() {
|
|
if (pcscf_.empty()) throw std::runtime_error("PCSCF not set — configure the carrier's P-CSCF address " "(P-CSCF discovery from the PDN's PCO is not implemented yet)");
|
|
auto card = RunCapture({"qmicli", "-d", "qrtr://0", "--uim-get-card-status"});
|
|
auto sel = imsd::aka::ParseCardStatus(card.out);
|
|
if (!sel) throw std::runtime_error("no ready USIM found");
|
|
auto modem = RunCapture({"mmcli", "-m", "any"});
|
|
auto simPath = imsd::aka::ParsePrimarySimPath(modem.out);
|
|
if (!simPath) throw std::runtime_error("no primary SIM path");
|
|
auto siminfo = RunCapture({"mmcli", "-i", *simPath});
|
|
auto info = imsd::aka::ParseSimInfo(siminfo.out);
|
|
if (!info) throw std::runtime_error("SIM IMSI/operator not found");
|
|
ctx_.id = imsd::aka::MakeIdentity(info->imsi, info->mcc, info->mnc);
|
|
ctx_.local = local_;
|
|
ctx_.ealgOffer = ealgOffer_;
|
|
SetTransport(transport_);
|
|
Log(std::format("SIP transport: {} ({})", TransportName(transport_), sipPolicy_));
|
|
// USER_AGENT overrides (some networks fingerprint UAs — setting the
|
|
// stock firmware's build string gives oracle parity, journal/ims.md
|
|
// s53); USER_AGENT= (empty) omits the header.
|
|
ctx_.userAgent = EnvOr("USER_AGENT", std::format("imsd/{}", Version));
|
|
if (auto imei = imsd::aka::ParseEquipmentId(modem.out))
|
|
if (auto urn = imsd::aka::ImeiUrn(*imei)) ctx_.instanceId = *urn;
|
|
reg_.slot = sel->slot;
|
|
reg_.aid = sel->aid;
|
|
Log(std::format("SIM slot={} IMSI={} domain={}", sel->slot, info->imsi, ctx_.id.domain));
|
|
RefreshPani();
|
|
|
|
std::string resume = EnvOr("RESUME", "auto");
|
|
// A resume that the network refuses (403 after another process
|
|
// registered fresh for the same IMPI, a stale binding, …) is not
|
|
// fatal: the fresh registration below replaces its SAs. Only a
|
|
// failed FRESH registration is.
|
|
// The network's word holds at bring-up as it does in recovery: a
|
|
// hold from before this start is waited out before the resume (a
|
|
// refresh's Retry-After) or the fresh registration (a fresh attempt's
|
|
// schedule or Retry-After), and so is
|
|
// one the resume itself earns: a refusal's Retry-After.
|
|
if (resume != "0") {
|
|
if (!WaitForPolicy()) throw Stopping{};
|
|
// a registration the network wrote off before this start (the
|
|
// holds carry it) is not resumed: the wait above was the fresh one
|
|
try { if (recovery_.Reconnectable() && TryResume()) return; }
|
|
catch (const RefusedError& e) {
|
|
Log(std::format("resume failed: {} — the next registration is a fresh one", e.what()));
|
|
CloseFlowAfterWait();
|
|
if (e.retryAfter > 0) recovery_.OnReconnectFailure(Boot(), imsd::engine::RegRecovery::Failure::Refused, e.retryAfter, e.status);
|
|
}
|
|
catch (const std::exception& e) { Log(std::format("resume failed: {} — the next registration is a fresh one", e.what())); CloseFlowAfterWait(); }
|
|
}
|
|
// a resume that failed found the stored SAs unusable (and after a
|
|
// reboot there are none): nothing to reconnect over while a deferred
|
|
// fresh registration waits
|
|
recovery_.OldGone();
|
|
portPs_ = 0;
|
|
KeepHolds();
|
|
if (recovery_.Next(Boot()).at > Boot()) Log(std::format("the network's hold stands; {}", NextStep()));
|
|
if (!WaitForPolicy()) throw Stopping{};
|
|
FreshRegister();
|
|
}
|
|
|
|
bool TryResume() {
|
|
auto state = RunCapture({"ip", "xfrm", "state"});
|
|
auto policy = RunCapture({"ip", "xfrm", "policy"});
|
|
auto sa = imsd::ipsec::ParseExistingSa(state.out, policy.out, pcscf_, local_);
|
|
if (!sa) return false;
|
|
auto ps = LoadState();
|
|
if (!ps || !ps->callid) { Log("no reg state file; resume falls back to fresh"); return false; }
|
|
// The registration's transport is what the P-CSCF knows; a resume
|
|
// must reuse it. A forced policy that disagrees means a fresh start
|
|
// — decided before anything from the file is adopted.
|
|
Transport t = ps->transport.value_or("TCP") == "UDP" ? Transport::Udp : Transport::Tcp;
|
|
if (sipPolicy_ != "auto" && t != transport_) { Log("state file transport differs from SIP_TRANSPORT; fresh"); return false; }
|
|
|
|
route_ = ps->route.value_or(std::format("<sip:{};lr>", imsd::util::HostPort(pcscf_, sa->portPs)));
|
|
// No fallback identity: an empty ppi omits P-Preferred-Identity and
|
|
// is re-learned from the next 200's P-Associated-URI.
|
|
ppi_ = ps->ppi.value_or("");
|
|
ss_ = sa->securityServer;
|
|
// The public identity our requests are signed with (From) — restored
|
|
// here so a call placed before the refresh 200 re-learns it does not
|
|
// fall back to the barred temporary IMPU.
|
|
ctx_.aor = ps->aor.value_or("");
|
|
ctx_.route = route_; ctx_.ppi = ppi_; ctx_.securityServer = ss_;
|
|
ctx_.portUc = PortUc; ctx_.portUs = PortUs;
|
|
Log(std::format("RESUME via existing SA (cseq {})", ps->cseq.value_or(1)));
|
|
|
|
portPs_ = sa->portPs;
|
|
SetTransport(t);
|
|
// Local refusals (TIME_WAIT after a restart) keep retrying; two
|
|
// silences mean the flow is not coming back — fresh instead.
|
|
if (!sip_.Connect(local_, PortUc, pcscf_, sa->portPs, transport_, 10, 2)) {
|
|
Log("resume connect failed; falling back to fresh");
|
|
return false;
|
|
}
|
|
reg_.callid = *ps->callid;
|
|
reg_.ftag = ps->ftag.value_or("");
|
|
// The refresh must carry the SAME Contact URI as the stored binding;
|
|
// an absent key means the binding predates the oracle diff and used
|
|
// the IMSI (the empty-contactUser fallback).
|
|
reg_.contactUser = ps->contactUser.value_or("");
|
|
ctx_.contactUser = reg_.contactUser;
|
|
reg_.cseq = ps->cseq.value_or(1);
|
|
reg_.spiUc = static_cast<std::uint32_t>(ps->spiUc.value_or(sa->spiUc));
|
|
reg_.spiUs = static_cast<std::uint32_t>(ps->spiUs.value_or(sa->spiUs));
|
|
reg_.expiry = ps->expiry.value_or(0);
|
|
auto [okMsg, used] = Reregister(reg_.callid, reg_.ftag, reg_.cseq + 1, reg_.spiUc, reg_.spiUs);
|
|
reg_.cseq = used;
|
|
if (auto e = imsd::sip::GrantedExpires(okMsg)) reg_.expiry = *e;
|
|
UpdateRouteAndPpi(okMsg);
|
|
LogBindings(okMsg);
|
|
PersistState(reg_, route_, ppi_, ctx_.aor, ctx_.transport);
|
|
Log("REGISTERED (resumed + true-refreshed)");
|
|
return true;
|
|
}
|
|
|
|
// The registrar's 200 OK echoes EVERY current binding for the implicit
|
|
// set — the network's own view. Log them: a stale binding at a dead
|
|
// SLAAC address is still tried by terminating routing until it expires.
|
|
void LogBindings(const std::string& ok) {
|
|
for (auto ct : imsd::sip::Headers(ok, "Contact"))
|
|
Log(std::format("binding: {}", ct));
|
|
}
|
|
|
|
// A fresh registration. The attempt mints its own Contact user-part into
|
|
// ctx_ for its REGISTERs; on any failure the stored binding's comes back,
|
|
// so requests over the existing SA meanwhile (a reconnect, a refresh)
|
|
// carry the binding the network knows. reg_ takes the new one on the 200.
|
|
void FreshRegister() {
|
|
saReplaced_ = false;
|
|
try { FreshRegisterAttempt(); }
|
|
catch (...) { ctx_.contactUser = reg_.contactUser; throw; }
|
|
}
|
|
|
|
void FreshRegisterAttempt() {
|
|
Log("FRESH registration");
|
|
// Oracle diff (journal/ims.md s53): stock's Contact user-part is a
|
|
// fresh UUID per registration, not the IMSI. Minted before reg1 so
|
|
// both REGISTERs and the stored binding carry the same URI.
|
|
std::string contactUser = imsd::util::Uuid4(rng_);
|
|
ctx_.contactUser = contactUser;
|
|
Log(std::format("contact user-part: {}", contactUser));
|
|
std::string callidReg = std::format("{}@{}", rng_.Token(16), local_);
|
|
std::string ftag = rng_.Token(8);
|
|
std::uint32_t spiUc = rng_.UInt(0x10000, 0xFFFFFFF);
|
|
std::uint32_t spiUs = rng_.UInt(0x10000, 0xFFFFFFF);
|
|
ctx_.portUc = PortUc; ctx_.portUs = PortUs; ctx_.initPort = InitPort;
|
|
|
|
// reg1 over UDP from the init port -> 401
|
|
int fam = Is6(local_) ? AF_INET6 : AF_INET;
|
|
int us = socket(fam, SOCK_DGRAM, 0);
|
|
int one = 1; setsockopt(us, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
|
|
sockaddr_storage la; socklen_t ll = MakeAddr(local_, InitPort, la);
|
|
if (bind(us, reinterpret_cast<sockaddr*>(&la), ll) != 0) {
|
|
close(us); throw std::runtime_error("bind init port failed");
|
|
}
|
|
std::string reg1 = imsd::msg::BuildRegisterInitial(ctx_, callidReg, ftag, rng_.Token(16), spiUc, spiUs);
|
|
sockaddr_storage pa; socklen_t pl = MakeAddr(pcscf_, pcscfPort_, pa);
|
|
sendto(us, reg1.data(), reg1.size(), 0, reinterpret_cast<sockaddr*>(&pa), pl);
|
|
std::string resp = AwaitInitialFinal(us, callidReg);
|
|
if (auto st1 = imsd::sip::Status(resp); st1 != 401) {
|
|
DumpRaw("imsd-register-fail.raw", resp);
|
|
std::string what = std::format("expected 401, got {}", imsd::sip::RefusalSummary(resp));
|
|
if (st1 && *st1 >= 300) throw RefusedError(what, *st1, imsd::sip::RetryAfter(resp).value_or(0));
|
|
throw std::runtime_error(what);
|
|
}
|
|
auto nonceB64 = QuotedAfter(resp, "nonce=\"");
|
|
if (!nonceB64) throw std::runtime_error("no nonce in 401");
|
|
auto raw = imsd::util::FromBase64(*nonceB64);
|
|
if (!raw || raw->size() < 32) throw std::runtime_error("bad nonce");
|
|
std::vector<std::uint8_t> rand16(raw->begin(), raw->begin() + 16);
|
|
std::vector<std::uint8_t> autn16(raw->begin() + 16, raw->begin() + 32);
|
|
// Every Security-Server instance is one comma-list (RFC 3261
|
|
// §7.3.1); the joined value is what Security-Verify echoes — RFC
|
|
// 3329 §2.2 wants the whole list back, not the chosen entry.
|
|
auto ssLines = imsd::sip::Headers(resp, "Security-Server");
|
|
if (ssLines.empty()) throw std::runtime_error("no Security-Server");
|
|
ss_.clear();
|
|
for (std::string_view line : ssLines) {
|
|
if (!ss_.empty()) ss_ += ',';
|
|
ss_ += line;
|
|
}
|
|
Log(std::format("Security-Server: {}", ss_));
|
|
// Algorithms from the mechanism we select against our offer (RFC
|
|
// 3329 §2.3.1), SPIs/ports from the entry carrying them (O2 lists
|
|
// six and marks one; ims ledger F11). An answer we cannot use is a
|
|
// deferral on the throttle schedule, not a fatal: a fatal restarts
|
|
// imsd every RestartSec, an initial REGISTER each time.
|
|
auto ss = imsd::ipsec::ParseSecurityServer(ss_, "hmac-sha-1-96", ealgOffer_);
|
|
if (!ss) throw ThrottledError("Security-Server has no ipsec-3gpp mechanism");
|
|
const imsd::ipsec::SecurityMechanism& mech = ss->Selected();
|
|
const imsd::ipsec::SecurityMechanism& carrier = ss->Carrier();
|
|
Log(std::format("selected mechanism {} of {}{}: {}", ss->selected + 1, ss->mechanisms.size(), ss->offerMatched ? "" : " (none matches our offer; taking the P-CSCF's)", mech.text));
|
|
if (ss->carrier != ss->selected) Log(std::format("SPIs/ports from mechanism {}: {}", ss->carrier + 1, carrier.text));
|
|
if (carrier.spiPs == 0u) throw ThrottledError("fresh-SA throttle active (spi-s=0)");
|
|
if (!carrier.spiPs || !carrier.spiPc || !carrier.portPs || !carrier.portPc) throw ThrottledError("Security-Server carries no spi-c/spi-s/port-c/port-s");
|
|
std::string alg = mech.alg.empty() ? "hmac-sha-1-96" : mech.alg; // absent: what we offered
|
|
std::string ealg = imsd::ipsec::NormalizeEalg(mech.ealg); // absent: the null cipher (RFC 3329)
|
|
if (!imsd::ipsec::KernelAuth(alg)) throw ThrottledError(std::format("Security-Server alg={} unsupported", alg));
|
|
if (!imsd::ipsec::KnownEalg(ealg)) throw ThrottledError(std::format("Security-Server ealg={} unsupported", ealg));
|
|
if (!mech.prot.empty() && mech.prot != "esp") throw ThrottledError(std::format("Security-Server prot={} unsupported", mech.prot));
|
|
if (!mech.mod.empty() && mech.mod != "trans") throw ThrottledError(std::format("Security-Server mod={} unsupported", mech.mod));
|
|
std::uint32_t spiPs = *carrier.spiPs;
|
|
std::uint32_t spiPc = *carrier.spiPc;
|
|
int portPs = *carrier.portPs;
|
|
int portPc = *carrier.portPc;
|
|
Log(std::format("SA: alg={} ealg={}{} spi-c={} spi-s={} port-c={} port-s={}", alg, ealg, mech.ealg.empty() ? " (absent)" : "", spiPc, spiPs, portPc, portPs));
|
|
|
|
auto aka = Authenticate(rand16, autn16);
|
|
if (!aka) throw std::runtime_error("USIM AKA failed");
|
|
|
|
// install the IPsec SA pair
|
|
imsd::ipsec::SaParams sp;
|
|
sp.local = local_; sp.pcscf = pcscf_;
|
|
sp.ik = aka->ik; sp.ck = aka->ck;
|
|
sp.spiUc = spiUc; sp.spiUs = spiUs; sp.spiPc = spiPc; sp.spiPs = spiPs;
|
|
sp.portUc = PortUc; sp.portUs = PortUs; sp.portPs = portPs; sp.portPc = portPc;
|
|
sp.alg = alg;
|
|
sp.ealg = ealg;
|
|
saReplaced_ = true; // from here on the old registration's SAs are gone
|
|
for (auto& cmd : imsd::ipsec::BuildSetupCommands(sp)) {
|
|
int rc = RunCmd(cmd);
|
|
if (rc != 0) Log(std::format("{} -> rc {}", RedactKeys(cmd), rc));
|
|
}
|
|
|
|
ctx_.securityServer = ss_;
|
|
portPs_ = portPs;
|
|
// The fallback is for a P-CSCF that never served TCP. Once a TCP
|
|
// registration has succeeded on this phone (the state file records
|
|
// it), a silent connect is an outage, not a policy — two unanswered
|
|
// SYNs during a radio gap must not become a second initial REGISTER
|
|
// (the throttle trigger on KPN).
|
|
bool tcpKnownGood = false;
|
|
if (auto ps = LoadState(); ps && ps->callid.has_value()) {
|
|
std::string t = ps->transport.value_or("TCP");
|
|
tcpKnownGood = (t == "TCP");
|
|
// A phone whose last registration was UDP goes straight to UDP:
|
|
// a TCP probe on every boot would be a second initial REGISTER
|
|
// per boot on a carrier that never answers it.
|
|
if (sipPolicy_ == "auto" && t == "UDP" && transport_ == Transport::Tcp) {
|
|
Log("state file records a UDP registration; skipping the TCP probe");
|
|
SetTransport(Transport::Udp);
|
|
}
|
|
}
|
|
bool autoTcp = (sipPolicy_ == "auto" && transport_ == Transport::Tcp && !tcpKnownGood);
|
|
if (!sip_.Connect(local_, PortUc, pcscf_, portPs, transport_, 10, autoTcp ? 2 : 0)) {
|
|
if (autoTcp) {
|
|
// Two unanswered TCP connects: treat the P-CSCF as UDP-only
|
|
// and register again over UDP — a new challenge and a new SA
|
|
// pair (the SA setup flushes this one), same ports.
|
|
Log("protected TCP connect unanswered; registering fresh over UDP");
|
|
SetTransport(Transport::Udp);
|
|
FreshRegisterAttempt();
|
|
return;
|
|
}
|
|
throw std::runtime_error(std::format("protected {} connect failed", TransportName(transport_)));
|
|
}
|
|
Log(std::format("protected leg over {}", TransportName(transport_)));
|
|
|
|
std::string cnonce = rng_.Token(16);
|
|
std::string response = imsd::aka::DigestAkav1(*nonceB64, aka->res, cnonce, ctx_.id.regUri, ctx_.id.impi, ctx_.id.domain);
|
|
std::string auth = imsd::msg::AuthAka(ctx_, *nonceB64, cnonce, response);
|
|
std::string reg2 = imsd::msg::BuildRegisterProtected(ctx_, callidReg, ftag, rng_.Token(16), 2, spiUc, spiUs, auth);
|
|
if (!sip_.Send(reg2)) throw std::runtime_error("send protected REGISTER failed");
|
|
std::string ok = AwaitFinal(callidReg, 2, "protected REGISTER");
|
|
if (auto st = imsd::sip::Status(ok); st != 200) {
|
|
DumpRaw("imsd-register-fail.raw", ok);
|
|
throw RefusedError(std::format("REGISTER refused: {}", imsd::sip::RefusalSummary(ok)), *st, imsd::sip::RetryAfter(ok).value_or(0));
|
|
}
|
|
reg_.callid = callidReg; reg_.ftag = ftag; reg_.cseq = 2;
|
|
reg_.contactUser = contactUser;
|
|
reg_.spiUc = spiUc; reg_.spiUs = spiUs;
|
|
reg_.expiry = imsd::sip::GrantedExpires(ok).value_or(0);
|
|
DumpRaw("imsd-register-200.raw", ok);
|
|
UpdateRouteAndPpi(ok);
|
|
LogBindings(ok);
|
|
if (route_.empty()) route_ = std::format("<sip:{};lr>", imsd::util::HostPort(pcscf_, portPs));
|
|
ctx_.route = route_; ctx_.ppi = ppi_;
|
|
PersistState(reg_, route_, ppi_, ctx_.aor, ctx_.transport);
|
|
Log("REGISTERED (fresh)");
|
|
}
|
|
|
|
// Closes the flow of a REGISTER wait that failed. A call that arrived
|
|
// under the wait (AwaitFinal dispatches requests) ends with it: a 486
|
|
// while the flow still carries one, and the bus told.
|
|
void CloseFlowAfterWait() {
|
|
if (call_) {
|
|
Log(std::format("call {} arrived under a registration that failed; ending it", call_->Uni()));
|
|
Execute(call_->OnHangup());
|
|
MaybeDropCall();
|
|
if (call_) { Execute(call_->Abandon("registration failed")); MaybeDropCall(); }
|
|
}
|
|
sip_.Close();
|
|
}
|
|
|
|
// The final of the REGISTER (callid, cseq) just sent, within 12 s of
|
|
// the send or of its last provisional. A request arriving on the client
|
|
// flow meanwhile (a NOTIFY, an OPTIONS) is dispatched and answered, not
|
|
// read as the reply; a provisional of our own transaction keeps the
|
|
// wait going; a response to another transaction is ignored. Throws
|
|
// when nothing answers or the flow dies under a dispatched request.
|
|
std::string AwaitFinal(const std::string& callid, long cseq, std::string_view what) {
|
|
std::string want = std::format("{} REGISTER", cseq);
|
|
double deadline = Mono() + 12.0;
|
|
for (;;) {
|
|
double left = deadline - Mono();
|
|
auto m = left > 0 ? sip_.RecvMsg(left) : std::nullopt;
|
|
if (!m) throw std::runtime_error(std::format("no reply to {}", what));
|
|
auto st = imsd::sip::Status(*m);
|
|
if (!st) {
|
|
reply_ = [this](const std::string& r) { sip_.Send(r); };
|
|
DispatchRequest(*m);
|
|
if (!sip_.Alive()) throw std::runtime_error(std::format("flow closed while awaiting the {} reply", what));
|
|
continue;
|
|
}
|
|
if (!imsd::sip::ResponseOf(*m, callid, want)) {
|
|
Log(std::format("ignoring a response to another transaction while awaiting the {} reply", what));
|
|
continue;
|
|
}
|
|
if (*st >= 200) return *m;
|
|
Log(std::format("{} -> {} (provisional); waiting for the final", what, *st));
|
|
deadline = Mono() + 12.0;
|
|
}
|
|
}
|
|
|
|
// The final of the unprotected REGISTER (callid, CSeq 1) on the init
|
|
// socket, within 8 s of the send or of its last provisional. The socket
|
|
// is bound to the init port, not connected: what else it delivers — a
|
|
// late final of an earlier attempt, a stray datagram — is logged with
|
|
// its source port and skipped, never judged as the reply. Closes the
|
|
// socket; throws when nothing answers.
|
|
std::string AwaitInitialFinal(int us, const std::string& callid) {
|
|
double deadline = Mono() + 8.0;
|
|
char buf[65535];
|
|
for (;;) {
|
|
double left = deadline - Mono();
|
|
if (left <= 0) break;
|
|
long sec = static_cast<long>(left);
|
|
long usec = static_cast<long>((left - static_cast<double>(sec)) * 1e6);
|
|
if (sec == 0 && usec == 0) usec = 1000;
|
|
timeval tv{sec, usec};
|
|
setsockopt(us, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
|
|
sockaddr_storage src; socklen_t sl = sizeof src;
|
|
ssize_t n = recvfrom(us, buf, sizeof buf, 0, reinterpret_cast<sockaddr*>(&src), &sl);
|
|
if (n <= 0) break;
|
|
std::string m(buf, static_cast<std::size_t>(n));
|
|
if (!imsd::sip::ResponseOf(m, callid, "1 REGISTER")) {
|
|
int sp = src.ss_family == AF_INET6 ? ntohs(reinterpret_cast<sockaddr_in6*>(&src)->sin6_port) : ntohs(reinterpret_cast<sockaddr_in*>(&src)->sin_port);
|
|
std::string_view sv = m;
|
|
Log(std::format("ignoring a datagram on the init port from port {} that is not the unprotected REGISTER's reply: {}", sp, sv.substr(0, sv.find("\r\n"))));
|
|
continue;
|
|
}
|
|
int st = *imsd::sip::Status(m);
|
|
if (st >= 200) { close(us); return m; }
|
|
Log(std::format("unprotected REGISTER -> {} (provisional); waiting for the final", st));
|
|
deadline = Mono() + 8.0;
|
|
}
|
|
close(us);
|
|
throw std::runtime_error("no 401 to unprotected REGISTER");
|
|
}
|
|
|
|
// re-REGISTER over the (resumed or live) SA. Returns (200 msg, used cseq).
|
|
std::pair<std::string, long> Reregister(const std::string& callid, const std::string& ftag, long startCseq, std::uint32_t spiUc, std::uint32_t spiUs) {
|
|
std::string auth = imsd::msg::AuthEmpty(ctx_);
|
|
long cseq = startCseq;
|
|
bool challenged = false;
|
|
for (;;) {
|
|
std::string reg = imsd::msg::BuildRegisterProtected(ctx_, callid, ftag, rng_.Token(16), cseq, spiUc, spiUs, auth);
|
|
if (!sip_.Send(reg)) throw std::runtime_error("send re-REGISTER failed");
|
|
std::string m = AwaitFinal(callid, cseq, "re-REGISTER");
|
|
auto st = imsd::sip::Status(m);
|
|
if (st == 200) return {m, cseq};
|
|
if (st == 401 && !challenged) {
|
|
challenged = true;
|
|
auto nonce = QuotedAfter(m, "nonce=\"");
|
|
auto raw = nonce ? imsd::util::FromBase64(*nonce) : std::nullopt;
|
|
if (!raw || raw->size() < 32) throw std::runtime_error("bad 401 nonce on refresh");
|
|
std::vector<std::uint8_t> rnd(raw->begin(), raw->begin() + 16);
|
|
std::vector<std::uint8_t> autn(raw->begin() + 16, raw->begin() + 32);
|
|
auto aka = Authenticate(rnd, autn);
|
|
if (!aka) throw std::runtime_error("AKA failed on refresh");
|
|
std::string cnonce = rng_.Token(16);
|
|
std::string response = imsd::aka::DigestAkav1(*nonce, aka->res, cnonce, ctx_.id.regUri, ctx_.id.impi, ctx_.id.domain);
|
|
auth = imsd::msg::AuthAka(ctx_, *nonce, cnonce, response);
|
|
cseq++;
|
|
continue;
|
|
}
|
|
DumpRaw("imsd-register-fail.raw", m);
|
|
throw RefusedError(std::format("re-REGISTER refused: {}", imsd::sip::RefusalSummary(m)), *st, imsd::sip::RetryAfter(m).value_or(0));
|
|
}
|
|
}
|
|
|
|
void UpdateRouteAndPpi(const std::string& okMsg) {
|
|
auto svc = imsd::sip::Headers(okMsg, "Service-Route");
|
|
if (svc.empty()) Log("200: no Service-Route (route stays P-CSCF)");
|
|
if (!svc.empty()) {
|
|
std::string r;
|
|
for (std::size_t i = 0; i < svc.size(); i++) { r += svc[i]; if (i + 1 < svc.size()) r += ", "; }
|
|
route_ = r; ctx_.route = r;
|
|
Log(std::format("200 Service-Route: {}", r));
|
|
}
|
|
for (auto p : imsd::sip::Headers(okMsg, "Path"))
|
|
Log(std::format("200 Path: {}", p));
|
|
auto pau = imsd::sip::Headers(okMsg, "P-Associated-URI");
|
|
if (pau.empty()) Log("200: NO P-Associated-URI");
|
|
for (auto a : pau)
|
|
Log(std::format("200 P-Associated-URI: {}", a));
|
|
for (auto a : imsd::sip::Headers(okMsg, "P-Associated-URI")) {
|
|
std::size_t lt = a.find("<tel:");
|
|
if (lt != std::string_view::npos) {
|
|
std::size_t gt = a.find('>', lt);
|
|
ppi_ = std::string(a.substr(lt + 1, gt - lt - 1));
|
|
ctx_.ppi = ppi_;
|
|
break;
|
|
}
|
|
}
|
|
// default public identity for self-targeted requests (reg-event
|
|
// SUBSCRIBE): first sip: P-Associated-URI entry, else the tel: one
|
|
// (the temporary IMPU is barred for anything but REGISTER)
|
|
for (auto a : imsd::sip::Headers(okMsg, "P-Associated-URI")) {
|
|
std::size_t lt = a.find("<sip:");
|
|
if (lt != std::string_view::npos) {
|
|
std::size_t gt = a.find('>', lt);
|
|
ctx_.aor = std::string(a.substr(lt + 1, gt - lt - 1));
|
|
break;
|
|
}
|
|
}
|
|
if (ctx_.aor.empty() && !ppi_.empty()) ctx_.aor = ppi_;
|
|
if (ppi_.empty()) Log("200: no tel: P-Associated-URI — P-Preferred-Identity omitted");
|
|
Log(std::format("self AOR: {}", ctx_.aor.empty() ? ctx_.id.impu : ctx_.aor));
|
|
}
|
|
|
|
// USIM AKA via qmicli UIM logical channel.
|
|
std::optional<imsd::aka::AkaResult> Authenticate(std::span<const std::uint8_t> rand16, std::span<const std::uint8_t> autn16) {
|
|
auto open = RunCapture({"qmicli", "-d", "qrtr://0",
|
|
std::format("--uim-open-logical-channel={},{}", reg_.slot, reg_.aid)});
|
|
auto ch = CompletedInt(open.out);
|
|
if (!ch) return std::nullopt;
|
|
int channel = static_cast<int>(*ch);
|
|
auto closeCh = [&] {
|
|
RunCapture({"qmicli", "-d", "qrtr://0",
|
|
std::format("--uim-close-logical-channel={},{}", reg_.slot, channel)});
|
|
};
|
|
std::string apdu = imsd::aka::BuildAkaApdu(channel, rand16, autn16);
|
|
auto r1 = RunCapture({"qmicli", "-d", "qrtr://0",
|
|
std::format("--uim-send-apdu={},{},{}", reg_.slot, channel, apdu)});
|
|
auto b1 = CompletedHex(r1.out);
|
|
if (!b1) { closeCh(); return std::nullopt; }
|
|
if (b1->size() >= 2 && b1->substr(0, 2) == "61") {
|
|
std::string gr = imsd::aka::BuildGetResponseApdu(channel, std::stoi(b1->substr(2, 2), nullptr, 16));
|
|
auto r2 = RunCapture({"qmicli", "-d", "qrtr://0",
|
|
std::format("--uim-send-apdu={},{},{}", reg_.slot, channel, gr)});
|
|
b1 = CompletedHex(r2.out);
|
|
if (!b1) { closeCh(); return std::nullopt; }
|
|
}
|
|
closeCh();
|
|
auto bytes = imsd::util::FromHex(*b1);
|
|
if (!bytes) return std::nullopt;
|
|
return imsd::aka::ParseAkaResponse(*bytes);
|
|
}
|
|
|
|
// ---- keepalive refresh (only while idle) ------------------------------
|
|
void MaybeRefresh() {
|
|
if (call_ || reg_.callid.empty()) return;
|
|
if (!sip_.Alive()) return; // MaybeReconnect owns dead-flow recovery
|
|
long exp = reg_.expiry ? reg_.expiry : 3600;
|
|
double interval;
|
|
if (const char* o = std::getenv("REFRESH_INTERVAL")) interval = std::atof(o);
|
|
else interval = std::max(120.0, std::min(exp * 0.5, 1800.0));
|
|
if (Mono() - lastRefresh_ < interval) return;
|
|
try {
|
|
RefreshPani();
|
|
auto [msg, used] = Reregister(reg_.callid, reg_.ftag, reg_.cseq + 1, reg_.spiUc, reg_.spiUs);
|
|
reg_.cseq = used;
|
|
if (auto e = imsd::sip::GrantedExpires(msg)) reg_.expiry = *e;
|
|
PersistState(reg_, route_, ppi_, ctx_.aor, ctx_.transport);
|
|
Log(std::format("keepalive re-REGISTER ok (cseq {})", used));
|
|
OnRegistered();
|
|
} catch (const RefusedError& e) {
|
|
// The network refused the refresh: the recovery policy counts it
|
|
// (a second refusal means a fresh registration) and the flow is
|
|
// dropped so the reconnect step retries the refresh after the
|
|
// wait (Retry-After when given).
|
|
Log(std::format("keepalive re-REGISTER failed: {}", e.what()));
|
|
CloseFlowAfterWait();
|
|
RecoveryFailed(imsd::engine::RegRecovery::Failure::Refused, e.retryAfter, "keepalive refresh refused", e.status);
|
|
} catch (const std::exception& e) {
|
|
// A dead flow or a silent P-CSCF: the recovery is the same as a
|
|
// daemon restart's — drop the flow and let MaybeReconnect re-run
|
|
// the connect + true-refresh sequence at once.
|
|
Log(std::format("keepalive re-REGISTER failed: {}", e.what()));
|
|
CloseFlowAfterWait();
|
|
}
|
|
lastRefresh_ = Mono();
|
|
lastKa_ = Mono();
|
|
}
|
|
|
|
// The protected client flow can die under us while the SA and the
|
|
// registration stay valid — a CSFB excursion resets it, the P-CSCF drops
|
|
// idle flows — which is exactly the state a daemon restart resumes from
|
|
// (s51: "restart-to-recover"). Do what the restart does, in place:
|
|
// reconnect the TCP leg over the existing SA and true-refresh. When that
|
|
// keeps failing — the network refuses the refresh, or nothing answers —
|
|
// do the rest of what a restart does: register fresh. RegRecovery holds
|
|
// the thresholds and the pacing (a dead PDN must not turn this into a
|
|
// hot loop; a carrier that refuses fresh SAs must not be hammered).
|
|
void MaybeReconnect() {
|
|
if (call_ || sip_.Alive() || portPs_ == 0 || reg_.callid.empty()) return;
|
|
auto plan = recovery_.Next(Boot());
|
|
if (plan.at > Boot()) return;
|
|
if (plan.step == imsd::engine::RegRecovery::Step::Fresh) FreshRecover();
|
|
else ReconnectCycle();
|
|
}
|
|
|
|
// The policy's next step, as the journal line: what, and when.
|
|
std::string NextStep() {
|
|
auto plan = recovery_.Next(Boot());
|
|
double in = plan.at - Boot();
|
|
std::string what = plan.step == imsd::engine::RegRecovery::Step::Fresh ? "fresh registration" : "reconnect over the existing SA";
|
|
if (in <= 0) return std::format("next: {} now", what);
|
|
if (in >= 60) return std::format("next: {} in {:.0f} min", what, in / 60);
|
|
return std::format("next: {} in {:.0f} s", what, in);
|
|
}
|
|
|
|
// ModemManager's word on the phone's own service, as ims-pdn-up.sh reads
|
|
// it (`mmcli -K`). False only when the modem clearly has none: a state
|
|
// short of registered, or packet service detached. Anything else —
|
|
// ModemManager not answering, a state or packet-service value this
|
|
// code does not know — counts as service: the network's silence, not
|
|
// the phone's, is the default.
|
|
bool PacketServiceUp() {
|
|
auto r = RunCapture({"mmcli", "-m", "any", "-K"});
|
|
auto field = [&](std::string_view key) -> std::string {
|
|
std::size_t at = r.out.find(key);
|
|
if (at == std::string::npos) return {};
|
|
std::size_t end = r.out.find('\n', at);
|
|
if (end == std::string::npos) end = r.out.size();
|
|
std::size_t colon = r.out.find(':', at);
|
|
if (colon == std::string::npos || colon > end) return {};
|
|
std::string v = r.out.substr(colon + 1, end - colon - 1);
|
|
while (!v.empty() && v.front() == ' ') v.erase(v.begin());
|
|
while (!v.empty() && (v.back() == ' ' || v.back() == '\r')) v.pop_back();
|
|
return v;
|
|
};
|
|
std::string state = field("modem.generic.state "), ps = field("modem.3gpp.packet-service-state ");
|
|
for (const char* down : {"failed", "initializing", "locked", "disabled", "disabling", "enabling", "enabled", "searching"})
|
|
if (state == down) return false;
|
|
return ps != "detached";
|
|
}
|
|
|
|
// A cycle that failed while the modem reports no packet service is the
|
|
// phone's silence, not the network's: not counted, retried on the
|
|
// local-refusal pace like a connect() the kernel refused — a radio gap
|
|
// across a refresh must not escalate to a fresh registration, which KPN
|
|
// refuses while the old one is live, and drops it for.
|
|
void CoverageGap(std::string_view what) {
|
|
if (registered_) { registered_ = false; EmitStatus(true); }
|
|
recovery_.OnLocalRefusal(Boot());
|
|
Log(std::format("{} while the modem reports no packet service: not counted; {}", what, NextStep()));
|
|
}
|
|
|
|
void ReconnectCycle() {
|
|
using F = imsd::engine::RegRecovery::Failure;
|
|
Log("client flow dead; reconnecting");
|
|
sip_.Close();
|
|
if (!sip_.Connect(local_, PortUc, pcscf_, portPs_, transport_, /*tries=*/2)) {
|
|
if (sip_.LastConnectLocal()) {
|
|
if (registered_) { registered_ = false; EmitStatus(true); }
|
|
recovery_.OnLocalRefusal(Boot());
|
|
return;
|
|
}
|
|
if (!PacketServiceUp()) { CoverageGap("P-CSCF silent"); return; }
|
|
RecoveryFailed(F::Silent, 0, "P-CSCF silent");
|
|
return;
|
|
}
|
|
try {
|
|
RefreshPani();
|
|
auto [msg, used] = Reregister(reg_.callid, reg_.ftag, reg_.cseq + 1, reg_.spiUc, reg_.spiUs);
|
|
reg_.cseq = used;
|
|
if (auto e = imsd::sip::GrantedExpires(msg)) reg_.expiry = *e;
|
|
UpdateRouteAndPpi(msg);
|
|
LogBindings(msg);
|
|
PersistState(reg_, route_, ppi_, ctx_.aor, ctx_.transport);
|
|
Log("reconnected + re-registered");
|
|
OnRegistered();
|
|
} catch (const RefusedError& e) {
|
|
Log(std::format("reconnect re-REGISTER failed: {}", e.what()));
|
|
CloseFlowAfterWait();
|
|
RecoveryFailed(F::Refused, e.retryAfter, "refresh refused", e.status);
|
|
} catch (const std::exception& e) {
|
|
Log(std::format("reconnect re-REGISTER failed: {}", e.what()));
|
|
CloseFlowAfterWait();
|
|
if (!PacketServiceUp()) { CoverageGap("refresh unanswered"); return; }
|
|
RecoveryFailed(F::Silent, 0, "refresh unanswered");
|
|
}
|
|
}
|
|
|
|
// A failed reconnect + refresh cycle: the status goes unregistered, the
|
|
// policy decides whether the next step is another cycle or a fresh
|
|
// registration, and when.
|
|
void RecoveryFailed(imsd::engine::RegRecovery::Failure f, long retryAfter, std::string_view what, int status = 0) {
|
|
if (registered_) { registered_ = false; EmitStatus(true); }
|
|
bool wasReconnectable = recovery_.Reconnectable();
|
|
recovery_.OnReconnectFailure(Boot(), f, retryAfter, status);
|
|
KeepHolds();
|
|
Log(std::format("{} ({} refused, {} silent cycles){}; {}", what, recovery_.refusals, recovery_.silentCycles,
|
|
wasReconnectable && !recovery_.Reconnectable() ? std::format(" — the old registration is gone ({})", status) : "", NextStep()));
|
|
}
|
|
|
|
// The rest of what a restart does, in place: a new Call-ID, a new
|
|
// challenge, a new SA pair (FreshRegister flushes the old ones), then
|
|
// the post-registration steps. A refused or throttled attempt waits on
|
|
// the throttle schedule (a wait no Dial cuts short — on KPN a refused
|
|
// attempt costs the old registration) and a silent one on the
|
|
// short backoff. The attempt's flow is closed whichever way it failed;
|
|
// past the SA setup the old registration's SAs are gone with it, so
|
|
// nothing is retried until the next fresh attempt.
|
|
void FreshRecover() {
|
|
using F = imsd::engine::RegRecovery::Failure;
|
|
Log(std::format("registering fresh (recovery attempt {})", recovery_.freshAttempts + 1));
|
|
sip_.Close();
|
|
saReplaced_ = false; // this attempt's, whatever fails first
|
|
subCallid_.clear();
|
|
try {
|
|
RefreshPani();
|
|
FreshRegister();
|
|
OnRegistered();
|
|
Log("recovered by a fresh registration");
|
|
} catch (const ThrottledError& e) {
|
|
FreshAttemptFailed(F::Throttled, 0, std::format("fresh registration deferred: {}", e.what()));
|
|
} catch (const RefusedError& e) {
|
|
FreshAttemptFailed(F::Refused, e.retryAfter, std::format("fresh registration refused: {}", e.what()));
|
|
} catch (const std::exception& e) {
|
|
FreshAttemptFailed(F::Silent, 0, std::format("fresh registration failed: {}", e.what()));
|
|
}
|
|
}
|
|
|
|
// After a failed fresh attempt, in recovery or at bring-up: the
|
|
// attempt's flow closed (a refused protected REGISTER leaves it open),
|
|
// the policy told, and its next step logged.
|
|
void FreshAttemptFailed(imsd::engine::RegRecovery::Failure f, long retryAfter, const std::string& what) {
|
|
CloseFlowAfterWait();
|
|
bool wasReconnectable = recovery_.Reconnectable();
|
|
recovery_.OnFreshFailure(Boot(), f, retryAfter, saReplaced_);
|
|
KeepHolds();
|
|
Log(std::format("{}{}; {}", what, wasReconnectable && !recovery_.Reconnectable() ? " — the old registration is gone" : "", NextStep()));
|
|
}
|
|
|
|
// After a registration succeeds — bring-up, a keepalive refresh, a
|
|
// reconnect + refresh, or a fresh recovery: the status (a signal only
|
|
// when it changes), the timers, the recovery policy, the reg-event
|
|
// subscription.
|
|
void OnRegistered() {
|
|
recovery_.OnSuccess();
|
|
KeepHolds();
|
|
bool was = registered_;
|
|
registered_ = true;
|
|
EmitStatus(!was);
|
|
lastRefresh_ = Mono(); lastKa_ = Mono();
|
|
SubscribeRegEvent();
|
|
}
|
|
|
|
// (Re-)subscribe to the reg event package (TS 24.229 5.1.1.3): a fresh
|
|
// dialog each time, sent over the registration flow; the S-CSCF's
|
|
// immediate NOTIFY (logged in DispatchRequest) is the network's own view
|
|
// of our bindings. Failure is non-fatal — registration is unaffected.
|
|
void SubscribeRegEvent() {
|
|
subCallid_ = std::format("{}@{}", rng_.Token(16), local_);
|
|
std::string sub = imsd::msg::BuildSubscribeReg(ctx_, subCallid_, rng_.Token(8), rng_.Token(16));
|
|
if (sip_.Send(sub)) Log("reg-event SUBSCRIBE sent");
|
|
else { Log("reg-event SUBSCRIBE send failed"); subCallid_.clear(); }
|
|
}
|
|
|
|
// ---- command handling -------------------------------------------------
|
|
// A Dial while a call exists: refused, unless it is an emergency dial,
|
|
// which preempts whatever exists (TS 22.101) — released, and abandoned
|
|
// if it lingers awaiting a CANCEL's 487 (the late final is ignored by
|
|
// Call-ID mismatch). False when the dial was refused.
|
|
bool ClearForDial(const Cmd& c, bool emergency) {
|
|
if (!call_) return true;
|
|
if (!emergency) {
|
|
Log(std::format("dial({}) refused: call in progress", c.number));
|
|
CallInfo bad{c.uni, c.number, "terminated", "error", NowEpoch(), 0};
|
|
PostAdded(bad);
|
|
PostState(c.uni, "terminated", "error");
|
|
PostDeleted(c.uni);
|
|
return false;
|
|
}
|
|
Log(std::format("emergency dial: preempting call {}", call_->Uni()));
|
|
Execute(call_->OnHangup());
|
|
MaybeDropCall();
|
|
if (call_) { Execute(call_->Abandon("preempted by emergency dial")); MaybeDropCall(); }
|
|
return true;
|
|
}
|
|
|
|
void HandleCmd(const Cmd& c) {
|
|
if (c.kind == Cmd::Kind::Stop) { quit_.store(true); return; }
|
|
if (c.kind == Cmd::Kind::Dial) {
|
|
bool emergency = imsd::msg::IsEmergency(c.number, emergencyExtra_);
|
|
if (!ClearForDial(c, emergency)) return;
|
|
// a dead client flow fails the INVITE instantly — give the
|
|
// recovery path one immediate shot first: user action cuts the
|
|
// backoff short, never a wait the network imposed (a
|
|
// Retry-After, the schedule after a refused or throttled fresh
|
|
// attempt — the policy keeps those). The shot's REGISTER wait dispatches
|
|
// requests, so an incoming call may have arrived under it: the
|
|
// same rule again.
|
|
if (!sip_.Alive()) {
|
|
recovery_.OnDial(); MaybeReconnect();
|
|
if (!ClearForDial(c, emergency)) return;
|
|
}
|
|
RefreshPani();
|
|
if (emergency)
|
|
Log(std::format("EMERGENCY dial ({}): urn:service:sos over the live registration, "
|
|
"fallback plain INVITE — stage 1, no emergency registration/PDN; "
|
|
"carrier-side behavior UNVERIFIED", c.number));
|
|
call_.emplace(ctx_, rng_, c.uni, c.number, rtpPort_, precond_, emergency, codecs_);
|
|
CallInfo info{c.uni, c.number, "dialing", "outgoing", NowEpoch(), 0};
|
|
PostAdded(info);
|
|
bool ok = Execute(call_->Start());
|
|
if (!ok && call_ && !call_->Terminated()) { Execute(call_->Fail("error")); }
|
|
MaybeDropCall();
|
|
} else if (c.kind == Cmd::Kind::HangUp) {
|
|
if (call_ && call_->Uni() == c.uni) { Execute(call_->OnHangup()); MaybeDropCall(); }
|
|
} else if (c.kind == Cmd::Kind::Accept) {
|
|
if (call_ && call_->Uni() == c.uni) { Execute(call_->OnAccept()); MaybeDropCall(); }
|
|
else Log(std::format("Accept({}) ignored: no such ringing call", c.uni));
|
|
}
|
|
}
|
|
|
|
void DispatchRequest(const std::string& msg) {
|
|
std::string callid(imsd::sip::Header(msg, "Call-ID").value_or(""));
|
|
std::size_t sp = msg.find(' ');
|
|
std::string method = msg.substr(0, sp == std::string::npos ? 0 : sp);
|
|
if (call_ && callid == call_->CallId()) {
|
|
callReply_ = reply_; // freshest channel for this dialog
|
|
Execute(call_->OnRequest(msg));
|
|
MaybeDropCall();
|
|
return;
|
|
}
|
|
// ACK is never answered — e.g. the caller ACKing the 486/487 of a
|
|
// call machine we already dropped
|
|
if (method == "ACK") return;
|
|
// reg-event NOTIFY: log the S-CSCF's reginfo (every binding it holds
|
|
// for the implicit set, feature tags as stored), then 200 it below.
|
|
// MESSAGE (terminating SMS-over-IP while +g.3gpp.smsip is
|
|
// advertised): log the whole body — the 200 acks delivery, so the
|
|
// journal is the only place the payload survives until real SMSoIP
|
|
// handling exists.
|
|
if (method == "NOTIFY" || method == "MESSAGE") {
|
|
std::size_t at = msg.find("\r\n\r\n");
|
|
std::string_view body = at == std::string::npos
|
|
? std::string_view{}
|
|
: std::string_view(msg).substr(at + 4);
|
|
if (method == "MESSAGE") Log(std::format("MESSAGE from {} ({} bytes):\n{}", imsd::sip::CallerId(msg), body.size(), body));
|
|
else if (auto ev = imsd::sip::Header(msg, "Event"); ev && ev->starts_with("reg")) Log(std::format("reg-event NOTIFY ({} bytes):\n{}", body.size(), body));
|
|
if (reply_) reply_(imsd::msg::BuildResponse200(ctx_, msg));
|
|
return;
|
|
}
|
|
if (method == "INVITE") {
|
|
OnIncomingInvite(msg);
|
|
return;
|
|
}
|
|
if (reply_)
|
|
reply_(imsd::msg::BuildResponse200(ctx_, msg)); // unsolicited (OPTIONS etc.)
|
|
}
|
|
|
|
// An out-of-dialog INVITE: a terminating (incoming) call.
|
|
void OnIncomingInvite(const std::string& msg) {
|
|
if (call_) {
|
|
Log("incoming INVITE while a call exists: 486");
|
|
if (reply_) reply_(imsd::msg::BuildInviteResponse(ctx_, msg, 486, "Busy Here", rng_.Token(10)));
|
|
return;
|
|
}
|
|
std::string uni = std::format("ims-call-{}", ++callSeq_);
|
|
DumpRaw("imsd-invite-in.raw", msg);
|
|
call_.emplace(ctx_, rng_, uni, imsd::engine::IncomingInvite{msg}, rtpPort_, codecs_);
|
|
callReply_ = reply_;
|
|
Log(std::format("incoming call {} from {}", uni, call_->Number()));
|
|
// Validate the offer BEFORE the UI hears of the call. A refused
|
|
// INVITE (488: nothing we can play) is answered and dropped without
|
|
// ever announcing it — announcing first produced a 24 ms
|
|
// added/terminated/deleted burst that left Plasma Dialer stuck as a
|
|
// lock-screen overlay with no call to show (field report 2026-09-01).
|
|
// The journal keeps the record: caller and reason are logged above
|
|
// and by the engine's teardown line.
|
|
auto actions = call_->OnInvite();
|
|
if (call_->Terminated()) {
|
|
Execute(actions, /*announce=*/false);
|
|
MaybeDropCall();
|
|
return;
|
|
}
|
|
CallInfo info{uni, call_->Number(), "incoming", "incoming", NowEpoch(), 0,
|
|
"incoming"};
|
|
PostAdded(info);
|
|
Execute(actions);
|
|
MaybeDropCall();
|
|
}
|
|
|
|
// ---- action execution -------------------------------------------------
|
|
// Returns false if a client-flow send failed (used to fail a dial's INVITE).
|
|
// `announce` false suppresses the D-Bus state/deleted events — for a call
|
|
// that was never announced (refused before ringing), so the bus never
|
|
// sees a call it cannot show.
|
|
bool Execute(const std::vector<imsd::engine::Action>& actions, bool announce = true) {
|
|
using T = imsd::engine::Action::Type;
|
|
bool sendOk = true;
|
|
for (const auto& a : actions) {
|
|
switch (a.type) {
|
|
case T::SendClient:
|
|
// the outgoing INVITE is the one request a field log could
|
|
// never show (DUMP_SIP dumped inbound messages only)
|
|
if (a.text.starts_with("INVITE ")) DumpRaw("imsd-invite-out.raw", a.text);
|
|
if (!sip_.Send(a.text)) { sendOk = false; Log("client send failed"); }
|
|
break;
|
|
case T::SendResponse:
|
|
if (callReply_) callReply_(a.text);
|
|
else if (reply_) reply_(a.text);
|
|
break;
|
|
case T::StartMedia: StartMedia(a.media); break;
|
|
case T::StopMedia: StopMedia(); break;
|
|
case T::State:
|
|
if (announce) PostState(call_->Uni(), a.state, a.reason);
|
|
break;
|
|
case T::Deleted:
|
|
if (announce) PostDeleted(call_->Uni());
|
|
dropCall_ = true;
|
|
break;
|
|
case T::SetDeadline: deadline_ = Mono() + a.seconds; break;
|
|
case T::Log: Log(a.text); break;
|
|
}
|
|
}
|
|
return sendOk;
|
|
}
|
|
|
|
void MaybeDropCall() {
|
|
if (dropCall_) { call_.reset(); callReply_ = nullptr; dropCall_ = false; }
|
|
}
|
|
|
|
void StartMedia(const imsd::engine::MediaLeg& leg) {
|
|
if (!leg.Valid()) { Log("SDP answer missing media endpoint; no media leg"); return; }
|
|
Log(std::format("media {} pt={} octet={} -> [{}]:{}", leg.codec, leg.payloadType, leg.octetAlign, leg.remoteIp, leg.remotePort));
|
|
if (Is6(leg.remoteIp)) RunCmd({"ip", "-6", "route", "replace", leg.remoteIp, "dev", dev_});
|
|
else
|
|
RunCmd({"ip", "route", "replace", leg.remoteIp, "dev", dev_});
|
|
std::string outBase = std::format("{}/dialer_{}", outDir_, call_ ? call_->Uni() : std::string("x"));
|
|
std::vector<std::string> argv = {
|
|
mediaBin_, local_, std::to_string(rtpPort_), leg.remoteIp,
|
|
std::to_string(leg.remotePort), std::to_string(leg.payloadType),
|
|
"86400", outBase};
|
|
pid_t pid = fork();
|
|
if (pid == 0) {
|
|
setenv("MIC", EnvOr("MIC", "1").c_str(), 1);
|
|
setenv("PLAY", EnvOr("PLAY", "1").c_str(), 1);
|
|
setenv("GAIN", EnvOr("GAIN", "10").c_str(), 1);
|
|
setenv("PLAY_GAIN", EnvOr("PLAY_GAIN", "1.0").c_str(), 1);
|
|
setenv("AMR_MODE", EnvOr("AMR_MODE", "2").c_str(), 1);
|
|
setenv("DTX", EnvOr("DTX", "0").c_str(), 1);
|
|
setenv("OCTET_ALIGN", leg.octetAlign ? "1" : "0", 1);
|
|
setenv("CODEC", leg.codec.c_str(), 1);
|
|
std::vector<char*> c;
|
|
for (auto& s : argv) c.push_back(const_cast<char*>(s.c_str()));
|
|
c.push_back(nullptr);
|
|
execvp(c[0], c.data());
|
|
_exit(127);
|
|
}
|
|
mediaPid_ = pid;
|
|
}
|
|
|
|
void StopMedia() {
|
|
if (mediaPid_ <= 0) return;
|
|
kill(mediaPid_, SIGTERM);
|
|
for (int i = 0; i < 100; i++) {
|
|
if (waitpid(mediaPid_, nullptr, WNOHANG) != 0) { mediaPid_ = -1; return; }
|
|
usleep(100000);
|
|
}
|
|
kill(mediaPid_, SIGKILL);
|
|
waitpid(mediaPid_, nullptr, 0);
|
|
mediaPid_ = -1;
|
|
}
|
|
|
|
void ReapMedia() {
|
|
if (!call_ || mediaPid_ <= 0) return;
|
|
if (call_->State() != imsd::engine::CallState::Active) return;
|
|
int status = 0;
|
|
pid_t r = waitpid(mediaPid_, &status, WNOHANG);
|
|
if (r == 0) return; // still running
|
|
int code = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
|
|
mediaPid_ = -1; // reaped; don't re-terminate
|
|
Execute(call_->OnMediaExit(code));
|
|
MaybeDropCall();
|
|
}
|
|
|
|
// ---- events -----------------------------------------------------------
|
|
void EmitStatus(bool registrationSignal) {
|
|
auto ev = std::make_unique<Event>();
|
|
ev->type = registrationSignal ? Event::Type::Registration : Event::Type::Status;
|
|
ev->status = StatusSnapshot{registered_, local_, pcscf_, ppi_, reg_.expiry, reg_.cseq};
|
|
PostEvent(std::move(ev));
|
|
}
|
|
void PostAdded(const CallInfo& info) {
|
|
auto ev = std::make_unique<Event>(); ev->type = Event::Type::Added; ev->info = info;
|
|
PostEvent(std::move(ev));
|
|
}
|
|
void PostState(const std::string& uni, const std::string& state, const std::string& reason) {
|
|
auto ev = std::make_unique<Event>(); ev->type = Event::Type::State;
|
|
ev->uni = uni; ev->state = state; ev->reason = reason;
|
|
PostEvent(std::move(ev));
|
|
}
|
|
void PostDeleted(const std::string& uni) {
|
|
auto ev = std::make_unique<Event>(); ev->type = Event::Type::Deleted; ev->uni = uni;
|
|
PostEvent(std::move(ev));
|
|
}
|
|
};
|
|
|
|
Engine* TheEngine = nullptr;
|
|
|
|
// ================= GDBus ===================================================
|
|
constexpr const char* IntrospectionXml = R"xml(
|
|
<node>
|
|
<interface name="net.catcrafts.IMS1">
|
|
<method name="Dial">
|
|
<arg type="s" name="number" direction="in"/>
|
|
<arg type="s" name="callUni" direction="out"/>
|
|
</method>
|
|
<method name="HangUp"><arg type="s" name="callUni" direction="in"/></method>
|
|
<method name="Accept"><arg type="s" name="callUni" direction="in"/></method>
|
|
<method name="SendDtmf">
|
|
<arg type="s" name="callUni" direction="in"/>
|
|
<arg type="s" name="tones" direction="in"/>
|
|
</method>
|
|
<method name="GetCalls"><arg type="aa{sv}" name="calls" direction="out"/></method>
|
|
<method name="GetStatus"><arg type="a{sv}" name="status" direction="out"/></method>
|
|
<signal name="CallAdded"><arg type="s" name="callUni"/><arg type="a{sv}" name="info"/></signal>
|
|
<signal name="CallStateChanged">
|
|
<arg type="s" name="callUni"/><arg type="s" name="state"/><arg type="s" name="reason"/>
|
|
</signal>
|
|
<signal name="CallDeleted"><arg type="s" name="callUni"/></signal>
|
|
<signal name="RegistrationChanged"><arg type="b" name="registered"/></signal>
|
|
</interface>
|
|
</node>)xml";
|
|
|
|
void HandleMethodCall(GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar* method, GVariant* params, GDBusMethodInvocation* inv, gpointer) {
|
|
std::string_view m = method;
|
|
if (m == "Dial") {
|
|
const gchar* number = nullptr;
|
|
g_variant_get(params, "(&s)", &number);
|
|
std::string uni = TheEngine->Dial(number ? number : "");
|
|
g_dbus_method_invocation_return_value(inv, g_variant_new("(s)", uni.c_str()));
|
|
return;
|
|
}
|
|
if (m == "HangUp") {
|
|
const gchar* uni = nullptr;
|
|
g_variant_get(params, "(&s)", &uni);
|
|
TheEngine->HangUp(uni ? uni : "");
|
|
g_dbus_method_invocation_return_value(inv, nullptr);
|
|
return;
|
|
}
|
|
if (m == "Accept") {
|
|
const gchar* uni = nullptr;
|
|
g_variant_get(params, "(&s)", &uni);
|
|
TheEngine->Accept(uni ? uni : "");
|
|
g_dbus_method_invocation_return_value(inv, nullptr);
|
|
return;
|
|
}
|
|
if (m == "SendDtmf") {
|
|
Log("SendDtmf accepted but not yet sent (TODO RFC4733)");
|
|
g_dbus_method_invocation_return_value(inv, nullptr);
|
|
return;
|
|
}
|
|
if (m == "GetCalls") {
|
|
GVariantBuilder b;
|
|
g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
|
|
for (auto& [uni, info] : Calls)
|
|
g_variant_builder_add_value(&b, CallVariant(info));
|
|
g_dbus_method_invocation_return_value(inv, g_variant_new("(aa{sv})", &b));
|
|
return;
|
|
}
|
|
if (m == "GetStatus") {
|
|
GVariantBuilder b;
|
|
g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
|
|
g_variant_builder_add(&b, "{sv}", "registered", g_variant_new_boolean(StatusSnap.registered));
|
|
g_variant_builder_add(&b, "{sv}", "local", g_variant_new_string(StatusSnap.local.c_str()));
|
|
g_variant_builder_add(&b, "{sv}", "pcscf", g_variant_new_string(StatusSnap.pcscf.c_str()));
|
|
g_variant_builder_add(&b, "{sv}", "expiry", g_variant_new_int64(StatusSnap.expiry));
|
|
g_variant_builder_add(&b, "{sv}", "cseq", g_variant_new_int64(StatusSnap.cseq));
|
|
g_variant_builder_add(&b, "{sv}", "ppi", g_variant_new_string(StatusSnap.ppi.c_str()));
|
|
g_dbus_method_invocation_return_value(inv, g_variant_new("(a{sv})", &b));
|
|
return;
|
|
}
|
|
g_dbus_method_invocation_return_dbus_error(inv, "org.freedesktop.DBus.Error.UnknownMethod", "no such method");
|
|
}
|
|
|
|
const GDBusInterfaceVTable Vtable = { HandleMethodCall, nullptr, nullptr, {} };
|
|
|
|
void OnBusAcquired(GDBusConnection* conn, const gchar*, gpointer) {
|
|
DbusConn = conn;
|
|
GDBusNodeInfo* node = g_dbus_node_info_new_for_xml(IntrospectionXml, nullptr);
|
|
g_dbus_connection_register_object(conn, ObjPath, node->interfaces[0], &Vtable, nullptr, nullptr, nullptr);
|
|
g_dbus_node_info_unref(node);
|
|
Log(std::format("object registered at {}", ObjPath));
|
|
}
|
|
|
|
gboolean OnTerm(gpointer loop) {
|
|
Log("SIGTERM — stopping engine (SA kept)");
|
|
if (TheEngine) TheEngine->Stop();
|
|
g_timeout_add_seconds(2, [](gpointer l) -> gboolean {
|
|
g_main_loop_quit(static_cast<GMainLoop*>(l)); return G_SOURCE_REMOVE; }, loop);
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) {
|
|
bool session = false;
|
|
for (int i = 1; i < argc; i++)
|
|
if (std::string_view(argv[i]) == "--session") session = true;
|
|
|
|
if (argv[0]) {
|
|
std::string p = argv[0];
|
|
auto slash = p.find_last_of('/');
|
|
if (slash != std::string::npos) SelfDir = p.substr(0, slash);
|
|
}
|
|
|
|
if (!session && geteuid() != 0) {
|
|
std::println(std::cerr, "imsd: must run as root (xfrm / qmicli)");
|
|
return 1;
|
|
}
|
|
|
|
std::string dev = EnvOr("DEV", "qmapmux0.0");
|
|
std::string local = EnvOr("LOCAL", "");
|
|
if (local.empty()) {
|
|
if (auto l = DetectLocal(dev)) local = *l;
|
|
}
|
|
if (local.empty() && !session) {
|
|
std::println(std::cerr, "imsd: no global IPv6 on {} — is the ims PDN up?", dev);
|
|
return 1;
|
|
}
|
|
Log(std::format("LOCAL={} P-CSCF=[{}]:{}", local, EnvOr("PCSCF", "(unset)"), EnvOr("PCSCF_PORT", "5060")));
|
|
|
|
Engine engine;
|
|
engine.SetLocal(local);
|
|
engine.SetDevMode(session);
|
|
TheEngine = &engine;
|
|
|
|
MainLoop = g_main_loop_new(nullptr, FALSE);
|
|
guint owner = g_bus_own_name(
|
|
session ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM, BusName,
|
|
G_BUS_NAME_OWNER_FLAGS_NONE, OnBusAcquired,
|
|
[](GDBusConnection*, const gchar* name, gpointer) { Log(std::format("owning {}", name)); },
|
|
[](GDBusConnection*, const gchar* name, gpointer lp) {
|
|
Log(std::format("lost {} — exiting", name));
|
|
g_main_loop_quit(static_cast<GMainLoop*>(lp));
|
|
},
|
|
MainLoop, nullptr);
|
|
|
|
g_unix_signal_add(SIGTERM, OnTerm, MainLoop);
|
|
g_unix_signal_add(SIGINT, OnTerm, MainLoop);
|
|
|
|
// Run the engine on a pthread with an explicit 8 MiB stack: musl's default
|
|
// thread stack is only 128 KiB, and the registration paths hold 64 KiB SIP
|
|
// recv buffers on the stack (a std::thread here segfaults on entry). The
|
|
// registration is bus-independent, so start it immediately.
|
|
pthread_t engineTid{};
|
|
pthread_attr_t attr;
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setstacksize(&attr, 8 * 1024 * 1024);
|
|
pthread_create(&engineTid, &attr, [](void*) -> void* { TheEngine->Run(); return nullptr; }, nullptr);
|
|
pthread_attr_destroy(&attr);
|
|
|
|
Log(std::format("starting on the {} bus", session ? "session" : "system"));
|
|
g_main_loop_run(MainLoop);
|
|
|
|
engine.Stop();
|
|
pthread_join(engineTid, nullptr);
|
|
g_bus_unown_name(owner);
|
|
g_main_loop_unref(MainLoop);
|
|
return FatalExit ? 1 : 0;
|
|
}
|