NPSTN Docs

History

Created and founded by Dylan Cruz, NPSTN rolled into its beta phase in August 2018 but quickly matured after that. By the beginning of 2019, NPSTN lay claim to approximately a dozen different nodes in several different countries (including the US, the UK, Canada, Australia, and Norway). Conceived as an alternative and supplement to C*NET, NPSTN today is a fully-fledged VoIP telephone network for phone phreaks and phone collectors.

To understand in a nutshell what makes NPSTN unique, here are a few major differences between NPSTN and C*NET:

• C*NET uses ENUM lookups whereas NPSTN uses custom APIs
• NPSTN has a more "phreak-friendly" culture that is more tolerant of phreaking activities, i.e. tandem stacking
• Far more DISAs exist on NPSTN and nearly all use city dialtones
• Nearly 100% of the network sounds on NPSTN are pre-Precise Tone Plan sounds
• While C*NET uses country codes, NPSTN uses only conventional 7-digit numbers
• NPSTN features special numbers like 0, N11, POPCORN, etc.

Otherwise, the two networks are both very similar. Both are home to phreaks and collectors, Asterisk boxes, and electromechanical switches. Both use IAX trunking and both have redundant lookup systems. Many node operators are on both networks, and gateways exist between the two networks, as well as from the PSTN.

Though Cruz remains at the head of development on NPSTN, particularly the backend, there are other large contributors to the network as well. Albert has spearheaded improvements to webpages and documentation and has been responsible for the creation of a large amount of Asterisk dialplan code part of the network today, including centralized and automatic operator services. He is also the main developer on the BBS and backend terminal systems, including those used by NPSTN operators. Much thanks to Brian Clancy, a longtime C*NET node owner, who taught Cruz and Albert much of what each knew about Asterisk, encouraging the two to write clean, proper, well-documented Asterisk code. You could say he serves as a sort of experiential consultant. Brian has been a major help and resource to both throughout the entire process and NPSTN as it is would not exist without his help, advice, and Asterisk wisdom and expertise. All three have been a part of NPSTN almost since the beginning and constitute its "core development team", bouncing ideas off of each other (although this also takes place on the public NPSTN listserv), discussing network standards, and testing dialplan code.

In its current phase, the next major addition to NPSTN is StepNet, which will (to a limited extent) simulate PSTN tandem switching back in the day. Calls will be routed through NPSTN nodes in a geographically realistic way until they reach their destination. StepNet is a layer on top of NPSTN, and is an experience that can be toggled on or off. StepNet is currently in development, but you can peruse its related documentation here and keep up with the project as progress is made.

Update: StepNet in its first phase is already reality! You can make StepNet calls over NPSTN. The next phase in the project is completing StepNet calls through electromechanical switches, which will require more complicated routing.

Hardware

To operate your own NPSTN node, you will need a server running Asterisk, a powerful but free VoIP/TDM/analog PBX/CO switch software solution. You don't need a powerful system to run Asterisk — many node operators on C*NET and NPSTN use servers with 1GB of RAM or less — even 512MB will be sufficient. uLaw (pronounced mu-law or, frequently but erroneously, u-law), is the preferred codec in the United States for VoIP, as it is 64kbps, or PSTN quality. Consequently, you will also need an Internet connection (but you knew that already, didn't you?). Although you can operate a node even with a very low-speed Internet connection, it is undesirable to have a connection speed of under 512kbps. A T1 (1.544Mbps) will be sufficient, and any package of broadband Internet will be more than enough bandwidth for several VoIP calls.

Some of the core servers on NPSTN are hosted servers, meaning they are not physically located at the premises of their owners. Hosted servers can be a great option for those just getting started or those without decent Internet connections or the space and resources to operate an on-premises Asterisk server. If you go this route, do understand its limitations. First, we can't stress enough how important it is to choose a reputable host. Initially, the main nodes on NPSTN were hosted by HiFormance on a plan that was (wait for it!) $10/year. Of course, you know what they say: if it sounds too good to be true, it probably is. In mid-December 2018, without warning, HiFormance servers stopped working without warning — owners were unable to SSH into the servers and the services on them went down. With some effort, it was discovered that HiFormance was closing its doors. Ironically, a post on the website informed its customers that HiFormance would be closing its doors and that data should be backed up, yet, HiFormance never emailed its customers and most people discovered this only after their servers stopped working. Fortunately, all of the NPSTN servers had been fully backed up and were soon operational with a new host.

Operating your Asterisk server locally is also an option. Almost any old computer from this millennium will suffice, but your options are really quite flexible. Asterisk can run seamlessly on a Raspberry Pi, which is a compact, low-energy solution that works well for many node operators. While you may run into roadblocks with connecting channel banks and other equipment to a Pi, for those with just ATAs (analog telephone adapters), a Pi should be more than sufficient. Many NPSTN nodes are operated using Raspberry Pis.

From our experiences with multiple VPS providers, we've seen some of the things that work and don't work well. We recommend using Digital Ocean's $5 per month Droplet, which is very affordable and reliable. You can sign up using our referral link if you aren't already a member, and we'll both get some free credit! Thanks for keeping our costs low, so we can work on more cool projects for you!

Software

Asterisk PBX is a free open-source VoIP PBX solution that has "taken the telecom industry by storm". It is used by both C*NET and NPSTN and is a requirement for operating a node, no matter what hardware is being used.

To start with, you'll need a flavor of Linux (also free and open-source) in order to run Asterisk. We recommend Debian, which works well on a variety of platforms. Any Linux commands featured in this documentation will assume an instance of Debian, but if you use a different flavor of Linux, you can consult your operating system's documentation for the proper commands and syntax. In many cases, minor variations in syntax and keywords will be the key distinguishment.

As for Asterisk itself, we recommend using Asterisk 18. Unlike other software packages, Asterisk has a large number of versions circulating, a great number of which are currently in use. Systems running Asterisk 1.0 and 1.2, for instance, are plentiful on C*NET. For our purposes, we've not needed any legacy functionality found in these versions that the newer versions lack; however, if you choose to install the Project MF patches on your system, an older version may be required.

Pre-Requisites

First, before doing anything, make sure the timezone on your server is set properly. By default, it will probably be UTC (Universal Coordinated Time, a.k.a. Greenwich Mean Time). If you live in North America, this is of little use to you. You will want the time to be set to your local time so that in the console and in the logs, the times accurately reflect your experience. Even if you don't care, you should still change the time to your local timezone (and if you have a hosted server, you should change it to your timezone, not that of the locality in which the server is hosted). Your server's time is used for various things, including the NPSTN "mock billing system", which depends on accurate timekeeping by each node (more on this in the "Billing" section).

For those on Debian 9, our OS of choice (we recommend Debian 10 now) for running Asterisk, here are some short and sweet instructions on how to change the time.

Essentially, it comes down to the following:

At the shell prompt, type timedatectl list-timezones

Make note of the name that corresponds to your region. Now, change the timezone by typing a command like this one:

sudo timedatectl set-timezone America/Chicago

The above would set your timezone to Central Time.

Now, verify the time is correct by executing timedatectl alone.

After this, there are a few packages you will want or need that are easy to install!

The following packages are not Asterisk-related but are a valuable asset to anyone operating a Linux-based server. Generally, you can install a package from the default Debian repository by typing sudo apt-get install name where name is what you are trying to install. Here are a few must-haves for any server exposed to the Internet:

• NIST — time synchronization
  sudo apt-get install ntp -y
• iptables — a versatile firewall, can block IP addresses, ports, etc.
  sudo apt-get install iptables -y
• tcpdump — can help identify spammer IP addresses
  sudo apt-get install tcpdump -y (to use just run tcpdump port 5060, or whatever your SIP port is)
• sudo
  apt-get install -y sudo
• fail2ban — a valuable supplement to iptables, can dynamically block IP addresses after repeated authentication failures. Read more about how to install and configure fail2ban.

fail2ban can be used to block SIP spam in Asterisk, which, combined with changing the SIP bindport away from 5060, can very effectively eliminate spam.

The process essentially comes down to:

• Installing fail2ban
• Run touch /var/log/asterisk/security
• In /etc/asterisk/logger.conf, enable the security log by uncommenting it
• Add the following to /etc/asterisk/fail2ban/jail.local, creating the file if needed:

  [DEFAULT]
  bantime = 1h
  ignoreip = 
  
  [sshd]
  enabled = true
  
  [asterisk-iptables]
  # if more than 4 attempts are made within 6 hours, ban for 24 hours
  enabled  = true
  filter   = asterisk
  action   = iptables-allports[name=ASTERISK, protocol=all]
  logpath  = /var/log/asterisk/security
  maxretry = 4
  findtime = 21600
  bantime = 86400
  
  				

• Run service fail2ban restart. Note that if the security file does not exist yet, fail2ban will crash (hence the touch command)
• To see blocked IPs that were blocked specifically due to Asterisk-related attacks, run fail2ban-client status asterisk-iptables

Once you have iptables installed, run the following command from the shell command-line:

It has been reported that 79% of honeypot traffic gets blocked by this one rule!

Here are some other Linux tools you'll want specifically for Asterisk. They are not required for basic Asterisk functionality but you will want to be sure they are all installed. The rest of this documentation will assume that the following components are available on your system. Here's how you would install them from the Debian command line:

• wget — a basic tool for downloading files non-interactively (may already be installed)
  sudo apt-get install -y wget
• curl — a basic tool for extracting the content of online documents (may already be installed)
  sudo apt-get install -y curl
• sox — for converting audio files to the proper formats for Asterisk
  sudo apt-get install -y sox
• OpenSSL — for crypto and encrypted calls
  sudo apt-get install -y libcurl4-openssl-dev
• mpg123 — for playing mp3 streams
  sudo apt-get install -y mpg123
• dig — for querying DNS servers
  sudo apt-get install -y dnsutils
• PHP — required for the pulsar (revertive-pulsing) add-on as well as speech-to-text
  sudo apt-get install -y php
• Festival — required for text-to-speech
  sudo apt-get install -y festival
• Basic Calculator — required for more complex calculations
  sudo apt-get install -y bc
• Apache — required for web server
  sudo apt-get install -y apache2 a2enmod ssl a2enmod rewrite a2enmod proxy_http a2enmod proxy_connect systemctl restart apache2

If you need a free SSL certificate, you can use Let's Encrypt to get one:

sudo apt install snapd
sudo snap install core
sudo snap install hello-world
hello-world
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot
sudo certbot certonly --apache
sudo certbot renew --dry-run
			

Newer versions of Asterisk may have some issues, but here is one list of pre-reqs for Asterisk 18, courtesy S. Y.:

# Install dependencies
apt -y install linux-headers-`uname -r` \
build-essential \
binutils-dev \
git \
bison \
flex \
default-libmysqlclient-dev \
freetds-dev \
libbluetooth-dev \
libcodec2-dev \
libcurl4-openssl-dev \
libedit-dev \
libfftw3-dev \
libghc-postgresql-simple-dev \
libgmime-3.0-dev \
libical-dev \
libjansson-dev \
libneon27-dev \
libosptk-dev \
libnewt-dev \
libradcli-dev \
librust-backtrace-dev \
libsndfile1-dev \
libspandsp-dev \
libspeexdsp-dev \
libsqlite0-dev \
libsqlite3-dev \
libssl-dev \
libunbound-dev \
libvorbis-dev \
libxml2-dev \
unixodbc-dev \
uuid-dev \
xmlstarlet \
libiksemel-dev \
libtolua-dev \
libsrtp2-dev \
libldap2-dev \
libsnmp-dev \
libpopt-dev 
			

Installing Asterisk

There are several different ways to use Asterisk. Packages like FreePBX exist that offer a GUI (graphical user interface) for configuration, which runs on Asterisk behind the scenes. You can, of course, use "just Asterisk", which is commonly referred to as "vanilla Asterisk", and this is by far the best option and is highly recommended. While GUI-based options like FreePBX may make it easier to get started initially, they are not worth it in the long-run, as you will find yourself restricted in terms of what you can configure, as much of the customizability and flexibility of Asterisk disappears when you use a GUI like FreePBX. We learned this the hard way, as the main NPSTN tandem was running on FreePBX, and Dylan had more than a few problems with it. When the core servers were migrated from HiFormance to VPSCheap, Dylan installed vanilla Asterisk as opposed to FreePBX - and for good reason. The rest of this documentation will assume you are using vanilla Asterisk as it is the only way to truly realize the full power of Asterisk, much of which is tapped into on NPSTN.

While there are many ways to install Asterisk on your system, the best and most reliable way to install Asterisk is by compiling from source. On one occasion, we installed Asterisk from its binaries in the default Debian repository with the result that all of our existing dialplan code didn't work, and other strange issues were encountered as well: differing directory structures, improper reloading of modules, etc.

While providing a tutorial on how to install Asterisk from source is beyond the scope of this documentation, we can point you to some Asterisk documentation as to how to do it.

If you already have an Asterisk server for, say, C*NET, or your own personal VoIP network at home, you can use the same server and the same instance of Asterisk for NPSTN. You have total flexibility with regards to how your Asterisk system is set up. You can choose to reserve the same NPSTN office code as you have on C*NET or you may opt for an entirely different one. You can create different extensions for NPSTN or provide access to the same extensions that your C*NET numbers map to, it's up to you.

WARNING: DO NOT INSTALL ASTERISK WITHOUT INSTALLING ALL THE PRE-REQS! Otherwise, you will probably find later that you are missing something that requires you to recompile and reinstall Asterisk after installing that pre-req. Do it right the first time!

Asterisk 13 was originally recommended for NPSTN, but Asterisk 13 EOL is at the end of 2021 and it is no longer receiving bug fixes. We now recommend Asterisk 18, the newest LTS version. It will be supported the longest out of 16 and 18 and has been more stable than v16 in our experience.

Here are instructions for Debian 10 and the latest version of Asterisk 18 (18.3.0 as of this writing), boiled down to just the commands:

rm -rf /usr/lib/asterisk/modules # optional - if upgrading Asterisk, wipe out all the modules in advance of the upgrade, to remove old modules that aren't in the new versions
cd /usr/src
wget https://downloads.asterisk.org/pub/telephony/asterisk/asterisk-18-current.tar.gz
tar -zxvf asterisk-18-current.tar.gz
cd asterisk-18.3.0
./contrib/scripts/install_prereq install

./contrib/scripts/get_mp3_source.sh
./configure --with-jansson-bundled
sed -i 's/ast_answer(chan)/\/\/ast_answer(chan)/g' apps/app_confbridge.c
cp contrib/scripts/voicemailpwcheck.py /usr/local/bin
chmod +x /usr/local/bin/voicemailpwcheck.py

The above sed one-liner simply comments out ast_answer(chan) in the ConfBridge() application code. This prevents ConfBridge() from automatically providing answer supervision, since there is no way to prevent it from doing so through the dialplan. The patch is strongly recommended if you intend to use ConfBridge in any, um, creative ways (since there is often no way to accomplish something in Asterisk without using ConfBridge(), and often times answer supervision is explicitly undesired). This patch will allow you to manually control answer supervision, with the caveat that you must supervise when you intend to. For more details, see Non-Supervising Conference Bridges.

If you need to support older ATAs, run the following two lines — otherwise, TLS will not work with older ATAs (such as the Linksys SPA-2102 and Grandstream HT7xx series), and encryption won't be possible. TLS 1.0 isn't great, but it's better than nothing. If you only have recent/modern ATAs, you can probably skip this step:

sed -i 's/TLSv1.2/TLSv1.0/g' /etc/ssl/openssl.cnf
sed -i 's/DEFAULT@SECLEVEL=2/DEFAULT@SECLEVEL=1/g' /etc/ssl/openssl.cnf

If you do make the changes above, it would not be a bad idea to reboot at this point.

Now, to begin the actual Asterisk compilation process:

make menuselect

• Add-ons: format_mp3
• Applications: macro → Macros are now deprecated and should no longer be used, but if you still have some around or would like to be able to run them, this needs to be enabled in v16+
• Core Sound Packages - Change from GSM to ULAW (required because, unfortunately, the Pat Fleet repository does not replace every single stock recording)
• Music On Hold: Check ULAW
• Extras Sound Package: Check ULAW (optional)

Save & Exit.

make
make samples # do not run this on upgrades or it will wipe out your config!
make install
make config
			

If you freshly installed Asterisk, open modules.conf for editing (e.g. nano /etc/asterisk/modules.conf) and look for this:

noload => chan_sip.so
			

If this line is present and you want to continue using the older SIP channel driver as opposed to the newer PJSIP channel driver, replace chan_sip.so with chan_pjsip.so. Most of the documentation here covers SIP currently, but note that SIP is deprecated and will be eventually removed from Asterisk. However, SIP is also more beginner-friendly and may be a better way to get started.

That's it! Enjoy your new Asterisk install!

Reserving an Office Code

Although you can dial into NPSTN from C*NET or the PSTN using inbounds without configuring your server at all, at some point, you'll probably want to become a full member of NPSTN with your own NPSTN node so you can dial other NPSTN numbers directly. Doing so is incredibly simple!

First, go to the NPSTN Contact Form or call the NPSTN business office and ask to join the network; simply call one of our external access numbers (dial any number that is listed as "terminating to" DISA, from either C*NET or the PSTN, then dial 0). We ask that you be considerate and only claim as many numbers as you actually need and will use. A thousands-block (NNX-X, or 1,000 numbers) should be enough for most people just getting started.

No matter how many numbers you'd like to stake a claim on, check the NPSTN Directory first and make sure someone hasn't already reserved the number blocks you want. For an easier (but more technical) view, you can also check the NPSTN route table which lists all assigned thousand blocks. Note that individual number assignments are not listed in the route table. For example, the number 867-5309 is in use and not available on NPSTN.

If you opt to fill out the form linked above as opposed to calling the NPSTN business office personally, please be sure to provide the following information:

• Thousand blocks you wish to acquire (NNX-X not NXX-X)
• Full Name
• Email Address
• Telephone Number (either C*NET or PSTN)
• Server IP Address or FQDN/DDNS
• IAX Username
• IAX Password
• IAX Authentication Mode (None, plaintext, md5, rsa)
• What you will use your office code for
• Exchange Name
• Physical Location, including ZIP code if you are in the U.S.
• Time zone
• PSTN NPA (area code) if located in the NANPA and PSTN phone number
• CLLI — we don't store this for you, but you control your CLLI code via the NPSTN ticketing system.

If you don't know what IAX usernames are, don't worry - they'll be covered in "Initial Configuration". Simply opt for the de facto "npstn" IAX username.

A note about CLLIs is warranted here: you may be familiar with how CLLIs are used on the PSTN — each central office telephone exchange has a unique CLLI. Multiple exchanges (NXXs) may be served off of one physical switch, and consequently, multiple exchanges may share a CLLI. A CLLI is a unique identifier for each switch. You have one CLLI per physical switch, not one per NNX-X or NNX. For our purposes, you can just make up a CLLI for use on NPSTN. Don't be hasty, though! You will need this later and you won't easily be able to change this later on. The CLLI, to be standards-compliant, should be NPSTN followed by 4 to 8 more additional characters briefly characterizing your switch's location and/or function. If you're drawing a blank here or haven't any ideas, NPSTNMS0 (master switch), NPSTNNA01 (North America 1), and NPSTNCFL01 (Central Florida 1) and NPSTNCFL02 are some examples of existing CLLIs on NPSTN. Create a CLLI that makes sense for your switch that matches the format above.

To get with the spirit of 2L+5N dialing (as opposed to 7N dialing), we encourage you to pick out an exchange name for your assigned numbers. Unless you have a good reason not to, it should be a Bell System-approved exchange name. You may wish to consult a list of telephone exchange names. Note that the exchange name you pick does not have to coordinate with adjacent exchanges. As an example, 288 on NPSTN is BUtterfield8 while 285 is, not BUtterfield5, as some might think, but ATwater5.

Exchange names appear in the directory and the Business Office should receive notification of them.

Note:If you only need 10 numbers or fewer, we can host numbers for you. Go to the Hosted Lines tab in the UCP after you've registered.

User Control Panel

Regardless of whether you operate your own node or are hosted on another, you will need an account to access to the NPSTN User Control Panel. This is used to add directory entries and access any mock billing statements issued to you (more on this in the "Billing" section). Contact us with your name, ZIP code, city, and state - as well as timezone and area code - to get this setup. We will email you your auth key (you cannot create an account yourself). Node owners should not add directory entries for others using their UCP key. All members should have their own auth key to access the UCP which they should use to add directory entries for themselves — and nobody else.

Boilerplate Code

The sections "Initial Configuration" and "Common Contexts" contain individual contexts in a well-documented manner for those thirsty for the details. However, for your convenience, if you'd like to get up and running with little attention to the details, you can simply use our boilerplate code. Below, you'll find an essential copy of each of the vital Asterisk configuration files you'll need to get started. You will need to adjust some things, such as properly setting certain variables and defining numbers, and so forth, but the code is otherwise plug and play.

If you are getting started for the first time, backup the files below on your system. Then, replace them with the ones below and go through each file, customizing to the extent required as directed.

• iax.conf
• sip.conf — note that SIP is deprecated and will eventually be removed from Asterisk
• musiconhold.conf
• verification.conf — a separate dialplan file containing just the code for the verification contexts, to minimize the clutter in extensions.conf — put this in either /etc/asterisk or /etc/asterisk/dialplan
• extensions.conf

You will need at least a few audio files to get started — the basic call progress tones and intercepts. We encourage all node owners to add variety to NPSTN by giving their nodes their own unique soundscapes. However, if you want to get up and running immediately, we've assembled a set of the basic audio files you will need. Download these files and place them in /var/lib/asterisk/sounds/en/custom/signal/, unless otherwise stated:

• dialtone.ulaw
• busy.ulaw
• reorder.ulaw
• ccad.ulaw
• acbn.ulaw
• ringback.ulaw — save in /var/lib/asterisk/moh/ringback/

Note that the above is not your one-stop shop for getting started! Be sure you have completed everything outlined in the "Pre-Requisites" section above, including changing your server's timezone to your local timezone!

The code above is only a starting point. Many of the contexts individually laid out in this documentation, like the simulated signalling subroutines (e.g. MFer, SFer, dial pulser) are not included in the configuration files above. Only the basics that every node really needs to fully participate in NPSTN are included above. Beyond the contents of the files above, you may wish to further add to your system using other contexts outlined in this documentation.

For maximal network functionality, it is recommended for a node to have the eXtensible dialplan. Many common and helpful routines and contexts are part of the eXtensible dialplan and are updated with new functionality or patches as necessary.

Note: New to Asterisk? No problem — we're here to help! Simply call the business office at 811 on NPSTN and we'll help get you set up.

Encryption

A word about authentication and encryption:

By default, VoIP, even using IAX2, is not encrypted. Encryption is easy, and it's now included in the boilerplate iax.conf. No other changes are necessary and there are not compatability issues. Some will argue that MD5 is not very robust, but it's better than nothing.

A few notes about IAX2 encryption that are not obvious from looking at the official Asterisk IAX2 or encryption documentation:

• Plain text authentication does not support encryption (note the difference!). Hence, authentication is a necessary but insufficient condition alone for IAX2 encryption.
• Encryption requires either MD5 or RSA authentication
• Plain Text and MD5 authentication use identical configurations and dial syntax. The difference is that MD5 uses a challenge/response rather than sending the password in plain text across the wire
• A password may be provided even if the dialed destination does not require one. That is perfectly OK. Obviously, if that password is not defined by the peer (and no password is), the call will proceed as usual and it will not be encrypted or authenticated. If the dialed endpoint happens to require authentication and that is, in fact, the correct password, the call will be encrypted.
• You can tell if IAX2 encryption is working by doing a packet capture in Wireshark. Do a packet capture of an unauthenticated/unencrypted call and then compare with a packet capture of an encrypted call. Import it into Wireshark: the unencrypted pcap will have lots of 7Es, 7Fs, and FFs (if the call was mostly silence); the encrypted call should appear to be mostly random.
• If you analyze a packet capture of an encrypted call in Wireshark, you may see G.723.1 in the first couple hundred packets. This is nonsense. Wireshark doesn't know the protocol of the packets, since the stream is encrypted.
• In the Asterisk console, a call is not encrypted if you see Accepting UNAUTHENTICATED call... when a call comes in. It must say Accepting AUTHENTICATED call...

[myrsaendpoint]
type=peer
host=iaxhost.example.com
username=iaxuser
auth=rsa
forceencryption=yes
outkey=privatekeyname
secret=iaxpassword
				

cd /tmp
wget https://code.phreaknet.org/asterisk/iaxrsa.patch
cd /usr/src/asterisk-18.4.0/
patch -u -b channels/chan_iax2.c -i /tmp/iaxrsa.patch
make channels
make install
asterisk -rx "core restart now"
				

cd /var/lib/asterisk/keys/
openssl genrsa -des3 -out npstnrsa.key -passout pass:SOMESECRETPASSWORDHERE 2048
openssl rsa -in npstnrsa.key -pubout -passin pass:SOMESECRETPASSWORDHERE -out npstnrsa.pub
				

cd /var/lib/asterisk/keys/
astgenkey -q -n npstnrsa
cat npstnrsa.pub | curl -X POST --data-urlencode "rsakey=$(</dev/stdin)" -d 'auth_key=YOURNPSTNAUTHKEY'  https://npstn.us/ucp?page=rsa # upload your public key to the NPSTN key repo
touch /etc/asterisk/iax-rsa-npstn-in.conf
touch /etc/asterisk/iax-rsa-npstn-out.conf
				

module reload res_crypto
keys init
keys show
				

[npstn-rsa]
type = user
context = from-npstn ; your primary incoming dialplan context, typically from-npstn. THIS MUST BE LISTED FIRST.
context = npstnextensible ; eXtensible dialplan. Not that important for RSA.
context = sntandem ; StepNet. Good candidate for RSA.
context = from-npstn-operator ; Operator. Good candidate for RSA.
context = from-npstn-tieline ; For tie line access. Good candidate for RSA.
auth = rsa
forceencryption = yes
requirecalltoken = yes
secret=yourmd5secret ; this MUST be exactly the same as your NPSTN IAX2 MD5 user secret.
#include iax-rsa-npstn-in.conf ; this file contains the inkeys

#include iax-rsa-npstn-out.conf
				

inkeys=npstnrsa ; colon-separated list of public keys to accept

				

[dialnpstn] ; NPSTN 20190215 NA, updated 20210518 to add RSA support ; Sends a call to NPSTN
exten => start,1,Set(LOCAL(num)=${ARG1})
	same => n,GotoIf($[${LEN("${ARG4}")}>2]?clidoverride)
	same => n,Set(LOCAL(lookup)=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&cid=${CALLERID(num)}&sntandem=${ARG2}&zipcode=${ARG3}")})
	same => n,Goto(verify)
	same => n(clidoverride),Set(lookup=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&sntandem=${ARG2}&zipcode=${ARG3}")})
	same => n(verify),Gosub(lookupchan,s,1(${lookup})) ; verifies lookup for extra security
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-BLOCKED,1)
	same => n,Gosub(lookupipcheck,s,1(${lookup})) ; verifies the destination is a public IP address
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?:npstn-BLOCKED,1) ; proceed if 0
	
	same => n(dial),Gosub(dialnpstn-rsa,s,1(${lookup},${num}))
	same => n,ExecIf($["${GOSUB_RETVAL}"="0"]?Dial(${lookup},,gF(autovonpreempted-callee,${autovonchan},1))) ; if RSA dial failed, fallback to primary non-encrypted or MD5
	
	same => n,Verbose(2, ${CALLERID(num)} -> ${num}: DIALSTATUS: ${DIALSTATUS} / HANGUPCAUSE: ${HANGUPCAUSE})
	same => n,Goto(npstn-${DIALSTATUS},1)
				

Initial Configuration

At this point, we will assume you have a working Asterisk server and have reached out to get some numbers on NPSTN allocated to you. In the meantime, you can work on getting your exchange setup so that everything will be working by the time your exchange appears in the route table (which usually occurs in less than 1 business day).

A note about Asterisk directories is necessary at this point. For those of you using the regular (compiled from source) version of Asterisk on Debian Linux, directories of particular importance are noted below:

/etc/asterisk/ — where the Asterisk configuration files reside
/var/lib/asterisk/agi-bin/ — where Asterisk AGI programs go
/var/lib/asterisk/moh/ — where music-on-hold audio files reside
/var/lib/asterisk/sounds/en/custom/ — where your custom audio files go (most any audio besides MOH)
/var/log/asterisk/ — where the Asterisk logs are located
/var/spool/asterisk/ — where recordings and voicemails are created

As you spend more time working Asterisk, you'll become more and more familiar with these directories.

To get started, we need to adjust some settings and configure some settings. The following configuration (.conf) files are all located in /etc/asterisk/. You will need to modify them. There are a few ways you can do this. You can opt for the "local modification" approach or the "direct modification" approach.

• Local Modification — this entails keeping a local copy of all your configuration files, essentially mirroring what is on the server. The principle is simple: perform all your edits locally, and do a one-way write to the server to copy your changes over. If you opt for this approach, you can use a text-editor of your choice, like Notepad++ on Windows, to make changes. If you go this route, you don't need to worry separately about backups, either, since what is on the server in production is just a copy of your local files. If you haven't modified a particular file before, you'll need to copy it over from the server, first.
  If you are using Notepad++, you can add a custom language package to Notepad++ to add dialplan color syntax highlighting.
• Direct Modification — this entails directly modifying the files on the server. Since there is no GUI, this involves using command-line based text editors, like nano or vim. If you are comfortable with doing complex text manipulation and editing in the terminal, you may find this to be an easier approach. If you go this route, you won't need to worry about version conflicts, but you will need to ensure your configuration files are being backed up (along with your other files, like audio files, etc.!)

Regardless of which method you are using, but particularly if you opt for the local modification approach, you will need an SFTP client, like FileZilla. If you use FileZilla, you will need to change the "Default Transfer Type" to binary. You can do this by going to Edit → Settings → Transfers → FTP: File Types → Default transfer type. Select "Binary" and uncheck the two "Treat files… as ASCII file(s)" at the bottom as well.

You will need to use an FTP client like FileZilla (but using the SFTP protocol) to transfer over your audio files as well as your .conf files each time you make a revision if you opt for the local modification editing approach. You can use your client's site manager to save your connection settings so you don't need to re-enter the connection information each time.

[options]
verbose = 3
timestamp = yes
				

[modules]
autoload=yes
				

noload => chan_skinny.so ; Don't load skinny (tcp port 2000)  
noload => chan_mgcp.so ; Don't load MGCP (udp port 2727)
noload => chan_unistim.so ; Don't load unistim (udp port 5000)
noload => chan_ooh323.so ; Don't load ooh323 (tcp port 1720)
noload => chan_323
noload => pbx_dundi.so ; Don't load dundi (udp port 4520)
				

[general]
bindport=5060
allowguest=no ;keep intruders out
alwaysauthreject=yes    ;make life difficult for scanners trying to find a way into your dialplan
nat=force_rport,comedia ;should make nat more secure
registertimeout=30
registerattempts=2
tos_sip=cs3      ; Sets TOS for SIP packets.
tos_audio=ef     ; Sets TOS for RTP audio packets.
threewaycalling = yes
transfer = yes
disallowed_methods=UPDATE
srvlookup=yes
				

[ATAs](!) ; template for all personal ATAs
context = from-internal
type = peer
host = dynamic
disallow=all
allow=g722
allow=ulaw
allow=alaw
allow=g729
allow=gsm
allow=ilbc
allow=g726
qualify = yes
insecure = port,invite
canreinvite = no ; don't allow RTP voice traffic to bypass Asterisk
relaxdtmf = yes
progressinband = yes

[ATAx1](ATAs)
defaultuser = ATAx1
secret = verysecretpassword
authid = ATAx1
callerid = "John Smith" <5550101>
				

dtmf=rfc2833
				

dtmfmode=info
				

(0|[2-9]11|11[2-9]|660S0|95[89]|10[2-9]xx|100xx|101xxxx|[2-9][2-9]xxxxx|1[2-9][2-9]xxxxx)
				

{ 0|[2-9]11|11[2-9]|660|95[89]|10[2-9]xx|100xx|101xxxx|[2-9][2-9]xxxxx|1[2-9][2-9]xxxxx}
				

(<:20>S0)
				

(<:20>S0|11xx|*xx)
				

(S0<:5551111>)
				

[general]
relaxdtmf=yes ; If your server has issues with DTMF this option may help
bandwidth=high
disallow=all
allow=ulaw
allow=alaw
allow=g722
jitterbuffer=no
tos=0x12
calltokenoptional=0.0.0.0/0.0.0.0
requirecalltoken=no
delayreject=yes ; for increased security against brute force attacks
autokill=yes
encryption=yes
				

[npstn]
type=user
context=from-npstn
auth=md5
secret=weyfuyhwgoyhrgwrofghfosdf ; change this to whatever you want, but let the Business Office know what this is or you won't be able to receive calls!
forceencryption=yes

[npstn-operator] ; Incoming/outgoing operator routings (recommended)
type=user
context=from-npstn-operator
auth=md5
secret=npstnoperator362362 ; do not change
forceencryption=yes
requirecalltoken=yes

[sntandem] ; StepNet (required for StepNet tandems, otherwise unnecessary)
type=user
context=sntandem
auth=md5
secret=stepnet3545434756
forceencryption=yes
requirecalltoken=yes

[npstnextensible] ; eXtensible dialplan (optional)
type=user
context=npstnextensible
auth=md5
secret=npstnextensible18771871984 ; do not change: this is not supposed to be a "secret". Call the Business Office if you have questions
forceencryption=yes
requirecalltoken=yes
				

[npstn-tieline-NPSTNNA01] ; for tieline calls to/from NA01
type=user
context=from-npstn-tieline
auth=md5
secret=somesecretyoushouldchange
forceencryption=yes
requirecalltoken=yes
				

Before continuing, you may wish to reload or restart Asterisk. To restart Asterisk entirely, type core restart now at the Asterisk CLI. To just reload a particular module, you can generally type the module name followed by the reload, such as sip reload. To reload music-on-hold, for example, you would type moh reload. To reload voicemail, you would type voicemail reload. To reload the dialplan (which is something you'll end up doing quite frequently, you'll type dialplan reload. To reload all modules without restarting Asterisk, you can simply type reload.

Occasionally, you may need to reboot your server as well. To do this, from the Asterisk CLI, type exit to quit the Asterisk CLI and exit to the Linux command line. Then type reboot. That's it!

Incoming Route

The following will allow NPSTN calls to enter your dialplan:

[from-npstn-tieline]
exten => _sX!,1,Gosub(npstn-verify,${maindisa},1)
	same => n,ExecIf($["${clidverif:-1:1}"!="0"]?Hangup(21))
	same => n,Goto(npstn-public-tielines,${EXTEN:1},1)

[npstn-public-tielines]
exten => _X!,1,Hangup(34)
exten => 1,1,Goto(dt,s,1) ; should go *DIRECTLY* to dial tone (DISA) with NO inpulsing, e.g. dt,s,1
; additional tie lines can be added if you have multiple dial tones e.g. exten => 2,1,Goto(dt2,s,1) or exten => 2,1,Goto(dt,DT2,1), etc.

[from-npstn-operator] ; Incoming calls to/from NPSTN operators
exten => s,1,Goto(000,1)
exten => _X!,1,Gosub(npstn-verify,${EXTEN},1)
	same => n,ExecIf($["${clidverif}"!="10"]?Hangup(21))
	same => n,Set(GROUP(npstnoperatortrunks)=0)
	same => n,ExecIf($[${GROUP_COUNT(0@npstnoperatortrunks)}>10]?Hangup(34))
	same => n,Goto(npstn-operator-route,${EXTEN},1)

[from-npstn]
exten => _X!,1,GoSub(npstn-verify,${EXTEN},1)
	same => n,Gosub(npstn-blacklist-check,s,1)
	same => n,GotoIf($[${GOSUB_RETVAL}>=2.5]?reject)
	same => n,GotoIf($["${clidverif}"="11"]?:allow)
	same => n,GotoIf($[${GROUP_COUNT(npstnspam@cvs)}<5]?:reject)
	same => n(allow),Log(NOTICE, Incoming call from NPSTN: "${clidverif}" ${CALLERID(all)} at "${CHANNEL(peerip)}" to ${EXTEN})
	same => n,GoTo(external-users,${EXTEN},1)
	same => n(reject),Log(NOTICE, Incoming call from NPSTN rejected: "${clidverif}" ${CALLERID(all)} at "${CHANNEL(peerip)}" to ${EXTEN})
	same => n,Hangup(21)
			

The "5" only allows a maximum of 5 spam NPSTN calls. This way, if someone with malicious intentions tried to spam your node, only 5 calls would get through; all subsequent calls would get rejected.

See tie lines for more details on the tie line context.

The following will allow calls from your ATA to enter your dialplan:

[from-internal]
exten => _X!,1,Log(Local call from ATA: ${CALLERID(all)} at "${CHANNEL(peerip)}" to ${EXTEN})
	same => n,GoSub(clunkcomplete,s,1)
	same => n,GoTo(internal-users,${EXTEN},1)
			

Sending external and internal calls to separate contexts will give you more flexibility in terms of call routing and private/public destinations. For now, we'll assume that all internal destinations are available to all internal and external callers. To create an internal-only extension, you could create it in a separate context (e.g. [KLondike5-private] that you then include in internal-users).

[internal-users]
include => local
include => long-distance
include => invalidincoming

[external-users]
include => local
include => invalidincoming

[local]
exten => _${OC1}XXXX,1,GoTo(KLondike5,${EXTEN:-4:4},1)
			

By creating the [local] context, we can dial locally numbers that have been allocated to us, rather than falling through to [dialnpstn] and doing a lookup and effectively dialing out using an IAX trunk and dialing right back in.

If you happened to own only 555-1XXX, instead of all of 555-XXXX, you would change this line to:

exten => _${OC1}1XXX,1,GoTo(KLondike5,${EXTEN:-4:4},1)
			

Now, if you dial, say, 555-2638, a match won't be found in [local], so the call will go out to NPSTN. Speaking of which, here is the code necessary to do just that:

[long-distance]
exten => 0,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _11N,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _N11,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => 660,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _95[89],1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _10[02-9]XX,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _101XXXX,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _NNXXXXX,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
exten => _1NNXXXXX,1,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode}))
	same => n,Hangup()
			

Basic Contexts

Creating a separate context for your exchange helps compartmentalize your code. For example, if you were the owner of the 555 exchange on NPSTN, you might choose to create a KLondike5 context:

[KLondike5]
exten => 1111,1,GoTo(dt,DTXB,1)
exten => _89XX,1,SayDigits(${EXTEN}) ; your NNX-89XX extensions will read back the last 4 digits of the number called
include => invalidincoming
			

Here we have included a couple extensions for you to get started. You can easily and quickly create a few more "typical" extensions for your node, in particular a milliwatt number and an echo test (instructions for these are available in the "Vintage Add-Ons" section. Inevitably, you'll create a great number of your own as time goes on, once your system is fully set up. Other extensions you created will go in this context. If you have more than one office code, you can create another context (e.g. [KLondike6]) and add the appropriate line to [local] (e.g. exten => _${OC2}XXXX,1,GoTo(KLondike6,${EXTEN:-4:4},1)).

We have included the _89XX example for newbies particularly (you'll probably want to remove this line when copying it to your node), though this may also serve as a friendly reminder to more seasoned Asterisk programmers. When you do pattern matching (i.e. specifying a range of possible extensions, in this case 8900-8999, you must start with an underscore. Otherwise, it will take it to mean the literal extension "89XX", which is probably not what you want! Any time you match on multiple possible numbers, start with the underscore!

You can change the name of that context to one that makes sense for your exchange, or call it something else altogether. Make sure to update all references to that context.

You can create a line of code for each ATA port you have connected to Asterisk. This code assumes you followed the naming conventions outlined in sip.conf earlier.

[ata] ; Automatically dials the SIP peer by name (ARG1 = SIP peer name)
exten => s,1,Dial(SIP/${ARG1},,m(ringback)g)
	same => n,GotoIf($["${DIALSTATUS}"="CHANUNAVAIL"]?reorder,1)
	same => n,GotoIf($["${DIALSTATUS}"="BUSY"]?busy,1)
	same => n,GotoIf($["${DIALSTATUS}"="CONGESTION"]?reorder,1)
	same => n,GotoIf($["${DIALSTATUS}"="NOANSWER"]?reorder,1)
	same => n,Return()
exten => busy,1,GoSub(busy,s,1)
	same => n,Return()
exten => reorder,1,GoSub(reorder,s,1)
	same => n,Return()
exten => ccad,1,GoSub(ccad,s,1)
	same => n,Return()
exten => acbn,1,GoSub(allcktsbusy,s,1)
	same => n,Return()
			

Putting your busy and reorder signals in a separate subroutine will allow you to easily change the audio files used for busy and reorder in one place:

[busy]
exten => s,1,Playback(custom/busy,noanswer)
	same => n,Return()

[reorder]
exten => s,1,Playback(custom/reorder,noanswer)
	same => n,Return()

[allcktsbusy]
exten => s,1,Playback(custom/acbn,noanswer)
	same => n,Return()

[clunkcomplete]
exten => start,1,Playback(custom/clunk,noanswer)
	same => n,Return()

[ccad]
exten => s,1,Playback(custom/ccad,noanswer)
	same => n,Return()
			

[clunkcomplete] plays quick "clunk" sound, usually after the caller has finished dialing. You can find an electromechanical clunk sound of your choosing to play here. If you don't have a clunk sound, or would rather not play one, instead of deleting the reference to [clunkcomplete], you can simply modify [clunkcomplete] so it is as follows:

[clunkcomplete]
exten => start,1,Return()
			

If you examine this, you will see that this subroutine does not do anything beside immediately return. However, if you wish to add a clunk when a user finishes dialing a call at some point in the future, you can easily do so by adding a Playback() statement before the Return.

Playback() has a root of /var/lib/asterisk/sounds/en/ so you only need to specify directories downstream from that point. Of course, adjust the Playback() path to that of your audio files. You will need to use SoX to convert WAV recordings of your switch tones to μLaw files; refer to the SoX section in Appendix A for more information.

Notice that the file extension (.ulaw) is not specified. Asterisk will search for the best audio file for the call and automatically select that one. If there is only one file with that name (excluding the file extension), then you can be assured it will be the ulaw file.

Now, let's create the CBCAD context:

[invalidincoming]
exten => s,1,Playback(custom/ccad,noanswer)
	same => n,Hangup()
exten => _X!,1,GoSub(SIPxNumToPeer,s,1(${EXTEN}))
	same => n,GoToIf($["${GOSUB_RETVAL}"=""]?intercept:ata)
	same => n(ata),GoSub(ata,s,1(${GOSUB_RETVAL})) ; Dial SIP peer if it exists
	same => n,Hangup()
	same => n(intercept),GoSub(ccad,s,1) ; Intercept message if SIP peer does not exist
	same => n,Hangup()

[SIPxNumToPeer] ; NPSTNNA 20191130 ; Returns SIP peer of a number or empty string if peer/number does not exist
exten => s,1,Set(num=${ARG1})
	same => n,GotoIf($["${num}"=""]?dne)
	same => n,Set(scriptexists=${STAT(e,/etc/asterisk/scripts/sipcontext.sh)})
	same => n,GotoIf($["${scriptexists}"="1"]?use)
	same => n(download),SYSTEM(wget https://phreaknet.org/npstn/code/sipcontext.sh -P /etc/asterisk/scripts/)
	same => n(perm),SYSTEM(sudo chmod 777 /etc/asterisk/scripts/sipcontext.sh)
	same => n(use),Set(peer=${SHELL(/etc/asterisk/scripts/sipcontext.sh "${num}")})
	same => n,GotoIf($["${peer}"=""]?dne)
	same => n,Return(${peer})
	same => n(dne),Return()
			

We've included a cool helper context here! What SIPxNumToPeer does is translate a phone number to a SIP peer, if one with that ANI exists in your sip.conf. If it does, it will automatically dial the number. This allows dialplan editors to have the convenience of not needing to manually specify each SIP peer in the dialplan while retaining the ability to distinguish between SIP peers that are unreachable and SIP peers that do not exist at all. If you simply in your [invalidincoming] context, as a catch-all, just blindly lazily dialed the SIP peer, assuming it existed, the same CCAD intercept would apply to calls to numbers that don't exist and those that do but are just currently unreachable. This is not ideal, which is why the helper context gives us that power back by telling us whether the number exists or not.

In this sense, the invalidincoming name is a bit of misnomer, because the incoming call may be valid, but we just catch it here if the SIP peer wasn't explicitly specified in the dialplan, and if it exists, we complete it anyways. We don't use a exten => _X! in the main KLondike5 context, because this can create other issues with dialplan matching; a best practice is to always specify catch-alls or fallthroughs in a separate context that is then included.

Obviously, adjust the path specified to that of your CBCAD (cannot be completed as dialed) recording.

Global Variables

At this point, you will want to set some global variables. Add the following to the top of your extensions.conf:

[globals]
clli=NPSTNXY00
zipcode=00000
allowdisathru=YES
allowpstnthru=YES
maindisa=5551111
usedefaultblacklistresult=1
npstnkey=YOURNPSTNKEY
OC1=555 ; "KLondike5"
DTL=60
			

NOTE: All of these variables will need to be tweaked to match your setup, as follows:

• clli — this is the CLLI you chose for switch when reserving an office code. For example, if you chose NPSTNSTHTX01 (NPSTN South Texas Switch 1), then change this statement to clli=NPSTNSTHTX01.
• zipcode — pretty self-explanatory: this is the 5-digit ZIP code in which your switch is physically located. If you have a hosted server, you can choose to set this to either the ZIP in which you personally live or the ZIP in which your server is located (if you happen to know). Note that you should set this to a U.S. ZIP code if you are located in the United States. If you do not live in the U.S., you should set this to 00000, which indicates "international switch" on NPSTN.
• allowdisathru — this variable should be set to YES by default but can also take on the value NO. When set to YES, incoming calls from another node's DISA will be allowed to make outgoing calls via this node's DISA(s). If set to NO, incoming calls from another node's DISA will not be allowed to make outgoing calls from this node; instead, they will only be allowed to make calls to numbers on this node; other calls will be sent to intercept.
• allowpstnthru — similar to the allowdisathru global variable; if set to YES, callers from the PSTN that arrived at this node from another node will be allowed to make outgoing calls from this node. If set to NO, callers from the PSTN that arrived at this node from anotehr node will not be allowed to make outgoing calls from this node; instead, they will be "trapped" here — only allowed to make calls to numbers on this node; other calls will be sent to intercept.
• maindisa — this is the 7-digit NPSTN number of your switch's primary DISA (if you have more than one). Even if you don't have a DISA, set this variable equal to a number that has been assigned to that particular Asterisk switch. For instance, if you owned both 555 and 556, but the 555 exchange went to your home Asterisk server at one IP address and the 556 exchange went to your work Asterisk server at another IP address, if you are configuring this variable on your home server, it must be set equal to some 555 number that has been allocated to you. If you owned just 555-1XXX, it would have to be 5551000 through 5551999. Conversely, if you had both 555 and 556 on the same Asterisk server, and you had DISAs at both 555-1111 and 556-1111, you could set maindisa to either 5551111 or 5561111. But, as the variable's name indicates, it should be the number of one of your NPSTN DISAs on that server, if you have one; otherwise it should be a number on that server (like 5550000), even if it's not necessarily an active extension.
• usedefaultblacklistresult — this optional variable can be set to 1 to automatically quarantine nuisance calls, allowing you to be a "good neighbor" and watch out for other nodes. The [npstn-blacklist-check] subroutine can be called manually at any time. Data is derived from community-sourced nuisance call reports.
• npstnkey — this is the 32-character auth id used to log in to the NPSTN User Control Panel. While multiple auth keys may be associated with numbers on one node if that node's owner is hosting others, this variable should be set to the auth key of the node owner. This value is used exclusively for authenticating with the NPSTN database for the mock billing system (more on this in the "Billing" section). The auth key's value is not used in any way; any valid auth key value is merely required in order to prevent spam from entering the billing system. Thus, a node owner using his auth key will not need to worry about it being used in any way in the backend for other users whom he hosts.

• OC1 — rather than hardcoding the office code 555 throughout your dialplan, it is good practice to use a variable, in this case OC1, in place of the office code. You will need to change 555 to whatever your office code is. If you have more than one office code, you could continue the pattern with OC2, OC3, etc.

You'll probably find yourself adding more global variables at some point in the future, but this is the bare minimum that you need to get started.

Billing Subroutine

There are two versions of the NPSTN billing subroutines. The second version was released to address the primary shortcoming of the first one, which was that it always charged answered calls for the total call duration, rather than only for the duration since the call had answered. The new version is simpler, more elegant, and more realistically tickets calls as they would have been/would be on the PSTN. The original NPSTN billing subroutine is deprecated and should not be used as it will always overcharge on answered calls.

v2

The following subroutine is used as a hangup handler in order to generate a "toll ticket" for each NPSTN call — whether "local" or "long distance".

[npstnticket] ; NPSTNNA 20201213 ; EXTEN = # called, ARG1 = ss, ARG2 = tt, ARG3 = ANI (at time of hangup handler instantiation)
exten => _X!,1,NoOp(DIALSTATUS: ${DIALSTATUS} / HANGUPCAUSE: ${HANGUPCAUSE} / CDR: duration: ${CDR(duration)} / billsec: ${CDR(billsec)} / start: ${CDR(start)} / answer: ${CDR(answer)} / end: ${CDR(end)})
	same => n,ExecIf($["${LEN(${FILTER(0-9,${CALLERID(num)})})}"="0"]?Set(CALLERID(num)=${ARG3})) ; restore original ANI if it was modified later
	same => n,Set(duration=${CDR(billsec)})
	same => n,Set(start=${CDR(answer)})
	same => n,GotoIf($["${CDR(answer)}"=""]?done) ; Don't even try to ticket the call if it wasn't answered (this includes cancelling ticketing on ANI fails, i.e. HANGUPCAUSE=29)
	same => n,ExecIf($["${CDR(billsec)}"="0"]?ExecIf($[${LEN(${CDR(answer)})}>0]?Set(duration=$[${STRFTIME(${EPOCH},,%s)}-${ARG1}]))) ; edge case: calls where called called party hangs up first...
	same => n,ExecIf($["${CDR(billsec)}"="0"]?ExecIf($[${LEN(${CDR(answer)})}>0]?Set(start=${ARG2}))) ; ...so fall back to old way of doing it, use ss/tt, which includes ring time in billing
	same => n,GoSub(npstnbilling2,${EXTEN},1(${duration},${start}))
	same => n(done),Return()
			

The actual v2 billing subroutine is:

[npstnbilling2] ; NPSTN NA 20201213 NPSTN Toll Ticketing v2; EXTEN= # dialed, ARG1= duration, ARG2= billing start time, ARG3 = type, ARG4= clid override
exten => _[ABCD].,1,GoTo(${EXTEN:1},1) ; Only ARG1 and ARG2 are required ; ARG3 through ARG6 are only used by NPSTNNA01
exten => _X!,1,GoToIf($["${ARG1}"=""]?done) ; Prevent WARNING errors if there are insufficient arguments
	same => n,Set(duration=${ARG1}) ; CDR(billsec)
	same => n,Set(start=${ARG2}) ; CDR(answer)
	same => n,Set(type=${ARG3}) ; optional argument, default=direct
	same => n,ExecIf($["${ARG3}"=""]?Set(type=direct))
	same => n,ExecIf($["${ARG4}"=""]?Set(ani=${FILTER(0-9A-Za-z,${CALLERID(num)})}):Set(ani=${FILTER(0-9A-Za-z,${ARG4})}))
	same => n,Set(callee=${FILTER(0-9,${EXTEN})})
	same => n,Set(request=${SHELL(curl "https://npstn.us/api/billing/?ani=${ani}&callee=${callee}&type=${type}&duration=${duration}&key=${npstnkey}&clli=${clli}&year=${start:0:4}&month=${start:5:2}&day=${start:8:2}&hr=${start:11:2}&min=${start:14:2}&sec=${start:17:2}")})
	same => n,Return()
			

To actually trigger billing, simply include the following line in your dialplan, wherever your outgoing routing context is from your dial tone (e.g. [dtroute]).

same => n,Set(CHANNEL(hangup_handler_push)=npstnticket,${EXTEN},1(${STRFTIME(${EPOCH},,%s)},${STRFTIME(${EPOCH},,%Y-%m-%d %H:%M:%S)},${CALLERID(num)})) ; NPSTN Toll Ticketing v2
			

Note that to work properly, this context must not return to the dial tone. To continue dialplan execution, you should dial it and include the /n option, e.g.:

same => n,Dial(Local/${num}@dtroute/n,,g)
			

Both of the above subroutines are also automatically included in the eXtensible dialplan. Because the eXtensible dialplan must support all nodes, including NPSTNNA01, which has slightly more sophisticated requirements for [npstnbilling2], the version there is slightly larger but functionally equivalent on all other nodes besides NPSTNNA01. If a node is not eXtensible, it may use the above subroutine which is slightly shorter and simpler to understand.

v1

Below is the original NPSTN billing subroutine. Although it still "works" since there were no API changes between v1 and v2, it is deprecated and using it is discouraged.

[npstnbilling] ; NPSTN NA 20190504 NPSTN Toll Ticketing; EXTEN= number dialed, ARG1= start time of call in seconds, ARG2= datetime that the call started
exten => _X!,1,GoToIf($["${ARG1}"=""]?done)
	same => n,Set(endtime=${STRFTIME(${EPOCH},,%s)})
	same => n,Set(duration=$[${endtime} -${ARG1}])
	same => n,GoToIf($["${ARG3}"=""]?:special)
	same => n,Set(type=direct)
	same => n,GoTo(request)
	same => n(special),Set(type=${ARG3})
	same => n(request),Set(request=${SHELL(curl "https://npstn.us/api/billing/?ani=${FILTER(0-9A-Za-z,${CALLERID(num)})}&callee=${FILTER(0-9,${EXTEN})}&type=${type}&duration=${duration}&key=${npstnkey}&clli=${clli}&year=${ARG2:0:4}&month=${ARG2:5:2}&day=${ARG2:8:2}&hr=${ARG2:11:2}&min=${ARG2:14:2}&sec=${ARG2:17:2}")})
	same => n(done),Set(__ticketed=1)
	same => n,Return()
			

You must have the npstnkey and clli global variables properly set in order to use this!

Calls to this are done before a call is made. In circumstances where there is no possibility of more than one call being made by a channel at a time, the following before the call is placed will be sufficient:

Set(CHANNEL(hangup_handler_push)=npstnbilling,${EXTEN},1(${STRFTIME(${EPOCH},,%s)},${STRFTIME(${EPOCH},,%Y-%m-%d %H:%M:%S)}))
			

The only value above that might depend on your implementation is EXTEN. If the number that was dialed is stored in a variable — rather than being used as the extension of the parent context — this should be adjust appropriately. The subroutine will never need to be modified in any way, nor will any of the arguments in the subroutine call. How you call the subroutine will depend on how call routing flow is defined on your node. When integrating this into a DISA that returns to dial tone upon callee hangup, for example, a hangup handler will not work and more complicated measures must be taken. In our boilerplate template code, we have already integrated this into the dialplan so you don't need to worry about adding this functionality. Integration into DISAs is as complicated as it gets; hangup handlers suffice in very simple DISAs that don't return to dial tone upon callee hangup, or with more basic call flow. However, if you use our template(s), you should not need to worry about this.

If you want to opt out of the mock billing system, simply remove this call. The billing system is only for fun. You will never need to pay the "balance" that appears on your statement. It simply gives users an idea of what they would have paid for their calls in the late 1970s. More information about this is available in the "Billing" section of this documentation.

Music on Hold

At this point, you will want to configure a music-on-hold class for your ringback signal.

Open up musiconhold.conf and add the following:

[ringback]
mode=files
directory=moh/ringback/rbs1
			

The [ringback] class is referenced in the Dial Statement in [ata]. If you change the name, make sure to do so in both places.

As written, this context expects your ringback audio file to be located in /var/lib/asterisk/moh/ringback/ and be named rbs1.ulaw. Adjust the paths if needed, but you should keep music on hold files in the moh directory. We recommend creating a separate directory inside of moh for your ringback audio and then placing it inside of that.

If you need a ringback audio file, there are a few available at the NPSTN Sounds Repository. You can also scour Evan Doorbell recordings for something more your style if you're looking for something particular. For example, if you decide your switch is going to be a simulated "Number 5 Crossbar" switch, then you should look for a #5XB ringback you can use (you can use Audacity to prepare the audio and export it as a WAV file to then convert with SoX). Likewise, you should find #5XB busy and reorder signals you can use in your [linebusy] and [linereorder] subroutines.

Now, delete the [default] context and add the following:

[default]
mode=files
directory=moh/silence
random = no

[asteriskdefault]
mode=files
directory=moh
random=yes
			

Create the folder silence inside the moh folder and then copy /var/lib/asterisk/sounds/en/silence/10.ulaw into it.

What did this accomplish? In keeping with the realism factor of NPSTN, by default, Asterisk's default music on hold will play if you flash during a call. In most cases, this is undesirable. Not only is it generally frowned-upon in production systems, but music-on-hold on an otherwise simulated electromechanical switch will stand out like a sore thumb. Now, when you flash, the party you just put on hold will not hear anything.

Remember, to reload music on hold you will need to enter moh reload from the Asterisk CLI.

City Dialtone DISA

One realm where NPSTN has been particularly innovative was with its approach to DISAs. Asterisk contains a built in DISA function, but this poses severe limitations for NPSTN. The DISA() function in Asterisk uses the dialtone specifications outlined in indications.conf. This doesn't leave any room for custom audio files to be used as the dialtone; only combined and modulated tones can be used. Though a set of old city tones does exist in indications.conf by default, the results are less than pleasing. A pure 600 Hz modulated by 120 Hz is a far cry from an actual city dial tone which can't be recreated by computer. For maximum realism, a custom audio file must be used for the dial tone.

Hence, most DISAs on NPSTN do not use the DISA() function in Asterisk at all. Instead, custom contexts are used that simulate an old city dialtone very accurately. On some switches, there are unique sounds between each digit as dialing is in progress. By specifying how you want your dialtone to work, line by line, you have full control over its operation. Furthermore, calls complete immediately when the last digit is dialed — users of the DISA() function must generally press # or suffer a timeout, not at all what happened in the old network.

The use of DISA() for any reason is generally discouraged on NPSTN, as it prevents the ability to implement advanced or enhanced features in your dial tone and call routing setup.

[dialtone] ; Example on how to dial onto NPSTN
exten => s,1,Answer
exten => s,n,Set(TIMEOUT(digit)=5)
exten => s,n,Set(TIMEOUT(response)=1)
exten => s,n,Read(number,custom/dialtone,7)
exten => s,n,Macro(dialnpstn,${number})
exten => i,1,Hangup
exten => h,1,Hangup
exten => bad,1,Hangup
				

[macro-dt]
exten => s,1,Answer
exten => s,n,Read(num,dialtone,7)
exten => s,n,NoOp(Office Code Dialed: ${num:0:1}${num:1:1}${num:2:1})
exten => s,n,GotoIf($["${num:0:1}${num:1:1}${num:2:1}"="${OC1}"]?100:200)
exten => s,100,Answer
exten => s,101,Macro(dl,${num})
exten => s,102,GoTo(1)
exten => s,200,Macro(dialnpstn,${num})
exten => s,201,GoTo(1)
exten => i,1,Hangup
exten => h,1,Hangup
exten => bad,1,Hangup

[macro-dl]
exten => s,1,Answer
exten => s,n,Set(num=${ARG1})
exten => s,n,Dial(Local/${OC1}${num:3:1}${num:4:1}${num:5:1}${num:6:1}@external-users,${DTL},m(ringback))
exten => s,n,GotoIf($["${DIALSTATUS}"="CHANUNAVAIL"]?400)
exten => s,n,GotoIf($["${DIALSTATUS}"="BUSY"]?600)
exten => s,n,GotoIf($["${DIALSTATUS}"="CONGESTION"]?800)
exten => s,n,GotoIf($["${DIALSTATUS}"="NOANSWER"]?454)
exten => s,400,Macro(dt)
exten => s,600,Playback(custom/busy,noanswer)
exten => s,601,Macro(dt)
exten => s,800,Playback(custom/reorder,noanswer)
exten => s,801,Macro(dt)
exten => s,454,Playback(custom/busy,noanswer)
exten => s,455,Macro(dt)
				

[macro-dt]
exten => s,1,Answer
exten => s,n,Set(TIMEOUT(digit)=5)
exten => s,n,Set(TIMEOUT(response)=0)
exten => s,n,Set(n1=n${RAND(1,3)})
exten => s,n,Set(n2=n${RAND(1,3)})
exten => s,n,Set(n3=n${RAND(1,3)})
exten => s,n,Set(n4=n${RAND(1,3)})
exten => s,n,Set(n5=n${RAND(1,3)})
exten => s,n,Set(n6=n${RAND(1,3)})
exten => s,n,Read(num1,dialtone,1)
exten => s,n,GotoIf($["${num1}"=""]?ps)
exten => s,n,GotoIf($["${num1}"="0"]?operator)
exten => s,n,Read(num2,${n1},1)
exten => s,n,GotoIf($["${num2}"=""]?dial_complete)
exten => s,n,Read(num3,${n2},1)
exten => s,n,GotoIf($["${num3}"=""]?dial_complete)
exten => s,n,GotoIf($["${num1}${num2}${num3}${num4}${num5}${num6}${num7}"="911"]?dial_complete)
exten => s,n,GotoIf($["${num1}${num2}${num3}${num4}${num5}${num6}${num7}"="411"]?dial_complete)
exten => s,n,GotoIf($["${num1}${num2}${num3}${num4}${num5}${num6}${num7}"="611"]?dial_complete)
exten => s,n,Read(num4,${n3},1)
exten => s,n,GotoIf($["${num4}"=""]?dial_complete)
exten => s,n,Read(num5,${n4},1)
exten => s,n,GotoIf($["${num5}"=""]?dial_complete)
exten => s,n,Read(num6,${n5},1)
exten => s,n,GotoIf($["${num6}"=""]?dial_complete)
exten => s,n,Read(num7,${n6},1)
exten => s,n,GotoIf($["${LEN(${num7})}"="7"]?dial_complete)
exten => s,n(dial_complete),GotoIf($["${num:0:1}${num:1:1}${num:2:1}"="${OC1}"]?dl)
exten => s,n,Macro(dialnpstn,${num1}${num2}${num3}${num4}${num5}${num6}${num7})
exten => s,n,GoTo(1)
exten => s,n(dl),Macro(dl,${num4}${num5}${num6}${num7})
exten => s,n,GoTo(1)
exten => s,n(ps),Playback(custom/permsig)
exten => s,n,Playback(custom/crybaby)
exten => s,n,Hangup
exten => s,n(operator),Macro(dialnpstn,0)
exten => i,1,Hangup
exten => h,1,Hangup
exten => bad,1,Hangup
				

[numclear] ; NPSTN 20190212 NA
exten => s,1,Return(,,,,,,,,,0,0)
				

[clanglookup] ; NPSTN 20190212 NA
exten => DTXB,1,Return(dialclang1a,dialclang2a,dialclang3a,dialclang4a,dialclang5a,dialclang6a,dialclang${RAND(1,6)},dialclang7)
exten => _DT.,1,GoTo(DTXB,1)

[dtlooplookup]
exten => _DT.,1,Return(0)

[dt] ; NPSTN 20190212 NA
exten => _DT.,1,Answer
	same => n,GoSub(clanglookup,${EXTEN},1)
	same => n,Set(ARRAY(clang1,clang2,clang3,clang4,clang5,clang6,clang7,clang8)=${GOSUB_RETVAL})
	same => n(begin),GoSub(numclear,s,1)
	same => n,Set(ARRAY(num,num1,num2,num3,num4,num5,num6,num7,num8,digit,clangcount)=${GOSUB_RETVAL})
	same => n(digit1),Set(digit=$[${digit}+1])
	same => n(read1),Set(TIMEOUT(response)=0)
	same => n,Read(num${digit},custom/switch/tones/dialtones/${$[${EXTEN}]},1)
	same => n,GoSub(dtlooplookup,${EXTEN},1)
	same => n,GotoIf($["${GOSUB_RETVAL}"="1"]?loopyes:loopno)
	same => n(loopyes),GotoIf($["${$[num${digit}]}"=""]?read1:postloopcheck)
	same => n(loopno),GotoIf($["${$[num${digit}]}"=""]?dtroute,permsig,1)
	same => n(postloopcheck),GoTo(processdigit)
	same => n(nextdigit),Set(digit=$[${digit}+1])
	same => n,Set(clangcount=$[${clangcount}+1])
	same => n,Read(num${digit},custom/dialsounds/${$[clang${clangcount}]},1)
	same => n,GotoIf($["${$[num${digit}]}"=""]?dtroute,${num},1)
	same => n,GotoIf($["${LEN(${num})}"="7"]?dialclang8)
	same => n,GoTo(processdigit)
	same => n(dialclang8),Playback(custom/dialsounds/${clang8})
	same => n(processdigit),Set(num=${num}${$[num${digit}]})
	same => n,GoSub(dtcheck,${num},1)
	same => n,Set(ARRAY(lineaction,linereturn,lineclunk)=${GOSUB_RETVAL})
	same => n,GotoIf($[${lineaction}=TERMINATE]?terminate)
	same => n,GoTo(nextdigit)
	same => n(terminate),Set(TIMEOUT(response)=15)
	same => n,GotoIf($[${lineclunk}=no]?linereturn)
	same => n,GoSub(clunkcomplete,start,1)
	same => n(linereturn),GotoIf($[${linereturn}=yes]?dialyes)
	same => n(dialno),GoTo(dtroute,${num},1)
	same => n(dialyes),Dial(Local/${num}@dtroute,${DTL1XB},g)
	same => n,ExecIf($["${HANGUPCAUSE}"="29"]?Dial(Local/${num}@npstnanifail/n,,g)) ; AST_CAUSE_FACILITY_REJECTED = 29 ; "ANI fail", cancel billing, route call through TSP instead
	same => n,GoTo(begin)

[npstnanifail] ; NPSTN 20201211 NA
exten => check,1,NoOp()
	same => n,GotoIf($["${clidverif}"="11"]?fail)
	same => n,GotoIf($["${clidverif}"="19"]?fail)
	same => n,GotoIf($["${clidverif}"="32"]?fail)
	same => n,Return(0)
	same => n(fail),Return(1)
exten => _X!,1,GoSub(npstn-out-verify,${EXTEN},1)
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-out-blocked,s,1)
	same => n,GoSub(dialnpstn,start,1(0${EXTEN},disable,${zipcode},${maindisa})) ; 0+ @ TSP will handle all billing, if any
	same => n,Hangup()
				

	same => n,Read(num${digit},custom/dialsounds/${$[clang${clangcount}]},1)
				

	same => n,Read(num${digit},,1)
				

[dtcheck] ; NPSTN 20190212 NA ; value 2 = whether to return to [dt], value 3 = whether to play the clunk sound
exten => 0,1,Return(TERMINATE,yes,yes)
exten => _11N,1,Return(TERMINATE,yes,yes)
exten => _N11,1,Return(TERMINATE,yes,yes)
exten => 660,1,Return(TERMINATE,no,no)
exten => _95[89],1,Return(TERMINATE,yes,no)
exten => _10[02-9],1,Return(TERMINATE,yes,yes)
exten => _101XXXX,1,Return(TERMINATE,yes,yes)
exten => _NXXXXXX,1,Return(TERMINATE,yes,yes)
exten => _1XXXXXXX,1,Return(TERMINATE,yes,yes)
include => dtcheckdef

[dtcheckdef] ; NPSTN 20190212 NA
exten => _X!,1,Return(n,n,n)
				

[dtroute] ; NPSTN 20190212 NA
exten => _X!,1,Log(NOTICE, Call from ${CALLERID(all)} to ${EXTEN} via ${clli} DISA)
	same => n,Set(CHANNEL(hangup_handler_push)=npstnticket,${EXTEN},1(${STRFTIME(${EPOCH},,%s)},${STRFTIME(${EPOCH},,%Y-%m-%d %H:%M:%S)},${CALLERID(num)})) ; NPSTN Toll Ticketing v2
	same => n,Dial(Local/${EXTEN}@dtdest/n) ; a double dial is unfortunately required to prevent multiple CDR events from messing with the entire CDR for the call (e.g. a Dial followed by Confbridge)
exten => permsig,1,Log(NOTICE, Call from ${CALLERID(all)} at "${CHANNEL(peerip)}" timed out to permanent signal)
	same => n,GoTo(dtdest,${EXTEN},1)
				

[dtdest] ; NPSTN 20190212 NA
exten => permsig,1,Playback(custom/permsig)
	same => n,Playback(custom/crybaby)
	same => n,Hangup
exten => _${OC1}XXXX,1,GoTo(dtlocal,${EXTEN},1)
exten => 0,1,GoTo(dtnpstn,${EXTEN},1)
exten => _11N,1,GoTo(dtnpstn,${EXTEN},1)
exten => _N11,1,GoTo(dtnpstn,${EXTEN},1)
exten => 660,1,GoTo(dtnpstn,${EXTEN},1)
exten => _95[89],1,GoTo(dtnpstn,${EXTEN},1)
exten => _10[02-9]XX,1,GoTo(dtnpstn,${EXTEN},1)
exten => _101XXXX,1,GoTo(dtnpstn,${EXTEN},1)
exten => _NXXXXXX,1,GoTo(dtnpstn,${EXTEN},1)
exten => _1XXXXXXX,1,GoTo(dtnpstn,${EXTEN},1)
include => invalidincoming
				

exten => _${OC2}XXXX,1,GoTo(dtlocal,${EXTEN},1)
				

exten => _101XXXX,1,GoTo(dtnpstn,${EXTEN},1)
exten => _XXXXXXX,1,GoSub(registersender,start,1(${EXTEN}))
	same => n,GoSub(sfinteroffice,start,1(${EXTEN}))
	same => n,GoTo(dtnpstn,${EXTEN},1)
				

[dtlocal] ; NPSTN 20190212 NA
exten => _NXXXXXX,1,GoTo(local,${EXTEN},1)
				

[dtlocal] ; NPSTN 20190212 NA
exten => _NXXXXXX,1,GoSub(mfinteroffice,start,1(${EXTEN}))
	same => n,GoTo(local,${EXTEN},1)
				

[dtnpstn] ; NPSTN 20190212 NA
exten => _X!,1,Set(originalclid=${CALLERID(all)})
	same => n,GoSub(npstn-out-verify,${EXTEN},1)
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-out-blocked,s,1)
	same => n,GoSub(npstnanifail,check,1) ; ANI FAIL CHECK
	same => n,ExecIf($["${GOSUB_RETVAL}"="1"]?Hangup(29)) ; ANI FAIL CHECK - prevent switch from ticketing by hanging up with cause code 29, call will get sent to TSP
	same => n,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode},${maindisa}))
	same => n,Set(CALLERID(all)=${originalclid})
	same => n,Hangup()
				

[globals]
DTXB=city/5xb_dialtone
				

	same => n,Read(num${digit},custom/dialtones/${$[${EXTEN}]},1)
				

exten => 1111,1,GoTo(dt,DTXB,1)
				

exten => DTXB,1,Return(dialclang1a,dialclang2a,dialclang3a,dialclang4a,dialclang5a,dialclang6a,dialclang7)
				

exten => 1111,1,GoTo(dt,DTXB,1) ; a "crossbar" dial tone
exten => 2222,1,GoTo(dt,DTXY,1) ; an "SC XY" dial tone
				

Dial NPSTN

The dialnpstn subroutine (or macro) is necessary to make calls to NPSTN.

[macro-dialnpstn] ; NPSTN DC
exten => s,1,Set(num=${ARG1})
exten => s,n,Set(lookup=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&cid=${CALLERID(num)}")})
exten => s,n,NoOp(NPSTN ROUTE TO: ${lookup})
exten => s,n,Dial(${lookup},60,g)
exten => s,n,MacroExit
				

[dialnpstn] ; NPSTN 20190215 NA ; Sends a call to NPSTN
exten => start,1,Set(num=${ARG1})
	same => n,GotoIf($[${LEN("${ARG4}")}>2]?clidoverride)
	same => n,Set(lookup=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&cid=${CALLERID(num)}&sntandem=${ARG2}&zipcode=${ARG3}")})
	same => n,GoTo(verify)
	same => n(clidoverride),Set(lookup=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&sntandem=${ARG2}&zipcode=${ARG3}")})
	same => n(verify),GoSub(lookupchan,s,1(${lookup})) ; verifies lookup for extra security
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-BLOCKED,1)
	same => n,GoSub(lookupipcheck,s,1(${lookup})) ; verifies the destination is a public IP address
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?:npstn-BLOCKED,1) ; proceed if 0
	same => n,NoOp(NPSTN ROUTE TO: ${lookup})
	same => n,Dial(${lookup},,g)
	same => n,GoTo(npstn-${DIALSTATUS},1)
exten => npstn-ANSWER,1,Return()
exten => npstn-NOANSWER,1,Return()
exten => npstn-BUSY,1,GoSub(linebusy,s,1())
	same => n,Return()
exten => npstn-CONGESTION,1,GotoIf($["${forcesecurechannel}"="1"]?cktsbusy) ; secure calls must be direct, if there is congestion, do not try an alternate route
	same => n,GotoIf($[${DIALPLAN_EXISTS(snroute,${ARG1},1)}]?sntandem) ; StepNet nodes can trunk via StepNet backbone for Alternate Route Selection
	same => n,GotoIf($["${altrouteattempted}"=""]?:cktsbusy) ; Don't try alternate routing more than once
	same => n,Set(altrouteattempted=1)
	same => n,Set(lookup=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&sntandem=yes&zipcode=${ARG3}")})
	same => n,Goto(start,verify)
	same => n(sntandem),Gosub(snroute,${ARG1:-7},1) ; try an alternate route via StepNet backbone
	same => n,Set(snrouting=${GOSUB_RETVAL})
	same => n(altroute),Gosub(sndialstring,${ARG1:-7},1(${snrouting:0:4}111)) ; Alternate routing for circuit busy conditions ; send only last 7 in case 1+ calls are congested and failover here
	same => n,Set(lookup=${GOSUB_RETVAL})
	same => n,Set(IAXVAR(snrouting)=${snrouting})
	same => n,Set(IAXVAR(sncount)=3) ; Tandem through one node only (min is 3, this prevents further tandeming)
	same => n(verify),Dial(${lookup},,g)
	same => n,GotoIf($["${DIALSTATUS}"="CONGESTION"]?:npstn-${DIALSTATUS},1)
	same => n,GotoIf($[${LEN(${snrouting})}>4]?:cktsbusy)
	same => n,Set(snrouting=${snrouting:4})
	same => n,Goto(altroute) ; Obtain another alternate routing
	same => n(cktsbusy),Playback(custom/all-ckts-busy-now,noanswer)
	same => n,Return()
exten => npstn-CHANUNAVAIL,1,GoSub(linereorder,s,1())
	same => n,Return()
exten => npstn-BLOCKED,1,Playback(custom/ccad,noanswer)
	same => n,Return()
exten => _npstn-.,1,Return()
				

[macro-dialnpstn]
exten => s,1,System(/bin/rm -f /var/spool/asterisk/monitor/npstn.txt)
exten => s,n,System(curl -o /var/spool/asterisk/monitor/npstn.txt https://crtc.npstn.us/api/v1/?auth=${npstnkey}&lookup=${ARG1}&cid=${CALLERID(num)})
exten => s,n,Wait(1)
exten => s,n,ReadFile(lookup=/var/spool/asterisk/monitor/npstn.txt,255)
exten => s,n,NoOp(NPSTN ROUTE TO: ${lookup})
exten => s,n,Dial(${lookup},60,g)
exten => s,n,MacroExit
				

Verification Subroutines

PRE-REQUISITE: You MUST have DIG installed on your server (part of the dnsutils). Please see the Pre-Requisites section for more details.

The verification subroutines rely on the following global variables being properly defined: maindisa, allowdisathru, and allowpstnthru.

Here is a list of the 2-digit "caller verification status codes" used on NPSTN. The network name on the left refers to the original source of the caller. The first upstream node (the node into which an external caller originally dials) determines the code below to use and passes it along to downstream nodes.

• 00 — Reserved, for local temporary use (e.g. if sending a call over a trunk that doesn't pass channel variables, temporarily turn null CVS into 00 and add that to the extension, then convert back on the other end)
• 10 — NPSTN, valid and legitimate
• 11 — NPSTN, valid but illegitimate
• 19 — NPSTN, untrusted/illegitimate (validity spoofed by upstream node)
• 20 — C*NET, valid and legitimate
• 21 — C*NET, valid but illegitimate
• 30 — US PSTN, valid
• 31 — US PSTN, invalid
• 32 — US PSTN, anonymous
• 40 — UK PSTN, valid
• 41 — UK PSTN, invalid
• 42 — UK PSTN, anonymous
• 50 — AU PSTN, valid
• 51 — AU PSTN, invalid
• 52 — AU PSTN, anonymous
• 60 — Other PSTN, valid
• 61 — Other PSTN, invalid
• 62 — Other PSTN, anonymous
• 90 — Other, valid
• 91 — Other, invalid
• 92 — Other, anonymous

Generally, X0 indicates the call is valid. Note that we can only confirm the caller if the CVS (caller verification status) code is 10 or 20. 30 or 40 indicate PSTN calls that, while they appear to be valid, cannot be 100% confirmed to be so. 9X codes are reserved for other use, such as assigning CVS codes to other private networks. This way, such calls do not have an empty CVS code and do not appear to be originating locally when performing CVS branch checks.

The verification subroutines will be updated in early 2021 to incorporate STIR/SHAKEN headers as part of the verification process for incoming PSTN calls from VoIP providers.

If the last digit the CVS code is not 0, the caller ID is almost definitely spoofed, unless the last digit is 2, which indicates an anonymous PSTN caller whose identity, while not necessarily spoofed, cannot possibly be verified.

Note that validity and legitimacy here are two different concepts. Validity refers to a number being of proper format. PSTN calls can be determined to have a valid number, based on the rules specified for PSTN numbering, but verifying that number is a legitimate is different altogether. Legitimacy can only be easily determined for NPSTN and C*NET callers.

CVS codes are frequently used to provide different classes of service. For instance, if you have sensitive contexts to which you wish to allow only trusted callers, you can, in addition to blocking calls with "via NPSTN" in the CNAM (which will block calls made via other nodes' DISAs or a via a node's PSTN gateway), choose to allow only calls with a CVS code of 10 or 20, as you can at least trust these callers are who they say they are.

You can also use CVS codes to act accordingly in your dial plan based on the origin of the caller, i.e. sending NPSTN callers to one context and C*NET callers to another. All you would need to do in this case is check the first digit of the CVS code to determine from where the caller originally dialed in. The second digit says more about the caller's verification status. Since the first digit is network status and the second is verification status, you could, for example, use GoToIf($["${clidverif:-2:1}"="1"]?npstn) and GoToIf($["${clidverif:-2:1}"="2"]?cnet) within your dialplan.

WARNING: If you use CVS codes to configure "forks" in your dialplan, you must always define an exception for calls where the clidverif variable is not defined, which will be the case for any local calls. Since all incoming calls to your node will be assigned a CVS code, if a call does not have a CVS code, it is a local call and you should handle it accordingly, like so: GoToIf($["${clidverif}"=""]?local). If you don't add this "null variable exception", any calls originating from your switch will not route properly at any such forks in your dialplan.

At this point, you may wonder why using IAX variables to pass around these 2-digit codes is necessary. If you care to examine the code carefully, the reason becomes obvious, but the quick answer is that it is only possible to accurately verify calls from the last upstream node. If a caller dials through a DISA and then dials to another node, this third node cannot possibly verify the original caller. This is because while its Caller ID is the original Caller ID, the IP address from which the caller will appear to be coming belongs to the second node. Hence, if a simple IP verification technique is used, the caller will be flagged as fradulent. Hence, it is necessary for each upstream node to "pass along" the results of its verification tests to subsequent downstream nodes. In this way, downstream nodes can be as sure of the validity of the caller as if he had dialed that node directly. Furthermore, the validity of the upstream node itself is also verified to be sure we can trust its judgment (i.e. to make sure a rogue impostor server pretending to be an NPSTN node is not fradulently attempting to pass along inaccurate verification information). Hence, the ${maindisa} variable is used to allow a downstream node to do a reverse lookup and confirm the node is who it says it is. With these subroutines, in conjunction with the CNAM subroutines below, it is impossible for a non-NPSTN node to fradulently present itself to any node, no matter how far up or downstream in a call a node may happen to be.

[dtnpstn] ; NPSTN 20190212 NA
exten => _X!,1,Set(originalclid=${CALLERID(all)})
	same => n,GoSub(npstnanifail,check,1) ; ANI FAIL CHECK
	same => n,ExecIf($["${GOSUB_RETVAL}"="1"]?Hangup(29)) ; ANI FAIL CHECK - prevent switch from ticketing by hanging up with cause code 29, call will get sent to TSP
	same => n,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode},${maindisa}))
	same => n,Set(CALLERID(all)=${originalclid})
	same => n,Hangup()
				

[dtnpstn] ; NPSTN 20190215 NA
exten => _X!,1,Set(originalclid=${CALLERID(all)})
	same => n,GoSub(npstn-out-verify,${EXTEN},1)
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-out-blocked,s,1)
	same => n,GoSub(npstnanifail,check,1) ; ANI FAIL CHECK
	same => n,ExecIf($["${GOSUB_RETVAL}"="1"]?Hangup(29)) ; ANI FAIL CHECK - prevent switch from ticketing by hanging up with cause code 29, call will get sent to TSP
	same => n,GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode},${maindisa}))
	same => n,Set(CALLERID(all)=${originalclid})
	same => n,Hangup()
				

IP Security Check

The IP check portion of outbound call verification ensures the resolving address is in the public address space. This mitigates against a lateral attack vector that a malicious privileged caller could exploit to move laterally within a private address space. For details about this vulnerability, see this whitepaper.

Fortunately, it's not a severe issue and the fix(es) is/are simple. One method you can use is by adding this simple line of code on outbound calls, in your [dialnpstn] context. You can place it after the lookupchan test which ensures the IAX string is properly formatted and not malicious in other ways. Find this code in your dialplan:

same => n(verify),GoSub(lookupchan,s,1(${lookup})) ; verifies lookup for extra security
same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-BLOCKED,1)
			

To patch this particular vulnerability, add the following code immediately afterwards:

same => n,GoSub(lookupipcheck,s,1(${lookup})) ; verifies the destination is a public IP address
same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?:npstn-BLOCKED,1) ; proceed if 0
			

The dialnpstn subroutine provided in the Docs already contains this change, as does the default boilerplate code's dialnpstn subroutine (as of 10/6/2020 only).

lookupipcheck returns 1 if the address is a private Class A, B, or C address, 0 if it's a public address, and -1 if it's the 127.0.0.1 loopback address.

The referenced subroutine is part of the standard verification subroutines. If your node is eXtensible, you will already have the latest copy. Otherwise, you will need to reload your verification subroutines. You can manually download the latest copy at any point by going to the link above.

Unlike many other aspects of the verification subroutines, this outbound verification process is not automatic. The verification subroutines includes the necessary subroutines to perform this security check, but you must be sure to manually call it in your dialplan in the relevant places. Any place in your dialplan that an arbitrary non-trusted (external) user could result in a lookup being performed, it is recommended that you perform an IP check. The call will fail to go through if it is determined that the IP has resolved to an address in the private IPv4 address space (either Class A, B, or C) as well as link-local loopback and APIPA addresses.

NetCID

The following information has been compiled courtesy of Don Froula:

For those using Windows machines on their LANs, you may wish to explore a very useful program that I have been using for many years. The Windows "NetCID" program receives an IP broadcast on your LAN from an Asterisk PERL AGI script that goes out to ALL local IP addresses on your LAN on a special port, where a popup and optional sound alerts to the incoming call. The contents of the popup may be customized in the AGI script. I have five different scripts to indicate if the call is coming from the PSTN, CNET, NPSTN or other sources.

You must have PERL installed on your Asterisk machine.

The program is quite old, and a bit hard to find. It does work fine on all versions of Windows, including Windows 10.

You can download the program here. Instructions for setting up the AGI and how to call it in your dialplan are available at VoIP-Info.

In the AGI script, set the first three octets of the IP address to match those of your LAN. Leave the last octet at 255, which signifies the data is to be broadcast to all devices on the LAN. You may need to allow IP broadcasts on your router. Do NOT change the port number.

You may modify the following to customize the popup display with hard-coded text that appears at the bottom of the screen. Change nothing else. Example:

You can call the AGI script from the dialplan like this:

Note I have multiple versions of the script to display different text at the bottom of the large-sized popup. This is ncid4.agi (for CNET) to adjust as needed.

My old router, since replaced, did have a setting that blocked IP broadcasts on the LAN, although it seems that the broadcasts should not be controllable through the router as they are peer<>peer. When I install NetCID on Windows 10, Windows defender pops up and asks if I want to allow NetCID traffic on my LAN. I don't think this is default behavior in Windows 7. This action openrd all TCP and UDP ports for the NetCID application, but in reality it only uses UDP port 42685, so opening that up should be sufficient.

I installed Asterisk as root. My /var/lib/asterisk/agi-bin/ directory is owned by root with directory permissions of 750. The ncid.agi scripts themselves are 777.

You can change the IP address to target one machine on the LAN to see if broadcasts are being disallowed on the Asterisk machine or the target PC.

The "sleep 5" commands send periodic RING indications to the NetCID app to keep the popup on the screen if the "display until ringing stops" option is set on the NetCID app.

I think there is a typo on the first line of the AGI script on the web page. Note the first line must begin with "#!/usr/bin/perl", making sure the path to the PERL executable is correct.

Here is my working CNET script:

#!/usr/bin/perl
use Socket;

open STDOUT, '>/dev/null';
fork and exit;

my $timedata = localtime(time);
my $cidnum = $ARGV[0];
my $cidname = $ARGV[1];
my $extension = $ARGV[2];

my $MSG1 = "STAT CNET Phone Call to $extension";
my $MSG2 = "RING";
my $MSG3 = "NAME $cidname";
my $MSG4 = "TTSN Call from $cidname";
my $MSG5 = "NMBR $cidnum to $extension";
my $MSG6 = "TYPE U";
my $MSG7 = "IDLE $timedata";

my $ipaddr=192.168.1.255;
my $portnum=42685;

socket(SOCKET, PF_INET, SOCK_DGRAM, getprotobyname("udp")) or die "socket: $!";
setsockopt(SOCKET, SOL_SOCKET, SO_BROADCAST, 1) or die "setsockopt: $!\n";
send(SOCKET, $MSG1, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
send(SOCKET, $MSG2, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
send(SOCKET, $MSG3, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
send(SOCKET, $MSG4, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
send(SOCKET, $MSG5, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
send(SOCKET, $MSG6, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
sleep(5);
send(SOCKET, $MSG2, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
sleep(5);
send(SOCKET, $MSG2, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
sleep(5);
send(SOCKET, $MSG7, 0, sockaddr_in($portnum,$ipaddr)) or die "cannot send to $HOSTNAME($PORTNO): $!";
close(SOCKET);
exit;
			

There are quite a few options that can be set in the NetCID application, but you need to open them when from the tiny icon in the system tray in the lower right corner of the Windows desktop. Right click on the little TV-looking icon and some options that can be checked or unchecked will pop up. Choose "Configure" for many more. You may need to click the "^" to see the full list in the system tray.

You might try running the script from a Linux terminal window as a PERL script directly, rather than as an SGI script through Asterisk for debugging. That would eliminate a few variables.

That invocation pops a window up on all my PCs in the house.

Potential Problems:

The script copied from the web site has open and close double quotes which are apparently not recognized by perl on my system. I found it when I tried to invoke the script from the command line and got error messages about an unrecognized character on a certain line. I changed all the open close double quotes to regular double quotes and all was well. It works from the command line and more importantly, from Asterisk as intended.

Number Aliases

If you have any "number aliases", that is, telephone numbers that map to the same physical line, you should define each of these aliases in sip.conf:

For example, say the following SIP peer was defined in the dialplan:

	[ATAx1](ATAs)
	defaultuser = ATAx1
	secret = P@ssw0rd
	authid = ATAx1
	callerid = "John Smith" <5551212>
	mailbox=1212@default
	context = from-internal
	qualifyfreq=30
			

Say the number 555-8372 also mapped to this line, for whatever reason. This should be defined in sip.conf as a comment exactly like so:

	[ATAx1](ATAs)
	defaultuser = ATAx1
	secret = P@ssw0rd
	authid = ATAx1
	callerid = "John Smith" <5551212> ; 5558372
	mailbox=1212@default
	context = from-internal
	qualifyfreq=30
			

The number is a comment, so it isn't actually interpreted by Asterisk, but it is interpreted by the eXtensible dialplan code, so this is very important!

If you have more than one alias, simply list them all on the same line, separating each with spaces and commas.

If you load verification.conf onto your switch and #include dialplan/verification.conf OR #include verification.conf, if your node is extensible, then the eXtensible dialplan will AUTOMATICALLY RELOAD the verification subroutines for if you if they are updated! As of December 2020, the eXtensible dialplan automatically includes the verification subroutines, so do not include the file yourself if your node is eXtensible.

Generally these updates are feature updates and improvements and new features, not security patches ☺. The improvements are "nice to have", but not 100% essential to the operation of the verification subroutines.

If your node is not extensible, your copy of the verification subroutines will not change and you will need to re-download them if improvements that you want incorporated on your node are made.

All extensible nodes will automatically have their verification subroutines updated as needed if/when changes are made, as long as the verification conf file is in one of the two specified locations (/etc/asterisk/dialplan/verification.conf OR /etc/asterisk/verification.conf). This includes nodes that are not initially extensible but become extensible later, although such nodes will need to remove their #include dialplan/verification.conf because the eXtensible dialplan automatically includes them.

Standard Variables

NPSTN uses a number of standardized dialplan and IAX variables. Their names and purposes are described below:

By their very nature, global variables are static.

Variables will be added as they are needed for network features. All channel variables listed above should be rewritten if calls are regenerated in order to maintain proper channel state (if you are not doing complicated things in your dialplan using ConfBridge(), you probably don't need to worry about this).

NPSTN Intercept Codes

NPSTN has a number of "NP Intercept" codes. These codes are integrated into the CRTC and are not provided by end offices or Class 4 tandems. (Thus, these codes should not be used by member nodes, but members may be interested in what these codes mean and what codes exist.)

These codes are manually dialable in the 231-90XX range.

Member nodes may take advantage of network centralized intercept services. To do so, perform a lookup for a non-assigned network number and note the format (57 + the dialed #). In the dialplan, adjust your pattern matching such that the dialed number is suffixed to the 57 extension prefix. If no number can be provided, 57 alone is sufficient.

ANI II Digits

ANI II (pronounced "A-N-I two or Annie two") digits provide information about the type of originating line, call routing, and class of service. They are used on the PSTN for a variety of purposes. On NPSTN, they provide additional information to downstream nodes about the nature of the call being received.

For the sake of consistency, the ANI II codes used on NPSTN mirror their PSTN counterparts where relevant or possible. However, the exact usage of many codes is slightly different.

Numbering Plan

A few words about the NPSTN numbering plan:

In order to be a valid NPSTN number, a number must be an odd number of digits. This does not necessarily mean a number is valid if its digit length is odd! All valid numbers on NPSTN are either 1, 3, 5, 7, or 8 digits long.

For the most part, NPSTN adheres to the traditional NANPA guidelines as they were originally set. This means that although NXX office codes exist today in the PSTN in the U.S., only NNX office codes are allowed on NPSTN.

Furthermore, unlike C*NET, NPSTN does not use country codes. Any node anywhere in the world on the network can be dialed with just 7 digits. This was an intentional decision reached by the NPSTN Board of Directors in order to make all nodes seem "local" and not "far away". Dialing more than 7 digits can discourage others from dialing a destination. This was a decision reached to better the network's experience for everyone.

A feature added later is the ability to dial a 1+ long-distance call. Dialing 1 + 7 digits will route your call over 2600 Hz-controlled trunks to the destination. The call goes to the same destination as if you had dialed it using 7 digits, but using a 2600-Hz controlled trunk, so now you can use your blue box on the call if you like.

In addition to that, NPSTN has Feature Group B (950-WXXX) and Feature Group D dial-around codes (101XXXX). At this time, a public listing of these carrier access codes is not available.

Note that 10[02-9]XX represents former Feature Group D codes. These codes are part of the NPSTN dial plan and will be routed to the appropriate intercept.

976 exchange numbers are premium-rate numbers charged at a premium rate.

Furthermore, there are special numbers on NPSTN, such as the following operator and directory services:

• 0 — Operator — rings human operator, goes to automatic operator if unavailable
• 411 — Directory Assistance — rings human operator, goes to automatic operator if unavailable
• KL5-1212 — same as 411, KLondike5-1212 (555-1212) will ring Directory Assistance
• 611 — Repair Service — rings human operator, goes to automatic operator if unavailable
• 711 — TTY Relay
• 811 — Business Office — rings the business office
• 112 — "NPSTN Long Distance Operator" — rings automatic operator directly
• 113 — Information — rings automatic information operator directly
• 114 — Repair Service — rings automatic repair agent directly
• 117 — Telegrams
• 118 — StepNet Trunk
• 119 — Long Distance Trunk (Stacking)

811 is not currently assigned but may be used in the future.

Other directory services include:

• POPCORN — POPCORN, a.k.a. 767-2676 will provide your local time
• 211 — Time & Temperature
• 511 — Temperature & Location
• 911 — Emergency Intercept Recording

Finally, network-wide test numbers include:

• 311 — "Party Line"
• 660 — Ring & Tone Test
• 958 — ANAC
• 959 — Ringback

To avoid confusion, we will use "Directory Assistance" to refer to 411 and 555-1212, which go first to a human operator and then to an automatic one if none is available and "Information" to refer exclusively to 113, which is our automated directory service.

Other special NXX/NXX codes include 101 (Feature Group D), 950 (Feature Group B), 976 (premium rate), 973 (mobile telephone service), and 555 (which is not reserved, in full or part, for fictitious numbers, as it is on the PSTN).

The following presents a concise dialplan version of the NPSTN numbering plan:

exten => 0,1,GoTo(npstn,${EXTEN},1)
exten => _11N,1,GoTo(npstn,${EXTEN},1)
exten => _N11,1,GoTo(npstn,${EXTEN},1)
exten => 660,1,GoTo(npstn,${EXTEN},1)
exten => _95[89],1,GoTo(npstn,${EXTEN},1)
exten => _10[02-9]XX,1,GoTo(npstn,${EXTEN},1)
exten => _101XXXX,1,GoTo(npstn,${EXTEN},1)
exten => _NNXXXXX,1,GoTo(npstn,${EXTEN},1) ; you can also use NXXXXXX, calls that are NXXXXXX but not NNXXXXX will be intercepted
exten => _1NNXXXXX,1,GoTo(npstn,${EXTEN},1)

[npstn]
exten => _X!,1,GoSub(dialnpstn,start,1(${EXTEN}))
	same => n,Hangup()

PSTN DID Exchanges

The thousands blocks (406) 957-1XXX on the PSTN is direct inward dial** into NPSTN.

PSTN DID numbers route into NPSTN through NPSTNNA01.

Qualified NPSTN members may qualify for a DID number. Contact NPSTN for more details. You may dial 811 during business hours to reach the NPSTN business office.

Pat Fleet Asterisk Sounds

To replace Asterisk's default Allison Smith voice prompts with "vintage" Pat Fleet prompts, run the following:

If the code above doesn't work for any reason, just know that the files and folders in /var/lib/asterisk/sounds/en should be replaced with those in the ZIP file, with the exception of the custom subdirectory which contains your custom recordings!

Automatic Intercept System

1. If you don't already have the Jane Barbe spliced AIS recordings, download them all from the C*NET Sounds Download page. You only need the files in the sounds folder itself, not any of its subfolders. Furthermore, you need only download the .wav files (not the .tgz files, for instance).
2. Use SoX to convert all of the wav files to ulaw files (see the SoX section in Appendix A for more on this).
3. Move all of the audio files beginning with a numeral (a number followed by either an n or a d to /var/lib/asterisk/sounds/en/custom/digits/. You may need to create this directory.
4. Move the remaining files to /var/lib/asterisk/sounds/en/custom/ais/. You may need to create this directory.
5. Add the following to your extensions.conf:

   [ais7] ; NPSTN 20190212 NA
   exten => start,1,Set(num=${ARG1})
   	same => n,Playback(custom/digits/${num:-7:1}n,noanswer)
   	same => n,Playback(custom/digits/${num:-6:1}n,noanswer)
   	same => n,Playback(custom/digits/${num:-5:1}d,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n,Playback(custom/digits/${num:-4:1}n,noanswer)
   	same => n,GotoIf($[${num:-3:3}=000]?thousand)
   	same => n,Playback(custom/digits/${num:-3:1}n,noanswer)
   	same => n,Playback(custom/digits/${num:-2:1}n,noanswer)
   	same => n,Playback(custom/digits/${num:-1:1}d,noanswer)
   	same => n,Return()
   	same => n(thousand),Playback(custom/ais/thousand,noanswer)
   	same => n,Return()
   
   [aisnis] ; NPSTN 20190212 NA
   exten => start,1,Set(num=${ARG1})
   	same => n,Verbose(AIS Not In Service -- "${num}")
   	same => n,Playback(custom/ais/clunk,noanswer)
   	same => n,Playback(custom/ais/numreach,noanswer)
   	same => n,GoSub(ais7,start,1(${num}))
   	same => n,Playback(custom/ais/notinservice,noanswer)
   	same => n,Playback(custom/ais/pleasecheck,noanswer)
   	same => n,Playback(custom/ais/dialagain,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n,Return
   
   [aischanged] ; NPSTN 20190212 NA ; This requires an argument with the new number
   exten => start,1,Set(num=${ARG1})
   	same => n,Set(newnum=${ARG2})
   	same => n,Verbose(AIS Number Changed -- "${num}")
   	same => n,Playback(custom/ais/clunk,noanswer)
   	same => n,Playback(custom/ais/numreach,noanswer)
   	same => n,GoSub(ais7,start,1(${num}))
   	same => n,Playback(custom/ais/hasbeenchanged,noanswer)
   	same => n,Playback(custom/ais/newnumberis,noanswer)
   	same => n,GoSub(ais7,start,1(${newnum}))
   	same => n,Playback(custom/ais/pleasemakenote,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n,Return
   
   [aisnpachanged] ; NPSTN 20190212 NA ; This requires an argument with the new number
   exten => start,1,Set(oldnum=${ARG1})
   	same => n,Set(newnum=${ARG2})
   	same => n,Verbose(AIS Number Changed To Different NPA -- "${oldnum}")
   	same => n,Playback(custom/ais/clunk,noanswer)
   	same => n,Playback(custom/ais/numreach,noanswer)
   	same => n,GoToIf($[${oldnum}=nonum]?changed)
   	same => n,GoSub(ais7,start,1(${oldnum}))
   	same => n(changed),Playback(custom/ais/hasbeenchanged,noanswer)
   	same => n,Playback(custom/ais/newnumberis,noanswer)
   	same => n,GoToIf($[${LEN(${newnum})}=7]?seven)
   	same => n,Playback(custom/ais/area,noanswer)
   	same => n,Playback(custom/digits/${newnum:-10:1}n,noanswer)
   	same => n,Playback(custom/digits/${newnum:-9:1}n,noanswer)
   	same => n,Playback(custom/digits/${newnum:-8:1}d,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n(seven),GoSub(ais7,start,1(${newnum}))
   	same => n,Playback(custom/ais/pleasemakenote,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n,Playback(custom/ais/numreach,noanswer)
   	same => n,Playback(custom/ais/hasbeenchanged,noanswer)
   	same => n,Playback(custom/ais/newnumberis,noanswer)
   	same => n,GoToIf($[${LEN(${newnum})}=7]?seven2)
   	same => n,Playback(custom/ais/area,noanswer)
   	same => n,Playback(custom/digits/${newnum:-10:1}n,noanswer)
   	same => n,Playback(custom/digits/${newnum:-9:1}n,noanswer)
   	same => n,Playback(custom/digits/${newnum:-8:1}d,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n(seven2),GoSub(ais7,start,1(${newnum}))
   	same => n,Playback(custom/ais/pleasemakenote,noanswer)
   	same => n,Playback(custom/ais/dialagain,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n,Return
   
   [aisworking] ; NPSTN 20190212 NA
   exten => start,1,Set(num=${ARG1})
   	same => n,Verbose(AIS Working Number -- "${num}")
   	same => n,Playback(custom/ais/clunk,noanswer)
   	same => n,Playback(custom/ais/numreach,noanswer)
   	same => n,GoSub(ais7,start,1(${num}))
   	same => n,Playback(custom/ais/isworkingnum,noanswer)
   	same => n,Playback(custom/ais/willdialagainplease,noanswer)
   	same => n,Playback(custom/digits/blank,noanswer)
   	same => n,Return
   				

6. Now, going back to our starter dialplan code, let's modify it so that AIS is used on all calls to nonexistent extensions. Here is what we had initially:

   [KLondike5]
   … all your 555 extensions here …
   include => invalidincoming
   					

   Now, tweak your code so it is as follows:

   [KLondike5]
   … all your 555 extensions here …
   include => KLondike5-unmatched
   
   [KLondike5-unmatched]
   exten => _XXXX,1,GoSub(aisnis,start,1(${OC1}${EXTEN:-4}))
   	same => n,Hangup()
   					

Now, any time anyone calls a 555-XXXX number that doesn't exist, he will hear AIS instead of CBCAD!

An important technical footnote is necessary here: if you have multiple office codes, you will need a separate AIS "catch" context for each of them. The reason for this is that by the time a call hits [KLondike5], only the last 4 digits have been sent to that context, meaning the [KLondike5] context has no idea what office code was dialed. However, AIS expects the proper office code! Notice that ${OC1} is specified to add the office code back in before sending the call to AIS.

Consequently, if you had both the KLondike5 and KLondike6 exchanges, your code might look like this:

[KLondike5]
… all your 555 extensions here …
include => KLondike5-unmatched

[KLondike5-unmatched]
exten => _XXXX,1,GoSub(aisnis,start,1(${OC1}${EXTEN:-4}))
	same => n,Hangup()

[KLondike6]
… all your 556 extensions here …
include => KLondike6-unmatched

[KLondike6-unmatched]
exten => _XXXX,1,GoSub(aisnis,start,1(${OC2}${EXTEN:-4}))
	same => n,Hangup()
			

ANAC

A prerequisite for creating an ANAC (automatic number announcement circuit) is having the Jane Barbe AIS audio files downloaded. If you already have AIS on your system, you're all set. If you don't, you don't need AIS to have an ANAC. Simply navigate to the C*NET Sounds Download page and download all the files in that directory beginning with a numeral (you will see two for each number, one ending with an "n", and the other ending with a "d"). You don't need the other audio files in this directory unless you'd also like to set AIS up on your node.

Download all these files and use SoX to convert them to ulaw files (see Appendix A for more on this). Then, place the ulaw files inside /var/lib/asterisk/sounds/en/custom/digits/ on your system. You may need to create the digits directory if you don't have AIS on your node (and hence never created that directory).

Then, copy and paste the following code into your dialplan (i.e. extensions.conf):

[anac] ; NPSTN 20190212 NA
exten => start,1,Set(num=${CALLERID(num)})
	same => n,Verbose(ANAC -- "${num}")
	same => n,Set(num=${FILTER(0-9,${num})})
	same => n,GotoIf($[${LEN(${num})}=7]?d7)
	same => n,GotoIf($[${LEN(${num})}=6]?d6)
	same => n,GotoIf($[${LEN(${num})}=5]?d5)
	same => n,GotoIf($[${LEN(${num})}=4]?d4)
	same => n,GotoIf($[${LEN(${num})}=3]?d3)
	same => n,GotoIf($[${LEN(${num})}=2]?d2)
	same => n,GotoIf($[${LEN(${num})}=1]?d1)
	same => n,GotoIf($[${LEN(${num})}=0]?d0)
	same => n(d7),Playback(custom/digits/${num:-7:1}n,noanswer)
	same => n(d6),Playback(custom/digits/${num:-6:1}n,noanswer)
	same => n(d5),Playback(custom/digits/${num:-5:1}d,noanswer)
	same => n,Playback(custom/digits/blank,noanswer)
	same => n(d4),Playback(custom/digits/${num:-4:1}n,noanswer)
	same => n(d3),Playback(custom/digits/${num:-3:1}n,noanswer)
	same => n(d2),Playback(custom/digits/${num:-2:1}n,noanswer)
	same => n(d1),Playback(custom/digits/${num:-1:1}d,noanswer)
	same => n(d0),Playback(beep,noanswer)
	same => n(done),Return
			

Now, to make your ANAC work, you'll need to put it on an extension. "958" network-wide on NPSTN is an ANAC (the very same one you see here), so you may want to put your ANAC on an extension ending in 958, like so:

exten => 9958,1,GoSub(anac,start,1)
	same => n,Hangup()
			

The reason we haven't included an Answer() statement here is because this is a test line, and test lines in the old network hardly ever supervised. You can choose to have your ANAC supervise if you wish — NPSTN and C*NET callers are never "charged" for making calls, so unless you call this inbound from the PSTN from a payphone or home phone without flat-rate long-distance, it's really a non-issue — but to be "time-period correct", we've opted here to not supervise.

Speaking Clock

Doing time announcements is something relatively complex that Asterisk makes relatively simple. The code featured here is the same code that runs POPCORN network-wide. You can set-up a speaking clock or "time number" on your node that is hardcoded to use your timezone, if you wish. The following code makes this relatively easy to do:

[time] ; NPSTN 20190212 NA ; ARG1 is number of times to announce the time, ARG2 is the timezone to use
exten => s,1,Set(NumLoops=0)
	same => n(start),Set(FutureTime=$[${EPOCH} + 8])
	same => n,Set(FutureTimeMod=$[${FutureTime} % 10])
	same => n,Set(FutureTime=$[${FutureTime} - ${FutureTimeMod} + 10])
	same => n,Gosub(sub-hr12format,s,1(${ARG2}))
	same => n(waitloop),Set(TimeLeft=$[${FutureTime} - ${EPOCH}])
	same => n,GotoIf($[${TimeLeft} < 1]?playbeep)
	same => n,Wait(1)
	same => n,Goto(waitloop)
	same => n(playbeep),Playback(beep)
	same => n,GotoIf($[${LEN(${ARG4})}=6]?skipwait)
	same => n,Wait(5)
	same => n(skipwait),Set(NumLoops=$[${NumLoops} + 1])
	same => n,GotoIf($[${NumLoops} < ${ARG1}]?start)
	same => n,GotoIf($[${LEN(${ARG3})}=4]?skipgoodbye)
	same => n,Playback(goodbye)
	same => n(skipgoodbye),Return()

[sub-hr12format]
exten => s,1,Answer
exten => s,n,Playback(at-tone-time-exactly)
exten => s,n,SayUnixTime(${FutureTime},${ARG1},IM 'vm-and' S 'seconds' p)
exten => s,n,Return()
exten => s,n,Playback(at-tone-time-exactly)
exten => s,n,SayUnixTime(${FutureTime},${ARG1},IM 'vm-and' S 'seconds' p)
exten => s,n,Return()
			

ARG1 is the number of times to announce the time. POPCORN is set to announce the time 100 times, so it goes on for quite a while. You'll probably want to set yours to a number between 5 and 10.

ARG2 is the timezone to use. The timezones are the "tz" format used in Unix. You can use this list of timezones and corresponding TZ database names to help you.

ARG3 and ARG4 are optional, and you will probably not need to use them. If ARG3 is set to skip, or any 4 characters for that matter, the speaking clock will not say "goodbye" before exiting. You may need to use ARG3 if you use this speaking clock as part of a broader context, rather than just a single, dedicated extension.

If ARG4 is set to nowait, or any 6 characters for that matter, then the speaking clock will not wait 5 seconds after the beep before entering another cycle. This is usually useful when you are calling [time] with ARG1 set to 1 (i.e. you only want the time announced once), and you wish to immediately exit the subroutine after the beep and continue with the dialplan code in the extension that called it. Note that if ARG1 is NOT 1 and you use ARG4 to disable the wait, it will not only disable the wait the last cycle, but every cycle, which is potentially undesirable. ARG4 is only meant to be set if ARG1 is equal to 1, but if you want to make the subroutine a bit more foolproof, you might modify it slightly so that it only calls GotoIf($[${LEN(${ARG4})}=6]?skipwait) if it is in its last cycle (in which case NumLoops will be 1 less than ARG1).

Now, to create a speaking clock for say, Chicago, or any city located in the Central Time Zone, that announces the time 7 times, all you need to do is add the following to your dialplan:

The speaking clock above is the traditional "at the tone, the time will be exactly X:YY and ZZ seconds, A.M. … beep.

If you'd like something a bit more customizable, check out the Asterisk TIM project on GitHub. At this time, the voice provided is Pat Simmons, but you can obtain and use your own custom audio prompts.

Airport Weather

For instructions on how to get airport-code-based weather reports in Asterisk, see this NerdVittles tutorial.

Currently, we don't have any of these types of services on NPSTN. The temperature readings provided at BE1-1200 and related numbers are powered by paid APIs.

Milliwatt Test Tone

In Asterisk, there are actually several ways you could implement a milliwatt (or 1004 Hz test) tone. Asterisk itself has a Milliwatt function:

[mw]
exten => start,1,Wait(0.5)
	same => n,Milliwatt(${ARG1})
	same => n,Return
			

ARG1 is the number of seconds for which to play the test tone. Usually, 10 minutes (or 600 seconds) will suffice. We wait 0.5 seconds before starting as milliwatt numbers usually offer a split second of silence before blasting your eardrums.

By now, you probably know that to call this, you would need to call GoSub(mw,start,1(600)) from an extension in your dialplan. (You can tell this is a subroutine because it has the Return statement in it.)

However, a great many people choose to create their milliwatt test numbers themselves. Since a milliwatt test tone consists of pure frequencies, this is relatively easy. To make things interesting, we have here chosen to combine 1004 Hz and 1000 Hz for our milliwatt (the latter was the original frequency, according to Steph Kerman "A mW is inherently a pure tone, originally nominally 1000Hz but eventually these tones were offset by 4Hz to 404, 1004 and 2804 for compatibility with digital transmission"):

[mwtone] ; NPSTN 2018 DC/NA
exten => start,1,Wait(0.5)
	same => n,PlayTones(1004/1000)
	same => n,Wait(${ARG1})
	same => n,Return
			

In this case, calling GoSub(mwtone,start,1(600)) would play a 1004 Hz tone for 600 seconds (or 10 minutes).

Now, if you want to really kick it up a notch, you can increase the volume of the channel so the milliwatt tone comes out more loudly than it would otherwise:

[mwtone] ; NPSTN 2018 DC/NA
exten => start,1,SET(VOLUME(TX)=8)
	same => n,Wait(0.5)
	same => n,PlayTones(1004/1000)
	same => n,Wait(${ARG1})
	same => n,SET(VOLUME(TX)=1)
	same => n,Return
			

A volume specification of about 8 matches PSTN milliwatt test numbers fairly closely. Of course, you can play around with this until you find a volume setting that works for you. Simply replace 8 with ${ARG2}, and then pass in a second argument containing the new volume. This way, you can easily create multiple extensions with different volume milliwatt tones.

Ringback

Ringback is a fairly simple task that is quite involved in terms of dialplan code. Here is the code that operates the 959 ringback number on NPSTN (at least, it's some of the code; the 959 code is more involved as it will also ring back C*NET callers in addition to NPSTN callers):

[ringbacknpstn] ; NPSTN 2018 DC/NA
exten => s,1,Answer
	same => n,PlayTones(600*120)
	same => n,Wait(60)
exten => h,1,Verbose(Ringing Back NPSTN Caller ${CALLERID(num)})
	same => n,Set(lookup=${SHELL(curl "https://crtc.npstn.us/api/v1/?auth=${npstnkey}lookup=${CALLERID(num)}")})
	same => n,Log(NOTICE, NPSTN Ringback: ${lookup})
	same => n,System(echo Channel: ${lookup} >> /tmp/cf.tmp)
	same => n,System(echo Application: Wait >> /tmp/cf.tmp)
	same => n,System(echo Data: 1209600 >> /tmp/cf.tmp)
	same => n,System(echo CallerID: "Ringback <${OC1}9959>" >> /tmp/cf.tmp)
	same => n,System(mv /tmp/cf.tmp /var/spool/asterisk/outgoing/)
	same => n,Hangup
			

The PlayTones(600*120) is what will happen when this number is called. In this case, you will here 600 Hz modulated with 120 Hz, or old city dial tone (though it sounds a bit modern, given that it's generated by a computer rather than an electromechanical tone plant). This line is optional, but does provide an indication to the caller that something has happened; if you don't want the caller to hear anything, you could replace this with Wait(600. Another option is choosing to play a NOYOL (number on your own line) announcement, which was used frequently when party lines were more common. You could then add some dialplan code in your exchange context to call [ringbacknpstn] whenever ${CALLERID(num)} is the same as ${OC1}${EXTEN}. This would allow you to form a simple intercom by allowing callers to dial their own number and hang up, which would allow multiple people to pick up and converse, even with just a single line.

The ringback itself doesn't actually happen until the caller hangs up (which is why the h extension is used here as well). When the caller hangs up, Asterisk creates a call file, dumps it in the spool directory, and it gets processed.

You will need to replace ${OC1}9959 here with the extension at which you create your ringback number. If you choose to have it be extension 9959 on your exchange, you don't need to change anything; otherwise, adjust the last 4 digits to the proper extension number. You should make sure that the number you use here matches the number used to call your ringback line. That way, if somebody calls your ringback line, the incoming Caller ID on the automatically generated call matches the number he dialed in the first place.

Note that [ringbacknpstn] is not a subroutine. You will need to call it as exten => 9959,1,GoTo(ringbacknpstn,s,1).

Revertive Pulsing Script

First, as outlined in the "Pre-Requisites" section, you will need to have PHP installed in order to use the revertive pulsing script. Once PHP is installed, exit the Asterisk CLI to the main command line and run the following commands:

wget https://octothorpe.info/downloads/pulsar-agi.tar.gz
mv pulsar-agi.tar.gz /var/lib/asterisk
cd /var/lib/asterisk
tar xvfz pulsar-agi.tar.gz
chmod 777 /var/lib/asterisk/agi-bin/pulsar.agi

A file named pulsar.agi should now be located in /var/lib/asterisk/agi-bin/.

Audio files go in /var/lib/asterisk/sounds/pulsar/.

It's worth mentioning that by default this script DOES supervise, which is incorrect! If you modify the AGI file, you can add the noanswer flag to the Playback command so that revertive pulsing does NOT return premature answer supervision (e.g. turn Playback(file) into Playback(file,noanswer).

Do not use revertive pulsing on NPSTN if your revertive pulsing supervises (i.e. don't use revertive pulsing if you are not going to modify the AGI). Otherwise, it will supervise, which is against the NPSTN supervision standards.

Now, add the following subroutine to your dialplan:

[revertive] ; NPSTN 20190212 NA ; Revertive pulsing (requires PHP installation)
exten => start,1,Verbose(Revertive Pulse Generator: ${ARG1})
	same => n,AGI(pulsar.agi,${ARG1},${ARG2},${ARG3}) ; ARG2 can be set to 1 to indicate a "B-side" that adds 5 pulses to the second RP digit.
	same => n,Return() ; ARG1 should be a 4-digit extension and ARG3 must be one of the following: panel,1xb,5xb
			

ARG1 is the 4-digit extension to revertive pulse.

ARG2 can be set to 1 to indicate a "B-side" that adds 5 pulses to the second RP digit. Otherwise, set it to 0.

ARG3 should be the type of revertive pulsing to simulate. Your options are panel, 1xb, or 5xb. If you are simulating one of these switches by chance, then use that one. Each type of revertive pulsing sounds very distinctive, so make sure to get this one right!

As you can see, you might call the revertive pulser like this: GoSub(revertive,start,1(${EXTEN:-4},0,5xb)). This will simulate #5XB revertive pulsing.

Unlike MF digits, which you could use for both inpulsing and outpulsing, revertive pulsing is a signaling method you should only use for incoming calls. Let's revisit our incoming contexts:

[internal-users]
include => local
include => long-distance
include => invalidincoming

[external-users]
include => local
include => invalidincoming

[local]
exten => _${OC1}XXXX,1,GoTo(KLondike5,${EXTEN:-4:4},1)
			

You might modify [local] so it is as follows:

[local]
exten => _${OC1}XXXX,1,GoSub(revertive,start,1(${EXTEN:-4},0,5xb))
	same => n,GoTo(KLondike5,${EXTEN:-4:4},1)
			

Now, all callers dialing into whichever office code ${OC1} happens to be will hear Number 5 crossbar revertive inpulsing before the call connects!

The only catch here is, if you look at the [internal-users] context, you will see that you will also hear revertive pulsing on a call that is "local" to you, i.e. within the same exchange. At worst, this is undesired, at best, it is not really technically correct.

The solution is having a different context for incoming "long-distance" calls, like so:

[internal-users]
include => local-intraoffice
include => long-distance
include => invalidincoming

[external-users]
include => local-interoffice
include => invalidincoming

[local-intraoffice]
exten => _${OC1}XXXX,1,GoTo(KLondike5,${EXTEN:-4:4},1)

[local-interoffice]
exten => _${OC1}XXXX,1,GoSub(revertive,start,1(${EXTEN:-4},0,5xb))
	same => n,GoTo(KLondike5,${EXTEN:-4:4},1)
			

Now, callers from other exchanges will hear revertive pulsing on all calls to KLondike5, but you will not. It is recommended that you adopt this approach.

If you'd like, in order to economize on code, you might adjust the last two contexts to the following:

[local-intraoffice]
exten => _${OC1}XXXX,1,GoTo(KLondike5,${EXTEN:-4:4},1)

[local-interoffice]
exten => _${OC1}XXXX,1,GoSub(revertive,start,1(${EXTEN:-4},0,5xb))
	same => n,GoTo(local-intraoffice,${EXTEN:-4:4},1)
			

What's the point of this, you might ask? We just made external callers hop through another step!

The advantage of structuring your code this way is you can simply define the inpulsing for each exchange in [local-interoffice], then send it to the other context. If you wanted a sound played on all incoming calls, you could include it in the first context only; in other words, you can cut down on future duplicated code.

The downside of using this approach is, as before, all internal and external callers are now sent to the same destination context. If you had a [KLondike5-internal] context, you might want to keep them separate, in order to allow different classes of callers access to different classes of extensions:

Now, if you call KL5-6666, you will end up going to [verysecretcontext], but callers from other exchanges will end up hearing an intercept message (or AIS) instead. Technically, this might not make sense, as the extension exists; it's just not accessible to external callers, and from Asterisk's perspective when routing an incoming call from another exchanges, the extension does not exist since it's in a different context to which it does not have access.

Part of Asterisk is structuring your dialplan code properly, and this is a skill that takes time to develop. Fortunately, you have an almost infinite amount of flexibility in terms of how you route your calls, so pick the approach that works best for you, knowing that you have the flexibility to tweak it should you ever need to.

MFer

Perhaps one of the most common and popular additions to any node is the MFer. Creating an MFer that would properly work with any number of digits proved to be a challenge, but in the end, it was surmounted. First, you may want to consider adding the MF tone specifications to the [us] context (if you are in the U.S.) in indications.conf, even though we will not be using them expressly:

mf1 = !700+900/55,!0/50
mf2 = !700+1100/55,!0/50
mf3 = !900+1100/55,!0/50
mf4 = !700+1300/55,!0/50
mf5 = !900+1300/55,!0/50
mf6 = !1100+1300/55,!0/50
mf7 = !700+1500/55,!0/50
mf8 = !900+1500/55,!0/50
mf9 = !1100+1500/55,!0/50
mf0 = !1300+1500/55,!0/50
kp = !1100+1700/100,!0/50
kp2 = !1300+1700/100,!0/50
st = !1500+1700/35,!0/50
st2 = !900+1700/35,!0/50
			

Depending on the specifications you use, the duration of each MF should be 50ms or 55ms, as it is in the case above. KP is 100ms and ST is 35ms, per Bell System specifications.

Here, we have used 50ms for each number. So it is! If you'd prefer to use 55ms tones, change the first 50 you see for MF1 through M0 to 55 (but not the second one!)

Now, add the following subroutines to your dialplan:

[signallookup] ; NPSTN 20210208 NA 
exten => MF,1,Return("|","!0/${ARG3}","!700+900/${ARG1}|!0/${ARG2}","!700+1100/${ARG1}|!0/${ARG2}","!900+1100/${ARG1}|!0/${ARG2}","!700+1300/${ARG1}|!0/${ARG2}","!900+1300/${ARG1}|!0/${ARG2}","!1100+1300/${ARG1}|!0/${ARG2}","!700+1500/${ARG1}|!0/${ARG2}","!900+1500/${ARG1}|!0/${ARG2}","!1100+1500/${ARG1}|!0/${ARG2}","!1300+1500/${ARG1}|!0/${ARG2}","!1100+1700/${ARG5}|!0/${ARG2}","!1500+1700/${ARG4}|!0/${ARG2}","!900+1700/${ARG4}|!0/${ARG2}","!1300+1700/${ARG4}|!0/${ARG2}","!700+1700/${ARG4}|!0/${ARG2}")
exten => SF,1,Return("|",200,100,"!0/200","!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}") ; ARG1 = frequency (2600), ARG2 = on (60ms), ARG3 = off (40ms) / SFX = interdigit silence

[mfer] ; NPSTN 20181212 NA/BJC, revised 20210208
exten => start,1,Set(number=${FILTER(0-9,${ARG1})}) ; ARG1 = digits to MF
	same => n,Gosub(signallookup,MF,1(50,50,500,35,100)) ; ARG1 = on, ARG2=off, ARG3=silence, ARG4=ST duration, ARG5=KP duration
	same => n,Set(ARRAY(digitsep,mfx,mf1,mf2,mf3,mf4,mf5,mf6,mf7,mf8,mf9,mf0,mfkp,mfst,mfstp,mfst2p,mfst3p)=${GOSUB_RETVAL}) ; R1, CCIT5: STP ~ code 12, ST2P ~ KP2, ST3P ~ code 11
	same => n,Set(c=0)
	same => n,Set(numdigits=${LEN(${ARG1})})
	same => n,Set(tonestring=${mfx}${digitsep}${mfkp}${digitsep})
	same => n,While($[${c}<${numdigits}])
	same => n,Set(mfnext=${mf${number:${c}:1}})
	same => n,Set(tonestring=${tonestring}${mfnext}${digitsep})
	same => n,Set(c=${INC(c)})
	same => n,EndWhile
	same => n,Set(mfnext=${mfst})
	same => n,Set(tonestring=${tonestring}${mfnext}${digitsep})
	same => n,Set(tonestring=${tonestring}${mfx})
	same => n,Set(toneduration=$[100*${LEN(${ARG1})}+1785])
	same => n,PlayTones(${FILTER(0-9\x21/|+,${tonestring})})
	same => n,Wait($[${toneduration}/1000])
	same => n,StopPlayTones()
	same => n,Return()
			

Below is an expanded MFer than do sequencing MF using different ST tone variations. It is not currently production ready, as longer sequences suffer from more and more of the end being cut off, so an additional timing buffer would need to be refined:

[mfer2] ; NPSTN 20181212 NA/BJC, revised 20210208
exten => start,1,NoOp()
	same => n,Set(lon=50) ; 50
	same => n,Set(loff=50) ; 50
	same => n,Set(lsil=500) ; 500
	same => n,Set(lst=50) ; 35/50
	same => n,Set(lkp=100) ; 100
	same => n,Gosub(signallookup,MF,1(${lon},${loff},${lsil},${lst},${lkp})) ; ARG1 = on, ARG2=off, ARG3=silence, ARG4=ST duration, ARG5=KP duration
	same => n,Set(ARRAY(digitsep,mfx,mf1,mf2,mf3,mf4,mf5,mf6,mf7,mf8,mf9,mf0,mfkp,mfst,mfstp,mfst2p,mfst3p)=${GOSUB_RETVAL}) ; R1, CCIT5: STP ~ code 12, ST2P ~ KP2, ST3P ~ code 11
	same => n,Set(number=${FILTER(0-9,${ARG1})}) ; ARG1 = digits to MF
	same => n,Set(mfstart=${FILTER(0-9,${ARG2})}) ; ARG2 = optional ST delimiter
	same => n,Set(number2=${FILTER(0-9,${ARG3})}) ; ARG3 = optional 2nd group of digits to MF
	same => n,Set(cv=0)
	same => n,Set(numdigits=${LEN(${number})})
	same => n,Set(tonestring=${mfx}${digitsep}${mfkp}${digitsep})
	same => n,While($[${cv}<${numdigits}])
	same => n,Set(mfnext=${mf${number:${cv}:1}})
	same => n,Set(tonestring=${tonestring}${mfnext}${digitsep})
	same => n,Set(cv=${INC(cv)})
	same => n,EndWhile()
	same => n,Set(mfnext=${mfst})
	same => n,ExecIf($["${mfstart}"="mfstp"]?Set(mfnext=${mfstp})) ; R1 STP, CCIT5: Code 12
	same => n,ExecIf($["${mfstart}"="mfst2p"]?Set(mfnext=${mfst2p})) ; R1 ST2P, CCIT5: KP2
	same => n,ExecIf($["${mfstart}"="mfst3p"]?Set(mfnext=${mfst3p})) ; R1 ST3P, CCIT5: Code 11
	same => n,Set(tonestring=${tonestring}${mfnext})
	;same => n,Set(tonestring=${digitsep}${tonestring}${mfx})
	same => n,Set(toneduration=$[$[${lon}+${loff}]*$[${LEN(${number})}+${LEN(${number2})}]+${lsil}+${lkp}+${loff}+${lst}+${loff}])
	same => n,GotoIf($[${LEN(${number2})}=0]?play)
	same => n,Set(cv=0)
	same => n,Set(numdigits=${LEN(${number2})})
	same => n,Set(tonestring=${tonestring}${digitsep}${mfkp}${digitsep})
	same => n,While($[${cv}<${numdigits}])
	same => n,Set(mfnext=${mf${number2:${cv}:1}})
	same => n,Set(tonestring=${tonestring}${mfnext}${digitsep})
	same => n,Set(cv=${INC(cv)})
	same => n,EndWhile()
	same => n,Set(tonestring=${tonestring}${mfst})
	same => n,Set(toneduration=$[${toneduration}+${lkp}+${loff}+${lst}+${loff}]) ; add on aditional KP/ST
	same => n(play),Set(td=0)
	same => n,Set(UNSHIFT(tones,|)=${tonestring})
	same => n,While($["${SET(t=${SHIFT(tones,|)})}" != ""])
	same => n,Set(t=${FILTER(0-9,${CUT(t,/,2)})})
	same => n,Set(td=$[${td}+${t}])
	same => n,EndWhile()
	same => n,Set(toneduration=${td}) ; increased buffer needed for longer strings
	same => n,PlayTones(${FILTER(0-9\x21/|+,${tonestring})})
	same => n,Wait($[${toneduration}/1000])
	same => n,StopPlayTones()
	same => n,Return()
			

A note about the [mfer] subroutine is perhaps warranted here. The original approach to a dynamic MFer was using a subroutine to loop through each digit and generate an MF tone using the tone definitions in indications.conf. However, this approach, originally tested by Don Froula, does not work for one reason or another. Hence, the idea came about of not using indications.conf but instead dynamically building up a tone string and passing that into PlayTones() all at once. Don Froula, intrigued by the idea, admitted this could work, and Naveen and Brian immediately set upon implementing it. With Brian's help, the complex subroutine you see above now allows a number of any length to be MFed. The KP and ST tones are automatically prepended and appended to the tone string automatically; there is no need to specify this.

To call the MFer, all you need to do is pass in the digits to MF (not including KP and ST) as ARG1, like so: GoSub(mfer,start,1(5551212)).

The above will result in KP + 5 + 5 + 5 + 1 + 2 + 1 + 2 + ST being MFed.

You can now use this MFer on incoming and/or outgoing calls from your node. Perhaps you want to have MF inpulsing on calls interoffice calls to your second exchange:

[local-interoffice]
exten => _${OC1}XXXX,1,GoSub(revertive,start,1(${EXTEN:-4},0,5xb))
	same => n,GoTo(KLondike5,${EXTEN:-4:4},1)
exten => _${OC2}XXXX,1,GoSub(mfer,start,1(${EXTEN}))
	same => n,GoTo(KLondike6,${EXTEN:-4:4},1)
			

Or perhaps, you only have one exchange code but be really ambitious:

exten => _${OC1}XXXX,1,GoSub(mfer,start,1(${EXTEN}))
	same => n,GoSub(revertive,start,1(${EXTEN:-4},0,5xb))
	same => n,GoTo(KLondike5,${EXTEN:-4:4},1)
			

Now, external callers would hear MFing, followed by #5XB revertive pulsing.

You have the flexibility to choose from various inpulsing and outpulsing options for your node, but remember to stay "period-correct". You might hear MFing followed by revertive pulsing, for instance, but you would not be likely to hear revertive pulsing followed by MFing! Pay attention to the order of your inpulsing and outpulsing and make sure it stays realistic.

Note: Do not add any outpulsing directly in the dialnpstn subroutine! Instead, create a separate outpulsing context that you call before dialnpstn (or call the particular outpulsing subroutine). Either way, call any outpulsing separately before calling the dialnpstn subroutine.

SFer

If you do not already have the [signallookup] subroutine (the same one used for the MFer), you will need that:

[signallookup] ; NPSTN 20210208 NA ; Bell System specs say 1st 50 should be 55? / MFX - silence / ST - Don has 35 here set to 50
exten => MF,1,Return("|","!0/${ARG3}","!700+900/${ARG1}|!0/${ARG2}","!700+1100/${ARG1}|!0/${ARG2}","!900+1100/${ARG1}|!0/${ARG2}","!700+1300/${ARG1}|!0/${ARG2}","!900+1300/${ARG1}|!0/${ARG2}","!1100+1300/${ARG1}|!0/${ARG2}","!700+1500/${ARG1}|!0/${ARG2}","!900+1500/${ARG1}|!0/${ARG2}","!1100+1500/${ARG1}|!0/${ARG2}","!1300+1500/${ARG1}|!0/${ARG2}","!1100+1700/100|!0/${ARG2}","!1500+1700/${ARG4}|!0/${ARG2}","!1300+1700/100|!0/${ARG2}","!900+1700/${ARG4}|!0/${ARG2}","!700+1700/${ARG4}|!0/${ARG2}")
exten => SF,1,Return("|",200,100,"!0/200","!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}","!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}|!${ARG1}/${ARG2}|!0/${ARG3}") ; ARG1 = frequency (2600), ARG2 = on (60ms), ARG3 = off (40ms) / SFX = interdigit silence
			

Regardless, you will need the [sfer] subroutine:

[sfer] ; NPSTN 20190218 NA, revised 20210208 ; ARG1 = digits to SF
exten => start,1,Set(number=${FILTER(0-9,${ARG1})}) ; ARG1 = digits to do something with
	same => n,Gosub(signallookup,SF,1(2600,60,40))
	same => n,Set(ARRAY(digitsep,sfinter,sfpulse,sfx,sf1,sf2,sf3,sf4,sf5,sf6,sf7,sf8,sf9,sf0)=${GOSUB_RETVAL})
	same => n,Set(c=0)
	same => n,Set(p=0)
	same => n,Set(numdigits=${LEN(${ARG1})})
	same => n,Set(tonestring=)
	same => n,While($[${c}<${numdigits}])
	same => n,Set(nextp=${number:${c}:1})
	same => n,ExecIf($["${nextp}"="0"]?Set(nextp=10))
	same => n,Set(p=$[${p}+${nextp}])
	same => n,Set(sfnext=${sf${number:${c}:1}})
	same => n,Set(tonestring=${tonestring}${sfnext}${digitsep})
	same => n,Set(tonestring=${tonestring}${sfx}${digitsep})
	same => n,Set(c=${INC(c)})
	same => n,EndWhile
	same => n,Set(toneduration=$[${sfpulse}*${p}+${sfinter}*${numdigits}])
	same => n,PlayTones(${FILTER(0-9\x21/|+,${tonestring})})
	same => n,Wait($[${toneduration}/1000])
	same => n,StopPlayTones()
	same => n,Return()
			

Dial Pulser

Below is the dialplan coded needed for the dial pulser:

[dialpulser] ; NPSTN 20190212 NA
exten => start,1,Set(number=${ARG1}) ; ARG1 = digits to dial pulse
	same => n,Set(c=0)
	same => n,Set(numdigits=${LEN(${ARG1})})
	same => n,While($[${c}<${numdigits}])
	same => n,Playback(custom/dialpulses/dp${number:${c}:1},noanswer)
	same => n,Set(c=${INC(c)})
	same => n,EndWhile
	same => n,Return
			

ARG1 is simply what number to dial pulse. The number can be of any length (beside 0, obviously).

You will need audio recordings of each number being dial pulsed. You can easily extract dial pulses from various Evan Doorbell recordings. Prefix each digit with dp when you save the audio file, convert to ulaw, and then move to /var/lib/asterisk/sounds/en/custom/dialpulses/.

If you'd prefer to use our dial pulsing audio files, you may download them here.

Conference Bridges

Creating a conference bridge in Asterisk is relatively easy. Here, we will provide a template for creating a kind of so-called "party line" conference bridge, much like those on which Evan Doorbell spent hours talking and listening in the 1970s.

You will need to add the following to confbridge.conf:

[bridge]
type=bridge
sound_join=/var/lib/asterisk/sounds/en/custom/conf/confjoin  ; The sound played to everyone when someone enters the conference.
sound_leave=/var/lib/asterisk/sounds/en/custom/conf/confdis ; The sound played to everyone when someone leaves the conference.

[caller]
type=user
dsp_drop_silence=no
announce_only_user=no

[volmenu]
type=menu
4=decrease_listening_volume
5=reset_listening_volume
6=increase_listening_volume
7=decrease_talking_volume
8=reset_talking_volume
9=increase_talking_volume
0=toggle_mute

[advmenu]
type=menu
1=participant_count
4=decrease_listening_volume
5=reset_listening_volume
6=increase_listening_volume
7=decrease_talking_volume
8=reset_talking_volume
9=increase_talking_volume
0=toggle_mute
			

You will need the "confjoin" and "confdis" audio files. You can use whatever audio files you like here; we recommend extracting actual "party line" conference joining and disconnect noises from an Evan Doorbell recording.

To have an extension go to a conference bridge, specify the following in your dialplan: ConfBridge(1,bridge,caller).

In this case, we have given the bridge an ID of 1. This number should be unique for each conference. You may choose to set this equal to the extension on which this conference is located.

You can have multiple extensions go to the same bridge but with different "experiences". For example, you could create a separate extension that joins the same bridge but also features a menu: ConfBridge(1,bridge,caller,volmenu). As you've probably figured out by now, ARG1 for ConfBridge is which bridge to use, ARG2 is which bridge profile to user, ARG3 is which user profile to use, and ARG4, which is optional, is which menu to use, if any. If you're trying to recreate a 1970s "party line", though, omit the menu.

It is important to note that conferences are not created or defined in confbridge.conf! Creating a second conference is as simple as making another extension with a ConfBridge call that uses something different for ARG1. For instance, ConfBridge(2111,bridge,caller) and ConfBridge(052,bridge,caller) would be two different conferences entirely, though they both use the same bridge and user profiles, so the experiences (i.e. sounds and functionality) will be the same.

Non-Supervising Conference Bridges

By default, the ConfBridge() application will supervise with no alternative, unlike the Playback() application which accepts a noanswer argument. Because ConfBridge is often the only way to get much functionality in Asterisk to work as desired, this is a significant limitation; however, modifying the source code can remove this behavior for better operation.

As of June 2021, Asterisk's app_confbridge now has the answer_channel user option. Set answer_channel = no, with Asterisk 18.5+/Asterisk 16.19+. No patching is required.

You must either use Progress() or Answer(). Failing to do so may result in no audio being passed at all.

Take care to revisit all uses of ConfBridge in your dialplan code to ensure you're using Progress or Answer before any calls to ConfBridge.

Answering Machines

Answering machines and voicemail are, in many ways, the antithesis of each other. Functionally, an answering machine has no place in Asterisk. However, it may be neat to simulate a physical telephone answering device (or answering machine) in Asterisk, to make it sound like somebody has reached an answering machine. This can be done with fairly trivial dialplan code.

Behind the scenes, the VoiceMail application can still be used. For the most part, the caller would never notice the difference. However, by default, Asterisk plays its own beep tone to the caller and this cannot be overridden. The following patch to Asterisk (not yet merged into Digium Asterisk as of April 2021) addresses this issue:

cd /tmp
wget https://code.phreaknet.org/asterisk/ASTERISK-29349.patch
cd /usr/src/asterisk-18.3.0/
patch -u -b apps/app_voicemail.c -i /tmp/ASTERISK-29349.patch # adds the t option to VoiceMail()
make
make install
asterisk -rx "core restart now"
			

This is a relatively simply patch which simply gives the dialplan programmer full control over what beep should be played, or whether one should be played at all. Simply add the t option, specifying a custom beep tone to use, or leaving this argument empty to suppress the beep entirely.

This allows you to use your own outgoing answering machines without a modern Asterisk tone coming on at the end, and you can even use beep tones that are noticably analog and old sounding.

Note that if a user presses the # key while recording, Asterisk will say "thank you" and exit the VoiceMail application (playing auth-thankyou). This patch does not address that behavior. If users are allowed to review messages in voicemail.conf, an additional menu plays afterwards anyways, so it's not merely a question of suppressing an auth-thankyou somewhere, and it's probably best to just leave this behavior be.

Hook Flashing

As of April 2021, Asterisk itself has very minimal support for hook flashing. All Asterisk has historically done is propogate these events across channels from one to the other, if they are compatible. It has not had any ability to do anything with these events or expose them in any way (i.e. AMI).

There are two primary reasons for this:

• In Asterisk, the "modern" and "hip" way to do certain tasks usually accessed through a hook flash is through special feature codes like *2 that are defined in features.conf
• ATAs can handle hook flashes locally and perform a small but generally sufficient set of actions, such as Call Waiting, Three Way Calling, etc.

For building advanced functionality, it is essential to be able to handle hook flashes in Asterisk rather than let them be handled locally. In fact, ATAs have better support for this than they do handling these events locally. Grandstream ATAs, for example, will not connect to the switch at all if you flash to spawn a three-way call, even if you have off-hook auto-dial configured. Generally speaking, you are limited to the idiosyncrasies of different ATAs and many events are simply impossible to handle in the desired way. Sending flash events to Asterisk and performing bridge operations switch-side is vastly superior, though it requires a significant investment in configuring such a system (not for the light-hearted!) You will need to handle flash events as desired and implement all relevant functionality yourself, including writing your own Call Waiting from scratch. However, if you are designing an actual Class 5 switch, this is probably what you are trying to do anyways.

Regardless of the purpose, being able to handle flash events increases flexibility. The good news is that as of April 2021, patches to make hook flash events a first class citizen in Asterisk are now available! To add hook flash events to Asterisk, it's as easy as running the following:

cd /tmp
wget https://code.phreaknet.org/asterisk/sip.patch
wget https://code.phreaknet.org/asterisk/file.patch  
wget https://issues.asterisk.org/jira/secure/attachment/60149/ASTERISK-29373.diff
wget https://code.phreaknet.org/asterisk/stasis_sample.patch
wget https://code.phreaknet.org/asterisk/stasis_channels.h.patch
wget https://code.phreaknet.org/asterisk/stasis_channels.c.patch
wget https://code.phreaknet.org/asterisk/manager_channels.patch
wget https://code.phreaknet.org/asterisk/stasis.patch
wget https://code.phreaknet.org/asterisk/channel.patch
cd /usr/src/asterisk-18.3.0/
patch -u -b channels/chan_sip.c -i /tmp/sip.patch # add application/hook-flash support for SIP INFO flash events
patch -u -b main/file.c -i /tmp/file.patch # ignore flash events and don't throw an error
patch -u -b res/res_rtp_asterisk.c -i /tmp/ASTERISK-29373.diff # don't create duplicate flash events for RTP flashes
patch -u -b configs/samples/stasis.conf.sample /tmp/stasis_sample.patch # AMI flash event
patch -u -b include/asterisk/stasis_channels.h /tmp/stasis_channels.h.patch # AMI flash event
patch -u -b main/stasis_channels.c /tmp/stasis_channels.c.patch # AMI flash event
patch -u -b main/manager_channels.c /tmp/manager_channels.patch # AMI flash event
patch -u -b main/stasis.c /tmp/stasis.patch # AMI flash event
patch -u -b main/channel.c /tmp/channel.patch # stop throwing warning for flash event and handle flash events by triggering AMI event
make
make install
asterisk -rx "core restart now"
			

This will expose hook flashes as AMI events. You will need to handle them using an out of band AMI process, such as PAMI for PHP. You can then spawn dialplan execution to perform flash logic and do other operations as desired based on the state of the call(s).

As of April 2021, the patches to add AMI support have been submitted to Digium but are not yet part of the master Asterisk source code. Until the feature is available natively, you simply need to patch your copy and recompile. It should not take more than a minute or two to do.

Credits & Contributions: J. Colp, Digium for correcting improper RTP stream handling of flash events; N.A. for two issues which add application/hook-flash support to SIP, suppress errors in file.c, and adding full AMI (Asterisk Manager Interface) support for flash events.

Announcement Drums

It is relatively simple to set up shared (and even talkable) busy signals or simulated drum announcement machines with Asterisk. The below will cover a simple example of a drum announcement. There are multiple ways to do this and this is just an example.

You will likely want the non-supervising ConfBridge patch for this kind of stuff.

Typically, the idea with these is:

• If the announcement is idle and it gets a call, "start" the drum up
• All callers who reach the announcement before it gets to the beginning are all simultaneously cut into it at the same time
• When no callers are left, the "machine" turns itself off. In software, this is even more important, because there's no legitimate reason to waste resources when nothing needs them

The example below cuts callers into an announcement for one announcement cycle and then sends them to another destination.

The example below supervises when callers are cut into the bridge. For intercepts, this may not be desirable. Instead of the initial Dial(), you could use MusicOnHold() directly and then StopMusicOnHold() instead of Answer() in the [drum]. With the patch to ConfBridge, callers will then be cut into a bridge, and the call still will not have supervised. All depends on how you want to set things up.

The example below is similar to the code that powers Centralized Intercept on NPSTN. POPCORN (767-2676) on NPSTN also uses similar "drum technology". Callers are cut in at the same time and stay on for 4 full cycles of the time from when they entered. Then, they're dropped to a "post-time conference" for about 10 seconds, then disconnected. This is an example of a more elaborate system.

exten => _X!,1,Dial(Local/${EXTEN}@drum,,m(ringback)g) ; drum announcement
	same => n,Goto(somewhere-else,s,1)

[drum]
exten => _X!,1,Set(GROUP(drumintercept)=1)
	same => n,Set(CDR_PROP(disable)=1)
	same => n,Set(CONFBRIDGE(user,wait_marked)=yes)
	same => n,Set(CONFBRIDGE(user,end_marked)=yes)
	same => n,Set(CONFBRIDGE(user,dtmf_passthrough)=no)
	same => n,Set(CONFBRIDGE(user,startmuted)=yes)
	same => n,Set(CONFBRIDGE(user,dsp_drop_silence)=yes)
	same => n,GotoIf($[${GROUP_COUNT(1@drumintercept)}=1]?startannouncement:waitloop)
	same => n(startannouncement),Originate(Local/1@drum-announcement,exten,announcement-access,1,,a)
	same => n,Wait(0.1)
	same => n(waitloop),GotoIf($["${CONFBRIDGE_INFO(parties,drumintercept1)}"="0"]?startannouncement) ; if nobody is in the conference, start it up
	same => n,WaitForCondition(#,#[#{GROUP_COUNT(1@interceptcutin)}>0])
	same => n(bridge),Answer()
	same => n,ConfBridge(drumintercept1,silentbridge,incogtalkeroptimized)
	same => n,Set(GROUP(drumintercept)=)
	same => n,Hangup()

[announcement-access]
exten => 1,1,Set(CONFBRIDGE(user,marked)=yes)
	same => n,Set(CDR_PROP(disable)=1)
	same => n,ConfBridge(drumintercept1,silentbridge,incogtalkeroptimized)
	same => n,Hangup()

[announcement-monitor]
exten => 1,1,Answer()
	same => n,Set(CDR_PROP(disable)=1)
	same => n,ConfBridge(drumintercept1,silentbridge,incoglistener)
	same => n,Hangup()

[drum-announcement]
exten => 1,1,Answer()
	same => n,Set(CDR_PROP(disable)=1)
	same => n,Wait(${RAND(2,3)})
	same => n,Set(GROUP(interceptcutin)=1)
	same => n,Wait(0.85)
	same => n,Set(GROUP(interceptcutin)=)
	same => n,Set(VOLUME(TX)=2)
	same => n,Playback(custom/intercept-announcement,noanswer)
	same => n,Wait(3)
	same => n,System(asterisk -rx "confbridge kick drumintercept1 all") ; you could kicked all the unmarked users here, instead of all the users
	same => n,Hangup() ; hang up, and kick out everyone presently in the bridge
			

Crosstalk

One would think that ChanSpy() could be used for this kind of thing, but ChanSpy is, for these purposes, almost completely useless, due to a long persistent limitation with audiohooks in Asterisk.

You will need to use ConfBridge. The non-supervising ConfBridge patches are a must-have pre-req. Once you have that, the mechanism is as follows:

• "Regenerate" the call. We use "regenerate" as pseudo-jargon to precisely mean: generating, via a call file (not via Originate(), due to the significant limitations of this application), a near-identical copy of the current call. This means all channel variables, and of course, the Caller ID, name, and presentation, as well as anything else you want to carry forward henceforth.
• Drop the original call into a ConfBridge(). Not supervised, so there won't be any answer supervision sent to the caller. The regenerated call is what's actually going to go to the destination, and this will enter the bridge as well.
• Use the G option for Dial() to fork the call on answer supervision. Once the called party answers, split the caller and callee paths. We don't need the caller path anymore, so get rid of it (Hangup), though be careful with the h extension! Next, set a flag to indicate the call has been answered (e.g. by using a global variable or a DB entry), then drop the original call from the ConfBridge. In the dialplan, it will check whether the call has been answered using that aforeset flag, and if it has, it will Answer() the call and then re-enter the bridge. (Basically, we kick the caller out of the bridge to provide him with answer supervision, then drop him back in.)
• All in the meanwhile, since we now have a ConfBridge, you can mix whatever audio you want into the bridge. For crosstalk, there's a fairly logical way to do this. You could have unique crosstalk per call or shared crosstalk across all calls, and source this crosstalk from audio files, other conference bridges, etc.

There is more involved, of course. Each call effectively has a unique conference bridge. Hangup handling using the h extension is an art that must be carefully mastered. Because the calling party is no longer directly connected to the called party, you will need to manually check for different cases and kick the other party if one has left. And if you forget to do this in all the required places, then you may find that you have "ghost" bridges with nobody in them piling up as calls take place. When a call is completed, the conference bridge should get destroyed.

Because there are some people interested in this concept, a subset of the crosstalk/carrier code used on NPSTNNA01 is provided below for reference.

;;; Usage example:
[dtnpstn]
exten => _X!,1,Gosub(npstnanifail,check,1) ; ANI FAIL CHECK
	same => n,ExecIf($["${GOSUB_RETVAL}"="1"]?Hangup(29)) ; ANI FAIL CHECK
	same => n,Gosub(carriersetup,out,1(${EXTEN}))
	same => n,GosubIf($[${LEN(${GOSUB_RETVAL})}>0]?regeneratecall,s,1(${GOSUB_RETVAL},carrierbridgeaccess,carrieronward,out,${EXTEN}))
	same => n,GotoIf($[${LEN(${GOSUB_RETVAL})}>0]?carrierbridge,${GOSUB_RETVAL},1)
	same => n(dial),Gosub(npstn-out-verify,${EXTEN},1)
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?linerestricted,${EXTEN},1)
	same => n,GotoIf($["${GOSUB_RETVAL}"="0"]?npstn-out-blocked,s,1)
	same => n,Gosub(dialnpstn,start,1(${EXTEN},disable,${zipcode},${maindisa}))
	same => n,Hangup()

;;; Carrier Code:

[carriersetup]
exten => in,1,Set(CDR_PROP(disable)=1)
	same => n,Gosub(carrierlookup,${ARG1},1)
	same => n,ExecIf($[${GOSUB_RETVAL}=0]?Return)
	same => n,Set(LOCAL(channel)=${FILTER(0-9,${UNIQUEID})})
	same => n,Set(__callednumber=${ARG1}) ; do we really need this?
	same => n,ExecIf($[${GROUP_COUNT(1@carriercalls)}=0]?DBdeltree(carrierchannels))
	same => n,Set(GROUP(carriercalls)=1)
	same => n,Set(GROUP(carriercrosstalk)=1)
	same => n,Set(DB(carrierchannels/${channel})=${CHANNEL})
	same => n,ExecIf($[${GROUP_COUNT(0@carriercrosstalk)}=0]?Originate(Local/s@carriercrosstalk,app,Wait,9999999,,,av(CDR_PROP(disable)=1^CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)})))
	same => n,Set(randl=BCDE) ; Subtle L-Carrier track options (we'll randomly pick one)
	same => n,Set(LOCAL(carriergroup)=${randl:$[${RAND(1,${LEN(${randl})})}-1]:1})
	same => n,Set(SHARED(carriergroup)=${carriergroup})
	same => n,Originate(Local/${carriergroup}@carriernoise,exten,carrierinject,${channel},1,,av(CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)})) ; Main L-Carrier
	same => n,Originate(Local/monitor@carriercrosstalk,exten,carrierinject,${channel},1,,av(CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)})) ; Crosstalk
	same => n,Return(${channel})
exten => out,1,Set(CDR_PROP(disable)=1)
	same => n,Gosub(carrierlookup,${ARG1},1)
	same => n,ExecIf($[${GOSUB_RETVAL}=0]?Return)
	same => n,Gosub(vsc-npstn-numcheck,${ARG1},1)
	same => n,ExecIf($[${GOSUB_RETVAL}=0]?Return)
	same => n,Set(LOCAL(channel)=${FILTER(0-9,${UNIQUEID})})
	same => n,Set(__callednumber=${ARG1}) ; do we really need this?
	same => n,ExecIf($[${GROUP_COUNT(1@carriercalls)}=0]?DBdeltree(carrierchannels))
	same => n,Set(GROUP(carriercalls)=1)
	same => n,Set(GROUP(carriercrosstalk)=1)
	same => n,Set(DB(carrierchannels/${channel})=${CHANNEL})
	same => n,ExecIf($[${GROUP_COUNT(0@carriercrosstalk)}=0]?Originate(Local/s@carriercrosstalk,app,Wait,9999999,,,av(CDR_PROP(disable)=1^CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)})))
	same => n,Set(randl=BCDE) ; Subtle L-Carrier track options (we'll randomly pick one)
	same => n,Set(LOCAL(carriergroup)=${randl:$[${RAND(1,${LEN(${randl})})}-1]:1})
	same => n,Set(SHARED(carriergroup)=${carriergroup})
	same => n,Originate(Local/${channel}@carrierinject,exten,carriernoise,${carriergroup},1,,av(CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)})) ; Main L-Carrier
	same => n,Originate(Local/monitor@carriercrosstalk,exten,carrierinject,${channel},1,,av(CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)})) ; Crosstalk
	same => n,Return(${channel})

[regeneratecall] ; ARG1 = local channel ID, ARG2 = local channel context, ARG3 = context, ARG4 = in/out, ARG5 = called #
exten => s,1,Originate(Local/${ARG1}@${ARG2},exten,${ARG3},${ARG5},1,,av(CALLERID(num)=${CALLERID(num)}^CALLERID(name)=${CALLERID(name)}^CALLERID(pres)=${CALLERID(pres)}^calldirection=${ARG4}^__channel=${ARG1}^__autovonchan=${autovonchan}^__clidverif=${clidverif}^__autovonprioritydigit=${autovonprioritydigit}^__forcesecurechannel=${forcesecurechannel}^__dtlocation=${dtlocation}^__isup-oli=${isup-oli}))
	same => n,Return(${ARG1})

[carrierbridge]
exten => _X!,1,Set(channel=${EXTEN}) ; if caller hangs up, end call
	same => n,Set(CDR_PROP(disable)=1)
	same => n,Progress()
	same => n,Set(carriergroup=${SHARED(carriergroup,${DB(carrierchannels/${channel})})})
	same => n,ExecIf($["${carriergroup}"!="B"]?Set(VOLUME(TX)=-${RAND(7,9)}))
	same => n,ExecIf($["${carriergroup}"!="B"]?Playback(custom/switch/connect/carrierconnect1,noanswer))
	same => n,ExecIf($["${carriergroup}"!="B"]?Set(VOLUME(TX)=1))
	same => n,ConfBridge(channel${channel},silentbridge,incogtalker) ; this MUST NOT ANSWER the call
	same => n,ExecIf($["${SHARED(carrieranswered,${DB(carrierchannels/${channel})})}"="1"]?Answer():Hangup) ; prevent answering the call if it wasn't... actually answered!
	same => n,Set(SHARED(carrieranswered,${DB(carrierchannels/${channel})})=2) ; this is the ${channel} channel so we don't need to explicitly specify it with SHARED
	same => n,ConfBridge(channel${channel},silentbridge,incogtalker)
	same => n,Hangup() ; used was kicked (other party hung up)
exten => h,1,ExecIf($[${CONFBRIDGE_INFO(parties,channel${channel})}>0]?ConfKick(channel${channel},all))

[carrieronward]
exten => _X!,1,Set(CDR_PROP(disable)=1)
	same => n,Answer() ; bridge audio to caller immediately
	same => n,Wait(${RAND(1,2)})
	same => n,Set(carriergroup=${SHARED(carriergroup,${DB(carrierchannels/${channel})})})
	same => n,Wait(0.5)
	same => n,ExecIf($["${calldirection}"="out"]?Wait(${RAND(1,${RAND(2,5)})})) ; give time for the L-carrier "B-loop" sound to play
	same => n,ExecIf($["${calldirection}"="in"]?Dial(Local/${EXTEN}@intraoffice-connect,,G(split))) ; channel variables will carry
	same => n,ExecIf($["${calldirection}"="out"]?Dial(Local/${EXTEN}@dtnpstn-out,,G(split))) ; channel variables will carry
	same => n,ConfKick(channel${channel},all) ; if called party hangs up without answering, end call
	same => n(caller),Goto(carrieronward-hangup,s,1) ; so h extension doesn't execute
	same => n(split),Goto(caller) ; disconnect caller to get rid of an unnecessary channel
	same => n(callee),Set(SHARED(carrieranswered,${DB(carrierchannels/${channel})})=1)
	same => n,ConfKick(channel${channel},${DB(carrierchannels/${channel})}) ; kick the caller from the bridge, which will Answer() the call and then drop him back in
	same => n,Set(CDR_PROP(disable)=1)
	same => n,Goto(carrierbridgecallee,${channel},1)
exten => h,1,ExecIf($[${CONFBRIDGE_INFO(parties,channel${channel})}>0]?ConfKick(channel${channel},all)) ; if calling party hangs up, end call

[carrieronward-hangup]
exten => s,1,Hangup()

[carrierbridgecallee]
exten => _X!,1,Set(channel=${EXTEN})
	same => n,Set(CDR_PROP(disable)=1)
	same => n,Originate(Local/answer@carriernoise,exten,carrierinject,${channel},1,,a)
	same => n(wait),WaitForCondition(#,#["#{SHARED(carrieranswered,#{DB(carrierchannels/#{channel})})}"="2"],1) ; prevents race conditions, where if the ConfKick before carrieronward,caller has NOT YET taken effect, we don't kill the call (that call must finish before this executes)
	same => n(bridge),ExecIf($[${CONFBRIDGE_INFO(parties,channel${channel})}>0]?ConfBridge(channel${channel},silentbridge,incogtalker))
	same => n,Hangup()
exten => h,1,ExecIf($[${CONFBRIDGE_INFO(parties,channel${channel})}>0]?ConfKick(channel${channel},all)) ; if called party hangs up, end call

[carrierbridgeaccess]
exten => _X!,1,Set(CDR_PROP(disable)=1)
	same => n,Answer()
	same => n,ConfBridge(channel${EXTEN},silentbridge,incogtalker)
	same => n,Hangup()
			

Echo Test

The standard way to create an echo test in Asterisk would be as follows:

exten => 9931,1,GoTo(echo,s,1)

[echo]
exten => s,1,Answer() ; Echo test with instructions
	same => n,Playback(demo-echotest)
	same => n,Echo()
	same => n,Playback(demo-echodone)
	same => n,Playback(vm-goodbye)
	same => n,Hangup()
			

We have created a separate context just for the echo test here, as this is generally good practice. Instead of duplicating code should you wish to add another echo test on a different extension, you can simply copy the GoTo statement and send it to the same context.

Note that the use of the s extension is completely arbitrary and could be anything. In macros, you are required to use the s extension, but subroutines often use the start extension instead (but could use anything, including s, as you may see elsewhere in this documentation).

However, this may not be what you want on your node. If you call extension 9931, by dialing, say, 555-9931, you won't immediately be dumped into the echo test. Most Asterisk systems with echo tests use the code above, which plays an introductory message about the echo test first and a concluding message afterward (if you press # as opposed to simply hanging up). If you simply want your extension to go to an echo test (perhaps more realistic if you are trying to stick with the "vintage" theme, you can replace the above [echo] context with the following:

[echo]
exten => s,1,Progress() ; Echo test with no instructions
	same => n,Echo()
	same => n,Hangup()
			

Now, you'll immediately enter the echo test when you call extension 9931, and you won't hear anything if you press "#" before it terminates the call. Here, we use Progress instead of Answer, since an echo test is a test number, so it should not provide answer supervision.

Silent Termination

Creating a silent termination line is incredibly simple:

[silentterm]
exten => start,1,Wait(86400)
	same => n,Return
			

What this subroutine actually does, when called, is wait for 86,400 seconds (or 24 hours), before returning. This way, a caller can't call your silent termination line and stay there forever.

To create a silent termination extension, simply add the following subroutine call to an extension:

exten => 9932,1,GoSub(silentterm,start,1)
	same => n,Hangup
			

Note that this silent termination line will not "supe" (it won't provide answer supervision). You can add an Answer statement first to change that:

exten => 9932,1,Answer
	same => n,GoSub(silentterm,start,1)
	same => n,Hangup
			

Live Feeds

Asterisk allows you to use the mpg123 utility to play MP3 streams from the Internet. Although it is not so popular anymore, in the mid to late-20th century, it was quite common to be able to listen to live music feeds and radio stations using certain access numbers, allowing people to listen to their favorite stations and news from wherever they were (provided they were willing to foot the long-distance charges). In Asterisk, there are two approaches you can take to play an MP3 stream.

The first approach is to define the stream in musiconhold.conf. For our example here, we will create a stream for the KZSU radio station which, as of this writing, features, among other things, a 1950s 701B SxS electromechanical switch in its office. We will also create a stream for KPFA, the flagship station of the Pacifica Radio Network:

[KZSU]
mode=custom
application = /usr/bin/mpg123 -q -s --mono -r 8000 -f 8192 -b 0 http://171.66.118.110:8080/kzsu-1-128.mp3

[KPFA]
mode=custom
application = /usr/bin/mpg123 -q -s --mono -r 8000 -f 8192 -b 0 http://streams.kpfa.org:8000/kpfa
			

Now, you will need to add the appropriate dialplan code to access the Music on Hold streams you defined:

exten => 5078,1,Answer()
	same => n,Set(TIMEOUT(absolute)=3600)
	same => n,MusicOnHold(KZSU)
	same => n,Hangup()
exten => 5732,1,Answer()
	same => n,Set(TIMEOUT(absolute)=3600)
	same => n,MusicOnHold(KPFA)
	same => n,Hangup()
			

The timeouts you see simply prevent the extension from being tied up forever (even though multiple people can access the stream). After 3600 seconds, or 1 hour, the call will automatically be disconnected. This can help ensure callers don't dial into a stream and let it run for perpetuity.

Now by dialing extension 5078 (or KZSU if dialing by letters) or dialing extension 5732 (or KPFA), you can listen to those respective radio stations.

*Technically, Z is not on the telephone dial, so we have substituted 0 for Z, since the two were equated for ZEnith dialing in many areas.

The downside of this approach is that it doesn't scale well. Every MP3 stream you define in musiconhold.conf is running all the time, 24/7/365. While we don't think this makes much sense (and perhaps constitutes a bug, unintentional or otherwise) in Asterisk, that's how it is. We learned this the hard way when we defined around 100 MP3 streams in musiconhold.conf. As soon we entered moh reload at the Asterisk CLI, the server immediately ground almost to a halt. Needless to say, things were not pleasant. We recommend using this approach only if you have a few streams; if you are looking to have more than 5 or 10 streams, a better approach is to not use musiconhold.conf at all but instead to create the stream on demand directly in the dialplan, like so:

exten => 5078,1,Answer()
	same => n,Set(TIMEOUT(absolute)=3600)
	same => n,MP3Player(http://171.66.118.110:8080/kzsu-1-128.mp3)
	same => n,Hangup()
exten => 5732,1,Answer()
	same => n,Set(TIMEOUT(absolute)=3600)
	same => n,MP3Player(http://streams.kpfa.org:8000/kpfa)
	same => n,Hangup()
			

As you can see, musiconhold.conf is not used at all. The advantage of this is that streams are not running when they are not in use. Resources will only be used to play the stream when there is an active call connected to these extensions.

So, which approach should you use? The downside of the latter approach is that a separate stream instance is created for each caller, even if they are all accessing the same stream. Thus, the approach you implement will depend largely on how and by whom your streams will be used. If you expect a lot of callers will be calling a small number of streams, go with the first method. If you want to create a large number of streams and don't expect much traffic to any single stream in particular, you should consider the second method, since you will not dedicating unnecessary resources to playing the streams when they are not in use.

Finally, worth mentioning is that since the latter approach creates the stream on-demand, rather than accessing an "already-on" stream, there is an additional delay when the stream is called of about 1 second. The delay is not really noticable unless you are listening for it, but you may want to keep this in mind if you need a stream to available the split instant you call it. If this is the case for you, then you will want to define the stream in musiconhold.conf so that it is always playing and immediately accessible. That being said, the discrepancy is only about 1 second, so it is not really worth doing this unless you have a good reason. The former approach is recommended if you only have a few streams and expect high traffic to them, but we personally prefer the latter approach as it allows you to have an unlimited number of streams that, provided they are generally low-traffic, will keep resource utilization to a minimum (i.e. none) when idle.

In other words, if streaming is a big part of what you do, but you don't have too many, define your streams in musiconhold.conf. Otherwise, don't; simply create the streams on demand.

Modems

Contrary to what you may have read elsewhere on the web, you can setup virtual modems in Asterisk! Here, we will set up a virtual modem and use that to create a BBS.

1. Enter the following in the terminal to install Telnet client and server, as well as other utilities you may need:
   sudo apt-get install telnetd -y
sudo apt-get install telnet -y
sudo apt-get install xinetd -y
sudo apt-get install tcpd -y
service xinetd restart
sudo apt-get install lynx -y — text/line mode text browser
   sudo apt-get install less -y — navigation of large outputs
   sudo apt-get install libxml2-utils -y — HTML parser
   sudo apt-get install bc -y — Basic Calculator
   sudo apt-get install sshpass -y — SSH Auto-Password Passer
   sudo apt-get install lynx -y — SSH Auto-Password Passer

If telnet does not work, or later stops working, follow the steps in these two StackOverflow answers:

1. https://stackoverflow.com/a/34390046/6110631
2. https://stackoverflow.com/a/61937840/6110631

Here are the critical steps from the two answers linked above:

1. Add telnet stream tcp nowait telnetd /usr/sbin/tcpd /usr/sbin/in.telnetd to /etc/inetd.conf.
2. Make this your default in /etc/xinetd.conf:

   Simple configuration file for xinetd
   #
   # Some defaults, and include /etc/xinetd.d/
   defaults
   {
   # Please note that you need a log_type line to be able to use log_on_success
   # and log_on_failure. The default is the following :
   # log_type = SYSLOG daemon info
   instances = 60
   log_type = SYSLOG authpriv
   log_on_success = HOST PID
   log_on_failure = HOST
   cps = 25 30
   }
   				

3. sudo /etc/init.d/xinetd restart
4. sudo apt-get install tcpd
2. For this sample, we will be using username "com" and password "com". Wherever you see "com", replace with the info for your system. Enter the following in your terminal:
   nano /etc/issue.net
   Delete the text Debian GNU/Linux 9 and replace it with text like:

   Welcome to the BBS! Login with username "com" and password "com"
   				

   Press CTRL+X to save, then Y to confirm, then press ENTER.
3. Now, create the account "com" with password "com":
   sudo adduser -p $(openssl passwd -l com) com (the first "com" is the password, the second is the password)

To change the password last type sudo passwd com and it will ask for the new password.

To get the user ID of the user, type id -u com.

To make this a passwordless account, first modify /etc/ssh/sshd_config and change #PermitEmptyPasswords no to PermitEmptyPasswords yes
Then, pw usermod com -w none

4. Now, create a blank shell script that will be used as the entry point for loopback Telnet sessions initiated from Asterisk:
   touch /home/com/main.sh
usermod -s /home/com/main.sh com
chmod a+x /home/com/main.sh
   The second line changes the home directory of "com" to the shell script we created, locking the user's connection into that script. The last line sets the proper permissions. At this point, this shell script doesn't do anything; we'll take care of that once the other mechanics are set up properly.

Alternate Instructions: adduser com; sudo chsh -s /home/com/main.sh com

5. The following lines remove the normal login information spew provided to users upon initial connection to the server. This does affect all users, but this provides a necessary improvement in realism:
   touch /home/com/.hushlogin
rm -rf /etc/motd
touch /etc/motd

6. Allow certain system access to the controlled shell environment:

   chmod 777 -R /var/spool/asterisk chmod 777 -R /home/com/log
7. Now the mechanism to initiate a Telnet session from Asterisk has been created. Now, we will install a softmodem in Asterisk that can connect to a shell script via the Telnet mechanisms we just set up:
   wget https://raw.githubusercontent.com/proquar/asterisk-Softmodem/app_softmodem/app_softmodem.c
wget https://code.phreaknet.org/asterisk/app_softmodem.c
mv app_softmodem.c /usr/src/asterisk-13.24.0/apps/
cd /user/src/asterisk-13.24.0/apps/
make apps
make install
service asterisk restart
reboot
8. Now, modify your dialplan to offer callers a way to connect to your softmodem. Here is the dialplan syntax:

   exten => btx,1,Answer()
   	same => n,Softmodem(host, port, options)
   	same => n,Hangup()
   
   Without any arguments the application acts as a V.23 modem and connects to a Telnet server (port 23) on localhost.
   
   Options are:
   	r(...): rx cutoff (dBi, float, default: -35)
   	t(...): tx power (dBi, float, default: -28)
   	v(...): modem version (default: V23):
   			V21        - 300/300 baud
   			V23        - 1200/75 baud
   			Bell103    - 300/300 baud
   			V22        - 1200/1200 baud
   			V22bis     - 2400/2400 baud
   	l or m: least or most significant bit first (default: m)
   	d(...): amount of data bits (5-8, default: 8)
   	s(...): amount of stop bits (1-2, default: 1)
   	u:      Send Ulm Relay Protocol header to Telnet server
   	n:      Send NULL-Byte to modem after carrier detection (Btx specific)
   
   The modem seems to work fine with VOIP as long as you use a codec like G.711 (alaw/ulaw). Please deactivate any echo cancellation you might use.
   					

   In your dialplan, to use a "Bell 103" 300 baud modem, you might use the following:

   exten => 4221,1,Answer()
   	same => n,Softmodem(127.0.0.1,23,v(Bell103)ld(8)s(1)un)
   	same => n,Hangup()
   					

9. Reload your dialplan by typing asterisk -r and then dialplan reload
10. At this point, you will be able to make a call to your Asterisk softmodem, which will establish a loopback Telnet connection that will launch the shell script we created earlier. However, at this point it is still blank, so nothing will happen. From here on, you will need to setup everything else you need and launch it from this main shell script. You can use other kinds of scripts, like PHP scripts to read values from databases and perform external authentication using databases, as well. You could, for example, store usernames and passwords to access your system in a database to which you connect using PHP as opposed to keeping track of authentication information locally. Or, the database could be on the same server. Or, you could not use databases at all. From here, everything is called using shell scripts, so you have the freedom to set things up how you like.
    The tutorial for creating a softmodem ends here. You will need shell scripting experience to code up a BBS. You can call the one created in this example at 564-4221 on NPSTN.

Fax

Asterisk actually has very good fax support built in (not including the fax stuff that Digium sells), so if you aren't using it, you're missing out.

Receiving faxes in Asterisk is easier than sending them, purely for logistical reasons. It's easy to have an incoming fax emailed to you. It's a bit more involved to receive documents in a compatible format and get them onto the system in a way that they can be sent.

Here are good starting resources for receiving and sending faxes:

• Incoming Fax Handling
• Outgoing Fax Handling

To make incoming faxes behave like voicemails, you can call a System command in the hangup handler to have incoming faxes emailed to you as TIF files.

The link above discussing outgoing faxes discusses an approach for doing this. However, it may be more feasible and conveient to design a secure file upload page than to process incoming emails for fax delivery.

MF/ACTS Detectors

ACTS when used here is an abuse of notation. More properly, they are known as single-slot coin denomination tones and were used in ACTS, among other things.

In December 2019, Asterisk source files, centered around dsp.c, were successfully forked to add MF and ACTS detection support to Asterisk.

Credits: Dylan Cruz, Howard Harte, Joshua Stein, Naveen Albert

Detection support is not integrated, but rather a separate program that can be called at will when a detector is needed. In other words, if you need an ACTS detector, you can bring one into the call and then get rid of it, much like how ACTS detectors are used for PSTN (non-COCOT) payphones.

Thanks to MF and ACTS support, it is now possible to have Project MF in modern Asterisk!

ZIP Download: detect.zip

The ZIP folder contains the following directories:

• arm
• x86

The _arm folder contains code for the ARM architecture (e.g. Raspberry Pi). The x86 folders are for x86/i386.

The contents of the appropriate subfolder of the detect folder should be extracted to /etc/asterisk/scripts/detect. You will need to choose the subfolders specific to your architecture. So, if you are running x86, you would extract detect/x86/mf to /etc/asterisk/scripts/detect/mf — don't preserve the x86 or arm in your file hierarchy — choose the architecture you need and place its subfolders right into /etc/asterisk/scripts/detect/

Note that the detector application is named mf for both the MF and ACTS detectors. Only the folder name distinguishes the two; the executable name should not be changed, and there is no extension.

Usage

ACTS tones are used for payphone coin signalling on modern non-COCOTs, succeeding the gong-style signalling used in 3-slot payphones. MF and 2600 are part of the multifrequency and singlefrequency signaling systems. DP is audible dial pulsing for real-time dial pulsing, which is generally not possible with VoIP connections.

There are three actual detectors that work separately:

• /etc/asterisk/scripts/detect/mf/mf — MF and 2600 Hz detector
• /etc/asterisk/scripts/detect/acts/acts — ACTS detector
• /etc/asterisk/scripts/detect/dp/dp — Dial Pulse detector

The ACTS detector is the simplest to use. For each detected ACTS beep (each of which is worth 5 cents), it returns one $ (dollar-sign) symbol.

Likewise, the dial pulse detector will return one P for each dial pulse.

The MF/2600 detector is one detector that supports multifrequency, single frequency, and 2600 Hz (general) detection. For multifrequency 0 through 9, it returns 0 through 9. For KP, it returns * and for ST, it returns #. For every single instance of 2600, it returns one "S". Thus, one loud constant 2600 burst (such as a trunk reset) returns a single "S"; dial-pulsing 2600 Hz (i.e. single-frequency signaling) at 10pps or 20pps will produce one S per pulse, making it possible to detect single-frequency dialing in addition to single 2600 Hz tones.

Here is a simple subroutine that uses the ACTS detector (on x86/i386 architecture, but that can be changed), to listen for ACTS tones. Notice that it automatically calculates how many "$"s appeared (\x24 is the hex escape code for $).

[acts-read] ; NPSTNNA 20200104 ; ARG1 = max silence, ARG2 = max duration, RETURNs # of ACTS beeps
exten => s,1,Set(ss=${STRFTIME(${EPOCH},,%s)})
	same => n,Set(file=/tmp/${UNIQUEID}-${ss}.wav)
	same => n,Record(${file},${ARG1},${ARG2},qx) ; q = quiet, x = ignore terminator keys
	same => n,Set(beeps=${SHELL(/etc/asterisk/scripts/detect/acts/acts ${file})})
	same => n,Set(beeps=${FILTER(\x24,${beeps})}) ; \x24 = hex for "$"
	same => n,Set(num=${LEN(${beeps})})
	same => n,NoOp(ACTS: ${beeps} -> ${num})
	same => n,Return(${num})
			

This detector is used on the NPSTN payphone trunks. So if you're thinking of using this detector to program a payphone controller… it's already been done! Applications of the detectors have already been fairly rigorously exhausted for everyone's benefit, and we've made the applications that make use of these detectors available as well. If you would like to help improve these end-applications or have ideas, please contact the Business Office.

NPSTN Cadence Plan

The NPSTN Cadence Plan allows for the use of standardized custom ring cadences across the network. These are used most commonly for party ling (coded) ringing, busy line callback, and priority ring on calls with greater than routine precedence. The cadences and their numbering were carefully chosen to minimize conflicts with the Bellcore specifications while allowing for maximal functionality and accessibility on NPSTN.

Grandstream ATAs typically allow for 10 cadences, while Linksys ATAs typically allow for 8 (sometimes 9) cadences.

If your ATA uses different formats for specifying cadences, please contact the Business Office and we can work with you to get your ATA set up correctly.

Subroutines like the following may be used to send the right cadence to your ATA:

[SIP-RingHeader] ; ARG1 = cadence / ARG2 = peers
exten => s,1,Set(peerstocheck=${ARG2})
	same => n,Set(i=-1)
	same => n(checkfree),Set(i=${LEN(${CUT(peerstocheck,&,1)})})
	same => n,Set(nextpeer=${peerstocheck:0:${i}})
	;same => n,Set(nextpeer=${nextpeer:4})
	same => n,Set(peerstocheck=${peerstocheck:$[${i}+1]})
	same => n,GotoIf($["${nextpeer:0:4}"="SIP/"]?sip)
	;;;; UNSUPPORTED TECHNOLOGY ;;;;
	same => n,Goto(next)
	
	same => n(sip),Set(nextpeer=${CUT(nextpeer,/,2)})
	same => n,Set(agent=${FILTER(A-Za-z0-9\x20\x2E\x2F\x2D,${SHELL(asterisk -rx 'sip show peer ${nextpeer}' | grep "Useragent" | grep -o ':.*')})})
	same => n,Gosub(SIP-RingHeader-indiv,s,1(${ARG1}, ${agent:1})) ; Trim space that was after the : from agent
	same => n(next),GotoIf($[${LEN(${peerstocheck})}=0]?allchecked:checkfree)
	same => n(allchecked),Return()

[SIP-RingHeader-indiv] ; ARG1 = cadence / ARG2 = SIP ATA user agent
exten => s,1,NoOp(${ARG2}) ; if we know what user agent this is, we'll only send that header
	same => n,GotoIf($[${REGEX("Grandstream" ${ARG2})}=1]?grandstream,1)
	same => n,GotoIf($[${REGEX("Linksys" ${ARG2})}=1]?linksys,1)
	same => n,GotoIf($[${REGEX("OBIHAI" ${ARG2})}=1]?obi,1)
	;same => n,SIPAddHeader(Alert-Info: info=) ; this is a bad fallback
	same => n,Goto(grandstream,1) ; fallback to Grandstream
exten => grandstream,1,SIPAddHeader("Alert-Info:\;info=ring${ARG1}") ; Supports 1-10
	same => n,Return()
exten => linksys,1,SIPAddHeader("Alert-Info:\;info=Bellcore-r${ARG1}") ; Linksys (e.g. PAP2T), etc.
	same => n,Return()
exten => obi,1,SIPAddHeader(Alert-Info: http://127.0.0.1/Bellcore-dr${ARG1:-1}) ; send only a single digit
	same => n,Return()
			

You could then set the cadence by calling it like: same => n,Gosub(SIP-RingHeader,s,1(${EXTEN},${ARG3})) (assuming EXTEN is the ring cadence and ARG3 is the SIP peer).

The SIP header should only get sent once, so if the cadence could be changed before ringing the phone, keep track of that in a separate variable. When determining the cadence to use, consider the priority of the call (MLPP) as well.

[autovoninit] ; Returns number of current trunk calls
exten => _[A-D0],1,NoOp(AUTOVON Precedence: ${EXTEN}) ; AUTOVON checks
	same => n,Gosub(currentldcalls,s,1)
	same => n,GotoIf($[${GOSUB_RETVAL}=0]?:database)
	same => n,DBdeltree(autovonA) ; Reset the key families, to wipe out old, unneeded data (none of which is currently needed)
	same => n,DBdeltree(autovonB)
	same => n,DBdeltree(autovonC)
	same => n,DBdeltree(autovonD)
	same => n,DBdeltree(autovon0)
	same => n(database),Set(GROUP(autovon)=${EXTEN})
	same => n,Set(DB(autovon${EXTEN}/${FILTER(0-9,${UNIQUEID})})=${CHANNEL})
	same => n,Return()

[autovonpreempt]
exten => s,1,GotoIf($["${autovonprioritydigit}"="0"]?done) ; can't preempt any calls
	same => n,Set(callids=${DB_KEYS(autovon0)})
	same => n,GotoIf($[${LEN(${callids})}>0]?0,1)
	same => n(ad),GotoIf($["${autovonprioritydigit}"="D"]?done) ; can't preempt other priority calls
	same => n,Set(callids=${DB_KEYS(autovonD)})
	same => n,GotoIf($[${LEN(${callids})}>0]?D,1)
	same => n(ac),GotoIf($["${autovonprioritydigit}"="C"]?done) ; can't preempt other immediate calls
	same => n,Set(callids=${DB_KEYS(autovonC)})
	same => n,GotoIf($[${LEN(${callids})}>0]?C,1)
	same => n(ab),GotoIf($["${autovonprioritydigit}"="B"]?done) ; can't preempt other flash calls
	same => n,Set(callids=${DB_KEYS(autovonB)}) ; so, yes, only a flash override can get to this point
	same => n,GotoIf($[${LEN(${callids})}>0]?B,1)
	same => n(done),Return() ; Sorry, can't preempt anything
exten => _[A-D0],1,Set(callid=${CUT(callids,\,,1)})
	same => n,Set(preemptchan=${DB(autovon${EXTEN}/${callid})})
	same => n(preemptcall),ChannelRedirect(${preemptchan},autovonpreempted,s,1) ; Set(redirect=${FILTER(A-Za-z0-9\x2E,${SHELL(asterisk -rx 'channel redirect ${preemptchan} autovonpreempted,s,1' | grep "failed")})})
	same => n,GotoIf($["${CHANNELREDIRECT_STATUS}"="SUCCESS"]?success) ; SUCCESS | NOCHANNEL
	same => n,Set(deleted=${DB_DELETE(autovon${EXTEN}/${callid})}) ; call isn't up anymore, so delete from DB
	same => n,Goto(a0) ; try again - hunt for another call to preempt
	same => n(success),Return()

[autovonpreemptfail]
exten => _[ABCD].,1,Progress()
	same => n,Playback(custom/switch/autovon/autovon603&custom/switch/autovon/autovon603,noanswer) ; audio file with 603 intercept
	same => n,Hangup()

[autovonpreempted]
exten => s,1,Set(GLOBAL(autovonpreempted${FILTER(0-9,${UNIQUEID})})=1)
	same => n,Set(GROUP(autovon)=)
	same => n(preempt),PlayTones(440+620) ; can also be defined as preemption in indications.conf
	same => n,Wait(15) ; Play preemption tone to caller for 15s
	same => n,StopPlayTones()
	same => n,Hangup(8) ; AST_CAUSE_PRE_EMPTED

[autovonpreempted-callee]
exten => _X!,1,Wait(0.3) ; wait ever so slightly, to give the variable time to get set
	same => n,ExecIf($["${$[autovonpreempted${EXTEN}]}"="1"]?PlayTones(440+620):Hangup()) ; can also be defined as preemption in indications.conf
	same => n,Wait(3) ; Play preemption tone to caller for 3s
	same => n,Hangup(8) ; AST_CAUSE_PRE_EMPTED

[currentldcalls]
exten => s,1,Return($[${GROUP_COUNT(A@autovon)}+${GROUP_COUNT(B@autovon)}+${GROUP_COUNT(C@autovon)}+${GROUP_COUNT(D@autovon)}+${GROUP_COUNT(0@autovon)}])
			

Payphone Trunks

NPSTN has several coin and coinless payphone trunks for both single-slot and 3-slot payphones. These trunks are designed for use with payphones on regular loop-start ATA lines with no additional hardware configurations. In other words, they are designed for payphones that have no smarts in them and won't act like payphones on their own. For those with a non-COCOT payphone and just an ATA and few other resources, these trunks can be used to bring your payphone to life!

To use the trunk, have the your payphone immediately connect to one of the following numbers below, depending on which kind of trunk you want for your payphone. If you have an ATA on NPSTN, hosted by somebody else, you can have the ATA off-hook hotdial the number (e.g. (<:9500903>S0) — Grandstream users would specify { 9500903 } for the digit map and need to configure hotline dialing on the "Lines" tab). If you have an Asterisk switch, you should have a separate incoming context in extensions.conf for each kind of payphone trunk you want to use, which only allows calls to the the number below corresponding with that trunk (thus, the payphone trunk would be specified by the dialplan context specified in sip.conf). This is more secure, because a payphone caller will not be able to flash at payphone trunk dialtone and simply dial calls directly another way (or use a different kind of coin trunk, if all the coin trunks were dialable from that context). Linksys ATAs configured for hotline dialing may also prevent callers from flashing out of the payphone trunk, but Grandstream ATAs will not.

NOTE: NA01 users should use the hotline vertical service code instead of off-hook auto-dialing from an ATA.

The payphone trunks are fully integrated with the NPSTN toll ticketing (billing) system. The charges for payphone calls will always equal or exceed the charges that appear on your bill, so the coin revenue from a payphone on these payphone trunks will more than pay for the charges that appear on the bill for the line a payphone is on. Thus, you don't need to worry about charges. All you need to do is make sure your payphone sends proper 7-digit NPSTN caller ID (as it should anyways). Based on that, the payphone trunk will determine what rates are appropriate for calls made through the trunk. The charges will be very similar to calls made directly (i.e. not using a payphone trunk) from that number.

The local rate (initial deposit) on these payphone trunks is 10 cents. While information/directory assistance is free normally on NPSTN, it costs 25 cents from payphones.

The way payphone rates are determined is either a flat rate greater than any possible charge for a call of that type OR a specific rate rounded up to the nearest $0.05 based on the station rate charges to a number are assessed.

Payphone operators (automated) handle select calls (e.g. long-distance). Long-distance can generally be dialed direct at 112 (or dial 0 for local calls or ask for long-distance).

These trunks are designed to be 99% plug and play with ~ZERO configuration on the part of the payphone owner (a small adjunct circuit in the physical vicinity of the phone is needed to monitor the line for MF tones and apply +/- 130V to do collect and return; however, the trunks themselves work fine without such a circuit, you'll just have to make your phone operate "piggy bank style" and not be able to get coins returned). These trunks are the equivalent of the CO-type trunks used for payphones.

Trunk Types

ACCESS NUM  TYPE          NETWORK   COIN OPERATION & SIGNALING                         LONG DISTANCE	
950-0900    CHARGE-A-CALL NPSTN     COINLESS                                           TSPS	
950-0901    1-SLOT        NPSTN     PRE-PAY (COIN FIRST)                               112 OR COIN ZONE
950-0902    1-SLOT        NPSTN     POST-PAY (WECo, i.e. "Post-Pay")                   112 OR COIN ZONE
950-0903    1-SLOT        NPSTN     DIALTONE FIRST PRE-PAY                             112 OR COIN ZONE
950-0904    1-SLOT        NPSTN     ACTS                                               112 OR ACTS
905-0905    1-SLOT        NPSTN     DIALTONE FIRST FULL PRE-PAY                        112 OR ACTS
950-0902    1-SLOT        NPSTN     SEMI-POST-PAY (AECo, i.e. "Semi Post-Pay")         112 OR COIN ZONE
950-0911    3-SLOT        NPSTN     PRE-PAY (COIN FIRST) (GONG DETECTION)              COIN ZONE
950-1NPA    1-SLOT        PSTN      ACTS                                               ACTS
		

The Charge-A-Call trunk is designed specifically for Charge-A-Call and other coinless payphones. It is integrated with NPSTN TSPS and allows for seamless third-number billing. To use Charge-A-Call, as with the NSPTN toll-free number, you will need an NPSTN PIN, which can be set or reset in the NPSTN UCP. Calling card numbers are 12 digits, in the format NNXXXXXPPPPP, corresponding to the 7-digit phone number + 5-digit NPSTN PIN. The only difference is that instead of using # to dial sequence calls, dial ** instead.

1NPA is a PSTN trunk that offers outbound PSTN trunking. All you need to do is dial 950-1NPA, where NPA is the home NPA of your payphone, and PSTN calls will be billed based on the distance between called and calling NPAs (long-distance) or flat-rate (local). Local calls are 25 cents and long distance varies by distance and incurs an additional per-minute charge after the first 3 minutes. 0 and N11 are free, except for 411 from coin phones. Translations will handle N11 in each NPA.

WECo style plays a second dial tone upon callee answer, indicating coins should be deposited, whereas Automatic Electric muted the mouthpiece and DTMF pad until coins were deposited. The Automatic Electric post-pay trunk relies on the caller to determine whether or not he wishes to talk, or use the keypad, and thus pay for the call. If he doesn't, there is no charge for the call, but it is limited in duration to a reasonable ringback (between 1 and 3 minutes). If/when a coin is deposited, the caller will be able to speak and dial/use the keypad again. We recognize this will allow free calls to listen-only numbers (e.g. time and temperature numbers).

We recognize that it is possible to "phreak" all of the trunks above by using a redbox or similar device capable of reproducing ACTS tones and 3-slot bell gongs. Consequently, payphone trunk usage is limited to verified, legitimate NPSTN callers (e.g. CVS code 10). This is necessary because of the real possibility of toll fraud, and it is a choice deliberately made to minimize our losses. All coins deposited into payphones using the payphone trunks are kept by the payphone owner (like with a COCOT; we don't get any share in the profits, even though we're the "telephone company" — at the same time, we still foot the bill as the payphone provider. If you would like to donate to this project to offset our expenses, please contact us!

Payphone Advertisements & Instruction Cards

The following publications have been created for your convenience. They are actual size and ready to print. These are the recommended accessories for your NPSTN PSTN payphone:

Advertisement:

Single Slot Lower Instruction Card:

Single Slot Upper Instruction Card:

Old Instruction Cards:

The following instruction cards are designed for use with semi post-pay coin phones. However, the PSTN trunks use ACTS, which is dial-tone first, not post-pay.

Single Slot Lower Instruction Card:

Single Slot Upper Instruction Card:

Project MF 2.0

All the awesomeness of the original Project MF… ported to modern Asterisk…

See the official Project MF 2.0 GitHub repo.

StepNet

StepNet is an additional layer on top of NPSTN, not a separate network.

Using StepNet is very simple. When calling the dialnpstn subroutine, instead of calling it like so:
GoSub(dialnpstn,start,1(${EXTEN},disable,${zipcode})), call it like so:
GoSub(dialnpstn,start,1(${EXTEN},enable,${zipcode})).

Now, your call will use StepNet for that call!. Not quite. You will actually need to dial 118 on NPSTN, then dial your number, and it will tandem through StepNet and then terminate.

At this point, StepNet is still in development, so we recommend you keep all your subroutine calls using disable as ARG2 at this point. When StepNet is in beta or ready for public use, we will post updates here informing users that they can try it out.

[sntandem]
type=user
context=sntandem
auth=md5
secret=stepnet3545434756
forceencryption=yes
requirecalltoken=yes
			

Automatic Operators

NPSTN does a have a human operator who is frequently on-duty. When the operator lines are staffed, calls to operator services (i.e. 0, 411, 611, 555-1212) will be answered by an operator who can help you with long-distance calling, information/directory assistance, or troubleshooting your phone line. The proper numbers to call are documented in the "Numbering Plan" section of this documentation.

With the exception of the Business Office line, if the on-duty operator is, well, off-duty, or otherwise unavailable, calls will automatically be transferred to an automatic operator who will help you. The voice of these operators is our very own Brian Clancy. If you'd prefer, you can also dial an automatic operator directly, bypassing the regular network operator. Again, the proper numbers are documented in the "Numbering Plan" section.

The long-distance and information operators use speech recognition technology coupled with speech-to-text processing to power your request. Though not known for working well with a wide variety of voices, we're quite pleased with how well they work (it is perhaps a bit ironic that Brian Clancy, who has a British accent, sometimes has trouble getting "himself" to recognize himself when calling an automatic operator). Our speech-to-text processing is powered by IBM Watson (see the "Further Add-Ons" section for more on this).

The NPSTN and C*NET long-distance operators work as follows: certain phrases are translated to numbers, and the rest of the translation is discarded. This results in extremely accurate operator assistance. As long as you enunciate your number clearly, operator Brian will be able to place your call for you. In addition to using numerals (such as 0, 1, 2, etc.), you can also use exchange names. If all goes well, it will be interpreted as part of the number.

Our long-distance operators also support service inquiries. If you ask for the "time", you will be connected with POPCORN. If you say you have an emergency, or that you need the police, you will be connected with the NPSTN emergency intercept recording. If you ask for the temperature, you will be connected with 511. If you ask for time and temperature, you'll be connected with 211. If you ask for information, you'll be connected with Information. The automatic operator's high reliability is due, in part, to listening for and expecting only certain key phrases, and discarding the rest. Thus, we can expect a standardized response every time and can parse the request very accurately. Thus, if you say "Get me the police" or "Operator, could you get me the time and temperature, please?", the automatic operator will successfully be able to place your call since everything actionable is extracted and any extraneous text is discarded.

The Information operator, on the other hand, takes the reverse approach. Here, a caller could ask for any number of things that are in the NPSTN Directory. It is therefore not possible to listen for certain phrases and ignore the rest. Rather, we must do the opposite: detect certain likely phrases (such as "hello", "operator", "information", "please", etc.), discard them from the translation, and then do a lookup in the directory using a separate API. Hence, if the caller is extraneous with his words, unlike the regular long-distance operator, who will not mind at all, the Information agent may not be able to find what you're looking for, as extra words could be counted as part of the lookup. That being said, we have anticipated many of the most common phrases and words. For best results, however, we recommend being succint. "Hello, information? Could you get me the number for the muzak listen line, please?" is perfectly acceptable. "Hello, ouch, I just stubbed my toe, boy that hurt! Oh, hello? This is information, ain't it? Well what do you know! Might you by chance happen to have the number for the, uh, muzak listen line, perhaps?" is not. A bit far-fetched, perhaps, but hopefully you see our point.

Speech-to-text processing is not done for the automatic repair agent. Instead, the repairman will collect your information and, at a later point in time, your inquiry will be reviewed by an NPSTN service technician. To expedite a ticket, you can try calling our business office during regular hours.

Again, all the numbers described in this section are available in the "Numbering Plan" section of this documentation.

Services

CNAM

NPSTN provides free CNAM dips for NPSTN numbers via the authenticated CNAM API:

The strict argument will truncate CNAM after 15 characters, so as to remain compatible with telephone terminal equipment that does not expect more than 15 characters, e.g.:

Paging

NPSTN offers complimentary paging services to email endpoints, including SMS.

Please call the Business Office for a free pager number.

Telegrams

NPSTN has a complimentary telegram service. Telegrams can be ordered by filling out an electronic telegram blank or by calling the chief telegraphist at 117. Telegrams are delivered electronically by email as well as telephonically and are available anytime in the NPSTN UCP. There is no charge for these functions, and delivery by these methods is guaranteed. Additionally, senders can opt to have their telegram delivered physically as a Mailgram using the USPS. There is a 49-cent charge for this. Payment must be sent by check or cash. Further information is available with the chief telegraphist.

Telegrams are sent in American Morse Code (landline Morse), not International Morse (CW) as they were originally. If you have a Morse sounder, you can connect it your phone line using a Tandy DCM6 modem and a custom serial DB9 cable as follows:

9 pin female - 25 pin male - MorseKOB Use - RS-232 signal ID (9 pin - 25 pin)
pin 5 - pin 7 - Ground - (SG - SG)
pin 6 - pin 3 - Key signal from modem to MorseKOB - (DSR - RXD)
pin 7 - pin 2 - Sounder signal from MorseKOB to Modem - (RTS - TXD)

A conventional modem will not work, because pure tones must be passed through with no "smarts" or specified baud rate. A conventional serial cable will also not work.

You can then connect your phone line to MorseKOB to sound out the telegram using your computer's audio, or you can connect it directly to a telegraph sender. To connect it to a sounder and key, this terminal interface is required.

If you don't have the appropriate modem or cable, you will not be able to receive the Morse code, but the telegram is also read aloud to you afterwards.

While USPS has increased postage from 49 cents to 55 cents, the charge is still 49 cents. NPSTN plans to raise the charge to 70 cents in the future, in order to cover postage and associated mailing costs, but this motion has not yet gone into effect.

Wake Up Calls

You can schedule one-time wake-up calls or recurring, snoozable wakeup calls. One-time wakeup calls can be scheduled at LIncoln9-1414.

Recurring wakeup calls must be scheduled through the NPSTN Business Office or operator. Once scheduled, a recurring wakeup call will call you every day at the same time. You will be prompted to input the answer to a relatively simple arithmetic computation. Until you get it right, it will keep calling you back every 6 minutes, to ensure that you don't go back to sleep! If you don't answer or enter the wrong answer continually and/or hangup, it will keep trying to reach you. If you do not pick up at all that day, your recurring wakeup call will be automatically cancelled, and you will need to reschedule it. Recurring wakeup calls can be cancelled either by contacting the Business Office or not answering wakeup calls for 1 day. The wakeup call system will try to reach you for 2 hours each day; if the calls are not answered by 2 hours, your recurring wakeup call will be cancelled. This means if you go out of town and forget to suspend your wakeup call, it will be automatically cancelled for you after the first day.

Toll Free Number

NPSTN has a toll-free access number that can be used to call NPSTN numbers or send a telegram. Its primary use is to replace collect calls from payphones for members stranded without change. More information about the toll-free number can be found upon logging in to the UCP.

To use the toll-free number, you will need to enter an NPSTN calling card number. NPSTN calling card numbers are simply your 7-digit phone number + your 5-digit NPSTN PIN, which can be set in the NPSTN UCP. The phone number used must belong to you and must be in the White Pages (though it may be unlisted or private). Thus, the format of calling cards on NPSTN is NNXXXXXPPPPP, where "P" represents any numeric digit.

SIT-COM

SIT-COM, short for SIT Communications, is a free 2-way communications system that can be used at most COCOTs. It is targeted towards payphone users who frequently communicate tidbits of common information and would like to do so at no charge. More information about SIT-COM is available to logged in members.

Blue Box

For security reasons, public access to these trunks is no longer allowed. Their use is restricted to network operators only.

NPSTN System Practices

The NPSTN System Practices are a collection of documents modeled after the Bell System Practices. Each practice or specification contains information on a specific aspect of the network, beyond the level of detail provided in this documentation. Some documents are classified or intended for internal usage only. These documents are the property of NPSTN are not for use or circulation outside of NPSTN.

NSPs are circulated for internal use only. The latest copies are available through the Network Operations Center.

C*NET Connectivity

First, you will need to add the following to your iax.conf:

[cnet]
type=user
context=from-cnet
		

This assumes that cnet is your C*NET IAX username; adjust this accordingly if you already a C*NET IAX username that is different.

The approach you will adopt to handle C*NET calls will differ based on whether you want to provide access to the same extensions on both networks or not. In the easiest case, if your US C*NET office code matches your NPSTN office code, so that the only difference between the two numbers on both networks is that your C*NET numbers have a 1 before them, the following will be sufficient:

[from-cnet]
exten => _X!,1,GoSub(cnet-verify,${EXTEN},1)
	same => n,Log(NOTICE, Incoming call from C*NET: "${clidverif}" ${CALLERID(all)} at "${CHANNEL(peerip)}" to ${EXTEN})
	same => n,GoTo(external-users,${EXTEN:-7},1) ; strip leading 1 from received number
		

As you can see, the last line assumes you are using the same numbers on both networks. Change the destination context if you want to have different numbers for NPSTN and C*NET. While using the same numbers may be easier, differentiating between the two networks makes your node more unique.

You will need to register for a C*NET office code if you don't already have one. You'll need to do this with C*NET, with whom we are not affiliated. All the instructions you need to get setup are on the C*NET website.

To dial out, you will need the official [dialcnet] macro, developed by, once again, Brian Clancy. The code is also included below for your convenience:

[macro-dialcnet]                                        ;version bjc1.01 - asterisk1.4+ and asterisk 1.2
exten => s,1,Set(NUMBER=${ARG1})                       ;Store number to be called
exten => s,2,GotoIf($[ ${ARG1:0:1} = "+"]?search)       ;Is number prefixedwith '+'?
exten => s,3,Set(ARG1=+${ARG1})         ;Prefix number with '+',required toproperly retrieve US ENUM entries!!!
exten => s,4(search),Set(ENUM=${ENUMLOOKUP(${ARG1},ALL,,1,std.ckts.info)}) ;Search ENUM database (Asterisk 1.4+)
exten => s,5,GotoIf($[${LEN(${ENUM})}=0]?no_uri)        ;Is ENUM record found?
exten => s,6,Gotoif(${DB_EXISTS(ELBD/${NUMBER})}?cdata) ;Does backup entry exist?
exten => s,7,Set(DB(ELBD/${NUMBER})=${ENUM})            ;No existing backup so store backup ENUM data
exten => s,8(test),GotoIf($[${ENUM:0:3} = iax ]?iaxuri) ;Yes-IAX2 protocol
exten => s,9,GotoIf($[${ENUM:0:3} = sip ]?sipuri)       ;Yes-SIP protocol
exten => s,10,GotoIf($[${ENUM:0:3} = h32 ]?h323uri)      ;Yes-H323 protocol
exten => s,11(no_uri),Gotoif(${DB_EXISTS(ELBD/${NUMBER})}?seek)  ;ENUM="", is there a backup entry?
exten => s,12,Macro(invalid-office-code,${NUMBER})               ;No valid ENUM and no backup entry
exten => s,13,Wait(5)                                    ;Pause
exten => s,14,Hangup                                     ;Done - failed to make call - Goodbye
exten => s,15(seek),Set(ENUM=${DB_RESULT})               ;Set ENUM to backup base entry
exten => s,16,GotoIf(${REGEX("iax2,sip,h323"${ENUM})}?test)      ;If it's a single backup proceed to dial out
exten => s,17,Set(NE=${CUT(ENUM,":",1)})                 ;Get backup entry field 1
exten => s,18,Set(LU=${CUT(ENUM,":",2)})                 ;Get backup entry field 2
exten => s,19,GotoIf($[${NE}>${LU}]?grec)                ;Was last used the last entry in list?
exten => s,20(frec),Set(LU=0)                            ;Reset entry pointer
exten => s,21(grec),Set(LU=$[${LU}+1])                   ;Increment last used pointer
exten => s,22,Set(ENUM=${DB(ELBD/${NUMBER}/${LU})})      ;Read ENUM backup entry
exten => s,23,Set(DB(ELBD/${NUMBER})=${NE}:${LU})        ;Update last used record
exten => s,24,GoTo(test)                                 ;Proceed to dial out
exten => s,25(iaxuri),Set(DIALSTR=IAX2/${ENUM:5})        ;IAX2
exten => s,26,GoTo(dodial)                               ;Make call
exten => s,27(sipuri),Set(DIALSTR=SIP/${ENUM:4})         ;SIP
exten => s,28,GoTo(dodial)                               ;Make call
exten => s,29(h323uri),Set(DIALSTR=H323/${ENUM:5})       ;H323
exten => s,30,Macro(invalid,${NUMBER})                   ;Make Call
exten => s,31(dodial),NoOp(Outbound Caller ID is ${CALLERID(all)})
;exten => s,31(dodial),Set(CALLERID(all)= Brian Clancy - PBX6 < 4418072345 >)
exten => s,32,Dial(${DIALSTR})                           ;Dial Out
exten => s,33,Hangup                                     ;Done -call attempted - Goodbye
exten => s,34(cdata),Gotoif($["${DB_RESULT}"="${ENUM}"]?test)    ;Does entry have a single backup?
exten => s,35,Set(SR=${DB_RESULT})                               ;Backup does not match current
exten => s,36,GotoIf(${REGEX("iax2,sip,h323"${SR})}?shuffle)     ;Is more than one backup entry stored?
exten => s,37,Set(NE=${CUT(SR,":",1)})                   ;Get backup entry field 1
exten => s,38,Set(LU=${CUT(SR,":",2)})                   ;Get backup entry field 2
exten => s,39,Gosub(rent)                                ;Check multiple backup entries
exten => s,40,Set(DB(ELBD/${NUMBER})=${NE}:${MR})        ;Store no. of entries and match as entry last used
exten => s,41,GotoIf($[${MR}>0]?test)                    ;If backup exists proceed to dial out
exten => s,42,Set(NE=$[${NE}+1])                         ;Increment entries pointer
exten => s,43,Set(DB(ELBD/${NUMBER})=${NE}:${NE})        ;Update entry count and usage
exten => s,44,Set(DB(ELBD/${NUMBER}/${NE})=${ENUM})      ;Store nth backup entry
exten => s,45,GoTo(test)                                 ;Nth entry stored - proceed to dial out
exten => s,46(shuffle),Set(DB(ELBD/${NUMBER}/1)=${SR})   ;Move stored entry to backup entry /1
exten => s,47,Set(DB(ELBD/${NUMBER}/2)=${ENUM})          ;Create second backup entry /2
exten => s,48,Set(DB(ELBD/${NUMBER})=2:2)                ;Store no. of backup entries & last called
exten => s,49,GoTo(test)                                 ;Alternative backup entry stored - proceed to dial out
exten => s,50(rent),Set(i=0)                             ;Load test counter
exten => s,51,Set(MR=0)                                  ;Load match store
exten => s,52,While($[${i}<${NE}])                       ;Check multiple entries for a NUMBER looking for a match
exten => s,53,GotoIf($["${DB(ELBD/${NUMBER}/$[${i}+1])}"="${ENUM}"]?mark)
;Mark entry matching ENUM result
exten => s,54,Set(i=$[${i}+1])                           ;Increment counter
exten => s,55,EndWhile                                   ;Look at next entry if one exists
exten => s,56,Return                                     ;Done searching for ENUM result backup record
exten => s,57(mark),Set(MR=$[${i}+1])                    ;ENUM result already backed up
exten => s,58,Set(i=${NE})                               ;Load counter with no. of last entry
exten => s,59,ContinueWhile                              ;Stop searching

[macro-invalid-office-code]
exten => s,1,Playback(custom/switch/ccad,noanswer)
		

The version above caches ENUM lookups so that, if the ENUM lookup were ever to become unavailable, you would still be able to reach destinations to which you previously placed calls successfully. Here is an updated adapted and simplified version of the C*NET macro that is, in fact, not a macro but a subroutine, and does not cache ENUM lookups:

[dialcnet] ; CNET NA 20190219, adapted from BJC v1.01
exten => s,1,Set(NUMBER=${ARG1})
	same => n,GotoIf($[ ${NUMBER:0:1} = "+"]?search)
	same => n,Set(NUMBER=+${NUMBER})
	same => n(search),Set(ENUM=${ENUMLOOKUP(${NUMBER},ALL,,1,std.ckts.info)}) ; Asterisk 1.4+
	same => n,GotoIf($[${LEN(${ENUM})}=0]?no_uri)
	same => n,GotoIf($["${ENUM:0:3}"="iax"]?iax)
	same => n,GotoIf($["${ENUM:0:3}"="sip"]?sip)
	same => n,GotoIf($["${ENUM:0:3}"="h32"]?h323)
	same => n(no_uri),GoSub(invalidcnet,s,1)
	same => n,Return
	same => n(iax),Set(DIALSTR=IAX2/${ENUM:5})
	same => n,GoTo(dialstr)
	same => n(sip),Set(DIALSTR=SIP/${ENUM:4})
	same => n,GoTo(dialstr)
	same => n(h323),Set(DIALSTR=H323/${ENUM:5})
	same => n(dialstr),Dial(${DIALSTR},,g)
	same => n,Return()

[invalidcnet]
exten => s,1,Playback(custom/ccad,noanswer) ; CCBCAD
	same => n,Return()
		

You will need to adjust invalidcnet to play your local CBCAD intercept.

You can call the above subroutine with the following syntax:

exten => _1NXXXXXX,1,GoSub(dialcnet,s,1(${EXTEN}))
	same => n,Hangup()
exten => _011X.,1,GoSub(dialcnet,s,1(${EXTEN:3}))
	same => n,Hangup()
		

PSTN Connectivity

register => 2125551212:[email protected]/ipcomms
					

[ipcomms]
secret=password
defaultuser=2125551212
host=freedid.ipcomms.net
allow=ulaw
context=from-ipcomms
dtmfmode=rfc2833
insecure=port,invite
type=peer
directmedia=no
trustrpid=yes
					

[from-ipcomms] ; This is the incoming context for IPComms SIP calls
exten => 2125551212,1,Progress()
	same => n,Set(Var_TO=${CUT(CUT(SIP_HEADER(To),@,1),:,2)})
	same => n,GoSub(pstn-us-verify,s,1)
	same => n,Log(NOTICE, Incoming call from IPComms PSTN ${Var_TO} DID: "${clidverif}" ${CALLERID(all)} at "${CHANNEL(peerip)}" via ${EXTEN})
	same => n,Answer()
	same => n,SendDTMF(1) ; for Google Voice
	same => n,GoSub(mfer,start,1(2125551212))
	same => n,GoTo(from-pstn,s,1)

[from-pstn]
exten => s,1,GoTo(dt,DTXB,1)
					

register => 17775551212:[email protected]/callcentric
					

[callcentric]
type=peer
context=from-callcentric
host=callcentric.com
fromdomain=callcentric.com
defaultuser=17775551212
fromuser=17775551212
secret=password
insecure=port,invite
disallowed_methods=UPDATE
directmedia=no
videosupport=no
disallow=all
allow=ulaw

[callcentric1](callcentric)
host=alpha1.callcentric.com

[callcentric2](callcentric)
host=alpha2.callcentric.com

[callcentric3](callcentric)
host=alpha3.callcentric.com

[callcentric4](callcentric)
host=alpha4.callcentric.com

[callcentric5](callcentric)
host=alpha5.callcentric.com

[callcentric6](callcentric)
host=alpha6.callcentric.com

[callcentric7](callcentric)
host=alpha7.callcentric.com

[callcentric8](callcentric)
host=alpha8.callcentric.com

[callcentric9](callcentric)
host=alpha9.callcentric.com

[callcentric10](callcentric)
host=alpha10.callcentric.com

[callcentric11](callcentric)
host=alpha11.callcentric.com

[callcentric12](callcentric)
host=alpha12.callcentric.com

[callcentric13](callcentric)
host=alpha13.callcentric.com

[callcentric14](callcentric)
host=alpha14.callcentric.com

[callcentric15](callcentric)
host=alpha15.callcentric.com

[callcentric16](callcentric)
host=alpha16.callcentric.com

[callcentric17](callcentric)
host=alpha17.callcentric.com

[callcentric18](callcentric)
host=alpha18.callcentric.com

[callcentric19](callcentric)
host=alpha19.callcentric.com

[callcentric20](callcentric)
host=alpha20.callcentric.com

[callcentricA](callcentric)
host=doll3.callcentric.com

[callcentricB](callcentric)
host=doll4.callcentric.com

[callcentricC](callcentric)
host=doll5.callcentric.com
					

[from-callcentric] ; This is the incoming context for CallCentric SIP calls
exten => callcentric,1,Progress()
	same => n,Set(Var_TO=${CUT(CUT(SIP_HEADER(To),@,1),:,2)})
	same => n,GoSub(pstn-us-verify,s,1)
	same => n,Log(NOTICE, Incoming call from CallCentric PSTN ${Var_TO} DID: "${clidverif}" ${CALLERID(all)} at "${CHANNEL(peerip)}" to ${EXTEN})
	same => n,Wait(4)
	same => n,Answer()
	same => n,SendDTMF(1)
	same => n,GoSub(mfer,start,1(2125551212))
	same => n,GoTo(from-pstn,s,1)
					

[SkyetelCA]
disallow=all
type=peer
insecure=port,invite
host=52.8.201.128
dtmfmode=rfc2833
context=from-skyetel
allow=ulaw
qualify=yes
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
 
[SkyetelTERM]
disallow=all
type=peer
qualify=yes
insecure=port,invite
host=term.skyetel.com
dtmfmode=rfc2833
context=from-skyetel
allow=ulaw
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
 
[SkyetelOR]
disallow=all
type=peer
insecure=port,invite
host=52.41.52.34
dtmfmode=rfc2833
context=from-skyetel
allow=ulaw
qualify=yes
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
 
[SkyetelVA]
disallow=all
host=50.17.48.216
type=peer
allow=ulaw
dtmfmode=rfc2833
insecure=port,invite
context=from-skyetel
qualify=yes
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
 
[SkyetelHC]
disallow=all
host=hc.skyetel.com
type=peer
allow=ulaw
dtmfmode=rfc2833
insecure=port,invite
context=from-skyetel
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
 
[SkyetelHC1]
disallow=all
host=52.32.223.28
type=peer
allow=ulaw
dtmfmode=rfc2833
insecure=port,invite
context=from-skyetel
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
 
[SkyetelHC2]
disallow=all
host=52.4.178.107
type=peer
allow=ulaw
dtmfmode=rfc2833
insecure=port,invite
context=from-skyetel
directmedia=no
directrtpsetup=no
sendrpid=no
canreinvite=no
					

exten => _1NXXXXXXXXX,1,Dial(SIP/SkyetelTERM/${EXTEN},45)
	same => n,Dial(SIP/SkyetelOR/${EXTEN},45)
	same => n,Dial(SIP/SkyetelCA/${EXTEN},45)
	same => n,Dial(SIP/SkyetelVA/${EXTEN},45)
	same => n,Hangup()
					

cd /root
wget http://9142978376.com/newfiles/GV/gvsip-naf.tar
tar xvf gvsip-naf.tar
rm -f gvsip-naf.tar
cd gvsip-naf
./install-gvsip
					

sed -i 's|obihai.telephony.goog|voice.telephony.goog|' /etc/asterisk/pjsip_custom.conf
sed -i 's|obihai.telephony.goog|voice.telephony.goog|' /root/gvsip-naf/install-gvsip
asterisk -rx "core restart when convenient"
					

Further Add-Ons

[public]
exten => _X!,1,Log(NOTICE, Unauthorized call: ${CALLERID(all)} at "${CHANNEL(peerip)}" to ${EXTEN})
	same => n,System(iptables -A INPUT -s ${CHANNEL(peerip)} -j DROP)
	same => n,Hangup()
			

[pubic]
type=user
context=public

[guest]
type=user
context=public
callerid="Guest IAX User"
			

[general]
atxfernoanswertimeout = 60     ; Timeout for answer on attended transfer default is 15 seconds.
atxferabort = *1               ; cancel the attended transfer
atxfercomplete = *2            ; complete the attended transfer, dropping out of the call
atxferthreeway = *3            ; complete the attended transfer, but stay in the call. This will turn the call into a multi-party bridge
atxferswap = *4                ; swap to the other party. Once an attended transfer has begun, this option may be used multiple times

[featuremap]
blindxfer => #1                ; Blind transfer  (default is #) -- Make sure to set the T and/or t option in the Dial() or Queue() app call!
disconnect => *0               ; Disconnect  (default is *) -- Make sure to set the H and/or h option in the Dial() or Queue() app call!
atxfer => *2                   ; Attended transfer  -- Make sure to set the T and/or t option in the Dial() or Queue()  app call!
			

#!/bin/bash

curl -X POST -u "apikey:APIKEY" --header "Content-Type: audio/wav" --data-binary @/var/lib/asterisk/sounds/stt/$1.wav "https://api.us-south.speech-to-text.watson.cloud.ibm.com/instances//v1/recognize?model=en-US_NarrowbandModel" >/var/lib/asterisk/sounds/stt/$1.txt
#Extract transcript results from JSON response
TRANSCRIPT=`cat /var/lib/asterisk/sounds/stt/$1.txt | grep transcript | sed 's#^.*"transcript": "##g' | sed 's# "$##g' > /var/lib/asterisk/sounds/stt/stt-$1.txt`
sed -e :a -e N -e `s/\n/ /` ta /var/lib/asterisk/sounds/stt/stt-$1.txt >/var/lib/asterisk/sounds/stt/transcripted-stt-$1.txt

rawtext=`cat /var/lib/asterisk/sounds/stt/transcripted-stt-$1.txt`
echo $rawtext
			

[stt]
exten => s,1,Set(stt=${UNIQUEID}.${ARG1})
	same => n,Record(/var/lib/asterisk/sounds/stt/${stt}.wav,3,30,qx)
	same => n,Set(text=${SHELL(sh /etc/asterisk/scripts/stt.sh ${stt})})
	same => n,Return(${text})
			

Appendix A: Helpful Supplemental Tools

@echo off
cd C:\Users\%username%\Documents\sox\bin\
forfiles /S /M *.wav /C "cmd /c rename @file @fname"
for /f "delims=|" %%f in ('dir /b "C:\Users\%username%\Documents\sox\bin\"') do "C:\Users\%username%\Documents\sox\sox.exe" "C:\Users\%username%\Documents\sox\bin\%%f" --rate 8000 --channels 1 --type ul "C:\Users\%username%\Documents\sox\bin\%%f.ulaw" lowpass 3400 highpass 300