Jorijn van der Graaf
92fba40da0
SendDtmf was a stub: GNOME Calls' SendTones and Plasma Dialer's sendDtmf reached imsd and went nowhere. The SDP parser reads the telephone-event payload type at the chosen codec's clock into the answer, among the m-line's formats only — an rtpmap the line does not list is not negotiated, and nothing is sent with a format the answer does not carry (RFC 3264 §8.3.2); an event's rate is its rtpmap clock (RFC 4733 §2.4.1), an offer with two codec clocks lists telephone-event at each, and the name is matched as every encoding name is, case-insensitively, with the clock whole. The media leg carries it, and imsd-media gets it as DTMF_PT with its stdin on a pipe from imsd, the control pipe. The SDP answer imsd sends to an inbound offer carries telephone-event by the same rule, where it echoed any telephone-event rtpmap with a lower-case name and a clock prefix before: an rtpmap off the offer's m-line is no longer echoed, an upper-case name now is. The decision is the engine's: OnDtmf lets the tones through on an active call that negotiated telephone-event (the answer's number on a call we placed, the offer's on one we answered) and drops them otherwise with a line that says why: before the answer, after the call, no telephone-event at the codec's clock in the SDP, a character that is no tone or more than 128 tones (then the whole string, never part of what was pressed); letters are upper-cased. The shell writes one `dtmf <tones>` line per SendDtmf, whole or not at all: the bound keeps the line within one atomic pipe write, the write end is non-blocking so that a leg that stopped reading fails the write instead of holding the engine thread, and a longer line is refused; SIGPIPE is ignored so that a write after the leg died fails with EPIPE instead of ending the daemon. The command queue's one argument is `arg` now — the number to dial, or the tones. The `media …` start line gains the telephone-event pt at its end. Tested: tests/Sdp and tests/Engine (the eight suites pass); the dev phone's dtmf benches ran in builds of this series (journal/ims/captures/2026-10-14-dtmf-bench-1/ onward).
355 lines
17 KiB
C++
355 lines
17 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
// lint-disable-file fixed-width-types
|
|
/*
|
|
Imsd:Sdp — SDP offer/answer building + parsing for the voice media plane.
|
|
|
|
The offer is by default an AMR-WB (octet-aligned) + AMR + telephone-event
|
|
shape with an optional GSMA IR.92 QoS-precondition block; it is what
|
|
commercial IMS cores expect from a VoLTE UE, and its exact bytes are pinned by
|
|
tests/Sdp. The parser extracts only what the media plane needs: remote
|
|
address/port, the negotiated payload type, the codec and octet-align mode, and
|
|
the telephone-event payload type among the m-line's formats at that codec's
|
|
clock (DTMF, RFC 4733) — it
|
|
reads answers to our offers and inbound offers alike (same fields either way).
|
|
The codecs it knows are the ones imsd-media can play: AMR-WB, AMR (narrowband)
|
|
and G.711 (PCMA/PCMU) — the last two are what a PSTN gateway offers when a
|
|
landline calls. An explicit codec list (the daemon's CODECS override) replaces
|
|
both the offered set and the acceptance preference: it is how the narrowband
|
|
path is exercised against a network whose gateway transcodes every caller up
|
|
to AMR-WB. BuildAnswer is the terminating side: it answers an inbound
|
|
offer with the offer's own payload type numbers (RFC 3264) and mirrors its
|
|
octet-align mode (RFC 4867 requires both directions to use one mode). Pure
|
|
std C++.
|
|
*/
|
|
|
|
export module Imsd:Sdp;
|
|
import std;
|
|
|
|
namespace imsd::sdp {
|
|
|
|
bool Is6(std::string_view addr) { return addr.contains(':'); }
|
|
|
|
// First token (up to whitespace/CR/LF) starting at `pos`.
|
|
std::string_view TokenAt(std::string_view body, std::size_t pos) {
|
|
std::size_t end = body.find_first_of(" \t\r\n", pos);
|
|
return body.substr(pos, end == std::string_view::npos ? std::string_view::npos : end - pos);
|
|
}
|
|
|
|
std::optional<int> ParseInt(std::string_view s) {
|
|
int v = 0;
|
|
auto [p, ec] = std::from_chars(s.data(), s.data() + s.size(), v);
|
|
if (ec != std::errc{} || p != s.data() + s.size()) return std::nullopt;
|
|
return v;
|
|
}
|
|
|
|
// First occurrence of `needle` anywhere in the body; nullopt if absent.
|
|
std::optional<std::size_t> Find(std::string_view body, std::string_view needle) {
|
|
std::size_t at = body.find(needle);
|
|
if (at == std::string_view::npos) return std::nullopt;
|
|
return at;
|
|
}
|
|
}
|
|
|
|
export namespace imsd::sdp {
|
|
|
|
// The codec names imsd-media plays, in the default acceptance order:
|
|
// wideband beats narrowband, AMR beats G.711 (a mobile-to-mobile call
|
|
// must never land on a G.711 leg just because the gateway listed it).
|
|
constexpr std::array<std::string_view, 4> kCodecs{"AMR-WB", "AMR", "PCMA", "PCMU"};
|
|
|
|
// A codec preference list from its textual form ("PCMA, amr-nb"):
|
|
// case-insensitive, spaces ignored, AMR-NB accepted for AMR, unknown
|
|
// names and repeats dropped. Empty in = empty out = the defaults.
|
|
std::vector<std::string> ParseCodecList(std::string_view spec) {
|
|
std::vector<std::string> out;
|
|
for (auto part : std::views::split(spec, ',')) {
|
|
std::string n;
|
|
for (char c : std::string_view(part))
|
|
if (c != ' ' && c != '\t') n += static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
|
|
if (n == "AMR-NB") n = "AMR";
|
|
if (std::ranges::find(kCodecs, n) == kCodecs.end()) continue;
|
|
if (std::ranges::find(out, n) == out.end()) out.push_back(n);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
struct Offer {
|
|
std::string local; // connection address (v4 or v6)
|
|
int rtpPort = 0;
|
|
std::uint64_t sessionId = 0; // o= sess-id/version; caller randomizes
|
|
bool precond = false; // IR.92 QoS preconditions block
|
|
std::string currRemote = "none"; // a=curr:qos remote <this>
|
|
std::vector<std::string> codecs; // offered codecs in order; empty = AMR-WB, AMR
|
|
};
|
|
|
|
// Our offer: AMR-WB (octet-aligned) first, AMR narrowband second — the
|
|
// 3GPP-mandatory codec every IMS core and PSTN gateway can answer, so a
|
|
// call we place TO a landline no longer depends on the far side
|
|
// transcoding up to wideband — each with telephone-event at its own
|
|
// clock. Byte layout is pinned by tests/Sdp. An explicit `codecs` list
|
|
// offers exactly those, in that order, with fixed payload types (97
|
|
// AMR-WB, 99 AMR, 8 PCMA, 0 PCMU) and telephone-event only at the clocks
|
|
// in use. G.711 is not offered by default: a VoLTE UE offering PCMA
|
|
// deviates from stock shapes for no gain.
|
|
std::string BuildOffer(const Offer& o) {
|
|
static const std::vector<std::string> kDefaultOffer{"AMR-WB", "AMR"};
|
|
const std::vector<std::string>& codecs = o.codecs.empty() ? kDefaultOffer : o.codecs;
|
|
bool wb = std::ranges::find(codecs, "AMR-WB") != codecs.end();
|
|
bool amr = std::ranges::find(codecs, "AMR") != codecs.end();
|
|
bool nb = codecs.size() > (wb ? 1u : 0u); // anything besides AMR-WB is 8 kHz
|
|
auto pt = [](const std::string& c) { return c == "AMR-WB" ? 97 : c == "AMR" ? 99 : c == "PCMA" ? 8 : 0; };
|
|
std::string ipver = Is6(o.local) ? "IP6" : "IP4";
|
|
std::string s;
|
|
s += "v=0\r\n";
|
|
s += std::format("o=- {} {} IN {} {}\r\n", o.sessionId, o.sessionId, ipver, o.local);
|
|
s += "s=-\r\n";
|
|
s += std::format("c=IN {} {}\r\n", ipver, o.local);
|
|
s += "t=0 0\r\n";
|
|
std::string pts;
|
|
for (const auto& c : codecs) pts += std::format(" {}", pt(c));
|
|
if (wb) pts += " 98";
|
|
if (nb) pts += " 100";
|
|
s += std::format("m=audio {} RTP/AVP{}\r\n", o.rtpPort, pts);
|
|
s += std::format("b=AS:{}\r\n", wb ? 41 : amr ? 30 : 80);
|
|
s += "b=RS:512\r\n";
|
|
s += "b=RR:1536\r\n";
|
|
for (const auto& c : codecs) {
|
|
if (c == "AMR-WB") {
|
|
s += "a=rtpmap:97 AMR-WB/16000/1\r\n";
|
|
s += "a=fmtp:97 octet-align=1;mode-change-capability=2;max-red=0\r\n";
|
|
} else if (c == "AMR") {
|
|
s += "a=rtpmap:99 AMR/8000/1\r\n";
|
|
s += "a=fmtp:99 octet-align=1;mode-change-capability=2;max-red=0\r\n";
|
|
} else {
|
|
s += std::format("a=rtpmap:{} {}/8000/1\r\n", pt(c), c);
|
|
}
|
|
}
|
|
if (wb) {
|
|
s += "a=rtpmap:98 telephone-event/16000\r\n";
|
|
s += "a=fmtp:98 0-15\r\n";
|
|
}
|
|
if (nb) {
|
|
s += "a=rtpmap:100 telephone-event/8000\r\n";
|
|
s += "a=fmtp:100 0-15\r\n";
|
|
}
|
|
s += "a=ptime:20\r\n";
|
|
s += "a=maxptime:240\r\n";
|
|
if (o.precond) {
|
|
s += "a=curr:qos local sendrecv\r\n";
|
|
s += std::format("a=curr:qos remote {}\r\n", o.currRemote);
|
|
s += "a=des:qos mandatory local sendrecv\r\n";
|
|
s += "a=des:qos mandatory remote sendrecv\r\n";
|
|
}
|
|
s += "a=sendrecv\r\n";
|
|
return s;
|
|
}
|
|
|
|
struct Answer {
|
|
std::string ip; // empty = no c= line found
|
|
int port = -1; // -1 = no m=audio line found
|
|
int payloadType = -1;
|
|
bool octetAlign = false;
|
|
std::string codec = "AMR-WB"; // "AMR-WB" | "AMR" | "PCMA" | "PCMU" | "" (none we play)
|
|
std::optional<int> dtmfPt; // telephone-event at the codec's clock rate; nullopt = no DTMF
|
|
};
|
|
|
|
// Sample rate of a codec we play: AMR-WB is 16 kHz, everything else
|
|
// (AMR, G.711) is narrowband 8 kHz. Also the RTP clock rate.
|
|
int CodecRate(std::string_view codec) { return codec == "AMR-WB" ? 16000 : 8000; }
|
|
constexpr std::string_view Avp = " RTP/AVP "; // after the m=audio port: the one profile we speak
|
|
|
|
// The m=audio line's payload types in its order; empty without the line,
|
|
// its port or the " RTP/AVP " literal.
|
|
std::vector<int> AudioFormats(std::string_view body) {
|
|
std::vector<int> pts;
|
|
auto m = Find(body, "m=audio ");
|
|
if (!m) return pts;
|
|
std::string_view portTok = TokenAt(body, *m + 8);
|
|
std::size_t afterPort = *m + 8 + portTok.size();
|
|
if (!ParseInt(portTok) || !body.substr(afterPort).starts_with(Avp)) return pts;
|
|
// digits + spaces up to CR/LF
|
|
std::size_t ptsBegin = afterPort + Avp.size();
|
|
std::size_t ptsEnd = body.find_first_not_of("0123456789 ", ptsBegin);
|
|
std::string_view ptsRun = body.substr(ptsBegin, ptsEnd == std::string_view::npos ? std::string_view::npos : ptsEnd - ptsBegin);
|
|
for (auto part : std::views::split(ptsRun, ' '))
|
|
if (auto v = ParseInt(std::string_view(part))) pts.push_back(*v);
|
|
return pts;
|
|
}
|
|
|
|
// A payload type's rtpmap encoding, `NAME/CLOCK[/CHANNELS]` upper-cased
|
|
// (RFC 4566 §6: encoding names are case-insensitive); empty without one.
|
|
std::string Rtpmap(std::string_view body, int pt) {
|
|
const std::string key = std::format("a=rtpmap:{} ", pt);
|
|
auto at = Find(body, key);
|
|
if (!at) return "";
|
|
std::size_t begin = *at + key.size();
|
|
std::size_t end = body.find_first_of("\r\n", begin);
|
|
std::string enc(body.substr(begin, end == std::string_view::npos ? std::string_view::npos : end - begin));
|
|
for (char& c : enc)
|
|
c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
|
|
return enc;
|
|
}
|
|
|
|
// Payload type of `telephone-event/<clockRate>` among the m=audio line's
|
|
// formats (DTMF, RFC 4733); nullopt when the line lists none. An rtpmap
|
|
// the line does not list is not negotiated: nothing is sent with a format
|
|
// the answer does not carry (RFC 3264 §8.3.2). The clock is matched
|
|
// whole: `/8000` is not `/80000`.
|
|
std::optional<int> TelephoneEventPt(std::string_view body, int clockRate) {
|
|
const std::string needle = std::format("TELEPHONE-EVENT/{}", clockRate);
|
|
for (int pt : AudioFormats(body)) {
|
|
const std::string enc = Rtpmap(body, pt);
|
|
const bool whole = enc.size() == needle.size() || (enc.size() > needle.size() && (enc[needle.size()] == '/' || enc[needle.size()] == ' '));
|
|
if (enc.starts_with(needle) && whole) return pt;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
// The encoding name an offer gives a payload type: its a=rtpmap line,
|
|
// upper-cased (RFC 4566 §6: encoding names are case-insensitive), else
|
|
// the static assignment for 0/8 (RFC 3551 §6 — a G.711 offer may carry
|
|
// no rtpmap at all). Empty when neither applies.
|
|
std::string CodecName(std::string_view body, int pt) {
|
|
const std::string enc = Rtpmap(body, pt);
|
|
if (!enc.empty()) return enc.substr(0, enc.find('/'));
|
|
if (pt == 0) return "PCMU";
|
|
if (pt == 8) return "PCMA";
|
|
return "";
|
|
}
|
|
|
|
// The offer's audio payload types with their names, "8 PCMA, 96 AMR,
|
|
// 101 telephone-event" — for the log line of a refused offer, so a
|
|
// field journal says WHAT the gateway offered without a raw SIP dump.
|
|
std::string OfferedCodecs(std::string_view body) {
|
|
auto m = Find(body, "m=audio ");
|
|
if (!m) return "no m=audio line";
|
|
std::size_t lineEnd = body.find_first_of("\r\n", *m);
|
|
std::string_view line = body.substr(*m, lineEnd == std::string_view::npos ? std::string_view::npos : lineEnd - *m);
|
|
std::string out;
|
|
int field = 0;
|
|
for (auto part : std::views::split(line, ' ')) {
|
|
std::string_view tok(part);
|
|
if (field++ < 3 || tok.empty()) continue; // m=audio <port> <proto> <pt>...
|
|
auto pt = ParseInt(tok);
|
|
if (!pt) continue;
|
|
std::string name = CodecName(body, *pt);
|
|
if (!out.empty()) out += ", ";
|
|
out += name.empty() ? std::format("{}", *pt) : std::format("{} {}", *pt, name);
|
|
}
|
|
return out.empty() ? std::string(line) : out;
|
|
}
|
|
|
|
// Payload-type preference: AMR-WB with octet-align=1 > AMR-WB > AMR with
|
|
// octet-align=1 > AMR > PCMA > PCMU (kCodecs order). Octet-aligned wins
|
|
// within a codec because it is the media leg's native, call-proven
|
|
// format (bandwidth-efficient is supported but was the s56 static-audio
|
|
// culprit) — when the peer offers both variants, taking the
|
|
// octet-aligned pt keeps real calls on the battle-tested path. A
|
|
// non-empty `prefs` replaces the codec order (and restricts acceptance
|
|
// to the codecs named) — the CODECS override. With no acceptable codec
|
|
// at all, the first pt is used and codec comes back EMPTY — pretending
|
|
// otherwise would defeat codec checks upstream. The telephone-event pt
|
|
// is the one at the chosen codec's clock (an event's rate is its rtpmap
|
|
// clock, RFC 4733 §2.4.1; an offer with two codec clocks lists
|
|
// telephone-event at each), so a tone goes out on the stream's own clock.
|
|
Answer ParseAnswer(std::string_view body, std::span<const std::string> prefs = {}) {
|
|
Answer a;
|
|
if (auto at = Find(body, "c=IN IP6 ")) a.ip = TokenAt(body, *at + 9);
|
|
else if (auto at4 = Find(body, "c=IN IP4 ")) a.ip = TokenAt(body, *at4 + 9);
|
|
|
|
auto m = Find(body, "m=audio ");
|
|
if (!m) return a;
|
|
std::string_view portTok = TokenAt(body, *m + 8);
|
|
auto port = ParseInt(portTok);
|
|
// both the port and the " RTP/AVP " literal are required
|
|
std::size_t afterPort = *m + 8 + portTok.size();
|
|
if (!port || !body.substr(afterPort).starts_with(Avp)) return a;
|
|
a.port = *port;
|
|
|
|
std::vector<int> pts = AudioFormats(body);
|
|
if (pts.empty()) return a;
|
|
|
|
auto hasOctetAlign = [&](int p) {
|
|
auto fm = Find(body, std::format("a=fmtp:{} ", p));
|
|
if (!fm) return false;
|
|
std::size_t lineEnd = body.find_first_of("\r\n", *fm);
|
|
std::string_view line = body.substr(*fm, lineEnd == std::string_view::npos ? std::string_view::npos : lineEnd - *fm);
|
|
return line.contains("octet-align=1");
|
|
};
|
|
struct Seen { int first = -1; int oa = -1; };
|
|
std::map<std::string, Seen> seen; // codec name -> first pt, first octet-aligned pt
|
|
for (int p : pts) {
|
|
std::string name = CodecName(body, p);
|
|
if (std::ranges::find(kCodecs, name) == kCodecs.end()) continue;
|
|
Seen& s = seen[name];
|
|
if (s.first == -1) s.first = p;
|
|
if (s.oa == -1 && name.starts_with("AMR") && hasOctetAlign(p)) s.oa = p;
|
|
}
|
|
auto pick = [&](std::string_view name) {
|
|
auto it = seen.find(std::string(name));
|
|
if (it == seen.end()) return false;
|
|
a.payloadType = it->second.oa != -1 ? it->second.oa : it->second.first;
|
|
a.codec = std::string(name);
|
|
return true;
|
|
};
|
|
bool found = false;
|
|
if (prefs.empty()) {
|
|
for (std::string_view n : kCodecs) if ((found = pick(n))) break;
|
|
} else {
|
|
for (const std::string& n : prefs) if ((found = pick(n))) break;
|
|
}
|
|
if (!found) {
|
|
a.payloadType = pts.front();
|
|
a.codec.clear();
|
|
}
|
|
a.octetAlign = a.codec.starts_with("AMR") && hasOctetAlign(a.payloadType);
|
|
if (!a.codec.empty()) a.dtmfPt = TelephoneEventPt(body, CodecRate(a.codec));
|
|
return a;
|
|
}
|
|
|
|
struct AnswerSpec {
|
|
std::string local; // connection address (v4 or v6)
|
|
int rtpPort = 0;
|
|
std::uint64_t sessionId = 0; // o= sess-id/version; caller randomizes
|
|
int payloadType = 97; // the offer's pt for the chosen codec
|
|
bool octetAlign = true; // mirror of the offer's mode (AMR codecs only)
|
|
std::string codec = "AMR-WB"; // "AMR-WB" | "AMR" | "PCMA" | "PCMU"
|
|
std::optional<int> dtmfPt; // the offer's telephone-event pt, if any
|
|
};
|
|
|
|
// SDP answer to an inbound audio offer: single codec at the offer's own
|
|
// payload type, octet-align echoed only when the offer used it (absence
|
|
// = bandwidth-efficient, RFC 4867 §8.1; G.711 has no fmtp at all),
|
|
// telephone-event kept when the offer's m-line lists one at the codec's
|
|
// clock (ParseAnswer's rule). b=AS is the codec's peak payload
|
|
// rate plus IP/UDP/RTP overhead at 20 ms. Byte layout pinned by tests/Sdp.
|
|
std::string BuildAnswer(const AnswerSpec& s) {
|
|
std::string ipver = Is6(s.local) ? "IP6" : "IP4";
|
|
int rate = CodecRate(s.codec);
|
|
int as = s.codec == "AMR-WB" ? 41 : (s.codec == "AMR" ? 30 : 80);
|
|
std::string out;
|
|
out += "v=0\r\n";
|
|
out += std::format("o=- {} {} IN {} {}\r\n", s.sessionId, s.sessionId, ipver, s.local);
|
|
out += "s=-\r\n";
|
|
out += std::format("c=IN {} {}\r\n", ipver, s.local);
|
|
out += "t=0 0\r\n";
|
|
if (s.dtmfPt) out += std::format("m=audio {} RTP/AVP {} {}\r\n", s.rtpPort, s.payloadType, *s.dtmfPt);
|
|
else
|
|
out += std::format("m=audio {} RTP/AVP {}\r\n", s.rtpPort, s.payloadType);
|
|
out += std::format("b=AS:{}\r\n", as);
|
|
out += "b=RS:512\r\n";
|
|
out += "b=RR:1536\r\n";
|
|
out += std::format("a=rtpmap:{} {}/{}/1\r\n", s.payloadType, s.codec, rate);
|
|
if (s.octetAlign && s.codec.starts_with("AMR")) out += std::format("a=fmtp:{} octet-align=1\r\n", s.payloadType);
|
|
if (s.dtmfPt) {
|
|
out += std::format("a=rtpmap:{} telephone-event/{}\r\n", *s.dtmfPt, rate);
|
|
out += std::format("a=fmtp:{} 0-15\r\n", *s.dtmfPt);
|
|
}
|
|
out += "a=ptime:20\r\n";
|
|
out += "a=maxptime:240\r\n";
|
|
out += "a=sendrecv\r\n";
|
|
return out;
|
|
}
|
|
}
|