Negotiating MAP versions through TCAP application context

The Transaction Capabilities Application Part provides a framework for structured queries between SS7 network elements, including mobility procedures, roaming interactions, and short message handling. Each TCAP conversation opens with a BEGIN message that identifies the application and negotiates which version both peers will use.

The application context is the named agreement that makes this negotiation possible, encoding operations, error definitions, and abstract syntaxes in a single object identifier that names the MAP version. This agreement is what lets a Mobile Application Part dialogue coordinate across switches built by different vendors in different decades.

For operators in Australia, where Telstra, Optus, and Vodafone Australia run overlapping 2G, 3G, and 4G cores alongside the National Broadband Network, this negotiation is not academic. The Australian Communications and Media Authority regulates inter-carrier interoperability, and a botched negotiation can mean failed location updates for international roamers at Mascot or Tullamarine.

Understanding TCAP dialogues

A TCAP exchange begins when an invoking node sends a BEGIN containing a Dialogue Request component. That component lists the supported application contexts and embeds the first component, such as a MAP Update Location request. The peer answers with a CONTINUE carrying a Dialogue Response indicating whether the chosen context is accepted, rejected, or substituted with a fallback version.

Components carry the application work. Invoke, Return Result, Return Error, and Reject are the four types defined by ITU-T Q.771. The TCAP layer does not interpret them; it simply delivers them between endpoints that share a common application context.

Anatomy of the application context name

Application context names are encoded as object identifiers. For MAP, ITU-T and 3GPP register distinct OIDs for each version, and these OIDs carry semantic meaning beyond simple addressing. The OID for short message service differs from the OID for location services, and within location services a MAP v3 context differs from a MAP v4 context.

When a mobile switching centre initiates a dialogue, it places one or more AC names in the Dialogue Request. If multiple versions are listed, the peer may select any it supports and echoes the selection back. This list-based offer is the heart of MAP version negotiation and allows mixed Australian carrier cores to agree on the latest supported release without forcing legacy endpoints to understand new operations.

Evolution of MAP versions

MAP v2 was the GSM workhorse, supporting basic mobility and supplementary services. MAP v3 added GPRS support and refined handover, while MAP v4 introduced CAMEL triggers that enabled prepaid and value-added services common in the Australian prepaid market.

Each version was bound to a specific application context OID. Older cores advertised MAP v2 OIDs, while newer nodes added MAP v3 and v4 OIDs alongside. The SS7 stack itself has shifted from MTP transport to SIGTRAN with SCTP, and the application context negotiation has moved with it.

Step-by-step negotiation procedure

The negotiation starts when the invoking endpoint constructs a BEGIN message, places the highest version OID it supports in the application context name field, and embeds the first invoke. The message is wrapped in SCCP and routed to the destination point code.

The receiving node parses the BEGIN, looks up the offered context, and constructs a CONTINUE response. If supported, it echoes the OID; if not, it substitutes a lower version; if none is supported, it issues a Dialogue Abort. Dialogue timers enforce a bounded wait, and operators tune them to allow for cross-Pacific signalling latency from Australian cores.

Interoperability challenges

Negotiation succeeds when both ends agree, but operations may still fail. A vendor that accepts the negotiation but does not implement the operations defined in the negotiated context produces a dialogue that opens cleanly but ends in a component-level Reject. Troubleshooting requires both the trace and a careful reading of the negotiated application context.

If the peer selects a different version than offered, subsequent invokes may use operation names the peer does not recognise. Australian carriers maintain detailed interworking documents to capture these corner cases.

Security considerations

Application context negotiation is a signalling surface, and a misconfigured endpoint can be coaxed into downgrading to an older MAP version. Securing the session beyond the application context layer, through security measures in SIGTRAN TLS IPsec and SCTP authentication, closes many of these gaps by ensuring the transport itself cannot be tampered with.

Operators are subject to the Telecommunications (Interception and Access) Act 1979, and retaining the dialogue request and response allows security teams to correlate negotiated versions with subsequent activity, particularly when investigating unauthorised location queries on domestic subscribers.

Operational guidance

Production deployments benefit from a staging lab that mirrors the negotiation behaviour of every connected peer. Australian carriers frequently run such labs in Sydney and Melbourne, where they replicate international partner behaviour and verify fallback to a lower version when a peer refuses the highest offered context.

Network teams also benefit from diverse tooling. While TCAP traces are the primary diagnostic, broader online resources can illustrate how various platforms surface structured data; for example, gaming portals such as live dealer casino cashback demonstrate how structured offers are presented, a useful analogy when designing operator-facing negotiation dashboards.

MAP version	Context OID family	Key additions
v2	GSM 0.4.0.1.0.21	Basic mobility, SMS transfer
v3	3GPP 0.4.0.1.0.23	GPRS, refined handover
v4	3GPP 0.4.0.1.0.25	CAMEL, LCS, enhanced SMS

Always record the negotiated application context alongside the component-level operations. The dialogue-level context tells you what both peers agreed to, while the component-level trace tells you what they actually did. The pair together turns a puzzling signalling failure into a fixable configuration problem.