SCCP Segmentation and Reassembly for Long User Data Packets
When a TCAP or MAP message grows beyond what a single SCCP unit can carry, the Signaling Connection Control Part breaks it apart, ships each piece through the SS7 network, and stitches it back together at the destination. This segmentation and reassembly behaviour is invisible on a healthy link, but it becomes the first thing engineers check when a roaming transaction, an SMS delivery, or a number-portability lookup stalls. In Australia, where signalling often crosses half a continent between a mobile switch in Sydney and an HLR in Melbourne, the cost of one dropped segment is felt immediately by end users.
The mechanics behind SCCP segmentation are often confused with the fragmentation done at MTP3 or by SIGTRAN adaptation layers. They sit at different layers, use different fields, and recover from loss in different ways. Understanding where one ends and the next begins is the difference between debugging a problem in minutes and chasing it across teams for days.
| Transport option | Native SCCP segment size | Where segmentation happens | Typical reset cause |
|---|---|---|---|
| SCCP over MTP3 | 127 octets | SCCP layer | Reassembly timer expiry |
| SCCP over SUA/M3UA | Configurable, often 1500+ | Sometimes bypassed | TCP socket reset |
| SCCP over SUA/M2PA | Configurable | SCCP or SUA | SCTP association failure |
| MTP3 over M2PA | 127 octets | SCCP layer | Link-level congestion |
What SCCP Segmentation Actually Does
SCCP segmentation operates on the user data portion of an SCCP message. When the data field exceeds a configured maximum — typically 127 octets when using MTP3 transport, or larger when SCCP runs over SUA — the originating SCCP layer splits the payload into smaller segments. Each segment keeps the same routing label but adds sequence information so the receiver knows where it belongs in the original message.
The reassembly side runs on the destination SCCP entity, buffering incoming segments and watching the sequence markers. It only delivers the complete user data to TCAP once every piece has arrived. If a piece never shows up, the reassembly timer expires and the transaction is aborted.
When Segmentation Gets Triggered
In practice, segmentation is rarely triggered by the average ISUP call setup. It shows up with TCAP-based services such as MAP operations, ANSI-41 authentication, and intelligent network queries. A USSD string, a prepaid recharge, or a roaming location update can all push the payload past the single-segment limit.
Australian operators see this most clearly around number portability and advanced supplementary services. A Telstra or Optus subscriber porting from a smaller MVNO can trigger multi-segment TCAP exchanges between donor and recipient networks. Lawful interception workflows governed by the Telecommunications (Interception and Access) Act 1979 also introduce longer parameter blocks into signalling chains, pushing some transactions across the segmentation boundary.
Fields That Drive Segmenting and Reassembling
SCCP uses three pieces of information to manage segmentation. The segmentation bit tells the receiver that more segments follow, the reassembly bit marks the final piece, and a sequence number pair lets both ends track continuity. These fields live in the SCCP message header, separate from the SLS and DPC fields used by MTP3 for routing.
Hop count handling differs: segmented messages keep their original routing label so they cannot loop, and the hop counter only decrements on the initial unit. Intermediate transfer points forward each segment without inspecting the payload, which keeps them fast but means any loss is only noticed at the final SCCP endpoint.
SCCP Over MTP3 and SIGTRAN Adaptation Layers
When signalling migrates from TDM to IP, SCCP no longer rides directly on MTP3. It can be carried by SUA over M3UA, by SUA over M2PA, or by MTP3 itself tunneled through one of these layers. Engineers mapping out where segmentation actually happens in each stack typically start from a SIGTRAN adaptation layers comparison.
SUA can carry larger native SCCP units without splitting them, which removes a layer of fragmentation. M3UA in pass-through mode hands SCCP back to MTP3 semantics and inherits the same 127-octet limit. The wrong adaptation layer for a high-volume TCAP service can quietly introduce segment loss on congested IP paths between data centres in Brisbane and Perth.
Practical Limits and Hop Counter Behaviour
Even with segmentation enabled, SCCP enforces a hop counter on the first segment. In Australian networks connecting multiple carriers, this counter is usually set high, but a misconfigured STP can still consume it before the message arrives. When that happens, the originator receives a return error instead of the expected reply, and the problem often looks like an application bug until someone checks the hop counter field.
Payloads above roughly 4000 octets are uncommon in production traffic and usually signal either a poorly designed TCAP structure or an embedded debugging payload left in by mistake. Both are worth flagging during signalling audits before they start consuming reassembly buffer space.
Operational Pitfalls in Australian Deployments
ACMA audits occasionally reveal misconfigurations where segmented SCCP traffic fails silently across interconnect boundaries. The most common cause is a mismatch in maximum SCCP segment size between two carriers, often uncovered after a number-portability batch or a SIM swap campaign. The smaller side segments, the larger side expects a single unit, and neither side ever reports an error.
Long-haul IP signalling between east-coast cities and remote sites near Alice Springs adds another wrinkle. Higher latency on these links gives reassembly timers less margin, so a retransmitted SCTP chunk can push a transaction over the edge. Engineers supporting these regions tend to tune reassembly timers upward and segment size downward, trading overhead for predictable behaviour.
Tuning and Debugging Long-Payload Issues
The first debugging step is almost always to capture full SCCP packets at both ends of a suspect transaction and compare the send and receive sequence numbers. A gap in the sequence — or a repeated sequence after a retransmission — points directly at the transport layer. Tools that decode SCCP alongside TCAP make the work faster because the segmentation fields sit only a few bytes from the application payload.
The practical next step is to run a controlled load test against the suspect link with a synthetic TCAP payload sized just above the configured segment limit, then watch the reassembly timer in the trace. If the timer expires under load, raising the segment size on the SCCP layer or moving the service to an SUA-based transport removes the constraint without touching the application code.
