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