Connecting Two Asterisk Boxes Together via IAX

Often it is desirable to connect two physical Asterisk boxes together via IAX in order to send calls between two physical locations (the distance between these locations may be centimeters or kilometers). One of the advantages to using the IAX protocol to do this is a feature called trunking, which utilizes a method of sending the voice data for multiple calls at once with a single header. This has little effect on only one or two simultaneous calls, but if you are sending tens or hundreds of calls between two locations, the bandwidth savings by utilizing trunking can be tremendous.

Note

You will need a timing interface installed on your system, whether it be hardware from Digium or via the kernel by using the ztdummy driver. This will require you to have Zaptel installed on your system and running. See Chapter 3, Installing Asterisk for more information about installing Zaptel.

Configuring Our Asterisk Boxes

We’ll be utilizing a simple topology where we have two Asterisk boxes registered to each other directly, and separate phones registered to each Asterisk box. We’ll call the two Asterisk boxes Toronto and Osakafi (see the section called “Connecting Two Asterisk Boxes Together via SIP””). Bob’s phone will be registered and connected to Toronto, while Alice’s phone will be registered and connected to Osaka.

[PROD: I've commented out figure 4_8 as there's no image file for it...—DCPS]

[PROD: fileref for figure 4_8 was out of sequence (pointing to ast2_0407.pdf|png); I changed it to ast2_0408.pdf|png—DCPS]

The first thing we want to do is create a new channel file (iax.conf) by renaming the current sample file to iax.conf.sample and creating a new blank iax.conf:

# cd /etc/asterisk
# mv iax.conf iax.conf.sample
# touch iax.conf

Next, open up the iax.conf file and enter the following configuration on the Toronto Asterisk box:

[general]
autokill=yes

register => toronto:welcome@192.168.1.107

[osaka]
type=friend
host=dynamic
trunk=yes
secret=welcome
context=incoming_osaka
deny=0.0.0.0/0.0.0.0
permit=192.168.1.107/255.255.255.255

autokill=yes was explained in the previous section, but its purpose is to make sure new calls being set up to a remote system that are not acknowledged within a reasonable amount of time (two seconds by default) are torn down correctly. This saves us from having a lot of hung channels simply waiting for an acknowledgement that probably isn’t coming.

The register line is used to tell the remote Asterisk box where we are so that when the box at 192.168.1.107 is ready to send us a call, it sends it to our IP address (in this case our IP address is 192.168.1.104, which you’ll see in the iax.conf configuration of the Osaka box). We send the username Toronto and the password welcome to Osaka, which authenticates our registration, and if accepted, writes the location of our Asterisk box into its memory for when it needs to send us a call.

The [Osaka] definition is used to control the authentication of the remote box and delivery into our dialplan. Osaka is the username used in the incoming authentication. We set the type to friend because we want to have both the ability to send calls to Osaka and to receive calls from Osaka. The host option is set to dynamic which tells Asterisk to send calls to the IP address obtained when the opposite endpoint registers with us.

In the introduction to this section, we mentioned the possible bandwidth savings when utilizing IAX2 trunking. It’s simple to enable this functionality in Asterisk, as we just need to add trunk=yes to our friend definition. As long as a timing interface is installed and running (i.e., dummy), then we can take advantage of IAX2 trunking.

The secret is straightforward: it’s our authentication password. We’re defining the [incoming_osaka] context as the place we will process incoming calls for this friend in the extensions.conf file. Finally, we block all IP addresses with the deny option from being allowed to authenticate, and explicitly permit 192.168.1.107.

The iax.conf configuration for Osaka is nearly identical, except for the changes in IP address and names:

[general]
autokill=yes

register => osaka:welcome@192.168.1.104

[toronto]
type=friend
host=dynamic
trunk=yes
secret=welcome
context=incoming_toronto
deny=0.0.0.0/0.0.0.0
permit=192.168.1.104/255.255.255.255

IAX Phone Configuration

In the the section called “Configure the Softphone”” section, we configured our first IAX2 softphone using idefisk. The configuration we’ll be using here is nearly identical except for minor changes in order to cause the peers to be unique. If you’ve already configured a SIP softphone, then you can also utilize that on one (or both) of the peers. Remember that Asterisk is a multiprotocol application, and you can send a call from a SIP phone to Asterisk, across an IAX2 trunk, and then down to another SIP phone (or H.323, MGCP, etc.).

On Osaka:

[1001]
type=friend
host=dynamic
context=phones

On Toronto:

[2001]
type=friend
host=dynamic
context=phones

Next, configure your IAX2 softphone to register to Asterisk. If the phone successfully registers, you’ll see something like:

*CLI>     -- Registered IAX2 '1001' (UNAUTHENTICATED) at 192.168.1.104:4569

Configuring the Dialplan

In order to allow calling between our two Asterisk boxes over the IAX2 trunk, we need to configure a simple dialplan. The following dialplan will send all extensions in the 1000 range (1000–1999) to Osaka, and all extensions in the 2000 range (2000–2999) to Toronto. Our example is going to assume that you have configured a pair of IAX2 softphones, but feel free to utilize a SIP phone if you’ve already configured one (or two). Just be aware that you’ll need to change the Dial() application to send the call to the SIP phone via the SIP protocol instead of IAX2 (i.e. Dial(SIP/${EXTEN},30) instead of Dial(IAX2/${EXTEN},30)).

The extensions.conf file on Toronto:

[globals]

[general]
autofallthrough=yes

[default]

[incoming_calls]

[phones]
include => internal
include => remote

[internal]
exten => _1XXX,1,NoOp()
exten => _1XXX,n,Dial(IAX2/${EXTEN},30)
exten => _1XXX,n,Playback(the-party-you-are-calling&is-curntly-unavail)
exten => _1XXX,n,Hangup()

[remote]
exten => _2XXX,1,NoOp()
exten => _2XXX,n,Dial(IAX2/toronto/${EXTEN})
exten => _2XXX,n,Hangup()

[toronto_incoming]
include => internal

The extensions.conf file on Osaka:

[globals]

[general]
autofallthrough=yes

[default]

[incoming_calls]

[phones]
include => internal
include => remote

[internal]
exten => _2XXX,1,NoOp()
exten => _2XXX,n,Dial(IAX2/${EXTEN},30)
exten => _2XXX,n,Playback(the-party-you-are-calling&is-curntly-unavail)
exten => _2XXX,n,Hangup()

[remote]
exten => _1XXX,1,NoOp()
exten => _1XXX,n,Dial(IAX2/osaka/${EXTEN})
exten => _1XXX,n,Hangup()

[osaka_incoming]
include => internal