contrib/package/asterisk-xip/files/uci/dialplanconf

   1 #!/bin/sh
   2
   3 # Dialplans (extensions.conf)
   4
   5 # Implicit: ast_add_conf dialplan
   6 init_dialplanconf() {
   7         ast_enable_type dialplangeneral
   8         ast_enable_type dialplan
   9         ast_enable_type dialplanexten
  10         ast_enable_type dialplangoto
  11         ast_enable_type dialplansaytime
  12         ast_enable_type dialzone
  13         ast_enable_type inzone
  14         ast_enable_type incominggeneral
  15         ast_enable_type incoming
  16
  17         dialplan_allowtransfer=no
  18         dialplan_dialtimeout=30
  19         dialplan_answerfirst=no
  20         dialplan_static=yes
  21         dialplan_writeprotect=no
  22         dialplan_canreinvite=no
  23         dialplan_includes=
  24         dialplan_globals=
  25         return 0
  26 }
  27
  28 dialplangeneral_list="static writeprotect canreinvite clearglobalvars"
  29 dialplangeneral_list_ex="lastdialed lastdialedtype voiceboxext answerfirst dialtimeout allowtransfer international internationalout"
  30
  31 valid_dialplangeneral() {
  32         for i in  ${dialplangeneral_list} ${dialplangeneral_list_ex} ; do
  33                 [ "$i" == "$1" ] && return 0
  34         done
  35         return 1
  36 }
  37
  38
  39 check_add_context() {
  40         local context="${1}"
  41         local check="${context#macro-}"
  42         [ "${context}" == ${check} ] || check="macro__${check}"
  43         eval "local isadded=\"\${dialplan_add_context_${check}-0}\""
  44         if [ "$isadded" != "1" ] ; then
  45                 eval "dialplan_add_context_${check}=1"
  46                 append dialplan_contexts "$context"
  47                 return 0
  48         else
  49                 return 1
  50         fi
  51 }
  52 append_dialplan_context() {
  53         local context="${1}"
  54         local check="${context#macro-}"
  55         [ "${context}" == ${check} ] || check="macro__${check}"
  56         append dialplan_context_${check} "${2}" "${N}"
  57 }
  58
  59 reload_dialplan() astcmd "dialplan reload"
  60
  61 # Voicemail
  62
  63 enable_voicemail() {
  64         enable_module res_adsi
  65         enable_module app_voicemail
  66         enable_format gsm
  67 }
  68
  69 add_dialplan_exten() {
  70         local context=$1
  71         logdebug 3 "Exten: $2"
  72         local ext="exten => $2,"
  73         local planopt=
  74         local timeout=${dialplan_dialtimeout}
  75                 # Answer extensions first.
  76         local answerfirst=${dialplan_answerfirst}
  77         local mailbox=$4
  78         [ -z "$5" ] || timeout=$5
  79         [ -z "$6" ] || answerfirst=$6
  80
  81         check_add_context "$context"
  82
  83         if [ "$dialplan_allowtransfer" == "yes" ] ; then
  84                 planopt=${planopt}t
  85         fi
  86         if [ ! -z "${planopt}" ] ; then
  87                 planopt=",${timeout},${planopt}"
  88         elif [ ! -z "${timeout}" ] ; then
  89                 planopt=",${timeout}"
  90         fi
  91         local dial="Dial($3$planopt)"
  92         local item="1,"
  93         if [ "$answerfirst" == "yes" ] ; then
  94                 append_dialplan_context ${context}  "${ext}1,Answer"
  95                 item="n,"
  96         fi
  97         append_dialplan_context ${context}  "${ext}${item}${dial}"
  98         if [ ! -z "${mailbox}" ] ; then
  99                 enable_voicemail
 100                 append_dialplan_context ${context}  "${ext}n,VoiceMail(${mailbox})"
 101         fi
 102
 103         append_dialplan_context ${context}  "${ext}n,Congestion"
 104 }
 105
 106 add_dialplan_include() {
 107         local context=$1
 108         logdebug 1 "Adding Dialplan Include $1 $2"
 109         check_add_context "$context"
 110
 111         split_append dialplan_context_${context} "include => " "$2" "${N}"
 112 }
 113
 114 add_dialplan_saytime() {
 115         local context=$1
 116         logdebug 1 "Adding Dialplan saytime $1 $2"
 117         check_add_context "$context"
 118         local ext="exten => $2,"
 119         if [ "$dialplan_add_context_saytime" != 1 ] ; then
 120                 append dialplan_contexts saytime " "
 121                 dialplan_add_context_saytime=1
 122                 enable_format gsm
 123                 enable_module app_sayunixtime
 124                 local zone=${asterisk_zone}
 125                 [ ! -z "$3" ] && zone="$3"
 126                 local format="IMp AdbY"
 127                 [ ! -z "$4" ] && format="$4"
 128                 append dialplan_context_saytime "exten => s,1,SayUnixTime(,${zone},${format})" "${N}"
 129         fi
 130         append_dialplan_context ${context}  "${ext}1,Goto(saytime,s,1)"
 131 }
 132
 133 add_dialplan_goto() {
 134         local context=$1
 135         logdebug 1 "Adding Dialplan goto $1 $2 $3"
 136         check_add_context "$context"
 137         append dialplan_context_${context} "exten => $2,1,Goto($3,\${EXTEN},1)" "${N}"
 138 }
 139
 140 handle_inzone() {
 141         # TODO - Incoming zones.
 142         return 0
 143 }
 144
 145 #generate_inzone() {
 146         #[local_Vista]
 147         #exten => _X.,1,Ringing()
 148         #exten => _X.,n,Dial(SIP/Nokia,5)
 149         #exten => _X.,n,Answer
 150         #exten => _X.,n,wait(1)
 151         #exten => _X.,n,Set(EXITCONTEXT=xyzzy)
 152         #exten => _X.,n,Dial(SIP/Nokia,15,rd)
 153         #exten => _X.,n,Hangup
 154         #[xyzzy]
 155         #exten => 1,1,Noop(xyzzy)
 156         #exten => 1,n,SayAlpha(b)
 157         #exten => 1,n,Hangup
 158 #}
 159
 160 append_dialplan_dialzone()  {
 161         local file=$1
 162
 163         # Add the dialzone contexts
 164         logdebug 1 "Dialplan: Add the dialzone contexts"
 165         for zonename in ${dzones_match} ; do
 166                 eval "local diallist=\${dzone_${zonename}_match-}"
 167                 echo "${N}[${zonename}]" >> $file
 168                 eval "dialz=\${dzone_match_use_${zonename}-}"
 169
 170                 for v in prefix internationalprefix alwaysinternational countrycode ; do
 171                         eval "local $v=\${target_${v}_${dialz}:-}"
 172                         eval logdebug 3 "\"${v} = '\${$v}'\""
 173                 done
 174
 175                 for v in localzone addprefix localprefix; do
 176                         eval "local $v=\${dzone_${zonename}_${v}:-}"
 177                 done
 178                 while [ ! -z "$diallist" ] ; do
 179                         cur=${diallist%%,*}
 180                         nvar=${diallist#*,}
 181                         if [ "${alwaysinternational}" = "yes" ] ; then
 182                                 # Always dial international number with this target
 183                                 # remove 'localprefix' (usually 0) from  'addprefix'
 184                                 logdebug 3 "Removing ${localprefix} from ${addprefix}"
 185                                 addprefix=${addprefix#$localprefix}
 186                                 local curlen=`expr length "${localprefix}"`
 187                                 if [ $curlen != 0 ] ; then
 188                                         # remove 0 (or local prefix)
 189                                         echo "exten => _${localprefix}${cur},1,Goto(${dialz}_dial,${countrycode}${addprefix}\${EXTEN:$curlen},1)" >> $file
 190                                 fi
 191                                 echo "exten => _${cur},1,Goto(${dialz}_dial,${countrycode}${addprefix}\${EXTEN},1)" >> $file
 192                         else
 193                                 echo "exten => _${cur},1,Goto(${dialz}_dial,${addprefix}\${EXTEN},1)" >> $file
 194                         fi
 195                         [ "$nvar" == "$diallist" ] && break
 196                         diallist=${nvar}
 197                 done
 198                 eval "local diallist=\${dzone_${zonename}_international-}"
 199                 if [ ! -z "${diallist}" ] ; then
 200                         logdebug 2 "International: ${diallist}"
 201                         while [ ! -z "$diallist" ] ; do
 202                                 cur=${diallist%%,*}
 203                                 nvar=${diallist#*,}
 204
 205                                 local curlen=`expr length ${cur}`
 206                                 if [ "$alwaysinternational" = "yes" ]  ; then
 207                                         echo "exten => _${cur},1,Goto(${dialz}_dial,${addprefix}\${EXTEN:${curlen}},1)" >> $file
 208                                 else
 209                                         echo "exten => _${cur}.,1,Goto(${zonename}_check,${addprefix}\${EXTEN:${curlen}},1)" >> $file
 210                                 fi
 211                                 [ "$nvar" == "$diallist" ] && break
 212                                 diallist=${nvar}
 213                         done
 214
 215                         if [ "$alwaysinternational" != "yes" ]  ; then
 216                                 # Check for local country code
 217                                 echo "[${zonename}_check]" >> $file
 218
 219                                 local locallen=`expr length ${countrycode}`
 220                                 echo "exten => _${countrycode}X.,1,Goto(${localzone-default},${localprefix-0}\${EXTEN:${locallen}},1)" >> $file
 221                                 echo "exten => _X.,1,Goto(${dialz}_dial,${internationalprefix}\${EXTEN},1)" >> $file
 222                         fi
 223                 fi
 224         done
 225         logdebug 1 "Dialplan: Finish the dialzone contexts"
 226
 227 }
 228
 229 append_dialplan_dialzone_out(){
 230         local file=$1
 231
 232         # Add the dialzone target contexts (dialing out)
 233         logdebug 1 "Dialplan: Add the dialzone target contexts"
 234         for contype in SIP IAX ; do
 235                 eval local conlist=\${dzones_${contype}-}
 236                 logdebug 1 "Adding ${contype} targets: ${conlist}"
 237                 for conname in $conlist ; do
 238                         echo "${N}[${contype}_${conname}_dial]" >> $file
 239                         for  v in prefix internationalprefix alwaysinternational countrycode timeout lastdialed lastdialedtype ; do
 240                                 eval "local $v=\${target_${v}_${contype}_${conname}:-}"
 241                         done
 242
 243                         if [ -z "${lastdialed}" ] ; then
 244                                 lastdialed=${dialplan_lastdialed}
 245                                 lastdialedtype=${dialplan_lastdialedtype}
 246                         fi
 247
 248                         # [ -z "${lastcallout}" ] && lastcallout=${feature_lastcall_outqueue}
 249                         # if [ ! -z "${lastcalloutexten}" ] ; then
 250                         #       eval "local added=\${lastcallout_outqueue_extension_${lastcalloutexten}}"
 251                         #       if [ ! "${added}" == 1 ] ; then
 252                         #               add_dialplan_lastcall extensions "${lastcalloutexten}" "${lastcallout}" "${feature_lastcall_outcount}"
 253                         #               eval "local lastcallout_outqueue_extension_${lastcalloutexten}=1"
 254                         #       fi
 255                         # fi
 256                         local ext="exten => _X.,"
 257                         local en="1,"
 258                         # Do not use prefix unles 'alwaysinternational' is yes
 259                         [ "$alwaysinternational" != "yes" ]  && internationalprefix=
 260
 261                         # if [ ! -z "${lastcallout}" ] ; then # Add lastcall out
 262                         #       enable_lastcall
 263                         #       echo "${ext}${en}Macro(lastcallstore,${internationalprefix}\${EXTEN},${lastcallout},${feature_lastcall_outcount})" >> $file
 264                         #       en="n,"
 265                         # fi
 266
 267                         if [ ! -z "${lastdialed}" ] ; then
 268                                 enable_module func_callerid
 269                                 local lastparam="\${EXTEN}"
 270                                 local lastmacro=${lastdialed}
 271                                 local lastmacrotype=${lastdialedtype}
 272                                 [ -z ${lastdialedtype} ]  && lastdialedtype=goto
 273
 274                                 local jumpmacroline=
 275                                 gen_jumpmacro jumpmacroline "${ext}${en}" "" "${lastmacrotype}" "${lastmacro}" "${lastparam}"
 276                                 echo ${jumpmacroline} >> $file
 277                                 en="n,"
 278                         fi
 279                         echo "${ext}${en}Dial(${contype}/${prefix}${internationalprefix}\${EXTEN}@${conname},$timeout)" >> $file
 280                         echo "exten => _X.,n,Congestion" >> $file
 281                 done
 282         done
 283 }
 284
 285
 286 gen_jumpmacro() {
 287         logdebug 3 "Gen JumpMacro /$1/=/$2/$3/$4/$5/$6/"
 288         local leader=$2
 289         local condition=$3
 290         local macrotype=$4
 291         local name=$5
 292         local param=$6
 293
 294         if [ -z "${condition}" ] ; then
 295                 local cond="("
 296         else
 297                 local cond="If(${condition}?"
 298         fi
 299         case ${macrotype} in
 300                 gosub)
 301                         enable_module app_stack # for gosub
 302                         logdebug 1 "${1}=\"\${leader}Gosub\${cond}\${name},\${param},1)\""
 303                         eval "${1}=\"\${leader}Gosub\${cond}\${name},\${param},1)\"" ;;
 304                 gosub_s)
 305                         enable_module app_stack # for gosub
 306                         logdebug 1 "${1}=\"\${leader}Gosub\${cond}\${name},s,1(\${param}))\""
 307                         eval "${1}=\"\${leader}Gosub\${cond}\${name},s,1(\${param}))\"" ;;
 308                 macro)
 309                         enable_module app_macro
 310                         logdebug 1 "${1}=\"\${leader}Macro\${cond}\${name},\${param})\""
 311                         eval  "${1}=\"\${leader}Macro\${cond}\${name},\${param})\"" ;;
 312
 313                 s|start)
 314                         enable_module app_goto
 315                         logdebug 1 "${1}=\"\${leader}Goto(\${iz_target},s,1)\""
 316                         eval "${1}=\"\${leader}Goto(\${iz_target},s,1)\"" ;;
 317                 *)
 318                         enable_module app_goto
 319                         logdebug 1 "${1}=\"\${leader}Goto\${cond}\${name},\${param},1)\""
 320                         eval "${1}=\"\${leader}Goto\${cond}\${name},\${param},1)\"" ;;
 321         esac
 322 }
 323
 324 append_jumpmacro(){
 325         local context=$1
 326         local jumpmacroline=""
 327         gen_jumpmacro "jumpmacroline" "$2" "$3" "$4" "$5" "$6"
 328         append_dialplan_context ${context}  "${jumpmacroline}"
 329 }
 330
 331 append_dialplan_incoming(){
 332         local file=$1
 333         # Evaluate the incoming ringing dialplans
 334         logdebug 1 "Add the 'incoming' dialplans: ${dialplan_extensions_incoming}"
 335         for context in ${dialplan_extensions_incoming} ; do
 336                 eval "local curext=\"\${dialplan_incoming_$context}\""
 337                 logdebug 2 "Adding incoming ${curext}"
 338
 339                 check_add_context "$context"
 340                 # lastcall lastcallexten lastmissed lastmissedexten
 341                 for i in answerfirst beforeanswer timeout menucontext \
 342                                          lastcall lastcalltype missed missedtype allowtransfer mailbox match matchcaller aftertimeout aftertimeouttype; do
 343                         eval "local iz_$i=\"\${incoming_${context}_$i}\""
 344                         eval "logdebug 1 \"Incoming \$context: iz_\$i=\${iz_$i}\""
 345                 done
 346                 [ ! -z ${iz_menucontext} ] && iz_answerfirst=yes
 347
 348                 if [ ! -z ${curext} ] ; then
 349                         [ -z ${iz_answerfirst} ]   && iz_answerfirst=${incoming_answerfirst}
 350 #                       [ -z ${iz_lastcall} ]      && iz_lastcall=${feature_lastcall_inqueue}
 351                         if [ -z ${iz_lastcall} ] ; then
 352                                 iz_lastcall=${incoming_lastcall}
 353                                 iz_lastcalltype=${incoming_lastcalltype}
 354                         fi
 355                         if [ -z ${iz_missed} ] ; then
 356                                 iz_missed=${incoming_missed}
 357                                 iz_missedtype=${incoming_missedtype}
 358                         fi
 359                         [ -z ${iz_mailbox} ]       && iz_mailbox=${incoming_mailbox}
 360                         [ -z ${iz_timeout} ]       && iz_timeout=${incoming_timeout}
 361                         [ -z ${iz_allowtransfer} ] && iz_allowtransfer=${incoming_allowtransfer}
 362                 fi
 363
 364                 [ -z ${iz_match} ]         && iz_match=_X.
 365                 [ ! -z ${iz_matchcaller} ] && iz_match=${iz_match}/${iz_matchcaller}
 366
 367                 local ext="exten => ${iz_match},"
 368                 local planopt=
 369                 [ "${iz_allowtransfer}" == "yes" ] && planopt=${planopt}t
 370                 local item="1,"
 371
 372                 #append_dialplan_context ${context}  "${ext}${item}Ringing()"
 373                 if [ ! -z "${iz_lastcall}" ] ; then
 374
 375                         enable_module func_callerid
 376                         local lastparam="\${CALLERID(num)}"
 377                         local lastmacrotype="${iz_lastcalltype}"
 378                         [ -z "${iz_lastcalltype}" ] && lastmacrotype=goto
 379                         local lastmacro=${iz_lastcall}
 380                         append_jumpmacro "${context}" "${ext}${item}" "" "${lastmacrotype}" "${lastmacro}" "${lastparam}"
 381                         item="n,"
 382                 fi
 383                 if [ ! -z "${iz_missed}" ] ; then
 384                         enable_module func_callerid
 385                         local missedparam="\${CALLERID(num)}"
 386                         [ -z "${iz_missedtype}" ] && iz_missedtype=goto
 387
 388                         append_dialplan_context ${context}  "${ext}${item}Set(lcsMissed=\${CALLERID(num)})"
 389                         item="n,"
 390                 fi
 391                 # Ring before answering
 392                 if [ ! -z "${iz_beforeanswer}" -a ! -z "${curext}" ] ; then
 393                         append_dialplan_context ${context}  "${ext}${item}Dial(${curext},${iz_beforeanswer},${planopt})"
 394                         iz_answerfirst=yes
 395                         item="n,"
 396                 fi
 397                 # Now answer
 398                 if [ "$iz_answerfirst" == "yes" ] ; then
 399                         append_dialplan_context ${context}  "${ext}${item}Answer"
 400                         item="n,"
 401                 fi
 402                 # if [ ! -z ${iz_lastcallexten} ] ; then
 403                 #       enable_lastcall
 404                 #       add_dialplan_lastcall extensions "${iz_lastcallexten}" "${iz_lastcall}" "${feature_lastcall_incount}"
 405                 # fi
 406
 407                 if [ ! -z ${curext} ] ; then
 408                         if [ ! -z ${iz_menucontext} ] ; then
 409                                 planopt=${planopt}rd
 410                                 enable_module res_indications
 411                                 # wait so the next ring connects.
 412                                 append_dialplan_context ${context}  "${ext}${item}Wait(1)"
 413                                 append_dialplan_context ${context}  "${ext}n,Set(EXITCONTEXT=${iz_menucontext})"
 414                         fi
 415
 416                         if [ ! -z ${planopt} ] ; then
 417                                 planopt=",${iz_timeout-},${planopt}"
 418                         elif [ ! -z ${iz_timeout-} ] ; then
 419                                 planopt=",${iz_timeout-}"
 420                         fi
 421                         local dial="Dial(${curext}${planopt})"
 422
 423                         append_dialplan_context ${context}  "${ext}n,${dial})"
 424
 425                         if [ ! -z ${iz_missed} ] ; then
 426                                 # It went to voicemail or was hung up - consider missed
 427                                 append_jumpmacro ${context} "${ext}${item}" "" "${iz_missedtype}" "${iz_missed}" "\${lcsMissed}"
 428                         fi
 429                 fi
 430
 431                 local need_hangup=1
 432                 # Add a goto or macro at the end
 433                 if [ ! -z ${iz_target} ] ; then
 434                         case ${iz_aftertimeouttype} in
 435                                 macro) append_dialplan_context ${context}  "${ext}${item}Macro(${iz_target})";;
 436                                 s|start) append_dialplan_context ${context}  "${ext}${item}Goto(${iz_target},s,1)"
 437                                          need_hangup=0;;
 438                                 *) append_dialplan_context ${context}  "${ext}${item}Goto(${iz_target},\${EXTEN},1)"
 439                                          need_hangup=0;;
 440                         esac
 441                 fi
 442
 443                 if [ ! -z ${iz_mailbox} ] ; then
 444                         enable_voicemail
 445                         append_dialplan_context ${context}  "${ext}n,VoiceMail(${iz_mailbox})"
 446                 fi
 447
 448                 [ "${need_hangup}" = "1" ] && append_dialplan_context ${context}  "${ext}n,Hangup"
 449
 450                 if [ ! -z ${iz_missed} ] ; then
 451                         # Check for missed call
 452
 453                         append_jumpmacro ${context} "exten => h,1," "\$[\"\${DIALSTATUS}\" = \"CANCEL\"]" "${iz_missedtype}" "${iz_missed}" "\${lcsMissed}"
 454                         #append dialplan_context_${context} \
 455                         #       "exten => h,1,MacroIf(\$[\"\${DIALSTATUS}\" = \"CANCEL\"]?lastcallstore,\${lcsMissed},${iz_lastmissed},${feature_lastcall_incount})" "${N}"
 456                         # [ ! -z ${iz_lastmissedexten} ] && \
 457                         #       add_dialplan_lastcall extensions "${iz_lastmissedexten}" "${iz_lastmissed}" "${feature_lastcall_incount}"
 458                 fi
 459         done
 460 }
 461
 462 append_dialplan_extensions(){
 463         local file=$1
 464         # Evaluate the 'extension' dialplans
 465         logdebug 1 "Add the 'extension' dialplans: ${dialplan_exts}"
 466         for i in ${dialplan_exts} ; do
 467                 eval "local curext=\"\${dialplan_ext_$i}\""
 468                 add_dialplan_exten extensions $i $curext
 469         done
 470 }
 471
 472 append_include() {
 473         append dialplan_includes "#include <$1>" "$N"
 474 }
 475
 476
 477 create_dialplanconf() {
 478         # Add general section
 479         logdebug 1 "Dialplan: Add general section"
 480         local file=${DEST_DIR}/extensions.conf
 481         get_checksum dialplan_conf $file
 482
 483         echo "${asteriskuci_gen}" > $file
 484
 485         [ -z "${dialplan_includes}" ] || (echo "${dialplan_includes}${N}" >> $file)
 486
 487         if [ ! -z "${dialplan_globals}" ] ; then
 488                 echo "[globals]${N}${dialplan_globals}${N}" >> $file
 489         fi
 490
 491         echo "[general]" >> $file
 492         for i in  ${dialplangeneral_list} ; do
 493                 eval "local val=\"\$dialplan_$i\""
 494                 if [ ! -z "$val" ] ; then
 495                         echo "$i=$val" >> $file
 496                 fi
 497         done
 498
 499         append_dialplan_dialzone "$file"
 500
 501         append_dialplan_dialzone_out "$file"
 502
 503         append_dialplan_park "$file"
 504
 505         append_dialplan_extensions "$file"
 506
 507         append_dialplan_incoming "$file"
 508
 509         # append_dialplan_lastcall "$file"
 510
 511         # Add all the contexts
 512         logdebug 1 "Dialplan: Add all the contexts"
 513         for i in ${dialplan_contexts} ; do
 514                 echo "${N}[$i]" >> $file
 515                 [ "${i#macro-}" == "${i}" ] || i=macro__${i#macro-}
 516                 eval "local curcontext=\"\${dialplan_context_$i-}\""
 517                 echo "$curcontext">> $file
 518                 eval unset dialplan_context_$i
 519         done
 520
 521         check_checksum "$dialplan_conf" "$file"  || ast_dialplan_restart=1
 522
 523         return 0
 524 }
 525
 526 handle_dialplangeneral() {
 527         option_cb(){
 528                 if valid_dialplangeneral $1 $2 ; then
 529                         eval "dialplan_$1=\"$2\""
 530                 else
 531                         logerror "Invalid Dialplan General option: $1"
 532                 fi
 533         }
 534 }
 535
 536
 537 handle_dialplan(){
 538         context_name=$1
 539         if [ -z ${context_name} ] ; then
 540                 logerror "Context name required for dialplan"
 541                 context_name=default
 542         fi
 543         option_cb() {
 544                 logdebug 4 "dialplan ${context_name}: '$1' '$2'"
 545                 case $1 in
 546                         include_LENGTH) ;;
 547                         include|include_ITEM*) add_dialplan_include ${context_name} $2 ;;
 548                         *)
 549                                 lhs=$1
 550                                 logdebug 4 "Add extension $lhs"
 551                                 if [ "$(expr $lhs : [0-9][0-9]\*)" != 0 ] ; then
 552                                         addtype=${2%%:*}
 553                                         if [ "${addtype}" == "$2" ]; then
 554                                                 addparam=
 555                                         else
 556                                                 addparam=${2#*:}
 557                                         fi
 558                                         case ${addtype} in
 559                                                 mailbox|voice)
 560                                                         add_dialplan_voice ${context_name} $1 $addparam ;;
 561                                                 meetme|conf|conference)  add_dialplan_meetme ${context_name} $1 $addparam ;;
 562                                                 saytime|time) add_dialplan_saytime ${context_name} $1 $addparam ;;
 563                                                 clock) add_dialplan_talkclock ${context_name} $1 $addparam ;;
 564                                                 *) logerror "Unknown type '${addtype}' in dialplan ${context_name}, extension ${1}"
 565                                         esac
 566                                 else
 567                                         logerror "Invalid option: $1 for dialplan ${context_name}"
 568                                 fi
 569                 esac
 570         }
 571 }
 572
 573 handle_dialplanexten() {
 574         check_add dialplanexten
 575         option_cb() {
 576                 case $1 in
 577                         dialplan|extension|type|target|dialextension|voicebox|timeout|answerfirst)
 578                                 eval "dial_exten_$1=\"$2\""
 579                 esac
 580         }
 581 }
 582
 583 check_add_dialplanexten() {
 584         if [ ! -z "${dial_exten_dialplan}" -a ! -z "${dial_exten_extension}" ] ; then
 585
 586                 local dialtarget=${dial_exten_type}/${dial_exten_dialextension+@}${dial_exten_dialextension}${dial_exten_target}
 587
 588                 check_add_context ${dial_exten_dialplan}
 589                 add_dialplan_exten "${dial_exten_dialplan}" "${dial_exten_extension}" \
 590                     "${dialtarget}" "${dial_exten_voicebox}" "${dial_exten_timeout}" \
 591                                 "${dial_exten_answerfirst}"
 592         fi
 593         for i in dialplan extension voicebox type target dialextension timeout answerfirst ; do
 594                 eval "unset dial_voice_$i"
 595         done
 596 }
 597
 598 handle_dialplansaytime() {
 599         check_add dialplansaytime
 600         option_cb() {
 601                 case $1 in
 602                         dialplan|extension|zone|format)
 603                                 eval "dial_saytime_$1=\"$2\""
 604                 esac
 605         }
 606 }
 607
 608 check_add_dialplansaytime() {
 609         logdebug 1 "Add Saytime to $1 / $2"
 610         if [ ! -z "${dial_saytime_dialplan}" -a ! -z "${dial_saytime_extension}" ] ; then
 611                 #               local ext="exten => ${dial_saytime_extension},"
 612                 [ -z "${dial_saytime_dialplan}" ] && dial_saytime_dialplan=default
 613
 614                 add_dialplan_saytime "${dial_saytime_dialplan}" "${dial_saytime_extension}" \
 615                         "${dial_saytime_zone}" "${dial_saytime_format}"
 616         fi
 617         for i in dialplan extension zone format; do
 618                 eval "unset dial_saytime_$i"
 619         done
 620
 621 }
 622
 623 handle_dialzone_match() {
 624         eval "local isadded=\"\${dzone_${zone_name}-0}\""
 625         if [ "${isadded}" != "1" ] ; then
 626                 eval "dzone_${zone_name}=1"
 627                 append dzones_match ${zone_name} " "
 628         fi
 629         append dzone_${zone_name}_match $1 ","
 630 }
 631
 632 # Set up outgoing zones (match patterns)
 633 handle_dialzone() {
 634         zone_name=$1
 635         logdebug 2 "Loading dialzone: $zone_name"
 636         option_cb(){
 637                 logdebug 2 "Dialzone $1/$2"
 638                 case $1  in
 639                         uses)
 640                                 local areatype=${2%[-/]*}
 641                                 local areaname=${2#*[-/]}
 642                                 logdebug 3 "Added: $areatype $areaname"
 643                                 eval "local isadded=\"\${dzone_${areatype}_${areaname}-0}\""
 644                                 if [ "${isadded}" != "1" ] ; then
 645                                         eval dzone_${areatype}_${areaname}=1
 646                                         append dzones_${areatype} "${areaname}" " "
 647                                 fi
 648                                 eval "dzone_match_use_${zone_name}=${areatype}_${areaname}"
 649                                 logdebug 3 "Finished uses"
 650                                 ;;
 651                         match_LENGTH) ;;
 652                         match|match_ITEM*)
 653                                 handle_dialzone_match "$2"
 654                                 ;;
 655                         international_LENGTH) ;;
 656                         international|international_ITEM*)
 657                                 eval "local isadded=\"$dzone_${zone_name}\""
 658                                 if [ "${isadded}" != "1" ] ; then
 659                                         eval "dzone_${zone_name}=1"
 660                                         append dzones_match ${zone_name} " "
 661                                 fi
 662                                 append dzone_${zone_name}_international $2 ","
 663                                 ;;
 664                         countrycode|localzone|addprefix|localprefix)
 665                                 eval "dzone_${zone_name}_${1}=\"$2\""
 666                                 eval "y=\${dzone_${zone_name}_${1}}"
 667                                 ;;
 668                         *)
 669                                 logerror "Invalid Dialzone option: $1 in zone '${zone_name}'" ;;
 670                 esac
 671         }
 672 }
 673
 674 check_add_dialplangoto() {
 675         logdebug 1 "Add Goto to $1 / $2"
 676         if [ ! -z "${dial_goto_dialplan}" -a ! -z "${dial_goto_extension}" ] ; then
 677                 local ext="exten => ${dial_goto_extension},"
 678                 check_add_context ${dial_goto_dialplan}
 679                 append_dialplan_context ${dial_goto_dialplan}  "${ext}1,Goto(${dial_goto_target})"
 680         fi
 681         for i in dialplan extension room ; do
 682                 eval "unset dial_goto_$i"
 683         done
 684 }
 685
 686 handle_dialplangoto(){
 687         check_add dialplangoto
 688         option_cb() {
 689                 case $1 in
 690                         dialplan|extension|target)
 691                                 eval "dial_goto_$1=\"$2\"" ;;
 692                         *) logerror "Invalid dialplangoto option: $1"
 693                 esac
 694         }
 695 }
 696
 697 # Options for incoming calls.
 698
 699 valid_incoming_list="allowtransfer timeout answerfirst mailbox lastcall lastcalltype missed missedtype"
 700
 701 valid_incoming_option() {
 702         is_in_list $1 ${valid_incoming_list}
 703         return $?
 704 }
 705
 706 handle_incominggeneral() {
 707         option_cb() {
 708                 if valid_incoming_option $1 ; then
 709                         logdebug 3 "Add Incoming General option $1=$2"
 710                         eval "incoming_${1}=\"$2\""
 711                 else
 712                         logerror "Invalid incominggeneral option $1"
 713                 fi
 714         }
 715 }
 716
 717 handle_incoming() {
 718         incoming_context=$1
 719         incoming_list=
 720         add_incoming_context "${incoming_context}"
 721
 722         option_cb() {
 723                 logdebug 1 "Incoming ${incoming_context} $1=$2"
 724                 case $1 in
 725                         lastcall|lastcalltype|missed|missedtype) eval "incoming_${incoming_context}_${1}=\"$2\"" ;;
 726 #                       lastcall|lastcallexten|lastmissed|lastmissedexten)
 727 #                               enable_lastcall
 728 #                               eval "incoming_${incoming_context}_${1}=\"$2\""
 729 #                               ;;
 730                         mailbox|allowtransfer|answerfirst|beforeanswer|timeout|menucontext|match|matchcaller|aftertimeout|aftertimeouttype)
 731                                 eval "incoming_${incoming_context}_${1}=\"$2\""
 732                                 ;;
 733                         target|target_ITEM*)
 734                                 append dialplan_incoming_${incoming_context} "$2" "&"
 735                                 ;;
 736                         target_COUNT) ;;
 737                         *) logerror "Invalid option $1 in incoming" ;;
 738                 esac
 739         }
 740 }
 741
 742 # vim: ts=2 sw=2 noet foldmethod=indent