Connect Jasmin SMS Gateway to TelecomsXchange

Jasmin sends to TelecomsXchange through an SMPP client connector and takes your traffic over its HTTP API or SMPP Server API. Everything is configured in jCli, Jasmin's management console. This guide adds the connector, puts the route's tech prefix on every number with an MT interceptor, sets up receipts, and lets TelecomsXchange bind to Jasmin when you sell SMS. For the values themselves, see Connect an SMPP platform.

Before you start#

• An SMPP account with its SMPP System Id and SMPP Password. Set its IP Address to your Jasmin server's public IP, for example 203.0.113.10.
• An SMS route and its tech prefix, for example 80039. Below, TECH_PREFIX stands for it.
• A sender ID registered on the account.
• Jasmin 0.10 or later with the interceptor service (interceptord) running, and jCli access: telnet 127.0.0.1 8990.

How do I send SMS through TelecomsXchange?#

1. Add the SMPP client connector:

jcli : smppccm -a
> cid tcxc
> host smpp01.telecomsxchange.com
> port 2776
> username SYSTEM_ID
> password PASSWORD
> bind transceiver
> elink_interval 30
> submit_throughput 10
> ok
Successfully added connector [tcxc]
jcli : smppccm -1 tcxc

SYSTEM_ID and PASSWORD are the account's SMPP System Id and SMPP Password. Set submit_throughput (messages per second; Jasmin's default is 1) to your account's SMPP Rate Limit (req/sec) or lower.

2. Write the interceptor script, for example /opt/jasmin-scripts/tcxc-prefix.py. Jasmin runs it for every MT message before routing:

# Prepend the TelecomsXchange tech prefix to destination_addr.
# 447700900123 or +447700900123 becomes 80039#447700900123.
TECH_PREFIX = b"80039#"   # your route's prefix, then '#'

pdu = routable.pdu
while pdu is not None:                       # every part of a long message
    dst = pdu.params["destination_addr"]
    if isinstance(dst, str):
        dst = dst.encode()
    dst = dst.lstrip(b"+")
    if not dst.startswith(TECH_PREFIX):
        pdu.params["destination_addr"] = TECH_PREFIX + dst
    pdu = getattr(pdu, "nextPdu", None)

3. Register it. A DefaultInterceptor runs for all MT traffic; use a StaticMTInterceptor with filters if only some traffic goes to TelecomsXchange:

jcli : mtinterceptor -a
> type DefaultInterceptor
> script python3(/opt/jasmin-scripts/tcxc-prefix.py)
> ok
Successfully added MTInterceptor [DefaultInterceptor] with order:0

4. Route MT traffic to the connector. Interception runs before routing, so a route filter sees the prefixed number:

jcli : mtrouter -a
> type DefaultRoute
> connector smppc(tcxc)
> rate 0.0
> ok
Successfully added MTRoute [DefaultRoute] with order:0

5. Create a group and a user for your application, then save everything:

jcli : group -a
> gid apps
> ok
jcli : user -a
> username app
> password APP_PASS
> uid app
> gid apps
> ok
jcli : persist

6. Send through the HTTP API (port 1401 by default) with a plain number:

curl -G "http://127.0.0.1:1401/send" \
  --data-urlencode "username=app" \
  --data-urlencode "password=APP_PASS" \
  --data-urlencode "to=447700900123" \
  --data-urlencode "from=MyBrand" \
  --data-urlencode "content=Test from Jasmin" \
  --data-urlencode "dlr=yes" \
  --data-urlencode "dlr-url=http://127.0.0.1/dlr" \
  --data-urlencode "dlr-level=3"

Applications can also bind to Jasmin's SMPP Server API (port 2775 by default) with the same user and send submit_sm; the interceptor applies to both.

How do I receive delivery receipts?#

Request receipts per message: dlr=yes with a dlr-url and dlr-level on the HTTP API (3 for both SMSC and terminal level), or registered_delivery on submit_sm from SMPP clients. Jasmin stores the message_id from TelecomsXchange's submit_sm_resp; when the deliver_sm with id:<message_id> and stat:DELIVRD arrives on the tcxc connector, it calls your dlr-url or sends a deliver_sm to your bound SMPP client.

Jasmin keeps unacknowledged messages for dlr_expiry seconds (86400 by default). Receipts reach Jasmin only while the connector is bound; keep con_loss_retry at its default yes.

How do I receive SMS from TelecomsXchange as a seller?#

Jasmin's SMPP Server API accepts binds natively. TelecomsXchange binds to it as a transceiver from 174.136.44.213, as a Jasmin user.

1. Create a group and a user whose username and password are the SMPP System Id and SMPP Password you set on your TelecomsXchange SMS route:

jcli : group -a
> gid tcxc
> ok
jcli : user -a
> username TCXC_SYSTEM_ID
> password TCXC_PASSWORD
> uid tcxc
> gid tcxc
> smpps_cred authorization bind yes
> smpps_cred quota max_bindings 4
> mt_messaging_cred authorization smpps_send yes
> ok
jcli : persist

A Jasmin username is 1 to 15 letters, digits, _ or -, and a password at most 16 characters, so choose route credentials that fit.

2. Route the traffic TelecomsXchange sends you to your own connectors with MT routes, for example a StaticMTRoute with a UserFilter for uid tcxc and connector smppc(my_operator). If you use the prefix interceptor above, give it a filter so it doesn't touch this user's traffic.
3. Allow 174.136.44.213 to the SMPP Server API port (2775 by default) on your firewall. Jasmin users have no IP restriction of their own.
4. On your route in Routes → My Routes, enter IP:2775, SMPP Version 3.4, Field for Messages short_message, TLS No, and Allowed BIND Sessions no higher than max_bindings.

Jasmin answers each submit_sm with its own message_id and sends the receipt back to TelecomsXchange's bind when your operator connector reports delivery.

Inbound SMS for numbers you sell: add a second connector (cid tcxc_did) to the same host and port with username did and password did (or your custom DID credentials), and route messages for those numbers to it without the prefix interceptor. When you buy numbers, set the number's SMPP Endpoint to a Jasmin user, smpp:USER:PASS:number@203.0.113.10:2775; TelecomsXchange binds to it and delivers the SMS as MO.

How do I test it?#

1. In jCli, smppccm -l lists the tcxc connector; its Session should be BOUND_TRX. On TelecomsXchange, the account's Bind Status shows ONLINE.
2. Send the curl request above. Jasmin answers Success "<message id>".
3. Check the connector log (for example /var/log/jasmin/default-tcxc.log) for the SubmitSM with destination_addr: b'80039#447700900123', its response with status ESME_ROK, and the DeliverSM receipt.
4. Go to Logs → SDR (SMS), choose All Messages and click Search SMS.

What if something goes wrong?#

References#

• Jasmin jCli modules: smppccm, user, group, mtrouter, mtinterceptor, filters
• Jasmin message interception
• Jasmin HTTP API
• Jasmin SMPP Server API
• Jasmin source: HTTP /send parameter validation