Practice
When two subscribers start calling each other at the same moment, both get a «busy» signal. Why doesn't the telephone network recognize the mutual call and connect them automatically, instead of returning busy?
In traditional telephony (PSTN, ISDN), and even in most mobile networks, the logic is as follows:
Subscriber A sends a request to establish a call to subscriber B.
The network checks whether B is free.
If at that same moment:
Subscriber B also sends a request to A,
to the network this looks like two simultaneous incoming calls to the same number.
The network cannot «guess» that the people are calling each other.
It simply sees a conflict over a resource (the number).
A phone number is «one incoming connection at a time».
The second call automatically gets:
“busy here / user busy / line busy” → «busy».
There are several reasons — all of them technical.
Neither the PSTN standard, nor SS7, nor SIP has a mechanism for:
«If two subscribers called each other, connect them».
To the network, these are simply two independent calls.
The normal procedure:
Caller → server → Called
Called answers: the call is accepted
The server connects the media channels
But in the case of a mutual call:
A considers itself the caller
B also considers itself the caller
while the network requires that one be the Calling party and the other — the Called party
Otherwise a connection is impossible.
This is the key point.
SIP, GSM, and SS7 have no state for:
«both subscribers are calling each other — start the conversation»
Only the following are supported:
Idle
Outgoing call
Incoming call
Connected
Busy
Two OUTGOING states at once cannot exist → BUSY.
If the network tried to automatically connect mutual calls, it would be possible to create infinite loops:
A ↔ B
B ↔ C
C ↔ A
This breaks the signaling structure.
That is why the protocols have a strict rule:
«If two parties are calling each other — both are busy».
This is an example of a signaling loop, where each caller simultaneously becomes a callee, but in different pairings.
That is, for subscribers A, B, C:
A calls B
B calls C
C calls A
The result is a closed loop of calls, which telephone networks consider an erroneous and prohibited state.
Why is this dangerous for the telephone network? Because the network ends up holding three incomplete calls, each waiting for an answer, but:
A cannot accept the call from C, because A itself is calling B
B cannot accept the call from A, because B is calling C
C cannot accept the call from B, because C is calling A
None of the calls can complete.
SS7 signaling gateways or SIP servers perceive this state as a call loop.
Loops are dangerous because they:
occupy communication channels,
cause endless redial attempts,
create signaling load,
can lead to switch overload.
That is exactly why telephony standards have introduced strict rules:
If a subscriber's line is already occupied by an outgoing call,
return BUSY for an incoming one.
This guarantees that loops are impossible.
In reality, such a scenario among ordinary people is unlikely:
it would require three people to start calling each other literally within the same second.
But the network must be protected even against rare cases, so:
outgoing call → line busy
incoming during an outgoing call → BUSY
mutual calls → BUSY
any cycles → BUSY
Because there are no «numbers» or legacy network restrictions there.
The app creates the channel, and the server simply determines:
if both initiated a call → accept the first one
the second is automatically treated as an «accept», not a «new call»
This cannot be done in telephony without changing the standards of every operator.
Both hear «busy» because:
the network doesn't know the calls are mutual
PSTN/SS7/SIP signaling does not support symmetric calls
a single number can have only one incoming state
the second call is treated as a conflict → BUSY.
Comments