applications/luci-asterisk: initial dialplan voicemail box support
[project/luci.git] / applications / luci-asterisk / luasrc / asterisk.lua
1 --[[
2 LuCI - Lua Configuration Interface
3 Asterisk PBX interface library
4
5 Copyright 2009 Jo-Philipp Wich <xm@subsignal.org>
6
7 Licensed under the Apache License, Version 2.0 (the "License");
8 you may not use this file except in compliance with the License.
9 You may obtain a copy of the License at
10
11 http://www.apache.org/licenses/LICENSE-2.0
12
13 $Id$
14
15 ]]--
16
17 module("luci.asterisk", package.seeall)
18 require("luci.asterisk.cc_idd")
19
20 local _io = require("io")
21 local uci = require("luci.model.uci").cursor()
22 local sys = require("luci.sys")
23 local util = require("luci.util")
24
25 AST_BIN = "/usr/sbin/asterisk"
26 AST_FLAGS = "-r -x"
27
28
29 --- LuCI Asterisk - Resync uci context
30 function uci_resync()
31 uci = luci.model.uci.cursor()
32 end
33
34 --- LuCI Asterisk io interface
35 -- Handles low level io.
36 -- @type module
37 io = luci.util.class()
38
39 --- Execute command and return output
40 -- @param command String containing the command to execute
41 -- @return String containing the command output
42 function io.exec(command)
43 local fh = _io.popen( "%s %s %q" %{ AST_BIN, AST_FLAGS, command }, "r" )
44 assert(fh, "Failed to invoke asterisk")
45
46 local buffer = fh:read("*a")
47 fh:close()
48 return buffer
49 end
50
51 --- Execute command and invoke given callback for each readed line
52 -- @param command String containing the command to execute
53 -- @param callback Function to call back for each line
54 -- @return Always true
55 function io.execl(command, callback)
56 local ln
57 local fh = _io.popen( "%s %s %q" %{ AST_BIN, AST_FLAGS, command }, "r" )
58 assert(fh, "Failed to invoke asterisk")
59
60 repeat
61 ln = fh:read("*l")
62 callback(ln)
63 until not ln
64
65 fh:close()
66 return true
67 end
68
69 --- Execute command and return an iterator that returns one line per invokation
70 -- @param command String containing the command to execute
71 -- @return Iterator function
72 function io.execi(command)
73 local fh = _io.popen( "%s %s %q" %{ AST_BIN, AST_FLAGS, command }, "r" )
74 assert(fh, "Failed to invoke asterisk")
75
76 return function()
77 local ln = fh:read("*l")
78 if not ln then fh:close() end
79 return ln
80 end
81 end
82
83
84 --- LuCI Asterisk - core status
85 core = luci.util.class()
86
87 --- Retrive version string.
88 -- @return String containing the reported asterisk version
89 function core.version(self)
90 local version = io.exec("core show version")
91 return version:gsub(" *\n", "")
92 end
93
94
95 --- LuCI Asterisk - SIP information.
96 -- @type module
97 sip = luci.util.class()
98
99 --- Get a list of known SIP peers
100 -- @return Table containing each SIP peer
101 function sip.peers(self)
102 local head = false
103 local peers = { }
104
105 for line in io.execi("sip show peers") do
106 if not head then
107 head = true
108 elseif not line:match(" sip peers ") then
109 local online, delay, id, uid
110 local name, host, dyn, nat, acl, port, status =
111 line:match("(.-) +(.-) +([D ]) ([N ]) (.) (%d+) +(.+)")
112
113 if host == '(Unspecified)' then host = nil end
114 if port == '0' then port = nil else port = tonumber(port) end
115
116 dyn = ( dyn == 'D' and true or false )
117 nat = ( nat == 'N' and true or false )
118 acl = ( acl ~= ' ' and true or false )
119
120 online, delay = status:match("(OK) %((%d+) ms%)")
121
122 if online == 'OK' then
123 online = true
124 delay = tonumber(delay)
125 elseif status ~= 'Unmonitored' then
126 online = false
127 delay = 0
128 else
129 online = nil
130 delay = 0
131 end
132
133 id, uid = name:match("(.+)/(.+)")
134
135 if not ( id and uid ) then
136 id = name .. "..."
137 uid = nil
138 end
139
140 peers[#peers+1] = {
141 online = online,
142 delay = delay,
143 name = id,
144 user = uid,
145 dynamic = dyn,
146 nat = nat,
147 acl = acl,
148 host = host,
149 port = port
150 }
151 end
152 end
153
154 return peers
155 end
156
157 --- Get informations of given SIP peer
158 -- @param peer String containing the name of the SIP peer
159 function sip.peer(peer)
160 local info = { }
161 local keys = { }
162
163 for line in io.execi("sip show peer " .. peer) do
164 if #line > 0 then
165 local key, val = line:match("(.-) *: +(.*)")
166 if key and val then
167
168 key = key:gsub("^ +",""):gsub(" +$", "")
169 val = val:gsub("^ +",""):gsub(" +$", "")
170
171 if key == "* Name" then
172 key = "Name"
173 elseif key == "Addr->IP" then
174 info.address, info.port = val:match("(.+) Port (.+)")
175 info.port = tonumber(info.port)
176 elseif key == "Status" then
177 info.online, info.delay = val:match("(OK) %((%d+) ms%)")
178 if info.online == 'OK' then
179 info.online = true
180 info.delay = tonumber(info.delay)
181 elseif status ~= 'Unmonitored' then
182 info.online = false
183 info.delay = 0
184 else
185 info.online = nil
186 info.delay = 0
187 end
188 end
189
190 if val == 'Yes' or val == 'yes' or val == '<Set>' then
191 val = true
192 elseif val == 'No' or val == 'no' then
193 val = false
194 elseif val == '<Not set>' or val == '(none)' then
195 val = nil
196 end
197
198 keys[#keys+1] = key
199 info[key] = val
200 end
201 end
202 end
203
204 return info, keys
205 end
206
207
208 --- LuCI Asterisk - Internal helpers
209 -- @type module
210 tools = luci.util.class()
211
212 --- Convert given value to a list of tokens. Split by white space.
213 -- @param val String or table value
214 -- @return Table containing tokens
215 function tools.parse_list(v)
216 local tokens = { }
217
218 v = type(v) == "table" and v or { v }
219 for _, v in ipairs(v) do
220 if type(v) == "string" then
221 for v in v:gmatch("(%S+)") do
222 tokens[#tokens+1] = v
223 end
224 end
225 end
226
227 return tokens
228 end
229
230 --- Convert given list to a collection of hyperlinks
231 -- @param list Table of tokens
232 -- @param url String pattern or callback function to construct urls (optional)
233 -- @param sep String containing the seperator (optional, default is ", ")
234 -- @return String containing the html fragment
235 function tools.hyperlinks(list, url, sep)
236 local html
237
238 local function mkurl(p, t)
239 if type(p) == "string" then
240 return p:format(t)
241 elseif type(p) == "function" then
242 return p(t)
243 else
244 return '#'
245 end
246 end
247
248 list = list or { }
249 url = url or "%s"
250 sep = sep or ", "
251
252 for _, token in ipairs(list) do
253 html = ( html and html .. sep or '' ) ..
254 '<a href="%s">%s</a>' %{ mkurl(url, token), token }
255 end
256
257 return html or ''
258 end
259
260
261 --- LuCI Asterisk - International Direct Dialing Prefixes
262 -- @type module
263 idd = luci.util.class()
264
265 --- Lookup the country name for the given IDD code.
266 -- @param country String containing IDD code
267 -- @return String containing the country name
268 function idd.country(c)
269 for _, v in ipairs(cc_idd.CC_IDD) do
270 if type(v[3]) == "table" then
271 for _, v2 in ipairs(v[3]) do
272 if v2 == tostring(c) then
273 return v[1]
274 end
275 end
276 elseif v[3] == tostring(c) then
277 return v[1]
278 end
279 end
280 end
281
282 --- Lookup the country code for the given IDD code.
283 -- @param country String containing IDD code
284 -- @return Table containing the country code(s)
285 function idd.cc(c)
286 for _, v in ipairs(cc_idd.CC_IDD) do
287 if type(v[3]) == "table" then
288 for _, v2 in ipairs(v[3]) do
289 if v2 == tostring(c) then
290 return type(v[2]) == "table"
291 and v[2] or { v[2] }
292 end
293 end
294 elseif v[3] == tostring(c) then
295 return type(v[2]) == "table"
296 and v[2] or { v[2] }
297 end
298 end
299 end
300
301 --- Lookup the IDD code(s) for the given country.
302 -- @param idd String containing the country name
303 -- @return Table containing the IDD code(s)
304 function idd.idd(c)
305 for _, v in ipairs(cc_idd.CC_IDD) do
306 if v[1]:lower():match(c:lower()) then
307 return type(v[3]) == "table"
308 and v[3] or { v[3] }
309 end
310 end
311 end
312
313 --- Populate given CBI field with IDD codes.
314 -- @param field CBI option object
315 -- @return (nothing)
316 function idd.cbifill(o)
317 for i, v in ipairs(cc_idd.CC_IDD) do
318 o:value("_%i" % i, util.pcdata(v[1]))
319 end
320
321 o.formvalue = function(...)
322 local val = luci.cbi.Value.formvalue(...)
323 if val:sub(1,1) == "_" then
324 val = tonumber((val:gsub("^_", "")))
325 if val then
326 return type(cc_idd.CC_IDD[val][3]) == "table"
327 and cc_idd.CC_IDD[val][3] or { cc_idd.CC_IDD[val][3] }
328 end
329 end
330 return val
331 end
332
333 o.cfgvalue = function(...)
334 local val = luci.cbi.Value.cfgvalue(...)
335 if val then
336 val = tools.parse_list(val)
337 for i, v in ipairs(cc_idd.CC_IDD) do
338 if type(v[3]) == "table" then
339 if v[3][1] == val[1] then
340 return "_%i" % i
341 end
342 else
343 if v[3] == val[1] then
344 return "_%i" % i
345 end
346 end
347 end
348 end
349 return val
350 end
351 end
352
353
354 --- LuCI Asterisk - Country Code Prefixes
355 -- @type module
356 cc = luci.util.class()
357
358 --- Lookup the country name for the given CC code.
359 -- @param country String containing CC code
360 -- @return String containing the country name
361 function cc.country(c)
362 for _, v in ipairs(cc_idd.CC_IDD) do
363 if type(v[2]) == "table" then
364 for _, v2 in ipairs(v[2]) do
365 if v2 == tostring(c) then
366 return v[1]
367 end
368 end
369 elseif v[2] == tostring(c) then
370 return v[1]
371 end
372 end
373 end
374
375 --- Lookup the international dialing code for the given CC code.
376 -- @param cc String containing CC code
377 -- @return String containing IDD code
378 function cc.idd(c)
379 for _, v in ipairs(cc_idd.CC_IDD) do
380 if type(v[2]) == "table" then
381 for _, v2 in ipairs(v[2]) do
382 if v2 == tostring(c) then
383 return type(v[3]) == "table"
384 and v[3] or { v[3] }
385 end
386 end
387 elseif v[2] == tostring(c) then
388 return type(v[3]) == "table"
389 and v[3] or { v[3] }
390 end
391 end
392 end
393
394 --- Lookup the CC code(s) for the given country.
395 -- @param country String containing the country name
396 -- @return Table containing the CC code(s)
397 function cc.cc(c)
398 for _, v in ipairs(cc_idd.CC_IDD) do
399 if v[1]:lower():match(c:lower()) then
400 return type(v[2]) == "table"
401 and v[2] or { v[2] }
402 end
403 end
404 end
405
406 --- Populate given CBI field with CC codes.
407 -- @param field CBI option object
408 -- @return (nothing)
409 function cc.cbifill(o)
410 for i, v in ipairs(cc_idd.CC_IDD) do
411 o:value("_%i" % i, util.pcdata(v[1]))
412 end
413
414 o.formvalue = function(...)
415 local val = luci.cbi.Value.formvalue(...)
416 if val:sub(1,1) == "_" then
417 val = tonumber((val:gsub("^_", "")))
418 if val then
419 return type(cc_idd.CC_IDD[val][2]) == "table"
420 and cc_idd.CC_IDD[val][2] or { cc_idd.CC_IDD[val][2] }
421 end
422 end
423 return val
424 end
425
426 o.cfgvalue = function(...)
427 local val = luci.cbi.Value.cfgvalue(...)
428 if val then
429 val = tools.parse_list(val)
430 for i, v in ipairs(cc_idd.CC_IDD) do
431 if type(v[2]) == "table" then
432 if v[2][1] == val[1] then
433 return "_%i" % i
434 end
435 else
436 if v[2] == val[1] then
437 return "_%i" % i
438 end
439 end
440 end
441 end
442 return val
443 end
444 end
445
446
447 --- LuCI Asterisk - Dialzone
448 -- @type module
449 dialzone = luci.util.class()
450
451 --- Parse a dialzone section
452 -- @param zone Table containing the zone info
453 -- @return Table with parsed information
454 function dialzone.parse(z)
455 if z['.name'] then
456 return {
457 trunks = tools.parse_list(z.uses),
458 name = z['.name'],
459 description = z.description or z['.name'],
460 addprefix = z.addprefix,
461 matches = tools.parse_list(z.match),
462 intlmatches = tools.parse_list(z.international),
463 countrycode = z.countrycode,
464 localzone = z.localzone,
465 localprefix = z.localprefix
466 }
467 end
468 end
469
470 --- Get a list of known dial zones
471 -- @return Associative table of zones and table of zone names
472 function dialzone.zones()
473 local zones = { }
474 local znames = { }
475 uci:foreach("asterisk", "dialzone",
476 function(z)
477 zones[z['.name']] = dialzone.parse(z)
478 znames[#znames+1] = z['.name']
479 end)
480 return zones, znames
481 end
482
483 --- Get a specific dial zone
484 -- @param name Name of the dial zone
485 -- @return Table containing zone information
486 function dialzone.zone(n)
487 local zone
488 uci:foreach("asterisk", "dialzone",
489 function(z)
490 if z['.name'] == n then
491 zone = dialzone.parse(z)
492 end
493 end)
494 return zone
495 end
496
497 --- Find uci section hash for given zone number
498 -- @param idx Zone number
499 -- @return String containing the uci hash pointing to the section
500 function dialzone.ucisection(i)
501 local hash
502 local index = 1
503 i = tonumber(i)
504 uci:foreach("asterisk", "dialzone",
505 function(z)
506 if not hash and index == i then
507 hash = z['.name']
508 end
509 index = index + 1
510 end)
511 return hash
512 end
513
514
515 --- LuCI Asterisk - Voicemailbox
516 -- @type module
517 voicemail = luci.util.class()
518
519 --- Parse a voicemail section
520 -- @param zone Table containing the mailbox info
521 -- @return Table with parsed information
522 function voicemail.parse(z)
523 if z.number and #z.number > 0 then
524 local v = {
525 id = '%s@%s' %{ z.number, z.context or 'default' },
526 number = z.number,
527 context = z.context or 'default',
528 name = z.name or z['.name'] or 'OpenWrt',
529 zone = z.zone or 'homeloc',
530 password = z.password or '0000',
531 email = z.email or '',
532 page = z.page or '',
533 dialplans = { }
534 }
535
536 uci:foreach("asterisk", "dialplanvoice",
537 function(s)
538 if s.dialplan and #s.dialplan > 0 and
539 s.voicebox == v.number
540 then
541 v.dialplans[#v.dialplans+1] = s.dialplan
542 end
543 end)
544
545 return v
546 end
547 end
548
549 --- Get a list of known voicemail boxes
550 -- @return Associative table of boxes and table of box numbers
551 function voicemail.boxes()
552 local vboxes = { }
553 local vnames = { }
554 uci:foreach("asterisk", "voicemail",
555 function(z)
556 local v = voicemail.parse(z)
557 if v then
558 local n = '%s@%s' %{ v.number, v.context }
559 vboxes[n] = v
560 vnames[#vnames+1] = n
561 end
562 end)
563 return vboxes, vnames
564 end
565
566 --- Get a specific voicemailbox
567 -- @param number Number of the voicemailbox
568 -- @return Table containing mailbox information
569 function voicemail.box(n)
570 local box
571 n = n:gsub("@.+$","")
572 uci:foreach("asterisk", "voicemail",
573 function(z)
574 if z.number == tostring(n) then
575 box = voicemail.parse(z)
576 end
577 end)
578 return box
579 end
580
581 --- Find all voicemailboxes within the given dialplan
582 -- @param plan Dialplan name or table
583 -- @return Associative table containing extensions mapped to mailbox info
584 function voicemail.in_dialplan(p)
585 local plan = type(p) == "string" and p or p.name
586 local boxes = { }
587 uci:foreach("asterisk", "dialplanvoice",
588 function(s)
589 if s.extension and #s.extension > 0 and s.dialplan == plan then
590 local box = voicemail.box(s.voicebox)
591 if box then
592 boxes[s.extension] = box
593 end
594 end
595 end)
596 return boxes
597 end
598
599 --- Remove voicemailbox and associated extensions from config
600 -- @param box Voicemailbox number or table
601 -- @return Boolean indicating success
602 function voicemail.remove(v)
603 local box = type(v) == "string" and v or v.number
604 local ok1 = uci:delete_all("asterisk", "voicemail", {number=box})
605 local ok2 = uci:delete_all("asterisk", "dialplanvoice", {voicebox=box})
606 return ( ok1 or ok2 ) and true or false
607 end
608
609
610 --- LuCI Asterisk - Dialplan
611 -- @type module
612 dialplan = luci.util.class()
613
614 --- Parse a dialplan section
615 -- @param plan Table containing the plan info
616 -- @return Table with parsed information
617 function dialplan.parse(z)
618 if z['.name'] then
619 local plan = {
620 zones = { },
621 name = z['.name'],
622 description = z.description or z['.name']
623 }
624
625 -- dialzones
626 for _, name in ipairs(tools.parse_list(z.include)) do
627 local zone = dialzone.zone(name)
628 if zone then
629 plan.zones[#plan.zones+1] = zone
630 end
631 end
632
633 -- voicemailboxes
634 plan.voicemailboxes = voicemail.in_dialplan(plan)
635
636 return plan
637 end
638 end
639
640 --- Get a list of known dial plans
641 -- @return Associative table of plans and table of plan names
642 function dialplan.plans()
643 local plans = { }
644 local pnames = { }
645 uci:foreach("asterisk", "dialplan",
646 function(p)
647 plans[p['.name']] = dialplan.parse(p)
648 pnames[#pnames+1] = p['.name']
649 end)
650 return plans, pnames
651 end
652
653 --- Get a specific dial plan
654 -- @param name Name of the dial plan
655 -- @return Table containing plan information
656 function dialplan.plan(n)
657 local plan
658 uci:foreach("asterisk", "dialplan",
659 function(p)
660 if p['.name'] == n then
661 plan = dialplan.parse(p)
662 end
663 end)
664 return plan
665 end