Contexts

Dialplans are divided into sections called contexts, which serve to separate different parts of the dialplan. An extension that is defined in one context is completely isolated from extensions in any other context, unless interaction is specifically allowed.

As a simple example, let’s imagine we have two companies sharing an Asterisk server. If we place each company’s automated attendant (IVR) in its own context, the two companies will be completely separated from each other. This allows us to independently define what happens when, say, extension 0 is dialed:

• Callers dialing 0 from Company A’s voice menu need to be transferred to Company A’s receptionist.

• Callers dialing 0 at Company B’s voice menu will be sent to Company B’s customer service department.

Both callers are on the same system, interacting with the same dialplan, but because they arrived in different contexts, they experience totally separate call flow. What happens to each incoming call is determined by the dialplan code in each context.

Contexts are defined in the extensions.conf file by placing the name of the context inside square brackets ([]). The name can be made up of the letters A through Z (upper- and lowercase), the numbers 0 through 9, and the hyphen and underscore.¹ A context for incoming calls from a carrier might simply be named this:

[incoming]

Or perhaps:

[incoming_company_A]

Which then of course might require something like:

[incoming_company_B]

All of the instructions placed after a context definition are part of that context, until the next context is defined.

At the beginning of the dialplan, there are two special sections named [general] and [globals]. The [general] section contains a list of general dialplan settings (which you’ll probably never have to worry about), and we will discuss the [globals] context shortly. For now, it’s only important to know that these two labels are not contexts, despite using context syntax. Do not use [general], [globals], and [default]² as context names, but otherwise name your contexts anything you wish.

The contexts in a typical extensions.conf file might be structured something like this:

[general] ; This always has to be here
[globals] ; Global variables (we'll discuss these later)

[incoming] ; Calls from the carriers could arrive here

[sets] ; on a simple system, we can use this

[sets1] ; Multi-tenanted perhaps needs this (sets from one company enter dialplan here)

[sets2] ; ... and this (another group of sets might enter the dialplan here)

[services] ; Special services such as conferencing could be defined here

When you define a channel (which is not done in the extensions.conf file), one of the required parameters in each channel definition is context. The context is the point in the dialplan where connections coming from that channel will arrive. So the way you plug a channel into the dialplan is through the context (see Figure 6-2).

Figure 6-2. Relation between channel configuration (on the left) and contexts in the dialplan (on the right)

An important (perhaps the most important) use of contexts is to provide privacy and security. By using contexts correctly, you can give some channels access to features (such as long-distance calling) that aren’t made available to others. If you do not design your dialplan carefully, you may inadvertently allow others to fraudulently use your system. Please keep this in mind as you build your Asterisk system; there are many bots on the internet that were specifically written to identify and exploit poorly secured Asterisk systems.

Extensions

In the telecommunications industry the word extension typically has referred to a numeric identifier that, when dialed, will ring a phone (or system resource such as voicemail or a queue). In Asterisk, an extension is far more powerful, as it defines the unique series of steps (each step containing an application) through which Asterisk will take that call.

Within each context, we can define as many (or few) extensions as required. When a particular extension is triggered (by an incoming channel), Asterisk will follow the steps defined for that extension. It is the extensions, therefore, that specify what happens to calls as they make their way through the dialplan. Although extensions can, of course, be used to specify phone extensions in the traditional sense (i.e., extension 153 will cause the SIP telephone set on John’s desk to ring), in an Asterisk dialplan, they can be used for much more.

The syntax for an extension is the word exten, followed by an arrow formed by the equals sign and the greater-than sign, like this:

exten =>

This is followed by the name (or number) of the extension.

When dealing with traditional telephone systems, we tend to think of extensions as the numbers you would dial to make another phone ring. In Asterisk, extension names can be any combination of numbers and letters. Over the course of this chapter and the next, we’ll use both numeric and alphanumeric extensions.

Each step in an extension has three components:

• The name (or number) of the extension

• The priority (each extension can include multiple steps; the step number is called the “priority”)

• The application (or command) that will take place at that step

These three components are separated by commas, like this:

exten => name,priority,application()

Here’s a simple example:

exten => 123,1,Answer()

The extension name is 123, the priority is 1, and the application is Answer().

Priorities

Each extension can have multiple steps, called priorities. The priorities are numbered sequentially, starting with 1, and each executes one specific application. As an example, the following extension would answer the phone in priority number 1, and then hang it up in priority number 2. The steps in an extension take place one after the other.

exten => 123,1,Answer()
exten => 123,2,Hangup()

It’s pretty obvious that this code doesn’t really do anything useful. We’ll get there. The key point to note here is that for a particular extension, Asterisk follows the priorities in order.

exten => 123,1,Answer()
exten => 123,2,do something
exten => 123,3,do something else
exten => 123,4,do one last thing
exten => 123,5,Hangup()

This style of dialplan syntax is still seen from time to time, although (as you’ll see momentarily) it is not generally used anymore for new code. Newer syntax is similar, but simplified.

exten => 123,1,Answer()
exten => 123,n,do something
exten => 123,n,do something else
exten => 123,n,do one last thing
exten => 123,n,Hangup()

exten => 123,1,Answer()
exten => 123,n,do something
exten => 123,n,SOME NEW THING
exten => 123,n,do something else
exten => 123,n,do one last thing
exten => 123,n,Hangup()

exten => 123,1,Answer()
 same =>     n,do something
 same =>     n,do something  
 same =>     n,do one last thing
 same =>     n,Hangup()

exten => 123,n(label),application()

exten => 555,n,(label),application() ;<-- THIS WON'T WORK
exten => 556,n(label),application()  :<-- This is what we want

Applications

Applications are the workhorses of the dialplan. Each application performs a specific action on the current channel, such as playing a sound, accepting touch-tone input, looking something up in a database, dialing a channel, hanging up the call, feeding the cat, and so forth.⁴ In the previous example, you were introduced to two simple applications: Answer() and Hangup(). It’s obvious what they do, but it’s also obvious that on their own they aren’t terribly useful.

Some applications, including Answer() and Hangup(), need no other instructions to do their jobs. Most applications, however, require more information. These additional elements, or arguments, are passed on to the applications to affect how they perform their actions. To pass arguments to an application, place them between the parentheses that follow the application name, separated by commas.

The Answer(), Playback(), and Hangup() Applications

The Answer() application is used to answer a channel that is ringing. It seems a simple thing, but a lot of things happen on the channel with this one command. Answer() tells the channel to send a message back to the far end that the call has been answered, and also to enable the media paths (the network streams that will carry the sound between the caller and the system). As we mentioned earlier, Answer() takes no arguments. Answer() is not always required (in fact, in some cases it may not be desirable at all), but it is an effective way to ensure a channel is connected before performing further actions.

The Playback() application is used for playing a previously recorded sound file over a channel. Input from the user is ignored, which means that you would not use Playback() in an auto attendant, for example, unless you did not want to accept input at that point.⁵

To use Playback(), specify a filename as the argument. For example, Playback(filename) would play a sound file called filename.wav, assuming it was located in the default sounds directory. Note that you can include the full path to a file if you want, like this:

Playback(/home/john/sounds/filename)

The previous example would play filename.wav from the /home/john/sounds directory. This can be problematic, however, due to potential file permissions problems. If you’re planning on having a lot of custom sounds on your system, you’ll likely want a dedicated directory for them, and you’ll need to test to ensure Asterisk can find and play the files.

You can also use relative paths from the Asterisk sounds directory, as follows:

Playback(custom/filename)

This example would play filename.wav from the custom subdirectory of the default sounds directory (probably /var/lib/asterisk/sounds/en/custom/filename.wav). If the specified directory contains more than one file with that filename but with different file extensions, Asterisk automatically plays the best file.⁶

The Hangup() application does exactly as its name implies: it hangs up the active channel. You should use this application at the end of a context when you want to end the current call, to ensure that callers don’t continue on in the dialplan in a way you might not have anticipated. The Hangup() application does not require any arguments, but you can pass an ISDN cause code if you want, such as Hangup(16), and it will be translated into a comparable SIP message and sent to the far end.

As we work through the book, we will be introducing you to many more Asterisk applications, but that’s enough theory for now; let’s write some dialplan!

A Basic Dialplan Prototype

To reiterate, then, the form of all dialplans is built from those four concepts: Context, Extension, Priority, and Application (Figure 6-3).

Figure 6-3. Dialplan prototype

Hello World

As is typical in many technology books (especially computer programming books), our first example is called “Hello World.”

In the first priority of our extension, we answer the call. In the second, we play a sound file named hello-world, and in the third we hang up the call. The code we are interested in for this example looks like this:

exten => 200,1,Answer()
     same => n,Playback(hello-world)
     same => n,Hangup()

If you followed along in Chapter 5, you’ll already have a channel or two configured, as well as the sample dialplan that contains this code. If not, what you need is an extensions.conf file in your /etc/asterisk directory that contains the following code:

[general]
[globals]

[sets]
exten => 100,1,Dial(PJSIP/0000f30A0A01) ; Replace 0000f30A0A01 with your device name

exten => 101,1,Dial(PJSIP/SOFTPHONE_A)

exten => 102,1,Dial(PJSIP/0000f30B0B02)

exten => 103,1,Dial(PJSIP/SOFTPHONE_B)

exten => 200,1,Answer()
     same => n,Playback(hello-world)
     same => n,Hangup()

If you don’t have this dialplan code built yet, you’ll need to add it and reload the dialplan with this CLI command:

$ sudo asterisk -rvvvvv # ('r' attaches to a daemonized Asterisk; 'v's are for verbosity)
*CLI> dialplan reload

or you can issue the command directly from the shell with:

$ sudo asterisk -rx "dialplan reload"  # ('rx' execute an Asterisk command and return)

Calling extension 200 from either of your configured phones⁷ should reward you with the friendly voice of Allison Smith saying “Hello, World.”

If it doesn’t work, check the Asterisk console for error messages, and make sure your channels are assigned to the sets context.

Even though this example is very short and simple, it emphasizes the core dialplan concepts of contexts, extensions, priorities, and applications. You now have the fundamental knowledge on which all dialplans are built.

The Goto(), Background(), and WaitExten() Applications

As its name implies, the Goto() application is used to send a call to another part of the dialplan. Goto() requires us to pass the destination context, extension, and priority as arguments, like this:

    same => n,Goto(context,extension,priority)

We’re going to create a new context called TestMenu, and create an extension in our sets context that will pass calls to that context using Goto():

exten => 200,1,Answer()
     same => n,Playback(hello-world)
     same => n,Hangup()

exten => 201,1,Goto(TestMenu,start,1) ; add this to the end of the 
                                      ; [sets] context

[TestMenu]
exten => start,1,Answer()

Now, whenever a device enters the [sets] context and dials 201, the call will be passed to the start extension in the TestMenu context (which currently won’t do anything interesting because we still have more code to write).

One of the more useful applications in an interactive Asterisk dialplan is the Background()⁸ application. Like Playback(), it plays a recorded sound file. Unlike Playback(), however, when the caller presses a key (or series of keys) on their telephone keypad, it interrupts the playback and passes the call to the extension that corresponds with the pressed digit(s). If a caller presses 5, for example, Asterisk will stop playing the sound prompt and send control of the call to the first priority of extension 5 (assuming there is an extension 5 to send the call to).

The most common use of the Background() application is to create basic voice menus (often called auto attendants, IVRs,⁹ or phone trees). Many companies use voice menus to direct callers to the proper extensions, thus relieving their receptionists from having to answer every single call.

Background() has the same syntax as Playback():

[TestMenu]
exten => start,1,Answer()
  same => n,Background(enter-ext-of-person)

If you want Asterisk to wait for input from the caller after the sound prompt has finished playing, you can use WaitExten(). The WaitExten() application waits for the caller to enter DTMF digits and is used directly following the Background() application, like this:

[TestMenu]
exten => start,1,Answer()
  same => n,Background(enter-ext-of-person)
  same => n,WaitExten()

If you’d like the WaitExten() application to wait a specific number of seconds for a response (instead of using the default timeout),¹⁰ simply pass the number of seconds as the first argument to WaitExten(), like this:

   same => n,WaitExten(5) ; We always pass a time argument to WaitExten()

Both Background() and WaitExten() allow the caller to enter DTMF digits. Asterisk then attempts to find an extension in the current context that matches the digits that the caller entered. If Asterisk finds a match, it will send the call to that extension. Let’s demonstrate by adding a few lines to our dialplan example:

[TestMenu]
exten => start,1,Answer()
       same => n,Background(enter-ext-of-person)
       same => n,WaitExten(5)

exten => 1,1,Playback(digits/1)

exten => 2,1,Playback(digits/2)

After making these changes, save and reload your dialplan:

*CLI> dialplan reload

If you call into extension 201, you should hear a sound prompt that says, “Enter the extension of the person you are trying to reach.” The system will then wait 5 seconds for you to enter a digit. If the digit you press is either 1 or 2, Asterisk will match the relevant extension, and read that digit back to you. Since we didn’t provide any further instructions, your call will then end. You’ll also find that if you enter a different digit (such as 3), the dialplan will be unable to proceed.

Let’s embellish things a little. We’re going to use the Goto() application to have the dialplan repeat the greeting after playing back the number:

[TestMenu]
exten => start,1,Answer()
       same => n,Background(enter-ext-of-person)
       same => n,WaitExten(5)

exten => 1,1,Playback(digits/1)
   same => n,Goto(TestMenu,start,1)

exten => 2,1,Playback(digits/2)
   same => n,Goto(TestMenu,start,1)

These new lines will send control of the call back to the start extension after playing back the selected number.

Handling Invalid Entries and Timeouts

We need an extension for invalid entries. In Asterisk, when a context receives a request for an extension that is not valid within that context (e.g., pressing 9 in the preceding example), the call is sent to the i extension. We also need an extension to handle situations when the caller doesn’t give input in time (the default timeout is 10 seconds). Calls will be sent to the t extension if the caller takes too long to press a digit after WaitExten() has been called. Here is what our dialplan will look like after we’ve added these two extensions:

[TestMenu]
exten => start,1,Answer()
       same => n,Background(enter-ext-of-person)
       same => n,WaitExten(5)

exten => 1,1,Playback(digits/1)
   same => n,Goto(TestMenu,start,1)

exten => 2,1,Playback(digits/2)
   same => n,Goto(TestMenu,start,1)

exten => i,1,Playback(pbx-invalid)
   same => n,Goto(TestMenu,start,1)

exten => t,1,Playback(please-try-again)
   same => n,Goto(TestMenu,start,1)

Using the i¹¹ and t extensions makes our menu a little more robust and user-friendly. That being said, it is still quite limited, because outside callers still have no way of connecting to a live person. To do that, we’ll need to learn about the Dial() application.

Using the Dial() Application

One of Asterisk’s most valuable features is its ability to connect different callers to each other. While Asterisk currently is used mostly for SIP connections, it supports a wide variety of channel types (from Analog to SS7, and various old VoIP protocols such as MGCP and SCCP). Asterisk takes much of the hard work out of connecting and translating between disparate networks. All you have to do is learn how to use the Dial() application.

The syntax of the Dial() application is more complex than that of the other applications we’ve used so far, but it’s also where much of the magic of Asterisk happens. Dial() takes up to four arguments, which we’ll look at next.

The syntax of Dial() looks like this:

Dial(Technology/Resource[&Technology2/Resource2[&...]][,timeout[,options[,URL]]])

Put simply, you tell Dial() what channel¹² you want to send the call out to, and set a few options to tweak the behavior. The use of Dial() can get complex, but at its most basic, it’s that simple.

exten => 101,1,Dial(PJSIP/SOFTPHONE_A)

exten => 103,1,Dial(PJSIP/SOFTPHONE_B)

exten => 200,1,Answer()

exten => 101,1,Dial(PJSIP/SOFTPHONE_A)

exten => 103,1,Dial(PJSIP/SOFTPHONE_B)

exten => 110,1,Dial(PJSIP/0000f30A0A01&PJSIP/SOFTPHONE_A&PJSIP/SOFTPHONE_B)

exten => 200,1,Answer()

Dial(technology/user[:password]@remote_host[:port][/remote_extension])

Dial(DAHDI/[gGrR]channel_or_group[/remote_extension])

exten => 501,1,Dial(DAHDI/4/18005551212)

exten => 101,1,Dial(PJSIP/SOFTPHONE_A)

exten => 102,1,Dial(PJSIP/0000f30B0B02,10)

exten => 103,1,Dial(PJSIP/SOFTPHONE_B)

exten => 102,1,Dial(PJSIP/0000f30B0B02,10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 102,1,Dial(PJSIP/0000f30B0B02,10,m)
  same => n,Playback(vm-nobodyavail)
  same => n,Hangup()

[TestMenu]
exten => start,1,Answer()
   same => n,Background(enter-ext-of-person)
   same => n,WaitExten(5)

exten => 1,1,Dial(PJSIP/0000f30A0A01,10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 2,1,Dial(PJSIP/0000f30B0B02,10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 3,1,Dial(PJSIP/SOFTPHONE_A,10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 4,1,Dial(PJSIP/SOFTPHONE_B,10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => i,1,Playback(pbx-invalid)
   same => n,Goto(TestMenu,start,1)

exten => t,1,Playback(vm-goodbye)
   same => n,Hangup()

exten => 4,1,Dial(SIP/SOFTPHONE_B,,m)

Using Variables

If you have programming experience, you already understand what a variable is. If not, we’ll briefly explain what variables are and how they are used. Any dialplan work beyond the very simple examples just given will greatly benefit from the use of variables. They are one of the useful features of a customizable dialplan that you will not find in a typical proprietary PBX.

A variable is a named container that can hold a value. Think of it like a post office box. The advantage of a variable is that its contents may change, but its name does not, which means you can write code that references the variable name and not worry about what the value will be. It is almost impossible to do any sort of useful programming without variables.

There are two ways to reference a variable. To reference the variable’s name, simply type the name of the variable. If, on the other hand, you want to reference the value of the variable, you must type a dollar sign, an opening curly brace, the name of the variable, and a closing curly brace. So, to use the post office box analogy, you refer to the box itself by simply using its name, and you refer to the contents with the use of the ${} wrapper. A variable named MyVar is referred to as MyVar, and its contents are accessed with ${MyVar}. Here’s how we might use a variable inside the Dial() application:¹⁶

exten => 203,1,Noop(say some digits)
  same => n,Answer()
  same => n,Set(SomeDigits=123)
  same => n,SayDigits(${SomeDigits})
  same => n,Wait(.25)
  same => n,Set(SomeDigits=543)
  same => n,SayDigits(${SomeDigits})

In our dialplan, whenever we refer to ${SomeDigits}, Asterisk will automatically replace it with whatever value has been assigned to the variable named SomeDigits.

There are three types of variables we can use in our dialplan: global variables, channel variables, and environment variables. Let’s take a moment to look at each type.

[globals]
UserA_DeskPhone=PJSIP/0000f30A0A01
UserA_SoftPhone=PJSIP/SOFTPHONE_A
UserB_DeskPhone=PJSIP/0000f30B0B02
UserB_SoftPhone=PJSIP/SOFTPHONE_B

exten => 203,1,Noop(say some digits)
  same => n,Set(SomeDigits=123)
  same => n,SayDigits(${SomeDigits})
  same => n,Wait(.25)
  same => n,Set(SomeDigits=543)
  same => n,SayDigits(${SomeDigits})

[general]
[globals]
UserA_DeskPhone=PJSIP/0000f30A0A01
UserA_SoftPhone=PJSIP/SOFTPHONE_A
UserB_DeskPhone=PJSIP/0000f30B0B02
UserB_SoftPhone=PJSIP/SOFTPHONE_B

[sets]
exten => 100,1,Dial(${UserA_DeskPhone})

exten => 101,1,Dial(${UserA_SoftPhone})

exten => 102,1,Dial(${UserB_DeskPhone},10)
  same => n,Playback(vm-nobodyavail)
  same => n,Hangup()

exten => 103,1,Dial(${UserB_SoftPhone})

exten => 110,1,Dial(${UserA_DeskPhone}&${UserA_SoftPhone}&${UserB_SoftPhone})

exten => 200,1,Answer()

[TestMenu]
exten => start,1,Answer()
   same => n,Background(enter-ext-of-person)
   same => n,WaitExten(5)

exten => 1,1,Dial(${UserA_DeskPhone},10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 2,1,Dial(${UserA_SoftPhone},10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 3,1,Dial(${UserB_DeskPhone},10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => 4,1,Dial(${UserB_SoftPhone},10)
   same => n,Playback(vm-nobodyavail)
   same => n,Hangup()

exten => i,1,Playback(pbx-invalid)

# asterisk -rvvvvvv
*CLI> dialplan reload
    -- Executing [201@sets:1] Goto("PJSIP/0000f30A0A01", "TestMenu,start,1")
    -- Goto (TestMenu,start,1)
    -- Exec [start@TestMenu:1] Answer("PJSIP/0000f30A0A01", "")
    -- Exec [start@TestMenu:2] BackGround("PJSIP/0000f30A0A01", "enter-ext-of-person")
    -- <PJSIP/0000f30A0A01> Playing 'enter-ext-of-person.slin' (language 'en')
    -- Exec [1@TestMenu:1] Dial("PJSIP/0000f30A0A01", "PJSIP/0000f30A0A01,10")
    -- Called PJSIP/0000f30A0A01
    -- PJSIP/0000f30A0A01-00000011 is ringing
  == Spawn extension (TestMenu, 1, 1) exited non-zero on 'PJSIP/0000f30A0A01'

exten => 204,1,Answer()
  same => n,Answer()
  same => n,Set(ONETWO=12)
  same => n,Set(THREEFOUR=34)
  same => n,SayDigits(${ONETWO}${THREEFOUR})   ; easy peasy
  same => n,Wait(0.2)
  same => n,Set(NOTFIVE=${THREEFOUR}${ONETWO}) ; peasy easy
  same => n,SayNumber(${NOTFIVE})              ; see what we did here?
  same => n,Wait(0.2)
  same => n,SayDigits(2${ONETWO}3)             ; you can concatenate literals and variables

exten => example,1,Set(_MyVariable=thisValue)

exten => example,1,Set(__MyVariable=thisValue)

exten => example,1,Verbose(1,Value of MyVariable is: ${MyVariable})

Pattern Matching

If we want to be able to allow people to dial through Asterisk and have Asterisk connect them to outside resources, we need a way to match on any possible phone number that the caller might dial. For situations like this, Asterisk offers pattern matching. Pattern matching allows you to create one extension in your dialplan that matches many different numbers. This is enormously useful.

exten => _4XX,1,Noop(User Dialed ${EXTEN})
  same => n,Answer()
  same => n,SayDigits(${EXTEN})
  same => n,Hangup()

exten => _555XXXX,1,Answer()
  same => n,SayDigits(${EXTEN})
exten => _55512XX,1,Answer()
  same => n,Playback(tt-monkeys)

_NXXXXXX

_NXXNXXXXXX

_1NXXNXXXXXX

_011.

; UK, Germany, Italy, China, etc.
exten => _00X.,1,noop()   ; international dialing code
exten => _0X.,1,noop()    ; national dialing prefix
exten => 112,1,Noop(--==[ Emergency call ]==--)

; Australia
exten => _0011X.,1,noop() ; international dialing code
exten => _0X.,1,noop()    ; national dialing prefix

; Dutch Caribbean (Saba)
exten => _00X.,1,noop()        ; international
exten => _416XXXX,1,noop()     ; local (on-island)
exten => _0[37]XXXXXX,1,noop() ; call to country code 599 off-island (not Curacao)
exten => _09XXXXXXX,1,Noop()   ; call to country code 599 off-island (Curacao)

exten => _4XX,1,Noop(User Dialed ${EXTEN})
  same => n,Answer()
  same => n,SayDigits(${EXTEN})
  same => n,Hangup()

exten => _555XXXX,1,Answer()
  same => n,SayDigits(${EXTEN})

exten => _XXX,1,Answer()
   same => n,SayDigits(${EXTEN:1})

Includes

Asterisk has an important feature that allows extensions from one context to be available from within another context. This is accomplished through use of the include directive, which allows us to control access to different sections of the dialplan.

The include statement takes the following form, where context is the name of the remote context we want to include in the current context:

include => context

Including one context within another context allows extensions within the included context to be dialable.

When we include other contexts within our current context, we have to be mindful of the order in which we are including them. Asterisk will first try to match the dialed extension in the current context. If unsuccessful, it will then try the first included context (including any contexts included in that context), and then continue to the other included contexts in the order in which they were included.

We will discuss the include directive more in Chapter 7.