.github: Add PAT to PRSubmitActions/Add Reviewers

When using COMPILE_DOUBLE, dialplan_functions.xml is mistaken
for the source for an embedded XML document and gets compiled
to dialplan_functions.o.  This causes dialplan_functions.c to
be ignored making its functions unavailable and causing chan_pjsip
to fail to load.

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,87 @@
+name: Bug
+description: File a bug report
+title: "[bug]: "
+labels: ["bug", "triage"]
+#assignees:
+#  - octocat
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for creating a report! The issue has entered the triage process. That means the issue will wait in this status until a Bug Marshal has an opportunity to review the issue. Once the issue has been reviewed you will receive comments regarding the next steps towards resolution. Please note that log messages and other files should not be sent to the Sangoma Asterisk Team unless explicitly asked for. All files should be placed on this issue in a sanitized fashion as needed.
+
+        A good first step is for you to review the Asterisk Issue Guidelines if you haven't already. The guidelines detail what is expected from an Asterisk issue report.
+
+        Then, if you are submitting a patch, please review the Patch Contribution Process.
+
+        Please note that once your issue enters an open state it has been accepted. As Asterisk is an open source project there is no guarantee or timeframe on when your issue will be looked into. If you need expedient resolution you will need to find and pay a suitable developer. Asking for an update on your issue will not yield any progress on it and will not result in a response. All updates are posted to the issue when they occur.
+
+        Please note that by submitting data, code, or documentation to Sangoma through GitHub, you accept the Terms of Use present at
+        https://www.asterisk.org/terms-of-use/.      
+        Thanks for taking the time to fill out this bug report!
+  - type: dropdown
+    id: severity
+    attributes:
+      label: Severity
+      options:
+        - Trivial
+        - Minor
+        - Major
+        - Critical
+        - Blocker
+    validations:
+      required: true
+  - type: input
+    id: versions
+    attributes:
+      label: Versions
+      description: Enter one or more versions separated by commas.
+    validations:
+      required: true
+  - type: input
+    id: components
+    attributes:
+      label: Components/Modules
+      description: Enter one or more components or modules separated by commas.
+    validations:
+      required: true
+  - type: textarea
+    id: environment
+    attributes:
+      label: Operating Environment
+      description: OS,  Disribution, Version, etc.
+    validations:
+      required: true
+  - type: dropdown
+    id: frequency
+    attributes:
+      label: Frequency of Occurrence
+      options:
+        - "Never"
+        - "One Time"
+        - "Occasional"
+        - "Frequent"
+        - "Constant"
+  - type: textarea
+    id: description
+    attributes:
+      label: Issue Description
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell
+  - type: markdown
+    attributes:
+      value: |
+        [Asterisk Issue Guidelines](https://wiki.asterisk.org/wiki/display/AST/Asterisk+Issue+Guidelines)
+  - type: checkboxes
+    id: guidelines
+    attributes:
+      label: Asterisk Issue Guidelines
+      options:
+        - label: Yes, I have read the Asterisk Issue Guidelines
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Asterisk Community Support
+    url: https://community.asterisk.org
+    about: Please ask and answer questions here.
+  - name: Feature Requests
+    url: https://github.com/asterisk/asterisk-feature-requests/issues
+    about: Please submit feature requests here.

.github/ISSUE_TEMPLATE/improvement.yml

@@ -0,0 +1,27 @@
+name: Improvement
+description: Submit an improvement to existing functionality
+title: "[improvement]: "
+labels: ["improvement", "triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for creating a report! The issue has entered the triage process. That means the issue will wait in this status until a Bug Marshal has an opportunity to review the issue. Once the issue has been reviewed you will receive comments regarding the next steps towards resolution. Please note that log messages and other files should not be sent to the Sangoma Asterisk Team unless explicitly asked for. All files should be placed on this issue in a sanitized fashion as needed.
+
+        A good first step is for you to review the Asterisk Issue Guidelines if you haven't already. The guidelines detail what is expected from an Asterisk issue report.
+
+        Then, if you are submitting a patch, please review the Patch Contribution Process.
+
+        Please note that once your issue enters an open state it has been accepted. As Asterisk is an open source project there is no guarantee or timeframe on when your issue will be looked into. If you need expedient resolution you will need to find and pay a suitable developer. Asking for an update on your issue will not yield any progress on it and will not result in a response. All updates are posted to the issue when they occur.
+
+        Please note that by submitting data, code, or documentation to Sangoma through GitHub, you accept the Terms of Use present at
+        https://www.asterisk.org/terms-of-use/.      
+        Thanks for taking the time to fill out this bug report!
+  - type: textarea
+    id: description
+    attributes:
+      label: Improvement Description
+      description: Describe the improvement in as much detail as possible
+    validations:
+      required: true
+      

.github/ISSUE_TEMPLATE/new-feature.yml

@@ -0,0 +1,27 @@
+name: New Feature Submission
+description: Submit a New Feature
+title: "[new-feature]: "
+labels: ["new-feature", "triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for creating a report! The issue has entered the triage process. That means the issue will wait in this status until a Bug Marshal has an opportunity to review the issue. Once the issue has been reviewed you will receive comments regarding the next steps towards resolution. Please note that log messages and other files should not be sent to the Sangoma Asterisk Team unless explicitly asked for. All files should be placed on this issue in a sanitized fashion as needed.
+
+        A good first step is for you to review the Asterisk Issue Guidelines if you haven't already. The guidelines detail what is expected from an Asterisk issue report.
+
+        Then, if you are submitting a patch, please review the Patch Contribution Process.
+
+        Please note that once your issue enters an open state it has been accepted. As Asterisk is an open source project there is no guarantee or timeframe on when your issue will be looked into. If you need expedient resolution you will need to find and pay a suitable developer. Asking for an update on your issue will not yield any progress on it and will not result in a response. All updates are posted to the issue when they occur.
+
+        Please note that by submitting data, code, or documentation to Sangoma through GitHub, you accept the Terms of Use present at
+        https://www.asterisk.org/terms-of-use/.      
+        Thanks for taking the time to fill out this bug report!
+  - type: textarea
+    id: description
+    attributes:
+      label: Feature Description
+      description: Describe the new feature in as much detail as possible
+    validations:
+      required: true
+

.github/workflows/CherryPickTest.yml

@@ -0,0 +1,167 @@
+name: CherryPickTest
+run-name: "Cherry-Pick Tests for PR ${{github.event.number}}"
+on:
+  pull_request_target:
+    types: [ labeled ]
+
+concurrency:
+  group: ${{github.workflow}}-${{github.event.number}}
+  cancel-in-progress: true
+
+env:
+  PR_NUMBER:          ${{ github.event.number }}
+  MODULES_BLACKLIST:  ${{ vars.GATETEST_MODULES_BLACKLIST }} ${{ vars.UNITTEST_MODULES_BLACKLIST }}
+
+jobs:
+  IdentifyBranches:
+    name: IdentifyBranches
+    if: ${{ github.event.label.name == vars.CHERRY_PICK_TEST_LABEL }}
+    outputs:
+      branches:     ${{ steps.getbranches.outputs.branches }}
+      branch_count: ${{ steps.getbranches.outputs.branch_count }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Remove Trigger Label, Add InProgress Label
+        env:
+          GH_TOKEN:          ${{ secrets.GITHUB_TOKEN }}
+        run: | 
+          gh pr edit --repo ${{github.repository}} \
+            --remove-label ${{vars.CHERRY_PICK_TEST_LABEL}} \
+            --remove-label ${{vars.CHERRY_PICK_CHECKS_PASSED_LABEL}} \
+            --remove-label ${{vars.CHERRY_PICK_CHECKS_FAILED_LABEL}} \
+            --remove-label ${{vars.CHERRY_PICK_GATES_PASSED_LABEL}} \
+            --remove-label ${{vars.CHERRY_PICK_GATES_FAILED_LABEL}} \
+            --remove-label ${{vars.CHERRY_PICK_TESTING_IN_PROGRESS}} \
+            ${{env.PR_NUMBER}} || :
+
+      - name: Get cherry-pick branches
+        uses: asterisk/asterisk-ci-actions/GetCherryPickBranchesFromPR@main
+        id: getbranches
+        with:
+          repo:                    ${{github.repository}}
+          pr_number:               ${{env.PR_NUMBER}}
+          cherry_pick_regex:       ${{vars.CHERRY_PICK_REGEX}}
+          github_token:            ${{secrets.GITHUB_TOKEN}}
+
+      - name: Check Branch Count
+        if: ${{ steps.getbranches.outputs.branch_count > 0 }}
+        env:
+          GH_TOKEN:          ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr edit --repo ${{github.repository}} \
+          --add-label ${{vars.CHERRY_PICK_TESTING_IN_PROGRESS}} \
+          ${{env.PR_NUMBER}} || :
+
+  CherryPickUnitTestMatrix:
+    needs: [ IdentifyBranches ]
+    if: ${{ needs.IdentifyBranches.outputs.branch_count > 0 && ( success() || failure() ) }}
+    continue-on-error: false
+    strategy:
+      fail-fast: false
+      matrix:
+        branch: ${{ fromJSON(needs.IdentifyBranches.outputs.branches) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Unit Tests for branch ${{matrix.branch}}
+        uses: asterisk/asterisk-ci-actions/AsteriskUnitComposite@main
+        with:
+          asterisk_repo:     ${{github.repository}}
+          pr_number:         ${{env.PR_NUMBER}}
+          base_branch:       ${{matrix.branch}}
+          is_cherry_pick:    true
+          modules_blacklist: ${{env.MODULES_BLACKLIST}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+          unittest_command:  ${{vars.UNITTEST_COMMAND}}
+
+  CherryPickUnitTests:
+    needs: [ IdentifyBranches, CherryPickUnitTestMatrix ]
+    if: ${{ needs.IdentifyBranches.outputs.branch_count > 0 && ( success() || failure() ) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check unit test matrix status
+        env:
+          RESULT:    ${{needs.CherryPickUnitTestMatrix.result}}
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          case $RESULT in
+            success)
+              gh pr edit --repo ${{github.repository}} \
+                --add-label ${{vars.CHERRY_PICK_CHECKS_PASSED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::notice::All tests passed"
+              exit 0
+              ;;
+            skipped)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.CHERRY_PICK_TESTING_IN_PROGRESS}} \
+                --add-label ${{vars.CHERRY_PICK_CHECKS_FAILED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::notice::Unit tests were skipped because of an earlier failure"
+              exit 1
+              ;;
+            *)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.CHERRY_PICK_TESTING_IN_PROGRESS}} \
+                --add-label ${{vars.CHERRY_PICK_CHECKS_FAILED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::error::One or more tests failed ($RESULT)"
+              exit 1
+          esac
+
+  CherryPickGateTestMatrix:
+    needs: [ IdentifyBranches, CherryPickUnitTests ]
+    if: ${{ success() }}
+    continue-on-error: false
+    strategy:
+      fail-fast: false
+      matrix:
+        branch: ${{ fromJSON(needs.IdentifyBranches.outputs.branches) }}
+        group: ${{ fromJSON(vars.GATETEST_LIST) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Gate Tests for ${{ matrix.group }}-${{matrix.branch}}
+        uses: asterisk/asterisk-ci-actions/AsteriskGateComposite@main
+        with:
+          test_type:         Gate
+          asterisk_repo:     ${{github.repository}}
+          pr_number:         ${{env.PR_NUMBER}}
+          base_branch:       ${{matrix.branch}}
+          is_cherry_pick:    true
+          modules_blacklist: ${{env.MODULES_BLACKLIST}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+          testsuite_repo:    ${{vars.TESTSUITE_REPO}}
+          gatetest_group:    ${{matrix.group}}
+          gatetest_command:  ${{ toJSON(fromJSON(vars.GATETEST_COMMANDS)[matrix.group]) }}
+
+  CherryPickGateTests:
+    needs: [ IdentifyBranches, CherryPickGateTestMatrix ]
+    if: ${{ success() || failure() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check test matrix status
+        env:
+          RESULT:    ${{needs.CherryPickGateTestMatrix.result}}
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr edit --repo ${{github.repository}} \
+            --remove-label ${{vars.CHERRY_PICK_TESTING_IN_PROGRESS}} \
+            ${{env.PR_NUMBER}} || :
+          case $RESULT in
+            success)
+              gh pr edit --repo ${{github.repository}} \
+                --add-label ${{vars.CHERRY_PICK_GATES_PASSED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::notice::All Testsuite tests passed"
+              exit 0
+              ;;
+            skipped)
+              echo "::error::Testsuite tests were skipped because of an earlier failure"
+              exit 1
+              ;;
+            *)
+              gh pr edit --repo ${{github.repository}} \
+                --add-label ${{vars.CHERRY_PICK_GATES_FAILED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::error::One or more Testsuite tests failed ($RESULT)"
+              exit 1
+          esac

.github/workflows/CreateDocs.yml

@@ -0,0 +1,123 @@
+name: CreateDocs
+on:
+  workflow_dispatch:
+    inputs:
+      branches:
+        description: "JSON array of branches: ['18','20'] (no spaces)"
+        required:    false
+        type:        string
+  schedule:
+#           Times are UTC
+    - cron: '0 04 * * *'
+
+env:
+  ASTERISK_REPO:     ${{ github.repository }}
+  GITHUB_TOKEN:      ${{ secrets.GITHUB_TOKEN }}
+  GH_TOKEN:          ${{ secrets.GITHUB_TOKEN }}
+  DEFAULT_BRANCHES:  ${{ vars.WIKIDOC_BRANCHES }}
+  INPUT_BRANCHES:    ${{ inputs.branches }}
+
+jobs:
+  
+  CreateDocsDebug:
+    runs-on: ubuntu-latest
+    outputs:
+      manual_branches:     ${{ steps.setup.outputs.manual_branches }}
+    steps:
+      - name: setup
+        run: |
+          MANUAL_BRANCHES="$INPUT_BRANCHES"
+          [ -z "$MANUAL_BRANCHES" ] && MANUAL_BRANCHES="$DEFAULT_BRANCHES" || :
+          echo "manual_branches=${MANUAL_BRANCHES}"
+          echo "manual_branches=${MANUAL_BRANCHES}" >>${GITHUB_OUTPUT}
+          exit 0
+        
+      - name: DumpEnvironment
+        uses: asterisk/asterisk-ci-actions/DumpEnvironmentAction@main
+        with:
+          action-inputs: ${{toJSON(inputs)}}
+          action-vars: ${{ toJSON(steps.setup.outputs) }}
+
+  CreateDocsScheduledMatrix:
+    needs: [ CreateDocsDebug ]
+    if: ${{github.event_name == 'schedule' && fromJSON(vars.WIKIDOCS_ENABLE) == true }}
+    continue-on-error: false
+    strategy:
+      fail-fast: false
+      matrix:
+        branch: ${{ fromJSON(vars.WIKIDOC_BRANCHES) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: CreateDocs for ${{matrix.branch}}
+        uses: asterisk/asterisk-ci-actions/CreateAsteriskDocsComposite@main
+        with:
+          asterisk_repo:     ${{env.ASTERISK_REPO}}
+          base_branch:       ${{matrix.branch}}
+          docs_dir:          docs_dir/${{matrix.branch}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+
+  CreateDocsScheduled:
+    needs: [ CreateDocsScheduledMatrix ]
+    if: ${{  success() || failure() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check CreateDocsScheduledMatrix status
+        env:
+          RESULT:    ${{needs.CreateDocsScheduledMatrix.result}}
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          case $RESULT in
+            success)
+              echo "::notice::Docs created"
+              exit 0
+              ;;
+            skipped)
+              echo "::notice::Skipped"
+              exit 1
+              ;;
+            *)
+              echo "::error::One or CreateDocs failed ($RESULT)"
+              exit 1
+          esac
+
+  CreateDocsManualMatrix:
+    needs: [ CreateDocsDebug ]
+    if: ${{github.event_name == 'workflow_dispatch'}}
+    continue-on-error: false
+    strategy:
+      fail-fast: false
+      matrix:
+        branch: ${{ fromJSON(vars.WIKIDOC_MANUAL_BRANCHES) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: CreateDocs for ${{matrix.branch}}
+        uses: asterisk/asterisk-ci-actions/CreateAsteriskDocsComposite@main
+        with:
+          asterisk_repo:     ${{env.ASTERISK_REPO}}
+          base_branch:       ${{matrix.branch}}
+          docs_dir:          docs_dir/${{matrix.branch}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+
+  CreateDocsManual:
+    needs: [ CreateDocsManualMatrix ]
+    if: ${{  success() || failure() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check CreateDocsManualMatrix status
+        env:
+          RESULT:    ${{needs.CreateDocsManualMatrix.result}}
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          case $RESULT in
+            success)
+              echo "::notice::Docs created"
+              exit 0
+              ;;
+            skipped)
+              echo "::notice::Skipped"
+              exit 1
+              ;;
+            *)
+              echo "::error::One or CreateDocs failed ($RESULT)"
+              exit 1
+          esac

.github/workflows/IssueOpened.yml

@@ -0,0 +1,15 @@
+name: Issue Opened
+run-name: "Issue ${{github.event.number}} ${{github.event.action}} by ${{github.actor}}"
+on:
+  issues:
+    types: opened
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    steps:
+      - name: initial labeling
+        uses: andymckay/labeler@master
+        with:
+          add-labels: "triage"
+          ignore-if-labeled: true

.github/workflows/MergeApproved.yml

@@ -0,0 +1,187 @@
+name: MergeApproved
+run-name: "Merge Approved for PR ${{github.event.number}}"
+on:
+  pull_request_target:
+    types: [labeled]
+
+env:
+  PR_NUMBER:          ${{ github.event.number }}
+  BASE_BRANCH:        ${{github.event.pull_request.base.ref}}
+  MODULES_BLACKLIST:  ${{ vars.GATETEST_MODULES_BLACKLIST }} ${{ vars.UNITTEST_MODULES_BLACKLIST }}
+  FORCE:              ${{ endsWith(github.event.label.name, '-force') }}
+
+jobs:
+  IdentifyBranches:
+    if: contains(fromJSON(vars.MERGE_APPROVED_LABELS), github.event.label.name)
+    outputs:
+      branches:     ${{ steps.getbranches.outputs.branches }}
+      all_branches: ${{ steps.checkbranches.outputs.all_branches }}
+      branch_count: ${{ steps.getbranches.outputs.branch_count }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clean up labels
+        env:
+          GH_TOKEN:          ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr edit --repo ${{github.repository}} \
+            --remove-label ${{github.event.label.name}} \
+            --remove-label ${{vars.PRE_MERGE_CHECKS_PASSED_LABEL}} \
+            --remove-label ${{vars.PRE_MERGE_CHECKS_FAILED_LABEL}} \
+            --remove-label ${{vars.PRE_MERGE_GATES_PASSED_LABEL}} \
+            --remove-label ${{vars.PRE_MERGE_GATES_FAILED_LABEL}} \
+            --remove-label ${{vars.PRE_MERGE_TESTING_IN_PROGRESS}} \
+            ${{env.PR_NUMBER}} || :
+
+      - name: Get cherry-pick branches
+        uses: asterisk/asterisk-ci-actions/GetCherryPickBranchesFromPR@main
+        id: getbranches
+        with:
+          repo:                   ${{github.repository}}
+          pr_number:              ${{env.PR_NUMBER}}
+          cherry_pick_regex:      ${{vars.CHERRY_PICK_REGEX}}
+          github_token:           ${{secrets.GITHUB_TOKEN}}
+
+      - name: Check Branch Count
+        id: checkbranches
+        env:
+          BRANCH_COUNT:  ${{ steps.getbranches.outputs.branch_count }}
+          BRANCHES:  ${{ steps.getbranches.outputs.branches }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr edit --repo ${{github.repository}} \
+          --add-label ${{vars.PRE_MERGE_TESTING_IN_PROGRESS}} \
+          ${{env.PR_NUMBER}} || :
+          all_branches=$(echo "$BRANCHES" | jq -c "[ \"$BASE_BRANCH\" ] + .")
+          echo "all_branches=${all_branches}" >>${GITHUB_OUTPUT}
+
+      - name: Pre Check Cherry-Picks
+        if: ${{ steps.getbranches.outputs.branch_count > 0 }}
+        uses: asterisk/asterisk-ci-actions/CherryPick@main
+        with:
+          repo:              ${{github.repository}}
+          pr_number:         ${{env.PR_NUMBER}}
+          branches:          ${{steps.getbranches.outputs.branches}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+          push:              false
+
+  PreMergeUnitTestMatrix:
+    needs: [ IdentifyBranches ]
+    if: success()
+    continue-on-error: false
+    strategy:
+      fail-fast: false
+      matrix:
+        branch: ${{ fromJSON(needs.IdentifyBranches.outputs.all_branches) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Unit Tests for branch ${{matrix.branch}}
+        uses: asterisk/asterisk-ci-actions/AsteriskUnitComposite@main
+        with:
+          asterisk_repo:     ${{github.repository}}
+          pr_number:         ${{env.PR_NUMBER}}
+          base_branch:       ${{matrix.branch}}
+          is_cherry_pick:    true
+          modules_blacklist: ${{env.MODULES_BLACKLIST}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+          unittest_command:  ${{vars.UNITTEST_COMMAND}}
+
+  PreMergeUnitTests:
+    needs: [ IdentifyBranches, PreMergeUnitTestMatrix ]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check unit test matrix status
+        env:
+          RESULT:    ${{needs.PreMergeUnitTestMatrix.result}}
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          case $RESULT in
+            success)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.PRE_MERGE_TESTING_IN_PROGRESS}} \
+                --add-label ${{vars.PRE_MERGE_CHECKS_PASSED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::notice::All tests passed"
+              exit 0
+              ;;
+            skipped)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.PRE_MERGE_TESTING_IN_PROGRESS}} \
+                --add-label ${{vars.PRE_MERGE_CHECKS_FAILED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::notice::Unit tests were skipped because of an earlier failure"
+              exit 1
+              ;;
+            *)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.PRE_MERGE_TESTING_IN_PROGRESS}} \
+                --add-label ${{vars.PRE_MERGE_CHECKS_FAILED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              echo "::error::One or more tests failed ($RESULT)"
+              exit 1
+          esac
+
+  MergeAndCherryPick:
+    needs: [ IdentifyBranches, PreMergeUnitTests ]
+    if: success()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Start Merge
+        env:
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+        run: |
+            gh pr edit --repo ${{github.repository}} \
+              --add-label ${{vars.MERGE_IN_PROGRESS_LABEL}} \
+              ${{env.PR_NUMBER}} || :
+
+      - name: Get Token needed to push cherry-picks
+        id: get_workflow_token
+        uses: peter-murray/workflow-application-token-action@v2
+        with:
+          application_id: ${{secrets.ASTERISK_ORG_ACCESS_APP_ID}}
+          application_private_key: ${{secrets.ASTERISK_ORG_ACCESS_APP_PRIV_KEY}}
+          organization: asterisk
+
+      - name: Merge and Cherry Pick to ${{needs.IdentifyBranches.outputs.branches}}
+        id: mergecp
+        uses: asterisk/asterisk-ci-actions/MergeAndCherryPickComposite@main
+        with:
+          repo:          ${{github.repository}}
+          pr_number:     ${{env.PR_NUMBER}}
+          branches:      ${{needs.IdentifyBranches.outputs.branches}}
+          force:         ${{env.FORCE}}
+          github_token:  ${{steps.get_workflow_token.outputs.token}}
+
+      - name: Merge Cleanup
+        if: always()
+        env:
+          RESULT:    ${{ steps.mergecp.outcome }}
+          GH_TOKEN:  ${{ secrets.GITHUB_TOKEN }}
+          BRANCH_COUNT: ${{ needs.IdentifyBranches.outputs.branch_count }}
+          BRANCHES:     ${{ needs.IdentifyBranches.outputs.branches }}
+
+        run: |
+          case $RESULT in
+            success)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.MERGE_IN_PROGRESS_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              if [ $BRANCH_COUNT -eq 0 ] ; then
+                gh pr comment --repo ${{github.repository}} \
+                  -b "Successfully merged to branch $BASE_BRANCH." \
+                  ${{env.PR_NUMBER}} || :
+              else
+                gh pr comment --repo ${{github.repository}} \
+                  -b "Successfully merged to branch $BASE_BRANCH and cherry-picked to $BRANCHES" \
+                  ${{env.PR_NUMBER}} || :
+              fi
+              exit 0
+              ;;
+            failure)
+              gh pr edit --repo ${{github.repository}} \
+                --remove-label ${{vars.MERGE_IN_PROGRESS_LABEL}} \
+                --add-label ${{vars.MERGE_FAILED_LABEL}} \
+                ${{env.PR_NUMBER}} || :
+              exit 1
+              ;;
+              *)
+          esac

.github/workflows/NightlyAdmin.yml

@@ -0,0 +1,28 @@
+name: Nightly Admin
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+env:
+  ASTERISK_REPO:     ${{ github.repository }}
+  PR_NUMBER:         0
+  PR_COMMIT:         ''
+  GITHUB_TOKEN:      ${{ secrets.GITHUB_TOKEN }}
+  GH_TOKEN:          ${{ secrets.GITHUB_TOKEN }}
+  MODULES_BLACKLIST: ${{ vars.GATETEST_MODULES_BLACKLIST }} ${{ vars.UNITTEST_MODULES_BLACKLIST }}
+
+jobs:
+  CloseStaleIssues:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Close Stale Issues
+        uses: actions/stale@v7
+        with:
+          stale-issue-message: 'This issue is stale because it has been open 7 days with no activity. Remove stale label or comment or this will be closed in 14 days.'
+          stale-issue-label: stale
+          close-issue-message: 'This issue was closed because it has been stalled for 14 days with no activity.'
+          days-before-stale: 7
+          days-before-close: 14
+          days-before-pr-close: -1
+          only-labels: triage,feedback-required
+

.github/workflows/NightlyTests.yml

@@ -0,0 +1,59 @@
+name: NightlyTests
+on:
+  workflow_dispatch:
+
+  schedule:
+    - cron: '0 2 * * *'
+
+env:
+  ASTERISK_REPO:     ${{ github.repository }}
+  PR_NUMBER:         0
+  PR_COMMIT:         ''
+  GITHUB_TOKEN:      ${{ secrets.GITHUB_TOKEN }}
+  GH_TOKEN:          ${{ secrets.GITHUB_TOKEN }}
+  MODULES_BLACKLIST: ${{ vars.GATETEST_MODULES_BLACKLIST }}
+
+jobs:
+  AsteriskNightly:
+    strategy:
+      fail-fast: false
+      matrix:
+        branch: ${{ fromJSON(vars.NIGHTLYTEST_BRANCHES) }}
+        group: ${{ fromJSON(vars.NIGHTLYTEST_LIST) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Nightly Tests for ${{ matrix.group }}/${{ matrix.branch }}
+        uses: asterisk/asterisk-ci-actions/AsteriskGateComposite@main
+        with:
+          test_type:         Nightly
+          asterisk_repo:     ${{env.ASTERISK_REPO}}
+          pr_number:         ${{env.PR_NUMBER}}
+          base_branch:       ${{matrix.branch}}
+          modules_blacklist: ${{env.MODULES_BLACKLIST}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+          testsuite_repo:    ${{vars.TESTSUITE_REPO}}
+          gatetest_group:    ${{matrix.group}}
+          gatetest_command:  ${{ toJSON(fromJSON(vars.GATETEST_COMMANDS)[matrix.group]) }}
+
+  AsteriskNightlyTests:
+    if: ${{ always() }}
+    runs-on: ubuntu-latest
+    needs: AsteriskNightly
+    steps:
+      - name: Check test matrix status
+        env:
+          RESULT: ${{needs.AsteriskNightly.result}}
+        run: |
+          case $RESULT in
+            success)
+              echo "::notice::All Testsuite tests passed"
+              exit 0
+              ;;
+            skipped)
+              echo "::error::Testsuite tests were skipped because of an earlier failure"
+              exit 1
+              ;;
+              *)
+              echo "::error::One or more Testsuite tests failed"
+              exit 1
+          esac

.github/workflows/PRMerged.yml

@@ -0,0 +1,32 @@
+name: PRMerged
+run-name: "PR ${{github.event.number || inputs.pr_number}} ${{github.event.action || 'MANUAL POST MERGE'}} by ${{ github.actor }}"
+on:
+  pull_request_target:
+    types: [closed]
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'PR number'
+        required: true
+        type: number
+
+concurrency:
+  group: ${{github.workflow}}-${{github.event.number || inputs.pr_number}}
+  cancel-in-progress: true
+
+env:
+  REPO:              ${{github.repository}}
+  PR_NUMBER:         ${{github.event.number || inputs.pr_number}}
+  GITHUB_TOKEN:      ${{secrets.GITHUB_TOKEN}}
+
+jobs:
+  CloseIssues:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    steps:
+      - uses: wow-actions/auto-close-fixed-issues@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+

.github/workflows/PRSubmitActions.yml

@@ -0,0 +1,149 @@
+name: PRSubmitActions
+run-name: "PRSubmitActions: Test ${{github.event.action}}"
+on:
+  workflow_run:
+    workflows: [PRSubmitTests]
+    types:
+      - requested
+      - completed
+env:
+  ACTION:     ${{ github.event.action }}
+  CONCLUSION: ${{ github.event.workflow_run.conclusion }}
+  REPO:       ${{ github.repository }}
+
+jobs:
+  PRSubmitActions:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get PR Number
+        id: getpr
+        uses: actions/github-script@v7
+        with:
+          retries: 5
+          script: |
+            let search = `repo:${context.repo.owner}/${context.repo.repo} ${context.payload.workflow_run.head_sha}`; 
+            let prs = await github.rest.search.issuesAndPullRequests({
+                 q: search,
+              });
+            if (prs.data.total_count == 0) {
+              core.setFailed(`Unable to get PR for ${context.payload.workflow_run.head_sha}`);
+              return;
+            }
+            let pr_number = prs.data.items[0].number;
+            core.setOutput('pr_number', pr_number);
+            return;
+
+      - name: Set Label
+        id: setlabel
+        uses: actions/github-script@v7
+        env:
+          PR_NUMBER:  ${{ steps.getpr.outputs.PR_NUMBER }}
+          LABEL_TIP:  ${{ vars.PR_SUBMIT_TESTING_IN_PROGRESS }}
+          LABEL_PASS: ${{ vars.PR_SUBMIT_TESTS_PASSED }}
+          LABEL_FAIL: ${{ vars.PR_SUBMIT_TESTS_FAILED }}
+        with:
+          retries: 5
+          script: |
+            let label;
+            if (process.env.ACTION === 'requested') {
+              label = process.env.LABEL_TIP;
+            } else {
+              if ( process.env.CONCLUSION === 'success' ) {
+                label = process.env.LABEL_PASS;
+              } else {
+                label = process.env.LABEL_FAIL;
+              }
+            }
+            core.info(`Setting label ${label}`);
+            github.rest.issues.setLabels({
+              issue_number: process.env.PR_NUMBER,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              labels: [ label ]
+            });
+            return;
+
+      - name: Get cherry-pick branches
+        if: github.event.action == 'completed'
+        id: getbranches
+        uses: asterisk/asterisk-ci-actions/GetCherryPickBranchesFromPR@main
+        with:
+          repo:              ${{env.REPO}}
+          pr_number:         ${{steps.getpr.outputs.PR_NUMBER}}
+          cherry_pick_regex: ${{vars.CHERRY_PICK_REGEX}}
+          github_token:      ${{secrets.GITHUB_TOKEN}}
+
+      - name: Add cherry-pick reminder
+        if: github.event.action == 'completed'
+        uses: actions/github-script@v7
+        env:
+          PR_NUMBER:            ${{steps.getpr.outputs.PR_NUMBER}}
+          CHERRY_PICK_REMINDER: ${{vars.CHERRY_PICK_REMINDER}}
+          BRANCHES_OUTPUT:      ${{toJSON(steps.getbranches.outputs)}}
+          BRANCH_COUNT:         ${{steps.getbranches.outputs.branch_count}}
+          FORCED_NONE:          ${{steps.getbranches.outputs.forced_none}}
+        with:
+          retries: 5
+          script: |
+            if (process.env.FORCED_NONE === 'true' ||
+              process.env.BRANCH_COUNT > 0) {
+              core.info("No cherry-pick reminder needed.");
+              return;
+            }
+            let comments = await github.rest.issues.listComments({
+              issue_number: process.env.PR_NUMBER,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            });
+            let found = false;
+            for (const c of comments.data) {
+              if (c.body.startsWith("<!--CPR-->")) {
+                found = true;
+                break;
+              }
+            }
+            if (found) {
+              core.info("Cherry-pick reminder already exists.");
+              return;
+            }
+            core.info("Adding cherry-pick reminder.");
+            await github.rest.issues.createComment({
+              issue_number: process.env.PR_NUMBER,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: process.env.CHERRY_PICK_REMINDER
+            })
+            return;
+
+      - name: Add reviewers
+        if: github.event.action == 'completed'
+        uses: actions/github-script@v7
+        env:
+          PR_NUMBER: ${{steps.getpr.outputs.PR_NUMBER}}
+          REVIEWERS: ${{vars.PR_REVIEWERS}}
+        with:
+          retries: 5
+          github-token: ${{ secrets.ASTERISKTEAM_PAT }}
+          script: |
+            let rs = JSON.parse(process.env.REVIEWERS.length ? process.env.REVIEWERS : '[]');
+            let users = [];
+            let teams = [];
+            for (const r of rs) {
+              if (r.indexOf("/") > 0) {
+                teams.push(r.split('/')[1]);
+              } else {
+                users.push(r);
+              }
+            }
+            if (teams.length > 0 || users.length > 0) {
+              core.info(`Adding user reviewers ${users}`);
+              core.info(`Adding team reviewers ${teams}`);
+              await github.rest.pulls.requestReviewers({
+                pull_number: process.env.PR_NUMBER,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                reviewers: users,
+                team_reviewers: teams
+              });
+            }
+            return;

.github/workflows/PRSubmitTests.yml

@@ -0,0 +1,114 @@
+name: PRSubmitTests
+run-name: "PR ${{github.event.number}} ${{github.event.action}} by ${{ github.actor }}"
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+concurrency:
+  group: ${{github.workflow}}-${{github.event.number}}
+  cancel-in-progress: true
+
+env:
+  ASTERISK_REPO:     ${{github.repository}}
+  PR_NUMBER:         ${{github.event.number}}
+  PR_COMMIT:         ${{github.event.pull_request.head.sha}}
+  BRANCH:            ${{github.event.pull_request.base.ref}}
+
+jobs:
+#
+# Pull requests created from forked respositories don't have access to
+# the "Action Variables" ('vars' context) so we need to retrieve control
+# data from an action.
+#
+  PRSGetControlData:
+    runs-on: ubuntu-latest
+    outputs:
+      control_data:  ${{ steps.setvars.outputs.control_data }}
+    steps:
+      - id: setvars
+        uses: asterisk/asterisk-ci-actions/GetRepoControlData@main
+        with:
+          repo: ${{ github.event.repository.name}}
+      - name: DumpEnvironment
+        uses: asterisk/asterisk-ci-actions/DumpEnvironmentAction@main
+        with:
+          action-inputs: ${{toJSON(inputs)}}
+          action-vars: ${{ toJSON(steps.setvars.outputs) }}
+
+  PRSUnitTests:
+    needs: PRSGetControlData
+    runs-on: ubuntu-latest
+    env:
+      UNITTEST_COMMAND: ${{ fromJSON(needs.PRSGetControlData.outputs.control_data).UNITTEST_COMMAND }}
+    steps:
+      - name: Run Unit Tests
+        uses: asterisk/asterisk-ci-actions/AsteriskUnitComposite@main
+        with:
+          asterisk_repo:     ${{env.ASTERISK_REPO}}
+          pr_number:         ${{env.PR_NUMBER}}
+          base_branch:       ${{env.BRANCH}}
+          unittest_command:  ${{env.UNITTEST_COMMAND}}
+
+  PRSGateTestMatrix:
+    runs-on: ubuntu-latest
+    needs: PRSGetControlData
+    continue-on-error: false
+    strategy:
+      fail-fast: false
+      matrix:
+        group: ${{ fromJSON(fromJSON(needs.PRSGetControlData.outputs.control_data).GATETEST_LIST) }}
+    env:
+      TESTSUITE_REPO:    "${{ fromJSON(needs.PRSGetControlData.outputs.control_data).TESTSUITE_REPO }}"
+      GATETEST_COMMANDS: "${{ fromJSON(needs.PRSGetControlData.outputs.control_data).GATETEST_COMMANDS }}"
+      GATETEST_COMMAND: "${{ toJSON(fromJSON(fromJSON(needs.PRSGetControlData.outputs.control_data).GATETEST_COMMANDS)[matrix.group]) }}"
+    steps:
+      - id: runtest
+        name: Run Gate Tests for ${{ matrix.group }}
+        uses: asterisk/asterisk-ci-actions/AsteriskGateComposite@main
+        with:
+          test_type:         Gate
+          asterisk_repo:     ${{env.ASTERISK_REPO}}
+          pr_number:         ${{env.PR_NUMBER}}
+          base_branch:       ${{env.BRANCH}}
+          testsuite_repo:    ${{env.TESTSUITE_REPO}}
+          gatetest_group:    ${{matrix.group}}
+          gatetest_command:  ${{env.GATETEST_COMMAND}}
+
+  PRSTestResults:
+    if: always()
+    runs-on: ubuntu-latest
+    needs: [PRSUnitTests,PRSGateTestMatrix]
+    steps:
+      - name: Check test matrix status
+        env:
+          RESULT_UNIT: ${{ needs.PRSUnitTests.result }}
+          RESULT_GATE: ${{ needs.PRSGateTestMatrix.result }}
+        run: |
+          declare -i rc=0
+          echo "all results: ${{ toJSON(needs.*.result) }}"
+          case $RESULT_UNIT in
+            success)
+              echo "::notice::Unit tests passed"
+              ;;
+            skipped)
+              echo "::error::Unit tests were skipped because of an earlier failure"
+              rc+=1
+              ;;
+            *)
+              echo "::error::One or more unit tests failed ($RESULT_UNIT)"
+              rc+=1
+          esac
+          case $RESULT_GATE in
+            success)
+              echo "::notice::Gate tests passed"
+              ;;
+            skipped)
+              echo "::error::Gate tests were skipped because of an earlier failure"
+              rc+=1
+              ;;
+            *)
+              echo "::error::One or more gate tests failed ($RESULT_GATE)"
+              rc+=1
+          esac
+          echo "::notice::Final result code: $rc"
+          exit $rc

.github/workflows/Releaser.yml

@@ -0,0 +1,99 @@
+name: Releaser
+run-name: ${{ github.actor }} is creating ${{vars.PRODUCT_NAME}} release ${{inputs.new_version}}
+on:
+  workflow_dispatch:
+    inputs:
+      new_version:
+        description: |
+          New Version:
+          Examples:
+            20.4.0-rc1, 20.4.0-rc2, 20.4.0, 20.4.1
+            certified-20.4-cert1-rc1, certified-20.4-cert1
+        required: true
+        type: string
+      is_security:
+        description: |
+          Security?
+          (No prev RCs)
+        required: true
+        type: boolean
+        default: false
+      advisories:
+        description: |
+          Comma separated list of advisories.
+          NO SPACES
+          Example: GHSA-4xjp-22g4-9fxm,GHSA-4xjp-22g4-zzzz
+        required: false
+        type: string
+      is_hotfix:
+        description: |
+          Hotfix?
+          (A patch release but not security.  No prev RCs)
+        required: true
+        type: boolean
+        default: false
+      force_cherry_pick:
+        description: |
+          Force cherry-pick for non-RC1 releases? USE WITH CAUTION!
+        required: true
+        type: boolean
+        default: false
+      push_release_branches:
+        description: |
+          Push release branches live?
+        required: true
+        type: boolean
+        default: false
+      create_github_release:
+        description: |
+          Create the GitHub release?
+        required: true
+        type: boolean
+        default: false
+      push_tarballs:
+        description: |
+          Push tarballs to downloads server?
+        required: true
+        type: boolean
+        default: false
+      send_email:
+        description: |
+          Send announcement emails?
+        required: true
+        type: boolean
+        default: false
+
+jobs:
+  ReleaseAsterisk:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Releaser
+        uses: asterisk/asterisk-ci-actions/ReleaserComposite@main
+        with:
+          product: ${{vars.PRODUCT_NAME}}
+          is_security: ${{inputs.is_security}}
+          advisories: ${{inputs.advisories}}
+          is_hotfix: ${{inputs.is_hotfix}}
+          new_version: ${{inputs.new_version}}
+          force_cherry_pick: ${{inputs.force_cherry_pick}}
+          push_release_branches: ${{inputs.push_release_branches}}
+          create_github_release: ${{inputs.create_github_release}}
+          push_tarballs: ${{inputs.push_tarballs}}
+          send_email: ${{inputs.send_email}}
+          repo: ${{github.repository}}
+          mail_list_ga: ${{vars.MAIL_LIST_GA}}
+          mail_list_rc: ${{vars.MAIL_LIST_RC}}
+          mail_list_cert_ga: ${{vars.MAIL_LIST_CERT_GA}}
+          mail_list_cert_rc: ${{vars.MAIL_LIST_CERT_RC}}
+          mail_list_sec: ${{vars.MAIL_LIST_SEC_ADV}}
+          sec_adv_url_base: ${{vars.SEC_ADV_URL_BASE}}
+          gpg_private_key: ${{secrets.ASTDEV_GPG_PRIV_KEY}}
+          github_token: ${{secrets.GITHUB_TOKEN}}
+          application_id: ${{secrets.ASTERISK_ORG_ACCESS_APP_ID}}
+          application_private_key: ${{secrets.ASTERISK_ORG_ACCESS_APP_PRIV_KEY}}
+          asteriskteamsa_username: ${{secrets.ASTERISKTEAMSA_GMAIL_ACCT}}
+          asteriskteamsa_token: ${{secrets.ASTERISKTEAMSA_GMAIL_TOKEN}}
+          deploy_ssh_priv_key: ${{secrets.DOWNLOADS_DEPLOY_SSH_PRIV_KEY}}
+          deploy_ssh_username: ${{secrets.DOWNLOADS_DEPLOY_SSH_USERNAME}}
+          deploy_host: ${{vars.DEPLOY_HOST}}
+          deploy_dir: ${{vars.DEPLOY_DIR}}

.gitreview

@@ -1,10 +0,0 @@
-[gerrit]
-defaultbranch=master
-#
-# Intentional padding to ensure it is possible to point a commit
-# to an alternative gerrit server/repository without breaking
-# cherry-pick between branches.
-#
-host=gerrit.asterisk.org
-port=29418
-project=asterisk.git

BUGS

@@ -1,22 +1,22 @@
 Asterisk Bug Tracking Information
 =================================
 
-To learn about and report Asterisk bugs, please visit 
+To learn about and report Asterisk bugs, please visit
 the official Asterisk Bug Tracker at:
 
-	https://issues.asterisk.org/jira
+	https://github.com/asterisk/asterisk/issues/
 
-For more information on using the bug tracker, or to 
+For more information on using the bug tracker, or to
 learn how you can contribute by acting as a bug marshal
 please see:
 
-	http://www.asterisk.org/developers/bug-guidelines
+	https://wiki.asterisk.org/wiki/x/RgAtAQ
 
 If you would like to submit a feature request, please
 resist the temptation to post it to the bug tracker.
 Feature requests should be posted to the asterisk-dev
 mailing list, located at:
 
-	http://lists.digium.com 
+	http://lists.digium.com
 
 Thank you!

CREDITS

@@ -40,7 +40,7 @@
 		rewrite of SIP transfers
 
 
-=== WISHLIST CONTRIBUTERS ===
+=== WISHLIST CONTRIBUTORS ===
 
  We'd like to thank the following for contributing to our wishlist
 

Makefile

@@ -21,7 +21,7 @@
 #      on a single object just for that object
 # SOLINK - linker flags used only for creating dynamically loadable modules
 #          as .so files
-# DYLINK - linker flags used only for creating shared libaries
+# DYLINK - linker flags used only for creating shared libraries
 #          (.so files on Unix-type platforms, .dylib on Darwin)
 #
 # Values for ASTCFLAGS and ASTLDFLAGS can be specified in the
@@ -49,6 +49,7 @@ DESTDIR?=$(INSTALL_PATH)
 export DESTDIR
 
 export INSTALL_PATH       # Additional prefix for the following paths
+export ASTCACHEDIR
 export ASTETCDIR          # Path for config files
 export ASTVARRUNDIR
 export ASTSPOOLDIR
@@ -134,7 +135,7 @@ empty:=
 space:=$(empty) $(empty)
 ASTTOPDIR:=$(subst $(space),\$(space),$(CURDIR))
 
-# Overwite config files on "make samples" or other config installation targets
+# Overwrite config files on "make samples" or other config installation targets
 OVERWRITE=y
 
 # Include debug and macro symbols in the executables (-g) and profiling info (-pg)
@@ -249,7 +250,7 @@ else
 endif
 ifneq ($(AWK),)
   ifneq ($(wildcard .version),)
-    ASTERISKVERSIONNUM:=$(shell $(AWK) -F. '{printf "%01d%02d%02d", $$1, $$2, $$3}' .version)
+    ASTERISKVERSIONNUM:=$(shell $(SED) -e 's/^certified\///' -e 's/-cert/./' .version | $(AWK) -F. '{printf "%01d%02d%02d", $$1, $$2, $$3}')
   endif
 endif
 
@@ -368,7 +369,7 @@ $(MOD_SUBDIRS_MENUSELECT_TREE):
 	+@$(SUBMAKE) -C $(@:-menuselect-tree=) SUBDIR=$(@:-menuselect-tree=) moduleinfo
 	+@$(SUBMAKE) -C $(@:-menuselect-tree=) SUBDIR=$(@:-menuselect-tree=) makeopts
 
-$(SUBDIRS): makeopts .lastclean main/version.c include/asterisk/build.h include/asterisk/buildopts.h defaults.h
+$(SUBDIRS): makeopts .lastclean main/version.c include/asterisk/build.h defaults.h
 
 ifeq ($(findstring $(OSARCH), mingw32 cygwin ),)
 main: third-party
@@ -394,7 +395,7 @@ defaults.h: makeopts .lastclean build_tools/make_defaults_h
 	@cmp -s $@.tmp $@ || mv $@.tmp $@
 	@rm -f $@.tmp
 
-main/version.c: FORCE menuselect.makeopts .lastclean
+main/version.c: FORCE include/asterisk/buildopts.h menuselect.makeopts .lastclean
 	@build_tools/make_version_c > $@.tmp
 	@cmp -s $@.tmp $@ || mv $@.tmp $@
 	@rm -f $@.tmp
@@ -474,53 +475,24 @@ endif
 		$(INSTALL) -m 644 $$x "$(DESTDIR)$(ASTDATADIR)/rest-api" ; \
 	done
 
-ifeq ($(GREP),)
-else ifeq ($(GREP),:)
-else
-  XML_core_en_US = $(foreach dir,$(MOD_SUBDIRS),$(shell $(GREP) -l "language=\"en_US\"" $(dir)/*.c $(dir)/*.cc 2>/dev/null))
-endif
-
+DOC_MOD_SUBDIRS := $(filter-out third-party,$(MOD_SUBDIRS))
+XML_core_en_US := $(shell build_tools/make_xml_documentation --command=print_dependencies --source-tree=. --mod-subdirs="$(DOC_MOD_SUBDIRS)")
+# core-en_US.xml is the normal documentation created with asterisk builds.
 doc/core-en_US.xml: makeopts .lastclean $(XML_core_en_US)
-	@printf "Building Documentation For: "
-	@echo "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" > $@
-	@echo "<!DOCTYPE docs SYSTEM \"appdocsxml.dtd\">" >> $@
-	@echo "<?xml-stylesheet type=\"text/xsl\" href=\"appdocsxml.xslt\"?>" >> $@
-	@echo "<docs xmlns:xi=\"http://www.w3.org/2001/XInclude\">" >> $@
-	@for x in $(MOD_SUBDIRS); do \
-		printf "$$x " ; \
-		for i in `find $$x -name '*.c'`; do \
-			$(AWK) -f build_tools/get_documentation $$i >> $@ ; \
-		done ; \
-	done
-	@echo
-	@echo "</docs>" >> $@
+	@build_tools/make_xml_documentation --command=create_xml --source-tree=. --mod-subdirs="$(DOC_MOD_SUBDIRS)" \
+		--with-moduleinfo --validate --output-file=$@
 
-ifeq ($(GREP),)
-else ifeq ($(GREP),:)
-else
-  XML_full_en_US = $(foreach dir,$(MOD_SUBDIRS),$(shell $(GREP) -l "language=\"en_US\"" $(dir)/*.c $(dir)/*.cc 2>/dev/null))
-endif
-
-doc/full-en_US.xml: makeopts .lastclean $(XML_full_en_US)
+# The full-en_US.xml target is only called by the wiki documentation generation process
+# and does special post-processing in preparation for uploading to the wiki.
+# It creates full-en_US.xml but then re-creates core-en_US.xml as well.
+doc/full-en_US.xml: makeopts .lastclean $(XML_core_en_US)
 ifeq ($(PYTHON),:)
 	@echo "--------------------------------------------------------------------------"
 	@echo "---        Please install python to build full documentation           ---"
 	@echo "--------------------------------------------------------------------------"
 else
-	@printf "Building Documentation For: "
-	@echo "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" > $@
-	@echo "<!DOCTYPE docs SYSTEM \"appdocsxml.dtd\">" >> $@
-	@echo "<?xml-stylesheet type=\"text/xsl\" href=\"appdocsxml.xslt\"?>" >> $@
-	@echo "<docs xmlns:xi=\"http://www.w3.org/2001/XInclude\">" >> $@
-	@for x in $(filter-out third-party,$(MOD_SUBDIRS)); do \
-		printf "$$x " ; \
-		for i in `find $$x -name '*.c'`; do \
-			$(PYTHON) build_tools/get_documentation.py < $$i >> $@ ; \
-		done ; \
-	done
-	@echo
-	@echo "</docs>" >> $@
-	@$(PYTHON) build_tools/post_process_documentation.py -i $@ -o "doc/core-en_US.xml"
+	@build_tools/make_xml_documentation --command=create_xml --source-tree=. --mod-subdirs="$(DOC_MOD_SUBDIRS)" \
+		--for-wiki --validate --output-file=$@ --core-output-file=./doc/core-en_US.xml
 endif
 
 validate-docs: doc/core-en_US.xml
@@ -555,7 +527,7 @@ update:
 
 NEWHEADERS=$(notdir $(wildcard include/asterisk/*.h))
 OLDHEADERS=$(filter-out $(NEWHEADERS) $(notdir $(DESTDIR)$(ASTHEADERDIR)),$(notdir $(wildcard $(DESTDIR)$(ASTHEADERDIR)/*.h)))
-INSTALLDIRS="$(ASTLIBDIR)" "$(ASTMODDIR)" "$(ASTSBINDIR)" "$(ASTETCDIR)" "$(ASTVARRUNDIR)" \
+INSTALLDIRS="$(ASTLIBDIR)" "$(ASTMODDIR)" "$(ASTSBINDIR)" "$(ASTCACHEDIR)" "$(ASTETCDIR)" "$(ASTVARRUNDIR)" \
 	"$(ASTSPOOLDIR)" "$(ASTSPOOLDIR)/dictate" "$(ASTSPOOLDIR)/meetme" \
 	"$(ASTSPOOLDIR)/monitor" "$(ASTSPOOLDIR)/system" "$(ASTSPOOLDIR)/tmp" \
 	"$(ASTSPOOLDIR)/voicemail" "$(ASTSPOOLDIR)/recording" \
@@ -779,7 +751,8 @@ define INSTALL_CONFIGS
 	done ; \
 	if [ "$(OVERWRITE)" = "y" ]; then \
 		echo "Updating asterisk.conf" ; \
-		sed -e 's|^astetcdir.*$$|astetcdir => $(ASTETCDIR)|' \
+		sed -e 's|^astcachedir.*$$|astcachedir => $(ASTCACHEDIR)|' \
+			-e 's|^astetcdir.*$$|astetcdir => $(ASTETCDIR)|' \
 			-e 's|^astmoddir.*$$|astmoddir => $(ASTMODDIR)|' \
 			-e 's|^astvarlibdir.*$$|astvarlibdir => $(ASTVARLIBDIR)|' \
 			-e 's|^astdbdir.*$$|astdbdir => $(ASTDBDIR)|' \
@@ -1119,7 +1092,8 @@ ifeq ($(PYTHON),:)
 else
 	@$(INSTALL) -d doc/rest-api
 	$(PYTHON) rest-api-templates/make_ari_stubs.py \
-		rest-api/resources.json .
+		--resources rest-api/resources.json --source-dir $(ASTTOPDIR) \
+		--dest-dir $(ASTTOPDIR)/doc/rest-api --docs-prefix ../
 endif
 
 check-alembic: makeopts

Makefile.rules

@@ -204,4 +204,19 @@ endif
 	$(ECHO_PREFIX) echo "   [LD] $^ -> $@"
 	$(CMD_PREFIX) $(CXX) -o $@ $(PTHREAD_CFLAGS) $(_ASTLDFLAGS) $^ $(CXX_LIBS) $(ASTLDFLAGS)
 
+# These CC commands just create an object file with the input file embedded in it.
+# It can be access from code as follows:
+# If your input file is named abc_def.xml...
+#
+# extern const uint8_t _binary_abc_def_xml_start[];
+# extern const uint8_t _binary_abc_def_xml_end[];
+# extern const size_t _binary_abc_def_xml_size;
+%.o: %.xml
+	$(ECHO_PREFIX) echo "   [LD] $^ -> $@"
+	$(CMD_PREFIX) $(CC) -g -Wl,-znoexecstack -nostartfiles  -nodefaultlibs -nostdlib -r -Wl,-b,binary -o $@ $^
+
+%.o: %.xslt
+	$(ECHO_PREFIX) echo "   [LD] $^ -> $@"
+	$(CMD_PREFIX) $(CC) -g -Wl,-znoexecstack -nostartfiles  -nodefaultlibs -nostdlib -r -Wl,-b,binary -o $@ $^
+
 dist-clean:: clean

README.md

@@ -1,7 +1,7 @@
 # The Asterisk(R) Open Source PBX
 ```text
         By Mark Spencer <markster@digium.com> and the Asterisk.org developer community.
-        Copyright (C) 2001-2019 Digium, Inc. and other copyright holders.
+        Copyright (C) 2001-2021 Sangoma Technologies Corporation and other copyright holders.
 ```
 ## SECURITY
 
@@ -47,7 +47,7 @@ and the BSD variants.
 ANY special hardware, not even a sound card) to install and run Asterisk.
 
 Supported telephony hardware includes:
-* All Analog and Digital Interface cards from [Digium]
+* All Analog and Digital Interface cards from [Sangoma]
 * QuickNet Internet PhoneJack and LineJack (http://www.quicknet.net)
 * any full duplex sound card supported by ALSA, OSS, or PortAudio
 * any ISDN card supported by mISDN on Linux
@@ -251,7 +251,7 @@ Welcome to the growing worldwide community of Asterisk users!
 
 ---
 
-Asterisk is a trademark of Digium, Inc.
+Asterisk is a trademark of Sangoma Technologies Corporation
 
 [home page]: https://www.asterisk.org
 [support]: https://www.asterisk.org/support
@@ -261,7 +261,7 @@ Asterisk is a trademark of Digium, Inc.
 [voip-info.org]: http://www.voip-info.org/wiki-Asterisk
 [asteriskdocs.org]: http://www.asteriskdocs.org
 [NTP]: http://www.ntp.org/
-[Digium]: https://www.digium.com/
+[Sangoma]: https://www.sangoma.com/
 [UPGRADE.txt]: UPGRADE.txt
 [CHANGES]: CHANGES
 [configs]: configs

SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+## Supported Versions
+
+The Asterisk project maintains a [documentation page](https://docs.asterisk.org/About-the-Project/Asterisk-Versions/) of releases. Each version is listed with its release date, security fix only date, and end of life date. Consult this wiki page to see if the version of Asterisk you are reporting a security vulnerability against is still supported.
+
+## Reporting a Vulnerability
+
+To report a vulnerability use the "Report a vulnerability" button under the "Security" tab of this project.

addons/Makefile

@@ -64,6 +64,10 @@ chan_ooh323.so: _ASTCFLAGS+=$(H323CFLAGS)
 $(call MOD_ADD_C,chan_ooh323,$(H323SOURCE))
 
 ifneq ($(wildcard mp3/Makefile),)
+# At the current time, the fate of mp3 is in flux so it didn't make sense to
+# add configure/makeopts processing for array-bounds since this is the only
+# source file that needs that warning suppressed.
+mp3/layer3.o: _ASTCFLAGS+=-Wno-array-bounds
 $(call MOD_ADD_C,format_mp3,mp3/common.c mp3/dct64_i386.c mp3/decode_ntom.c mp3/layer3.c mp3/tabinit.c mp3/interface.c)
 
 .PHONY: check_mp3

addons/app_mysql.c

@@ -37,6 +37,8 @@
 	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
 	<replacement>func_odbc</replacement>
+	<deprecated_in>1.8</deprecated_in>
+	<removed_in>19</removed_in>
  ***/
 
 #include "asterisk.h"

addons/cdr_mysql.c

@@ -38,6 +38,8 @@
 	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
 	<replacement>cdr_adaptive_odbc</replacement>
+	<deprecated_in>1.8</deprecated_in>
+	<removed_in>19</removed_in>
  ***/
 
 #include "asterisk.h"

addons/chan_mobile.c

@@ -102,7 +102,7 @@ struct adapter_pvt {
 	char id[31];					/* the 'name' from mobile.conf */
 	bdaddr_t addr;					/* adddress of adapter */
 	unsigned int inuse:1;				/* are we in use ? */
-	unsigned int alignment_detection:1;		/* do alignment detection on this adpater? */
+	unsigned int alignment_detection:1;		/* do alignment detection on this adapter? */
 	struct io_context *io;				/*!< io context for audio connections */
 	struct io_context *accept_io;			/*!< io context for sco listener */
 	int *sco_id;					/*!< the io context id of the sco listener socket */
@@ -2006,7 +2006,7 @@ static int at_match_prefix(char *buf, char *prefix)
 }
 
 /*!
- * \brief Read an AT message and clasify it.
+ * \brief Read an AT message and classify it.
  * \param rsock an rfcomm socket
  * \param buf the buffer to store the result in
  * \param count the size of the buffer or the maximum number of characters to read
@@ -2156,10 +2156,12 @@ static inline const char *at_msg2str(at_message_t msg)
  * \param buf the buffer to parse (null terminated)
  * \return -1 on error (parse error) or a ECAM value on success
  *
- * Example string: *ECAV: <ccid>,<ccstatus>,<calltype>[,<processid>]
- * [,exitcause][,<number>,<type>]
+ * Example:
+ * \verbatim *ECAV: <ccid>,<ccstatus>,<calltype>[,<processid>]
+                    [,exitcause][,<number>,<type>] \endverbatim
  *
- * Example indicating busy: *ECAV: 1,7,1
+ * Example indicating busy:
+ * \verbatim *ECAV: 1,7,1 \endverbatim
  */
 static int hfp_parse_ecav(struct hfp_pvt *hfp, char *buf)
 {
@@ -2176,7 +2178,7 @@ static int hfp_parse_ecav(struct hfp_pvt *hfp, char *buf)
 }
 
 /*!
- * \brief Enable Sony Erricson extensions / indications.
+ * \brief Enable Sony Ericsson extensions / indications.
  * \param hfp an hfp_pvt struct
  */
 static int hfp_send_ecam(struct hfp_pvt *hfp)
@@ -3040,7 +3042,7 @@ static void msg_queue_free_and_pop(struct mbl_pvt *pvt)
 }
 
 /*!
- * \brief Remove all itmes from the queue and free them.
+ * \brief Remove all items from the queue and free them.
  * \param pvt a mbl_pvt structure
  */
 static void msg_queue_flush(struct mbl_pvt *pvt)
@@ -3347,7 +3349,7 @@ static int handle_response_ok(struct mbl_pvt *pvt, char *buf)
 			}
 			break;
 		case AT_CLIP:
-			ast_debug(1, "[%s] caling line indication enabled\n", pvt->id);
+			ast_debug(1, "[%s] calling line indication enabled\n", pvt->id);
 			if (hfp_send_ecam(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_ECAM)) {
 				ast_debug(1, "[%s] error enabling Sony Ericsson call monitoring extensions\n", pvt->id);
 				goto e_return;
@@ -3567,7 +3569,7 @@ static int handle_response_ciev(struct mbl_pvt *pvt, char *buf)
 			if (pvt->owner) {
 				ast_debug(1, "[%s] hanging up owner\n", pvt->id);
 				if (mbl_queue_hangup(pvt)) {
-					ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id);
+					ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnecting...\n", pvt->id);
 					return -1;
 				}
 			}
@@ -3601,7 +3603,7 @@ static int handle_response_ciev(struct mbl_pvt *pvt, char *buf)
 						handle_response_busy(pvt);
 					}
 					if (mbl_queue_hangup(pvt)) {
-						ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id);
+						ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnecting...\n", pvt->id);
 						return -1;
 					}
 				}
@@ -4431,7 +4433,7 @@ static struct adapter_pvt *mbl_load_adapter(struct ast_config *cfg, const char *
 
 	/* bind the sco listener socket */
 	if (sco_bind(adapter) < 0) {
-		ast_log(LOG_ERROR, "Skipping adapter %s. Error binding audio connection listerner socket.\n", adapter->id);
+		ast_log(LOG_ERROR, "Skipping adapter %s. Error binding audio connection listener socket.\n", adapter->id);
 		goto e_destroy_io;
 	}
 
@@ -4443,7 +4445,7 @@ static struct adapter_pvt *mbl_load_adapter(struct ast_config *cfg, const char *
 
 	/* start the sco listener for this adapter */
 	if (ast_pthread_create_background(&adapter->sco_listener_thread, NULL, do_sco_listen, adapter)) {
-		ast_log(LOG_ERROR, "Skipping adapter %s. Error creating audio connection listerner thread.\n", adapter->id);
+		ast_log(LOG_ERROR, "Skipping adapter %s. Error creating audio connection listener thread.\n", adapter->id);
 		goto e_remove_sco;
 	}
 
@@ -4499,7 +4501,7 @@ static struct mbl_pvt *mbl_load_device(struct ast_config *cfg, const char *cat)
 	}
 	AST_RWLIST_UNLOCK(&adapters);
 	if (!adapter) {
-		ast_log(LOG_ERROR, "Skiping device %s. Unknown adapter '%s' specified.\n", cat, adapter_str);
+		ast_log(LOG_ERROR, "Skipping device %s. Unknown adapter '%s' specified.\n", cat, adapter_str);
 		goto e_return;
 	}
 

addons/chan_ooh323.c

@@ -2055,7 +2055,7 @@ int onOutgoingCall(ooCallData *call)
 			}
 			ooCallAddAliasDialedDigits(call, p->caller_dialedDigits);
 		} else if (!ast_strlen_zero(p->callerid_num)) {
-			if (ooIsDailedDigit(p->callerid_num)) {
+			if (ooIsDialedDigit(p->callerid_num)) {
 				if (gH323Debug) {
 					ast_verb(0, "setting callid number %s\n", p->callerid_num);
 				}
@@ -2136,7 +2136,7 @@ int onNewCallCreated(ooCallData *call)
 			}
 			ooCallAddAliasDialedDigits(call, p->caller_dialedDigits);
 		} else if (!ast_strlen_zero(p->callerid_num)) {
-			if (ooIsDailedDigit(p->callerid_num)) {
+			if (ooIsDialedDigit(p->callerid_num)) {
 				if (gH323Debug) {
 					ast_verb(0, "setting callid number %s\n", p->callerid_num);
 				}
@@ -2148,7 +2148,7 @@ int onNewCallCreated(ooCallData *call)
 
 
 		if (!ast_strlen_zero(p->exten))  {
-			if (ooIsDailedDigit(p->exten)) {
+			if (ooIsDialedDigit(p->exten)) {
 				ooCallSetCalledPartyNumber(call, p->exten);
 				ooCallAddRemoteAliasDialedDigits(call, p->exten);
 			} else {

addons/ooh323c/README

@@ -75,7 +75,7 @@ To run the stack test application chansetup
 3. For running calling instance
 
         ./h323peer [--use-ip ip] -n <number of calls> -duration <call duration>
-                   -interval <inetrval between successive calls> destination
+                   -interval <interval between successive calls> destination
 
    where all times are in seconds. Interval of 0 means next call will be placed
    after current call finishes. "destination" is the dotted ip address of the

addons/ooh323c/src/decode.c

@@ -417,7 +417,7 @@ int decodeDynBitString (OOCTXT* pctxt, ASN1DynBitStr* pBitStr)
    ASN1OCTET* ptmp;
    int nbits, stat = ASN_OK;
 
-   /* If "fast copy" option is not set (ASN1FATSCOPY) or if constructed,
+   /* If "fast copy" option is not set (ASN1FASTCOPY) or if constructed,
     * copy the bit string value into a dynamic memory buffer;
     * otherwise, store the pointer to the value in the decode
     * buffer in the data pointer argument. */

addons/ooh323c/src/encode.c

@@ -1007,7 +1007,7 @@ int encode2sCompBinInt (OOCTXT* pctxt, ASN1INT value)
 {
    /* 10.4.6  A minimum octet 2's-complement-binary-integer encoding    */
    /* of the whole number has a field width that is a multiple of 8     */
-   /* bits and also satisifies the condition that the leading 9 bits    */
+   /* bits and also satisfies the condition that the leading 9 bits     */
    /* field shall not be all zeros and shall not be all ones.           */
 
    /* first encode integer value into a local buffer */
@@ -1048,7 +1048,7 @@ static int encodeNonNegBinInt (OOCTXT* pctxt, ASN1UINT value)
    /* 10.3.6  A minimum octet non-negative binary integer encoding of   */
    /* the whole number (which does not predetermine the number of       */
    /* octets to be used for the encoding) has a field which is a        */
-   /* multiple of 8 bits and also satisifies the condition that the     */
+   /* multiple of 8 bits and also satisfies the condition that the      */
    /* leading eight bits of the field shall not be zero unless the      */
    /* field is precisely 8 bits long.                                   */
 

addons/ooh323c/src/eventHandler.h

@@ -49,7 +49,7 @@ extern "C" {
  * SEQUENCE OF, SET OF, or CHOICE construct is parsed.
  *
  * @param name         For SEQUENCE, SET, or CHOICE, this is the name of the
- *                       element as defined in the ASN.1 defination. For
+ *                       element as defined in the ASN.1 definition. For
  *                       SEQUENCE OF or SET OF, this is set to the name
  *                       "element".
  * @param index        For SEQUENCE, SET, or CHOICE, this is not used and is
@@ -68,7 +68,7 @@ typedef void (*StartElement) (const char* name, int index) ;
  * SEQUENCE, SET, SEQUENCE OF, SET OF, or CHOICE construct.
  *
  * @param name         For SEQUENCE, SET, or CHOICE, this is the name of the
- *                       element as defined in the ASN.1 defination. For
+ *                       element as defined in the ASN.1 definition. For
  *                       SEQUENCE OF or SET OF, this is set to the name
  *                       "element".
  * @param index        For SEQUENCE, SET, or CHOICE, this is not used and is
@@ -194,7 +194,7 @@ typedef void (*EnumValue) (ASN1UINT value) ;
  * within a decode function when an ASN.1 open type is parsed.
  *
  * @param numocts      Number of octets in the parsed value.
- * @param data         Pointer to byet array contain in tencoded ASN.1
+ * @param data         Pointer to byte array contain in tencoded ASN.1
  *                       value.
  * @return             - none
  */

addons/ooh323c/src/h323/H323-MESSAGES.h

@@ -1926,7 +1926,7 @@ typedef struct EXTERN H225SecurityCapabilities {
    } m;
    H225NonStandardParameter nonStandard;
    H225SecurityServiceMode encryption;
-   H225SecurityServiceMode authenticaton;
+   H225SecurityServiceMode authentication;
    H225SecurityServiceMode integrity;
 } H225SecurityCapabilities;
 

addons/ooh323c/src/h323/H323-MESSAGESDec.c

@@ -6357,14 +6357,14 @@ EXTERN int asn1PD_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilit
 
    invokeEndElement (pctxt, "encryption", -1);
 
-   /* decode authenticaton */
+   /* decode authentication */
 
-   invokeStartElement (pctxt, "authenticaton", -1);
+   invokeStartElement (pctxt, "authentication", -1);
 
-   stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->authenticaton);
+   stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->authentication);
    if (stat != ASN_OK) return stat;
 
-   invokeEndElement (pctxt, "authenticaton", -1);
+   invokeEndElement (pctxt, "authentication", -1);
 
    /* decode integrity */
 

addons/ooh323c/src/h323/H323-MESSAGESEnc.c

@@ -4408,9 +4408,9 @@ EXTERN int asn1PE_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilit
    stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->encryption);
    if (stat != ASN_OK) return stat;
 
-   /* encode authenticaton */
+   /* encode authentication */
 
-   stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->authenticaton);
+   stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->authentication);
    if (stat != ASN_OK) return stat;
 
    /* encode integrity */

addons/ooh323c/src/memheap.c

@@ -265,7 +265,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
                   if (nunits <= (ASN1UINT)pElem_nunits (pElem)) {
                      RTMEMDIAG3
                         ("memHeapAlloc: "
-                         "found an exisiting free element 0x%x, size %d\n",
+                         "found an existing free element 0x%x, size %d\n",
                         pElem, (pElem_nunits (pElem) * 8u));
 
                      if (pMemBlk->freeElemOff ==
@@ -373,7 +373,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
          CHECKMEMBLOCK (pMemHeap, pMemBlk);
       }
       else  {
-	 ast_mutex_unlock(&pMemHeap->pLock);
+	      ast_mutex_unlock(&pMemHeap->pLock);
          return NULL;
       }
    }
@@ -753,9 +753,10 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
              if (newMemBlk == 0)
                 return 0;
              pMemLink->pMemBlk = newMemBlk;
-	 }
-         else
+	      }
+         else {
             return 0;
+         }
          *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes_;
          return pMemLink->pMemBlk;
       }
@@ -1132,7 +1133,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
          RTMEMDIAG2 ("memHeapMarkSaved: the element 0x%x is "
                          "already free!\n", pElem);
 
-	 ast_mutex_unlock(&pMemHeap->pLock);
+	      ast_mutex_unlock(&pMemHeap->pLock);
          return 0;
       }
 
@@ -1151,9 +1152,10 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
             CLEAR_SAVED (pMemBlk, pElem);
          nsaved = pMemBlk->nsaved;
       }
-      else
-	 ast_mutex_unlock(&pMemHeap->pLock);
-         return 0;
+      else {
+	      ast_mutex_unlock(&pMemHeap->pLock);
+      }
+      return 0;
    }
    if (saved && nsaved > 0)
       pMemLink->blockType |= RTMEMSAVED;
@@ -1212,7 +1214,7 @@ static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
 
    /* if pMemBlk has RTMEMLINK flags it means that it is allocated
     * cooperatively with OSMemLink, and we don't need to do additional
-    * allocations for it. Just use pointer's arithemtic. */
+    * allocations for it. Just use pointer's arithmetic. */
 
    if (blockType & RTMEMLINK)
       pMemLink = (OSMemLink*) (((ASN1OCTET*)pMemBlk) - sizeof (OSMemLink));

addons/ooh323c/src/ooCalls.c

@@ -783,7 +783,7 @@ OOH323CallData* ooFindCallByToken(const char *callToken)
 
 
 
-/* Checks whether session with suplied ID and direction is already active*/
+/* Checks whether session with supplied ID and direction is already active*/
 ASN1BOOL ooIsSessionEstablished(OOH323CallData *call, int sessionID, char* dir)
 {
    OOLogicalChannel * temp = NULL;

addons/ooh323c/src/ooCapability.h

@@ -294,7 +294,7 @@ EXTERN int ooCapabilityDisableDTMFQ931Keypad(struct OOH323CallData *call);
  * and txframes parameters to the endpoint or call.(ex. G711, G728, G723.1,
  * G729)
  * @param call                 Handle to a call. If this is not Null, then
- *                             capability is added to call's remote enpoint
+ *                             capability is added to call's remote endpoint
  *                             capability list, else it is added to local H323
  *                             endpoint list.
  * @param cap                  Type of G711 capability to be added.
@@ -326,7 +326,7 @@ EXTERN int ooCapabilityAddSimpleCapability
  * to local endpoints capability list or to remote endpoints capability list or
  * to a call's capability list.
  * @param call                 Handle to a call. If this is not Null, then
- *                             capability is added to call's remote enpoint
+ *                             capability is added to call's remote endpoint
  *                             capability list, else it is added to local H323
  *                             endpoint list.
  * @param cap                  Type of GSM capability to be added.
@@ -357,7 +357,7 @@ int ooCapabilityAddGSMCapability(struct OOH323CallData *call, int cap,
  * capability list or to remote endpoints capability list or to a call's
  * capability list.
  * @param call                 Handle to a call. If this is not Null, then
- *                             capability is added to call's remote enpoint
+ *                             capability is added to call's remote endpoint
  *                             capability list, else it is added to local H323
  *                             endpoint list.
  * @param sqcifMPI             Minimum picture interval for encoding/decoding
@@ -396,7 +396,7 @@ EXTERN int ooCapabilityAddH263VideoCapability(struct OOH323CallData *call,
 /**
  * This function is an helper function to ooCapabilityAddH263VideoCapability.
  * @param call                 Handle to a call. If this is not Null, then
- *                             capability is added to call's remote enpoint
+ *                             capability is added to call's remote endpoint
  *                             capability list, else it is added to local H323
  *                             endpoint list.
  * @param sqcifMPI             Minimum picture interval for encoding/decoding
@@ -717,11 +717,11 @@ EXTERN int ooAppendCapToCapPrefs(struct OOH323CallData *call, int cap);
 EXTERN int ooChangeCapPrefOrder(struct OOH323CallData *call, int cap, int pos);
 
 /**
- * This function is used to preppend a particular capability to preference
+ * This function is used to prepend a particular capability to preference
  * list.
  * @param call     Handle to call, if call's preference list has to be modified
  *                 else NULL, to modify endpoint's preference list.
- * @param cap      Capability to be preppended.
+ * @param cap      Capability to be prepended.
  *
  * @return         OO_OK, on success. OO_FAILED, otherwise.
  */

addons/ooh323c/src/ooCmdChannel.c

@@ -186,7 +186,7 @@ int ooReadAndProcessStackCommand()
                 if(!pCall) {
                    OOTRACEINFO2("Call \"%s\" does not exist\n",
                                 (char*)cmd.param1);
-                   OOTRACEINFO1("Call migth be cleared/closed\n");
+                   OOTRACEINFO1("Call might be cleared/closed\n");
                 }
                 else {
                      ooSendProgress(ooFindCallByToken((char*)cmd.param1));
@@ -200,7 +200,7 @@ int ooReadAndProcessStackCommand()
                   if(!pCall) {
                      OOTRACEINFO2("Call \"%s\" does not exist\n",
                                   (char*)cmd.param1);
-                     OOTRACEINFO1("Call migth be cleared/closed\n");
+                     OOTRACEINFO1("Call might be cleared/closed\n");
                   }
                   else {
                      ooSendAlerting(ooFindCallByToken((char*)cmd.param1));

addons/ooh323c/src/ooGkClient.c

@@ -1231,7 +1231,7 @@ int ooGkClientHandleRegistrationConfirm
                                 (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
       if(!cbData)
       {
-         OOTRACEERR1("Error:Failed to allocate memory for Regisration timer."
+         OOTRACEERR1("Error:Failed to allocate memory for Registration timer."
                      "\n");
          pGkClient->state = GkClientFailed;
          return OO_FAILED;
@@ -1927,7 +1927,7 @@ int ooGkClientSendAdmissionRequest
                                (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
    if(!cbData)
    {
-      OOTRACEERR1("Error:Failed to allocate memory for Regisration timer."
+      OOTRACEERR1("Error:Failed to allocate memory for Registration timer."
                   "\n");
       pGkClient->state = GkClientFailed;
       ast_mutex_unlock(&pGkClient->Lock);

addons/ooh323c/src/ooGkClient.h

@@ -318,7 +318,7 @@ EXTERN int ooGkClientHandleRASMessage
 
 
 /**
- * This function is used to send a message on Gatekeeper clien't RAS channel.
+ * This function is used to send a message on Gatekeeper client RAS channel.
  * @param pGkClient   Handle to the gatekeeper client.
  * @param pRasMsg     Handle to Ras message to be sent.
  *

addons/ooh323c/src/ooLogChan.c

@@ -78,7 +78,7 @@ OOLogicalChannel* ooAddNewLogicalChannel(OOH323CallData *call, int channelNo,
       OOTRACEDBGC3("Using configured media info (%s, %s)\n", call->callType,
                    call->callToken);
       pNewChannel->localRtpPort = pMediaInfo->lMediaRedirPort ? pMediaInfo->lMediaRedirPort : pMediaInfo->lMediaPort;
-      /* check MediaRedirPort here because RedirCPort is ReditPort + 1 and can't be 0 ;) */
+      /* check MediaRedirPort here because RedirCPort is RedirPort + 1 and can't be 0 ;) */
       pNewChannel->localRtcpPort = pMediaInfo->lMediaRedirPort ? pMediaInfo->lMediaRedirCPort : pMediaInfo->lMediaCntrlPort;
       /* If user application has not specified a specific ip and is using
          multihomed mode, substitute appropriate ip.

addons/ooh323c/src/ooSocket.h

@@ -318,7 +318,7 @@ EXTERN int ooSocketSendTo(OOSOCKET socket, const ASN1OCTET* pdata,
 
 /**
  * This function is used for synchronous monitoring of multiple sockets.
- * For more information refer to documnetation of "select" system call.
+ * For more information refer to documentation of "select" system call.
  *
  * @param nfds         The highest numbered descriptor to be monitored
  *                     plus one.

addons/ooh323c/src/ooUtils.c

@@ -30,7 +30,7 @@ OOBOOL ooUtilsIsStrEmpty (const char* str)
 }
 
 
-OOBOOL ooIsDailedDigit(const char* str)
+OOBOOL ooIsDialedDigit(const char* str)
 {
    if(str == NULL || *str =='\0') { return FALSE; }
    while(*str != '\0')

addons/ooh323c/src/ooUtils.h

@@ -48,6 +48,6 @@ EXTERN OOBOOL ooUtilsIsStrEmpty (const char * str);
  * @param str    String to test
  * @return       TRUE if string contains all digits; FALSE otherwise
  */
-EXTERN OOBOOL ooIsDailedDigit(const char* str);
+EXTERN OOBOOL ooIsDialedDigit(const char* str);
 
 #endif

addons/ooh323c/src/ooasn1.h

@@ -607,7 +607,7 @@ EXTERN int initContextBuffer
 /**
  * This function initializes a context block. It makes sure that if the block
  * was not previosly initialized, that all key working parameters are set to
- * thier correct initial state values (i.e. declared within a function as a
+ * their correct initial state values (i.e. declared within a function as a
  * normal working variable), it is required that they invoke this function
  * before using it.
  *

addons/ooh323c/src/oochannels.c

@@ -297,7 +297,7 @@ int ooCreateH225Connection(OOH323CallData *call)
       {
          call->pH225Channel->sock = channelSocket;
 
-         OOTRACEINFO3("H2250 transmiter channel creation - successful "
+         OOTRACEINFO3("H2250 transmitter channel creation - successful "
                       "(%s, %s)\n", call->callType, call->callToken);
 
          /* If multihomed, get ip from socket */

addons/ooh323c/src/ooh245.c

@@ -2559,7 +2559,7 @@ int ooOnReceivedRequestChannelClose(OOH323CallData *call,
    if (lChannel->state == OO_LOGICALCHAN_ESTABLISHED) {
      ret = ooSendCloseLogicalChannel(call, lChannel);
      if (ret != OO_OK) {
-      OOTRACEERR3("ERROR:Failed to build CloseLgicalChannel message(%s, %s)\n",
+      OOTRACEERR3("ERROR:Failed to build CloseLogicalChannel message(%s, %s)\n",
                    call->callType, call->callToken);
       return OO_FAILED;
      }

addons/ooh323c/src/ooh245.h

@@ -174,7 +174,7 @@ EXTERN int ooSendMasterSlaveDeterminationReject (struct OOH323CallData* call);
  * MasterSlaveDetermination procedure.
  * @param call        Handle to the call for which MasterSlaveReject is
  *                    received.
- * @param reject      Poinetr to the received reject message.
+ * @param reject      Pointer to the received reject message.
  *
  * @return            OO_OK, on success. OO_FAILED, on failure.
  */
@@ -271,7 +271,7 @@ EXTERN int ooOnReceivedUserInputIndication
    (OOH323CallData *call, H245UserInputIndication *indication);
 
 /**
- * This function is called on receiving a TreminalCapabilitySetAck message.
+ * This function is called on receiving a TerminalCapabilitySetAck message.
  * If the MasterSlaveDetermination process is also over, this function
  * initiates the process of opening logical channels.
  * @param call          Pointer to call for which TCSAck is received.

addons/ooh323c/src/ooh323.c

@@ -616,7 +616,7 @@ int ooOnReceivedSetup(OOH323CallData *call, Q931Message *q931Msg)
               removeEventHandler(call->pctxt);
               return OO_FAILED;
          }
-         /* For now, just add decoded fast start elemts to list. This list
+         /* For now, just add decoded fast start elements to list. This list
             will be processed at the time of sending CONNECT message. */
          dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc);
       }
@@ -1062,16 +1062,17 @@ int ooOnReceivedAlerting(OOH323CallData *call, Q931Message *q931Msg)
    if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent &&
       q931Msg->userInfo->h323_uu_pdu.h245Tunneling &&
 	 OO_TESTFLAG (call->flags, OO_M_TUNNELING)) {
-      if (alerting->m.h245AddressPresent)
+      if (alerting->m.h245AddressPresent) {
       	OOTRACEINFO3("Tunneling and h245address provided."
                      "Giving preference to Tunneling (%s, %s)\n",
                    	call->callType, call->callToken);
-	if (call->h225version >= 4) {
-		ret =ooSendTCSandMSD(call);
-	}
-	if (ret != OO_OK)
-		return ret;
-
+      }
+	   if (call->h225version >= 4) {
+		   ret =ooSendTCSandMSD(call);
+	   }
+	   if (ret != OO_OK) {
+		   return ret;
+      }
    } else if(alerting->m.h245AddressPresent) {
       if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
       {
@@ -1314,15 +1315,17 @@ int ooOnReceivedProgress(OOH323CallData *call, Q931Message *q931Msg)
    if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent &&
       q931Msg->userInfo->h323_uu_pdu.h245Tunneling &&
       OO_TESTFLAG (call->flags, OO_M_TUNNELING)) {
-      if (progress->m.h245AddressPresent)
+      if (progress->m.h245AddressPresent) {
       	OOTRACEINFO3("Tunneling and h245address provided."
                      "Giving preference to Tunneling (%s, %s)\n",
                      call->callType, call->callToken);
-	if (call->h225version >= 4) {
-		ret =ooSendTCSandMSD(call);
-	}
-	if (ret != OO_OK)
+      }
+	   if (call->h225version >= 4) {
+		   ret =ooSendTCSandMSD(call);
+	   }
+	   if (ret != OO_OK) {
 		return ret;
+      }
    } else if(progress->m.h245AddressPresent) {
       if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
       {

addons/ooh323c/src/ooh323ep.c

@@ -65,7 +65,7 @@ int ooH323EpInitialize
    }
 
    /* Initialize default port ranges that will be used by stack.
-      Apps can override these by explicitely setting port ranges
+      Apps can override these by explicitly setting port ranges
    */
 
    gH323ep.tcpPorts.start = TCPPORTSSTART;

addons/ooh323c/src/ooq931.c

@@ -192,11 +192,13 @@ EXTERN int ooQ931Decode
          screening indicators ;-) */
       if(ie->discriminator == Q931CallingPartyNumberIE)
       {
+         int numoffset=1;
          OOTRACEDBGB1("   CallingPartyNumber IE = {\n");
-         if(ie->length < OO_MAX_NUMBER_LENGTH)
+         if(!(0x80 & ie->data[0])) numoffset = 2;
+
+         if( (ie->length >= numoffset) &&
+             (ie->length < OO_MAX_NUMBER_LENGTH) )
          {
-            int numoffset=1;
-            if(!(0x80 & ie->data[0])) numoffset = 2;
             memcpy(number, ie->data+numoffset,ie->length-numoffset);
             number[ie->length-numoffset]='\0';
             OOTRACEDBGB2("      %s\n", number);
@@ -204,7 +206,7 @@ EXTERN int ooQ931Decode
                ooCallSetCallingPartyNumber(call, number);
          }
          else{
-            OOTRACEERR3("Error:Calling party number too long. (%s, %s)\n",
+            OOTRACEERR3("Error:Calling party number outside range. (%s, %s)\n",
                            call->callType, call->callToken);
          }
          OOTRACEDBGB1("   }\n");
@@ -214,7 +216,8 @@ EXTERN int ooQ931Decode
       if(ie->discriminator == Q931CalledPartyNumberIE)
       {
          OOTRACEDBGB1("   CalledPartyNumber IE = {\n");
-         if(ie->length < OO_MAX_NUMBER_LENGTH)
+         if( (ie->length >= 1) &&
+             (ie->length < OO_MAX_NUMBER_LENGTH) )
          {
             memcpy(number, ie->data+1,ie->length-1);
             number[ie->length-1]='\0';
@@ -223,7 +226,7 @@ EXTERN int ooQ931Decode
                ooCallSetCalledPartyNumber(call, number);
          }
          else{
-            OOTRACEERR3("Error:Calling party number too long. (%s, %s)\n",
+            OOTRACEERR3("Error:Calling party number outside range. (%s, %s)\n",
                            call->callType, call->callToken);
          }
          OOTRACEDBGB1("   }\n");
@@ -585,7 +588,7 @@ int ooDecodeUUIE(OOCTXT* pctxt, Q931Message *q931Msg)
    unsigned int i;
    ASN1BOOL aligned=TRUE;
    int stat;
-   Q931InformationElement *ie;
+   Q931InformationElement *ie=NULL;
    /* OOCTXT *pctxt = &gH323ep.msgctxt; */
    if(q931Msg ==NULL)
    {
@@ -1210,7 +1213,7 @@ int ooSetFastStartResponse(OOH323CallData *pCall, Q931Message *pQ931msg,
          pChannel = ooFindLogicalChannelByLogicalChannelNo
                       (pCall, olc->forwardLogicalChannelNumber);
 
-         /* start receive and tramsmit channel listening */
+         /* start receive and transmit channel listening */
          if(dir & OORX)
          {
             strcpy(pChannel->remoteIP, remoteMediaControlIP);
@@ -2025,7 +2028,7 @@ int ooSendStatusInquiry(OOH323CallData *call)
    /* OOCTXT *pctxt = &gH323ep.msgctxt; */
    OOCTXT *pctxt = call->msgctxt;
 
-   OOTRACEDBGC3("Building StatusInquryMsg (%s, %s)\n", call->callType,
+   OOTRACEDBGC3("Building StatusInquiryMsg (%s, %s)\n", call->callType,
                  call->callToken);
    ret = ooCreateQ931Message(pctxt, &q931msg, Q931StatusEnquiryMsg);
    if(ret != OO_OK)
@@ -2987,7 +2990,7 @@ int ooH323MakeCall_helper(OOH323CallData *call)
          }
          if(!epCap)
          {
-            OOTRACEWARN4("Warn:Preferred capability %s is abscent in "
+            OOTRACEWARN4("Warn:Preferred capability %s is absent in "
                          "capability list. (%s, %s)\n",
                          ooGetCapTypeText(call->capPrefs.order[k]),
                          call->callType, call->callToken);

addons/ooh323c/src/ooq931.h

@@ -582,7 +582,7 @@ EXTERN int ooH323MakeCall_helper(struct OOH323CallData *call);
  * @param dest      Destination string to be parsed.
  * @param parsedIP  Pointer to buffer in which parsed ip:port will be returned.
  * @param len       Length of the buffer passed.
- * @param aliasList Aliase List in which new aliases will be added.
+ * @param aliasList Aliases List in which new aliases will be added.
  *
  * @return          OO_OK, on success. OO_FAILED, on failure.
  */

agi/eagi-test.c

@@ -6,6 +6,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -93,7 +94,7 @@ static char *wait_result(void)
 				fprintf(stderr, "Got %d/%d bytes of audio\n", res, bytes);
 #endif
 				bytes += res;
-				/* Prentend we detected some audio after 3 seconds */
+				/* Pretend we detected some audio after 3 seconds */
 				if (bytes > 16000 * 3) {
 					return "Sample Message";
 					bytes = 0;

agi/jukebox.agi

@@ -348,7 +348,7 @@ sub music_dir_cache {
 }
 
 # this function will fill the @masterCacheList of all the files that
-# need to have text2speeced ulaw files of their names generated
+# need to have text2speech ulaw files of their names generated
 sub music_dir_cache_genlist {
 	my $dir = shift;
 	if (!opendir(THEDIR, rmts($MUSIC.$dir))) {

apps/app_adsiprog.c

@@ -36,6 +36,7 @@
 
 /*** MODULEINFO
 	<depend>res_adsi</depend>
+	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
  ***/
 

apps/app_agent_pool.c

@@ -24,8 +24,14 @@
  *
  * See Also:
  * \arg \ref AstCREDITS
- * \arg \ref Config_agent
+ * \arg \ref agents.conf "Config_agent"
  */
+
+/*!
+ * \page agents.conf agents.conf
+ * \verbinclude agents.conf.sample
+ */
+
 /*** MODULEINFO
 	<support_level>core</support_level>
  ***/
@@ -456,17 +462,11 @@ struct agents_cfg {
 	struct ao2_container *agents;
 };
 
-static const char *agent_type_blacklist[] = {
-	"general",
-	"agents",
-	NULL,
-};
-
 static struct aco_type agent_type = {
 	.type = ACO_ITEM,
 	.name = "agent-id",
-	.category_match = ACO_BLACKLIST_ARRAY,
-	.category = (const char *)agent_type_blacklist,
+	.category_match = ACO_BLACKLIST_EXACT,
+	.category = "general",
 	.item_alloc = agent_cfg_alloc,
 	.item_find = agent_cfg_find,
 	.item_offset = offsetof(struct agents_cfg, agents),
@@ -652,8 +652,6 @@ static struct ao2_container *agents;
  * \brief Lock the agent.
  *
  * \param agent Agent to lock
- *
- * \return Nothing
  */
 #define agent_lock(agent)	_agent_lock(agent, __FILE__, __PRETTY_FUNCTION__, __LINE__, #agent)
 static inline void _agent_lock(struct agent_pvt *agent, const char *file, const char *function, int line, const char *var)
@@ -665,8 +663,6 @@ static inline void _agent_lock(struct agent_pvt *agent, const char *file, const
  * \brief Unlock the agent.
  *
  * \param agent Agent to unlock
- *
- * \return Nothing
  */
 #define agent_unlock(agent)	_agent_unlock(agent, __FILE__, __PRETTY_FUNCTION__, __LINE__, #agent)
 static inline void _agent_unlock(struct agent_pvt *agent, const char *file, const char *function, int line, const char *var)
@@ -684,8 +680,6 @@ static inline void _agent_unlock(struct agent_pvt *agent, const char *file, cons
  * \note Assumes the agent lock is already obtained.
  *
  * \note Defined locking order is channel lock then agent lock.
- *
- * \return Nothing
  */
 static struct ast_channel *agent_lock_logged(struct agent_pvt *agent)
 {
@@ -750,8 +744,6 @@ static enum ast_device_state agent_pvt_devstate_get(const char *agent_id)
  * \since 12.0.0
  *
  * \param agent_id Which agent needs the device state updated.
- *
- * \return Nothing
  */
 static void agent_devstate_changed(const char *agent_id)
 {
@@ -1011,8 +1003,6 @@ AST_MUTEX_DEFINE_STATIC(agent_holding_lock);
  * \param payload_size Size of the payload if payload is non-NULL.  A number otherwise.
  *
  * \note The payload MUST NOT have any resources that need to be freed.
- *
- * \return Nothing
  */
 static void clear_agent_status(struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
 {
@@ -1028,8 +1018,6 @@ static void clear_agent_status(struct ast_bridge_channel *bridge_channel, const
  * \param agent Which agent is connecting to the caller.
  *
  * \note The agent is locked on entry and not locked on exit.
- *
- * \return Nothing
  */
 static void agent_connect_caller(struct ast_bridge_channel *bridge_channel, struct agent_pvt *agent)
 {
@@ -1363,8 +1351,6 @@ static int bridge_agent_hold_push(struct ast_bridge *self, struct ast_bridge_cha
  * bridge_channel->bridge_pvt.
  *
  * \note On entry, self is already locked.
- *
- * \return Nothing
  */
 static void bridge_agent_hold_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
 {
@@ -1382,8 +1368,6 @@ static void bridge_agent_hold_pull(struct ast_bridge *self, struct ast_bridge_ch
  * references to the bridge so it can be destroyed.
  *
  * \note On entry, self must NOT be locked.
- *
- * \return Nothing
  */
 static void bridge_agent_hold_dissolving(struct ast_bridge *self)
 {
@@ -1475,8 +1459,6 @@ static void send_agent_logoff(struct ast_channel *chan, const char *agent, long
  * \param agent Which agent logging out.
  *
  * \note On entry agent is already locked.  On exit it is no longer locked.
- *
- * \return Nothing
  */
 static void agent_logout(struct agent_pvt *agent)
 {
@@ -1514,8 +1496,6 @@ static void agent_logout(struct agent_pvt *agent)
  *
  * \param agent Which agent.
  * \param logged The logged in channel.
- *
- * \return Nothing
  */
 static void agent_run(struct agent_pvt *agent, struct ast_channel *logged)
 {
@@ -2034,8 +2014,6 @@ static int agent_request_exec(struct ast_channel *chan, const char *data)
  *
  * \param agent What to setup channel config values on.
  * \param chan Channel logging in as an agent.
- *
- * \return Nothing
  */
 static void agent_login_channel_config(struct agent_pvt *agent, struct ast_channel *chan)
 {

apps/app_alarmreceiver.c

@@ -40,6 +40,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -158,7 +159,7 @@ static const char app[] = "AlarmReceiver";
 			events to the standard input of the application.
 			The configuration file also contains settings for DTMF timing, and for the loudness of the
 			acknowledgement tones.</para>
-			<note><para>Few Ademco DTMF signalling formats are detected automaticaly: Contact ID, Express 4+1,
+			<note><para>Few Ademco DTMF signalling formats are detected automatically: Contact ID, Express 4+1,
 			Express 4+2, High Speed and Super Fast.</para></note>
 			<para>The application is affected by the following variables:</para>
 			<variablelist>
@@ -203,7 +204,6 @@ static char event_file[14] = "/event-XXXXXX";
  * family, then create it and set its value to 1.
  *
  * \param key A database key to increment
- * \return Nothing
  */
 static void database_increment(char *key)
 {

apps/app_amd.c

@@ -38,6 +38,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 

apps/app_attended_transfer.c

@@ -26,6 +26,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -140,4 +141,4 @@ static int load_module(void)
 	return ast_register_application_xml(app, attended_transfer_exec);
 }
 
-AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Attended transfer to the given extension");
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Attended transfer to the given extension");

apps/app_audiosocket.c

@@ -27,6 +27,7 @@
 
 /*** MODULEINFO
 	<depend>res_audiosocket</depend>
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 

apps/app_blind_transfer.c

@@ -26,6 +26,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -134,4 +135,4 @@ static int load_module(void)
 	return ast_register_application_xml(app, blind_transfer_exec);
 }
 
-AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Blind transfer channel to the given destination");
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Blind transfer channel to the given destination");

apps/app_bridgewait.c

@@ -391,17 +391,6 @@ static void wait_wrapper_removal(struct wait_bridge_wrapper *wrapper)
 	ao2_cleanup(wrapper);
 }
 
-/*!
- * \internal
- * \since 12.0.0
- * \brief Application callback for the bridgewait application
- *
- * \param chan channel running the application
- * \param data Arguments to the application
- *
- * \retval 0 Ran successfully and the call didn't hang up
- * \retval -1 Failed or the call was hung up by the time the channel exited the holding bridge
- */
 static enum wait_bridge_roles validate_role(const char *role)
 {
 	if (!strcmp(role, "participant")) {
@@ -413,6 +402,17 @@ static enum wait_bridge_roles validate_role(const char *role)
 	}
 }
 
+/*!
+ * \internal
+ * \since 12.0.0
+ * \brief Application callback for the bridgewait application
+ *
+ * \param chan channel running the application
+ * \param data Arguments to the application
+ *
+ * \retval 0 Ran successfully and the call didn't hang up
+ * \retval -1 Failed or the call was hung up by the time the channel exited the holding bridge
+ */
 static int bridgewait_exec(struct ast_channel *chan, const char *data)
 {
 	char *bridge_name = DEFAULT_BRIDGE_NAME;

apps/app_chanisavail.c

@@ -28,6 +28,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 

apps/app_chanspy.c

@@ -245,6 +245,11 @@
 							</enum>
 						</enumlist>
 					</option>
+					<option name="D">
+						<para>Interleave the audio coming from the channel and the audio coming to the channel in
+						the output audio as a dual channel stream, rather than mix it. Does nothing if 'o'
+						is also set.</para>
+					</option>
 					<option name="e">
 						<argument name="ext" required="true" />
 						<para>Enable <emphasis>enforced</emphasis> mode, so the spying channel can
@@ -393,6 +398,7 @@ enum {
 	OPTION_EXITONHANGUP      = (1 << 18),   /* Hang up when the spied-on channel hangs up. */
 	OPTION_UNIQUEID          = (1 << 19),	/* The chanprefix is a channel uniqueid or fully specified channel name. */
 	OPTION_LONG_QUEUE        = (1 << 20),	/* Allow usage of a long queue to store audio frames. */
+	OPTION_INTERLEAVED       = (1 << 21),	/* Interleave the Read and Write frames in the output frame. */
 };
 
 enum {
@@ -411,6 +417,7 @@ AST_APP_OPTIONS(spy_opts, {
 	AST_APP_OPTION('B', OPTION_BARGE),
 	AST_APP_OPTION_ARG('c', OPTION_DTMF_CYCLE, OPT_ARG_CYCLE),
 	AST_APP_OPTION('d', OPTION_DTMF_SWITCH_MODES),
+	AST_APP_OPTION('D', OPTION_INTERLEAVED),
 	AST_APP_OPTION_ARG('e', OPTION_ENFORCED, OPT_ARG_ENFORCED),
 	AST_APP_OPTION('E', OPTION_EXITONHANGUP),
 	AST_APP_OPTION_ARG('g', OPTION_GROUP, OPT_ARG_GROUP),
@@ -471,6 +478,56 @@ static int spy_generate(struct ast_channel *chan, void *data, int len, int sampl
 	if (ast_test_flag(&csth->flags, OPTION_READONLY)) {
 		/* Option 'o' was set, so don't mix channel audio */
 		f = ast_audiohook_read_frame(&csth->spy_audiohook, samples, AST_AUDIOHOOK_DIRECTION_READ, ast_format_slin);
+	} else if (ast_test_flag(&csth->flags, OPTION_INTERLEAVED)) {
+		/* Option 'D' was set, so mix the spy frame as an interleaved dual channel frame. */
+		int i;
+		struct ast_frame *fr_read = NULL;
+		struct ast_frame *fr_write = NULL;
+		short read_buf[samples];
+		short write_buf[samples];
+		short stereo_buf[samples * 2];
+		struct ast_frame stereo_frame = {
+			.frametype = AST_FRAME_VOICE,
+			.datalen = sizeof(stereo_buf),
+			.samples = samples,
+		};
+
+		f = ast_audiohook_read_frame_all(&csth->spy_audiohook, samples, ast_format_slin, &fr_read, &fr_write);
+		if (f) {
+			ast_frame_free(f, 0);
+			f = NULL;
+		}
+
+		if (fr_read) {
+			memcpy(read_buf, fr_read->data.ptr, sizeof(read_buf));
+		} else {
+			/* silent out the output frame if we can't read the input */
+			memset(read_buf, 0, sizeof(read_buf));
+		}
+
+		if (fr_write) {
+			memcpy(write_buf, fr_write->data.ptr, sizeof(write_buf));
+		} else {
+			memset(write_buf, 0, sizeof(write_buf));
+		}
+
+		for (i = 0; i < samples; i++) {
+			stereo_buf[i*2] = read_buf[i];
+			stereo_buf[i*2+1] = write_buf[i];
+		}
+
+		stereo_frame.data.ptr = stereo_buf;
+		stereo_frame.subclass.format = ast_format_cache_get_slin_by_rate(samples);
+
+		f = ast_frdup(&stereo_frame);
+
+		if (fr_read) {
+			ast_frame_free(fr_read, 0);
+		}
+		if (fr_write) {
+			ast_frame_free(fr_write, 0);
+		}
+
 	} else {
 		f = ast_audiohook_read_frame(&csth->spy_audiohook, samples, AST_AUDIOHOOK_DIRECTION_BOTH, ast_format_slin);
 	}
@@ -559,7 +616,7 @@ static int pack_channel_into_message(struct ast_channel *chan, const char *role,
  * \brief Publish the chanspy message over Stasis-Core
  * \param spyer The channel doing the spying
  * \param spyee Who is being spied upon
- * \start start If non-zero, the spying is starting. Otherwise, the spyer is
+ * \param start If non-zero, the spying is starting. Otherwise, the spyer is
  * finishing
  */
 static void publish_chanspy_message(struct ast_channel *spyer,
@@ -845,13 +902,13 @@ static int channel_spy(struct ast_channel *chan, struct ast_autochan *spyee_auto
 	ast_audiohook_unlock(&csth.spy_audiohook);
 	ast_audiohook_destroy(&csth.spy_audiohook);
 
+	ast_verb(2, "Done Spying on channel %s\n", name);
+	publish_chanspy_message(chan, spyee_autochan->chan, 0);
+
 	if (spyee_bridge_autochan) {
 		ast_autochan_destroy(spyee_bridge_autochan);
 	}
 
-	ast_verb(2, "Done Spying on channel %s\n", name);
-	publish_chanspy_message(chan, NULL, 0);
-
 	return running;
 }
 
@@ -899,7 +956,7 @@ static int common_exec(struct ast_channel *chan, struct ast_flags *flags,
 	signed char zero_volume = 0;
 	int waitms;
 	int res;
-	int num_spyed_upon = 1;
+	int num_spied_upon = 1;
 	struct ast_channel_iterator *iter = NULL;
 
 	if (ast_test_flag(flags, OPTION_EXIT)) {
@@ -926,7 +983,7 @@ static int common_exec(struct ast_channel *chan, struct ast_flags *flags,
 		struct ast_autochan *autochan = NULL, *next_autochan = NULL;
 		struct ast_channel *prev = NULL;
 
-		if (!ast_test_flag(flags, OPTION_QUIET) && num_spyed_upon) {
+		if (!ast_test_flag(flags, OPTION_QUIET) && num_spied_upon) {
 			res = ast_streamfile(chan, "beep", ast_channel_language(chan));
 			if (!res)
 				res = ast_waitstream(chan, "");
@@ -991,7 +1048,7 @@ static int common_exec(struct ast_channel *chan, struct ast_flags *flags,
 
 		/* reset for the next loop around, unless overridden later */
 		waitms = 100;
-		num_spyed_upon = 0;
+		num_spied_upon = 0;
 
 		for (autochan = next_channel(iter, chan);
 			autochan;
@@ -1146,7 +1203,7 @@ static int common_exec(struct ast_channel *chan, struct ast_flags *flags,
 			}
 
 			res = channel_spy(chan, autochan, &volfactor, fd, user_options, flags, exitcontext);
-			num_spyed_upon++;
+			num_spied_upon++;
 
 			if (res == -1) {
 				ast_autochan_destroy(autochan);

apps/app_confbridge.c

@@ -124,6 +124,37 @@
 				</variable>
 			</variablelist>
 		</description>
+		<see-also>
+			<ref type="application">ConfKick</ref>
+			<ref type="function">CONFBRIDGE</ref>
+			<ref type="function">CONFBRIDGE_INFO</ref>
+		</see-also>
+	</application>
+	<application name="ConfKick" language="en_US">
+		<synopsis>
+			Kicks channel(s) from the requested ConfBridge.
+		</synopsis>
+		<syntax>
+			<parameter name="conference" required="true" />
+			<parameter name="channel">
+				<para>The channel to kick, <literal>all</literal>
+				to kick all users, or <literal>participants</literal>
+				to kick all non-admin participants. Default is all.</para>
+			</parameter>
+		</syntax>
+		<description>
+			<para>Kicks the requested channel(s) from a conference bridge.</para>
+			<variablelist>
+				<variable name="CONFKICKSTATUS">
+					<value name="FAILURE">
+						Could not kick any users with the provided arguments.
+					</value>
+					<value name="SUCCESS">
+						Successfully kicked users from specified conference bridge.
+					</value>
+				</variable>
+			</variablelist>
+		</description>
 		<see-also>
 			<ref type="application">ConfBridge</ref>
 			<ref type="function">CONFBRIDGE</ref>
@@ -426,6 +457,7 @@
  */
 
 static const char app[] = "ConfBridge";
+static const char app2[] = "ConfKick";
 
 /*! Number of buckets our conference bridges container can have */
 #define CONFERENCE_BRIDGE_BUCKETS 53
@@ -765,8 +797,8 @@ struct confbridge_conference *conf_find_bridge(const char *conference_name)
  *
  * \note Must be called with the conference locked
  *
- * \retval 1, conference is recording.
- * \retval 0, conference is NOT recording.
+ * \retval 1 conference is recording.
+ * \retval 0 conference is NOT recording.
  */
 static int conf_is_recording(struct confbridge_conference *conference)
 {
@@ -877,7 +909,7 @@ static int conf_start_record(struct confbridge_conference *conference)
 	return 0;
 }
 
-/* \brief Playback the given filename and monitor for any dtmf interrupts.
+/*! \brief Playback the given filename and monitor for any dtmf interrupts.
  *
  * This function is used to playback sound files on a given channel and optionally
  * allow dtmf interrupts to occur.
@@ -891,7 +923,9 @@ static int conf_start_record(struct confbridge_conference *conference)
  * \param channel Optional channel to play file on if bridge_channel not given
  * \param filename The file name to playback
  *
- * \retval -1 failure during playback, 0 on file was fully played, 1 on dtmf interrupt.
+ * \retval -1 failure during playback.
+ * \retval 0 on file was fully played.
+ * \retval 1 on dtmf interrupt.
  */
 static int play_file(struct ast_bridge_channel *bridge_channel, struct ast_channel *channel,
 		     const char *filename)
@@ -948,7 +982,8 @@ static int sound_file_exists(const char *filename)
  * \param bridge_channel The bridged channel involved
  *
  * \note if caller is NULL, the announcment will be sent to all participants in the conference.
- * \return Returns 0 on success, -1 if the user hung up
+ * \retval 0 on success.
+ * \retval -1 if the user hung up.
  */
 static int announce_user_count(struct confbridge_conference *conference, struct confbridge_user *user,
 			       struct ast_bridge_channel *bridge_channel)
@@ -998,7 +1033,9 @@ static int announce_user_count(struct confbridge_conference *conference, struct
  * \param user User to play audio prompt to
  * \param filename Prompt to play
  *
- * \return Returns 0 on success, -1 if the user hung up
+ * \retval 0 on success.
+ * \retval -1 if the user hung up.
+ *
  * \note Generally this should be called when the conference is unlocked to avoid blocking
  * the entire conference while the sound is played. But don't unlock the conference bridge
  * in the middle of a state transition.
@@ -1135,8 +1172,6 @@ static void hangup_data_destroy(struct hangup_data *hangup)
  * \brief Destroy a conference bridge
  *
  * \param obj The conference bridge object
- *
- * \return Returns nothing
  */
 static void destroy_conference_bridge(void *obj)
 {
@@ -1273,7 +1308,7 @@ void conf_update_user_mute(struct confbridge_user *user)
 		ast_channel_name(user->chan));
 }
 
-/*
+/*!
  * \internal
  * \brief Mute/unmute a single user.
  */
@@ -1357,8 +1392,6 @@ void conf_moh_start(struct confbridge_user *user)
  * \brief Unsuspend MOH for the conference user.
  *
  * \param user Conference user to unsuspend MOH on.
- *
- * \return Nothing
  */
 static void conf_moh_unsuspend(struct confbridge_user *user)
 {
@@ -1374,8 +1407,6 @@ static void conf_moh_unsuspend(struct confbridge_user *user)
  * \brief Suspend MOH for the conference user.
  *
  * \param user Conference user to suspend MOH on.
- *
- * \return Nothing
  */
 static void conf_moh_suspend(struct confbridge_user *user)
 {
@@ -1650,7 +1681,7 @@ static struct confbridge_conference *join_conference_bridge(const char *conferen
 	struct post_join_action *action;
 	int max_members_reached = 0;
 
-	/* We explictly lock the conference bridges container ourselves so that other callers can not create duplicate conferences at the same */
+	/* We explicitly lock the conference bridges container ourselves so that other callers can not create duplicate conferences at the same */
 	ao2_lock(conference_bridges);
 
 	ast_debug(1, "Trying to find conference bridge '%s'\n", conference_name);
@@ -1730,6 +1761,9 @@ static struct confbridge_conference *join_conference_bridge(const char *conferen
 				ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_LOWEST_ALL);
 			} else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST_ALL)) {
 				ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_HIGHEST_ALL);
+			} else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_FORCE)) {
+				ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_FORCE);
+				ast_bridge_set_remb_estimated_bitrate(conference->bridge, conference->b_profile.remb_estimated_bitrate);
 			}
 		}
 
@@ -2532,10 +2566,6 @@ static int confbridge_exec(struct ast_channel *chan, const char *data)
 		AST_APP_ARG(menu_profile_name);
 	);
 
-	if (ast_channel_state(chan) != AST_STATE_UP) {
-		ast_answer(chan);
-	}
-
 	if (ast_bridge_features_init(&user.features)) {
 		pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
 		res = -1;
@@ -2585,6 +2615,11 @@ static int confbridge_exec(struct ast_channel *chan, const char *data)
 		goto confbridge_cleanup;
 	}
 
+	/* If channel hasn't been answered already, answer it, unless we're explicitly not supposed to */
+	if ((ast_channel_state(chan) != AST_STATE_UP) && (ast_test_flag(&user.u_profile, USER_OPT_ANSWER_CHANNEL))) {
+		ast_answer(chan);
+	}
+
 	quiet = ast_test_flag(&user.u_profile, USER_OPT_QUIET);
 
 	/* ask for a PIN immediately after finding user profile.  This has to be
@@ -3458,7 +3493,7 @@ static char *handle_cli_confbridge_list(struct ast_cli_entry *e, int cmd, struct
 	return CLI_SHOWUSAGE;
 }
 
-/* \internal
+/*! \internal
  * \brief finds a conference by name and locks/unlocks.
  *
  * \retval 0 success
@@ -3482,7 +3517,7 @@ static int generic_lock_unlock_helper(int lock, const char *conference_name)
 	return res;
 }
 
-/* \internal
+/*! \internal
  * \brief finds a conference user by channel name and mutes/unmutes them.
  *
  * \retval 0 success
@@ -4217,6 +4252,53 @@ static int func_confbridge_info(struct ast_channel *chan, const char *cmd, char
 	return 0;
 }
 
+static int confkick_exec(struct ast_channel *chan, const char *data)
+{
+	char *parse;
+	struct confbridge_conference *conference;
+	int not_found;
+
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(confbridge);
+		AST_APP_ARG(channel);
+	);
+
+	if (ast_strlen_zero(data)) {
+		ast_log(LOG_WARNING, "No conference bridge specified.\n");
+		pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "FAILURE");
+		return 0;
+	}
+
+	parse = ast_strdupa(data);
+	AST_STANDARD_APP_ARGS(args, parse);
+
+	conference = ao2_find(conference_bridges, args.confbridge, OBJ_KEY);
+	if (!conference) {
+		ast_log(LOG_WARNING, "No conference bridge named '%s' found!\n", args.confbridge);
+		pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "FAILURE");
+		return 0;
+	}
+	if (ast_strlen_zero(args.channel)) {
+		not_found = kick_conference_participant(conference, "all");
+	} else {
+		not_found = kick_conference_participant(conference, args.channel);
+	}
+
+	ao2_ref(conference, -1);
+	if (not_found) {
+		if (ast_strlen_zero(args.channel) || !strcasecmp("all", args.channel) || !strcasecmp("participants", args.channel)) {
+			ast_log(LOG_WARNING, "No participants found in conference bridge '%s'!\n", args.confbridge);
+		} else {
+			ast_log(LOG_WARNING, "No participant named '%s' found in conference bridge '%s'!\n", args.channel, args.confbridge);
+		}
+		pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "FAILURE");
+		return 0;
+	}
+	ast_debug(1, "Kicked '%s' out of conference '%s'\n", args.channel, args.confbridge);
+	pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "SUCCESS");
+	return 0;
+}
+
 void conf_add_user_active(struct confbridge_conference *conference, struct confbridge_user *user)
 {
 	AST_LIST_INSERT_TAIL(&conference->active_list, user, list);
@@ -4272,8 +4354,6 @@ void conf_remove_user_waiting(struct confbridge_conference *conference, struct c
  * \since 12.0.0
  *
  * \param tech What to unregister.
- *
- * \return Nothing
  */
 static void unregister_channel_tech(struct ast_channel_tech *tech)
 {
@@ -4310,6 +4390,7 @@ static int register_channel_tech(struct ast_channel_tech *tech)
 static int unload_module(void)
 {
 	ast_unregister_application(app);
+	ast_unregister_application(app2);
 
 	ast_custom_function_unregister(&confbridge_function);
 	ast_custom_function_unregister(&confbridge_info_function);
@@ -4380,6 +4461,7 @@ static int load_module(void)
 	res |= manager_confbridge_init();
 
 	res |= ast_register_application_xml(app, confbridge_exec);
+	res |= ast_register_application_xml(app2, confkick_exec);
 
 	res |= ast_custom_function_register_escalating(&confbridge_function, AST_CFE_WRITE);
 	res |= ast_custom_function_register(&confbridge_info_function);

apps/app_dahdiras.c

@@ -27,7 +27,10 @@
 
 /*** MODULEINFO
 	<depend>dahdi</depend>
+	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
+	<deprecated_in>16</deprecated_in>
+	<removed_in>19</removed_in>
  ***/
 
 #include "asterisk.h"

apps/app_dial.c

@@ -93,11 +93,17 @@
 			</parameter>
 			<parameter name="options" required="false">
 				<optionlist>
-				<option name="A">
-					<argument name="x" required="true">
+				<option name="A" argsep=":">
+					<argument name="x">
 						<para>The file to play to the called party</para>
 					</argument>
-					<para>Play an announcement to the called party, where <replaceable>x</replaceable> is the prompt to be played</para>
+					<argument name="y">
+						<para>The file to play to the calling party</para>
+					</argument>
+					<para>Play an announcement to the called and/or calling parties, where <replaceable>x</replaceable>
+					is the prompt to be played to the called party and <replaceable>y</replaceable> is the prompt
+					to be played to the caller. The files may be different and will be played to each party
+					simultaneously.</para>
 				</option>
 				<option name="a">
 					<para>Immediately answer the calling channel when the called channel answers in
@@ -924,7 +930,7 @@ static const char *get_cid_name(char *name, int namelen, struct ast_channel *cha
  * XXX this code is highly suspicious, as it essentially overwrites
  * the outgoing channel without properly deleting it.
  *
- * \todo eventually this function should be intergrated into and replaced by ast_call_forward()
+ * \todo eventually this function should be integrated into and replaced by ast_call_forward()
  */
 static void do_forward(struct chanlist *o, struct cause_args *num,
 	struct ast_flags64 *peerflags, int single, int caller_entertained, int *to,
@@ -1161,8 +1167,6 @@ static void publish_dial_end_event(struct ast_channel *in, struct dial_head *out
  * \param chan Channel to get connected line updated.
  * \param peer Channel providing connected line information.
  * \param is_caller Non-zero if chan is the calling channel.
- *
- * \return Nothing
  */
 static void update_connected_line_from_peer(struct ast_channel *chan, struct ast_channel *peer, int is_caller)
 {
@@ -1204,7 +1208,8 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 	struct privacy_args *pa,
 	const struct cause_args *num_in, int *result, char *dtmf_progress,
 	const int ignore_cc,
-	struct ast_party_id *forced_clid, struct ast_party_id *stored_clid)
+	struct ast_party_id *forced_clid, struct ast_party_id *stored_clid,
+	struct ast_bridge_config *config)
 {
 	struct cause_args num = *num_in;
 	int prestart = num.busy + num.congestion + num.nochan;
@@ -1223,7 +1228,7 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 	int sent_ring = 0;
 	int sent_progress = 0;
 	struct timeval start = ast_tvnow();
-	SCOPE_TRACE(1, "%s\n", ast_channel_name(in));
+	SCOPE_ENTER(3, "%s\n", ast_channel_name(in));
 
 	if (single) {
 		/* Turn off hold music, etc */
@@ -1239,7 +1244,8 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 				*to = -1;
 				strcpy(pa->status, "CONGESTION");
 				ast_channel_publish_dial(in, outgoing->chan, NULL, pa->status);
-				return NULL;
+				SCOPE_EXIT_RTN_VALUE(NULL, "%s: can't be made compat with %s\n",
+					ast_channel_name(in), ast_channel_name(outgoing->chan));
 			}
 		}
 
@@ -1281,7 +1287,7 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 			if (is_cc_recall) {
 				ast_cc_failed(cc_recall_core_id, "Everyone is busy/congested for the recall. How sad");
 			}
-			return NULL;
+			SCOPE_EXIT_RTN_VALUE(NULL, "%s: No outging channels available\n", ast_channel_name(in));
 		}
 		winner = ast_waitfor_n(watchers, pos, to);
 		AST_LIST_TRAVERSE(out_chans, o, node) {
@@ -1390,7 +1396,7 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 				case AST_CONTROL_ANSWER:
 					/* This is our guy if someone answered. */
 					if (!peer) {
-						ast_trace(1, "%s answered %s\n", ast_channel_name(c), ast_channel_name(in));
+						ast_trace(-1, "%s answered %s\n", ast_channel_name(c), ast_channel_name(in));
 						ast_verb(3, "%s answered %s\n", ast_channel_name(c), ast_channel_name(in));
 						if (o->orig_chan_name
 							&& strcmp(o->orig_chan_name, ast_channel_name(c))) {
@@ -1418,6 +1424,18 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 							}
 						}
 						peer = c;
+						/* Answer can optionally include a topology */
+						if (f->subclass.topology) {
+							/*
+							 * We need to bump the refcount on the topology to prevent it
+							 * from being cleaned up when the frame is cleaned up.
+							 */
+							config->answer_topology = ao2_bump(f->subclass.topology);
+							ast_trace(-1, "%s Found topology in frame: %p %p %s\n",
+								ast_channel_name(peer), f, config->answer_topology,
+								ast_str_tmp(256, ast_stream_topology_to_str(config->answer_topology, &STR_TMP)));
+						}
+
 						/* Inform everyone else that they've been canceled.
 						 * The dial end event for the peer will be sent out after
 						 * other Dial options have been handled.
@@ -1545,12 +1563,14 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 						ast_channel_stage_snapshot_done(in);
 						ast_channel_unlock(in);
 						sent_progress = 1;
-					}
-					if (!ast_strlen_zero(dtmf_progress)) {
-						ast_verb(3,
-							"Sending DTMF '%s' to the called party as result of receiving a PROGRESS message.\n",
-							dtmf_progress);
-						ast_dtmf_stream(c, in, dtmf_progress, 250, 0);
+
+						if (!ast_strlen_zero(dtmf_progress)) {
+							ast_verb(3,
+								"Sending DTMF '%s' to the called party as result of "
+								"receiving a PROGRESS message.\n",
+								dtmf_progress);
+							ast_dtmf_stream(c, in, dtmf_progress, 250, 0);
+						}
 					}
 					ast_channel_publish_dial(in, c, NULL, "PROGRESS");
 					break;
@@ -1708,7 +1728,7 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 				if (is_cc_recall) {
 					ast_cc_completed(in, "CC completed, although the caller hung up (cancelled)");
 				}
-				return NULL;
+				SCOPE_EXIT_RTN_VALUE(NULL, "%s: Caller hung up\n", ast_channel_name(in));
 			}
 
 			/* now f is guaranteed non-NULL */
@@ -1728,7 +1748,8 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 						if (is_cc_recall) {
 							ast_cc_completed(in, "CC completed, but the caller used DTMF to exit");
 						}
-						return NULL;
+						SCOPE_EXIT_RTN_VALUE(NULL, "%s: Caller pressed %c to end call\n",
+							ast_channel_name(in), f->subclass.integer);
 					}
 					ast_channel_unlock(in);
 				}
@@ -1743,7 +1764,8 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in,
 					if (is_cc_recall) {
 						ast_cc_completed(in, "CC completed, but the caller hung up with DTMF");
 					}
-					return NULL;
+					SCOPE_EXIT_RTN_VALUE(NULL, "%s: Caller requested disconnect\n",
+						ast_channel_name(in));
 				}
 			}
 
@@ -1849,7 +1871,8 @@ skip_frame:;
 	if (is_cc_recall) {
 		ast_cc_completed(in, "Recall completed!");
 	}
-	return peer;
+	SCOPE_EXIT_RTN_VALUE(peer, "%s: %s%s\n", ast_channel_name(in),
+		peer ? "Answered by " : "No answer", peer ? ast_channel_name(peer) : "");
 }
 
 static int detect_disconnect(struct ast_channel *chan, char code, struct ast_str **featurecode)
@@ -2185,8 +2208,6 @@ static int dial_handle_playtones(struct ast_channel *chan, const char *data)
  * \param peer Peer channel for bridge.
  * \param opts Dialing option flags.
  * \param opt_args Dialing option argument strings.
- *
- * \return Nothing
  */
 static void setup_peer_after_bridge_goto(struct ast_channel *chan, struct ast_channel *peer, struct ast_flags64 *opts, char *opt_args[])
 {
@@ -2217,7 +2238,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 	struct dial_head out_chans = AST_LIST_HEAD_NOLOCK_INIT_VALUE; /* list of destinations */
 	struct chanlist *outgoing;
 	struct chanlist *tmp;
-	struct ast_channel *peer;
+	struct ast_channel *peer = NULL;
 	int to; /* timeout */
 	struct cause_args num = { chan, 0, 0, 0 };
 	int cause;
@@ -2271,7 +2292,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 	 */
 	struct ast_party_caller caller;
 	int max_forwards;
-	SCOPE_TRACE(1, "%s Data: %s\n", ast_channel_name(chan), data);
+	SCOPE_ENTER(1, "%s: Data: %s\n", ast_channel_name(chan), data);
 
 	/* Reset all DIAL variables back to blank, to prevent confusion (in case we don't reset all of them). */
 	ast_channel_lock(chan);
@@ -2295,7 +2316,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 		ast_log(LOG_WARNING, "Cannot place outbound call from channel '%s'. Max forwards exceeded\n",
 				ast_channel_name(chan));
 		pbx_builtin_setvar_helper(chan, "DIALSTATUS", "BUSY");
-		return -1;
+		SCOPE_EXIT_RTN_VALUE(-1, "%s: Max forwards exceeded\n", ast_channel_name(chan));
 	}
 
 	if (ast_check_hangup_locked(chan)) {
@@ -2313,7 +2334,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 		 */
 		ast_verb(3, "Caller hung up before dial.\n");
 		pbx_builtin_setvar_helper(chan, "DIALSTATUS", "CANCEL");
-		return -1;
+		SCOPE_EXIT_RTN_VALUE(-1, "%s: Caller hung up before dial\n", ast_channel_name(chan));
 	}
 
 	parse = ast_strdupa(data ?: "");
@@ -2838,7 +2859,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 	}
 
 	peer = wait_for_answer(chan, &out_chans, &to, peerflags, opt_args, &pa, &num, &result,
-		dtmf_progress, ignore_cc, &forced_clid, &stored_clid);
+		dtmf_progress, ignore_cc, &forced_clid, &stored_clid, &config);
 
 	if (!peer) {
 		if (result) {
@@ -2922,33 +2943,71 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 			int digit = 0;
 			struct ast_channel *chans[2];
 			struct ast_channel *active_chan;
+			char *calledfile = NULL, *callerfile = NULL;
+			int calledstream = 0, callerstream = 0;
 
 			chans[0] = chan;
 			chans[1] = peer;
 
-			/* we need to stream the announcement to the called party when the OPT_ARG_ANNOUNCE (-A) is setted */
+			/* we need to stream the announcement(s) when the OPT_ARG_ANNOUNCE (-A) is set */
+			callerfile = opt_args[OPT_ARG_ANNOUNCE];
+			calledfile = strsep(&callerfile, ":");
 
-			/* stream the file */
-			res = ast_streamfile(peer, opt_args[OPT_ARG_ANNOUNCE], ast_channel_language(peer));
-			if (res) {
-				res = 0;
-				ast_log(LOG_ERROR, "error streaming file '%s' to callee\n", opt_args[OPT_ARG_ANNOUNCE]);
+			/* stream the file(s) */
+			if (!ast_strlen_zero(calledfile)) {
+				res = ast_streamfile(peer, calledfile, ast_channel_language(peer));
+				if (res) {
+					res = 0;
+					ast_log(LOG_ERROR, "error streaming file '%s' to callee\n", calledfile);
+				} else {
+					calledstream = 1;
+				}
+			}
+			if (!ast_strlen_zero(callerfile)) {
+				res = ast_streamfile(chan, callerfile, ast_channel_language(chan));
+				if (res) {
+					res = 0;
+					ast_log(LOG_ERROR, "error streaming file '%s' to caller\n", callerfile);
+				} else {
+					callerstream = 1;
+				}
 			}
 
+			/* can't use ast_waitstream, because we're streaming two files at once, and can't block
+				We'll need to handle both channels at once. */
+
 			ast_channel_set_flag(peer, AST_FLAG_END_DTMF_ONLY);
-			while (ast_channel_stream(peer)) {
-				int ms;
+			while (ast_channel_stream(peer) || ast_channel_stream(chan)) {
+				int mspeer, mschan;
 
-				ms = ast_sched_wait(ast_channel_sched(peer));
+				mspeer = ast_sched_wait(ast_channel_sched(peer));
+				mschan = ast_sched_wait(ast_channel_sched(chan));
 
-				if (ms < 0 && !ast_channel_timingfunc(peer)) {
-					ast_stopstream(peer);
+				if (calledstream) {
+					if (mspeer < 0 && !ast_channel_timingfunc(peer)) {
+						ast_stopstream(peer);
+						calledstream = 0;
+					}
+				}
+				if (callerstream) {
+					if (mschan < 0 && !ast_channel_timingfunc(chan)) {
+						ast_stopstream(chan);
+						callerstream = 0;
+					}
+				}
+
+				if (!calledstream && !callerstream) {
 					break;
 				}
-				if (ms < 0)
-					ms = 1000;
 
-				active_chan = ast_waitfor_n(chans, 2, &ms);
+				if (mspeer < 0)
+					mspeer = 1000;
+
+				if (mschan < 0)
+					mschan = 1000;
+
+				/* wait for the lowest maximum of the two */
+				active_chan = ast_waitfor_n(chans, 2, (mspeer > mschan ? &mschan : &mspeer));
 				if (active_chan) {
 					struct ast_channel *other_chan;
 					struct ast_frame *fr = ast_read(active_chan);
@@ -2998,6 +3057,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 					ast_frfree(fr);
 				}
 				ast_sched_runq(ast_channel_sched(peer));
+				ast_sched_runq(ast_channel_sched(chan));
 			}
 			ast_channel_clear_flag(peer, AST_FLAG_END_DTMF_ONLY);
 		}
@@ -3267,6 +3327,7 @@ static int dial_exec_full(struct ast_channel *chan, const char *data, struct ast
 				ast_channel_setoption(chan, AST_OPTION_OPRMODE, &oprmode, sizeof(oprmode), 0);
 			}
 			setup_peer_after_bridge_goto(chan, peer, &opts, opt_args);
+
 			res = ast_bridge_call(chan, peer, &config);
 		}
 	}
@@ -3304,6 +3365,18 @@ out:
 	}
 
 done:
+	if (config.answer_topology) {
+		ast_trace(2, "%s Cleaning up topology: %p %s\n",
+			peer ? ast_channel_name(peer) : "<no channel>", &config.answer_topology,
+			ast_str_tmp(256, ast_stream_topology_to_str(config.answer_topology, &STR_TMP)));
+
+		/*
+		 * At this point, the channel driver that answered should have bumped the
+		 * topology refcount for itself.  Here we're cleaning up the reference we added
+		 * in wait_for_answer().
+		 */
+		ast_stream_topology_free(config.answer_topology);
+	}
 	if (config.warning_sound) {
 		ast_free((char *)config.warning_sound);
 	}
@@ -3314,7 +3387,7 @@ done:
 		ast_free((char *)config.start_sound);
 	}
 	ast_ignore_cc(chan);
-	return res;
+	SCOPE_EXIT_RTN_VALUE(res, "%s: Done\n", ast_channel_name(chan));
 }
 
 static int dial_exec(struct ast_channel *chan, const char *data)

apps/app_dictate.c

@@ -28,6 +28,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 

apps/app_directory.c

@@ -103,6 +103,14 @@
 						receiver to their ear while entering DTMF.</para>
 						<argument name="n" required="true" />
 					</option>
+					<option name="c">
+						<para>Load the specified config file instead of voicemail.conf</para>
+						<argument name="filename" required="true" />
+					</option>
+					<option name="s">
+						<para>Skip calling the extension, instead set it in the <variable>DIRECTORY_EXTEN</variable>
+						channel variable.</para>
+					</option>
 				</optionlist>
 				<note><para>Only one of the <replaceable>f</replaceable>, <replaceable>l</replaceable>, or <replaceable>b</replaceable>
 				options may be specified. <emphasis>If more than one is specified</emphasis>, then Directory will act as
@@ -114,12 +122,12 @@
 		<description>
 			<para>This application will present the calling channel with a directory of extensions from which they can search
 			by name. The list of names and corresponding extensions is retrieved from the
-			voicemail configuration file, <filename>voicemail.conf</filename>.</para>
+			voicemail configuration file, <filename>voicemail.conf</filename>, or from the specified filename.</para>
 			<para>This application will immediately exit if one of the following DTMF digits are
 			received and the extension to jump to exists:</para>
 			<para><literal>0</literal> - Jump to the 'o' extension, if it exists.</para>
 			<para><literal>*</literal> - Jump to the 'a' extension, if it exists.</para>
-			<para>This application will set the following channel variable before completion:</para>
+			<para>This application will set the following channel variables before completion:</para>
 			<variablelist>
 				<variable name="DIRECTORY_RESULT">
 					<para>Reason Directory application exited.</para>
@@ -131,6 +139,10 @@
 					<value name="USEREXIT">User exited with '#' during selection</value>
 					<value name="FAILED">The application failed</value>
 				</variable>
+				<variable name="DIRECTORY_EXTEN">
+					<para>If the skip calling option is set this will be set to the selected extension
+					provided one is selected.</para>
+				</variable>
 			</variablelist>
 		</description>
 	</application>
@@ -153,6 +165,8 @@ enum {
 	OPT_PAUSE =           (1 << 5),
 	OPT_NOANSWER =        (1 << 6),
 	OPT_ALIAS =           (1 << 7),
+	OPT_CONFIG_FILE =     (1 << 8),
+	OPT_SKIP =            (1 << 9),
 };
 
 enum {
@@ -160,8 +174,9 @@ enum {
 	OPT_ARG_LASTNAME =    1,
 	OPT_ARG_EITHER =      2,
 	OPT_ARG_PAUSE =       3,
+	OPT_ARG_FILENAME =    4,
 	/* This *must* be the last value in this enum! */
-	OPT_ARG_ARRAY_SIZE =  4,
+	OPT_ARG_ARRAY_SIZE =  5,
 };
 
 struct directory_item {
@@ -183,6 +198,8 @@ AST_APP_OPTIONS(directory_app_options, {
 	AST_APP_OPTION('m', OPT_SELECTFROMMENU),
 	AST_APP_OPTION('n', OPT_NOANSWER),
 	AST_APP_OPTION('a', OPT_ALIAS),
+	AST_APP_OPTION_ARG('c', OPT_CONFIG_FILE, OPT_ARG_FILENAME),
+	AST_APP_OPTION('s', OPT_SKIP),
 });
 
 static int compare(const char *text, const char *template)
@@ -318,6 +335,9 @@ static int select_entry(struct ast_channel *chan, const char *dialcontext, const
 	if (ast_test_flag(flags, OPT_FROMVOICEMAIL)) {
 		/* We still want to set the exten though */
 		ast_channel_exten_set(chan, item->exten);
+	} else if (ast_test_flag(flags, OPT_SKIP)) {
+		/* Skip calling the extension, only set it in the channel variable. */
+		pbx_builtin_setvar_helper(chan, "DIRECTORY_EXTEN", item->exten);
 	} else if (ast_goto_if_exists(chan, S_OR(dialcontext, item->context), item->exten, 1)) {
 		ast_log(LOG_WARNING,
 			"Can't find extension '%s' in context '%s'.  "
@@ -396,7 +416,7 @@ static int select_item_menu(struct ast_channel *chan, struct directory_item **it
 {
 	struct directory_item **block, *item;
 	int i, limit, res = 0;
-	char buf[9];
+	char buf[7+12]; /* INT_MIN has a length of 12 chars */
 
 	/* option p(n): cellphone pause option */
 	select_item_pause(chan, flags, opts);
@@ -458,7 +478,7 @@ static int select_item_menu(struct ast_channel *chan, struct directory_item **it
 
 AST_THREADSTORAGE(commonbuf);
 
-static struct ast_config *realtime_directory(char *context)
+static struct ast_config *realtime_directory(char *context, const char *filename)
 {
 	struct ast_config *cfg;
 	struct ast_config *rtdata = NULL;
@@ -475,14 +495,14 @@ static struct ast_config *realtime_directory(char *context)
 	}
 
 	/* Load flat file config. */
-	cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags);
+	cfg = ast_config_load(filename, config_flags);
 
 	if (!cfg) {
 		/* Loading config failed. */
 		ast_log(LOG_WARNING, "Loading config failed.\n");
 		return NULL;
 	} else if (cfg == CONFIG_STATUS_FILEINVALID) {
-		ast_log(LOG_ERROR, "Config file %s is in an invalid format.  Aborting.\n", VOICEMAIL_CONFIG);
+		ast_log(LOG_ERROR, "Config file %s is in an invalid format.  Aborting.\n", filename);
 		return NULL;
 	}
 
@@ -867,7 +887,9 @@ static int directory_exec(struct ast_channel *chan, const char *data)
 	if (args.options && ast_app_parse_options(directory_app_options, &flags, opts, args.options))
 		return -1;
 
-	if (!(cfg = realtime_directory(args.vmcontext))) {
+	cfg = realtime_directory(args.vmcontext, S_OR(opts[OPT_ARG_FILENAME], VOICEMAIL_CONFIG));
+
+	if (!cfg) {
 		ast_log(LOG_ERROR, "Unable to read the configuration data!\n");
 		return -1;
 	}

apps/app_dtmfstore.c

@@ -0,0 +1,293 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2021, Naveen Albert
+ *
+ * Naveen Albert <asterisk@phreaknet.org>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Technology independent asynchronous DTMF collection
+ *
+ * \author Naveen Albert <asterisk@phreaknet.org>
+ *
+ * \ingroup functions
+ *
+ */
+
+/*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
+	<support_level>extended</support_level>
+ ***/
+
+#include "asterisk.h"
+
+#include "asterisk/module.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/framehook.h"
+#include "asterisk/app.h"
+#include "asterisk/conversions.h"
+
+/*** DOCUMENTATION
+	<application name="StoreDTMF" language="en_US">
+		<synopsis>
+			Stores DTMF digits transmitted or received on a channel.
+		</synopsis>
+		<syntax>
+			<parameter name="direction" required="true">
+				<para>Must be <literal>TX</literal> or <literal>RX</literal> to
+				store digits, or <literal>remove</literal> to disable.</para>
+			</parameter>
+		</syntax>
+		<description>
+			<para>The StoreDTMF function can be used to obtain digits sent in the
+			<literal>TX</literal> or <literal>RX</literal> direction of any channel.</para>
+			<para>The arguments are:</para>
+			<para><replaceable>var_name</replaceable>: Name of variable to which to append
+			digits.</para>
+			<para><replaceable>max_digits</replaceable>: The maximum number of digits to
+			store in the variable. Defaults to 0 (no maximum). After reading <literal>
+			maximum</literal> digits, no more digits will be stored.</para>
+			<example title="Store digits in CDR variable">
+			same => n,StoreDTMF(TX,CDR(digits))
+			</example>
+			<example title="Store up to 24 digits">
+			same => n,StoreDTMF(RX,testvar,24)
+			</example>
+			<example title="Disable digit collection">
+			same => n,StoreDTMF(remove)
+			</example>
+		</description>
+	</application>
+ ***/
+
+static char *app = "StoreDTMF";
+
+/*! \brief Private data structure used with the function's datastore */
+struct dtmf_store_data {
+	int framehook_id;
+	char *rx_var;
+	char *tx_var;
+	int maxdigits;
+};
+
+static void datastore_destroy_cb(void *data) {
+	struct dtmf_store_data *d;
+	d = data;
+	if (d) {
+		if (d->rx_var) {
+			ast_free(d->rx_var);
+		}
+		if (d->tx_var) {
+			ast_free(d->tx_var);
+		}
+		ast_free(data);
+	}
+}
+
+/*! \brief The channel datastore the function uses to store state */
+static const struct ast_datastore_info dtmf_store_datastore = {
+	.type = "dtmf_store",
+	.destroy = datastore_destroy_cb
+};
+
+/*! \internal \brief Store digits tx/rx on the channel */
+static int remove_dtmf_store(struct ast_channel *chan)
+{
+	struct ast_datastore *datastore = NULL;
+	struct dtmf_store_data *data;
+	SCOPED_CHANNELLOCK(chan_lock, chan);
+
+	datastore = ast_channel_datastore_find(chan, &dtmf_store_datastore, NULL);
+	if (!datastore) {
+		ast_log(AST_LOG_WARNING, "Cannot remove StoreDTMF from %s: StoreDTMF not currently enabled\n",
+		        ast_channel_name(chan));
+		return -1;
+	}
+	data = datastore->data;
+
+	if (ast_framehook_detach(chan, data->framehook_id)) {
+		ast_log(AST_LOG_WARNING, "Failed to remove StoreDTMF framehook from channel %s\n",
+		        ast_channel_name(chan));
+		return -1;
+	}
+
+	if (ast_channel_datastore_remove(chan, datastore)) {
+		ast_log(AST_LOG_WARNING, "Failed to remove StoreDTMF datastore from channel %s\n",
+		        ast_channel_name(chan));
+		return -1;
+	}
+	ast_datastore_free(datastore);
+
+	return 0;
+}
+
+/*! \brief Frame hook that is called to intercept digit/undigit */
+static struct ast_frame *dtmf_store_framehook(struct ast_channel *chan,
+	struct ast_frame *f, enum ast_framehook_event event, void *data)
+{
+	char currentdata[512];
+	char varnamesub[64];
+	char *varname = NULL;
+	struct dtmf_store_data *framedata = data;
+	int len;
+
+	if (!f || !framedata) {
+		return f;
+	}
+
+	if ((event != AST_FRAMEHOOK_EVENT_WRITE) && (event != AST_FRAMEHOOK_EVENT_READ)) {
+		return f;
+	}
+
+	if (f->frametype != AST_FRAME_DTMF_END) {
+		return f;
+	}
+
+	/* If this is DTMF then store the digits */
+	if (event == AST_FRAMEHOOK_EVENT_READ && framedata->rx_var) { /* coming from source */
+		varname = framedata->rx_var;
+	} else if (event == AST_FRAMEHOOK_EVENT_WRITE && framedata->tx_var) { /* going to source */
+		varname = framedata->tx_var;
+	}
+
+	if (!varname) {
+		return f;
+	}
+
+	sprintf(varnamesub, "${%s}", varname);
+	pbx_substitute_variables_helper(chan, varnamesub, currentdata, 511);
+	/* pbx_builtin_getvar_helper works for regular vars but not CDR vars */
+	if (ast_strlen_zero(currentdata)) { /* var doesn't exist yet */
+		ast_debug(3, "Creating new digit store: %s\n", varname);
+	}
+	len = strlen(currentdata);
+	if (framedata->maxdigits > 0 && len >= framedata->maxdigits) {
+		ast_debug(3, "Reached digit limit: %d\n", framedata->maxdigits);
+		remove_dtmf_store(chan); /* reached max digit count, stop now */
+		return f;
+	} else {
+		char newdata[len + 2]; /* one more char + terminator */
+		if (len > 0) {
+			ast_copy_string(newdata, currentdata, len + 2);
+		}
+		newdata[len] = (unsigned) f->subclass.integer;
+		newdata[len + 1] = '\0';
+		ast_debug(3, "Appending to digit store: now %s\n", newdata);
+		pbx_builtin_setvar_helper(chan, varname, newdata);
+	}
+	return f;
+}
+
+/*! \internal \brief Enable digit interception on the channel */
+static int dtmfstore_exec(struct ast_channel *chan, const char *appdata)
+{
+	struct ast_datastore *datastore;
+	struct dtmf_store_data *data;
+	static struct ast_framehook_interface digit_framehook_interface = {
+		.version = AST_FRAMEHOOK_INTERFACE_VERSION,
+		.event_cb = dtmf_store_framehook,
+		.disable_inheritance = 1,
+	};
+	char *parse = ast_strdupa(appdata);
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(direction);
+		AST_APP_ARG(varname);
+		AST_APP_ARG(maxdigits);
+	);
+	SCOPED_CHANNELLOCK(chan_lock, chan);
+	AST_STANDARD_APP_ARGS(args, parse);
+
+	if (ast_strlen_zero(appdata)) {
+		ast_log(AST_LOG_WARNING, "StoreDTMF requires an argument\n");
+		return -1;
+	}
+
+	if (!strcasecmp(args.direction, "remove")) {
+		return remove_dtmf_store(chan);
+	}
+
+	datastore = ast_channel_datastore_find(chan, &dtmf_store_datastore, NULL);
+	if (datastore) {
+		ast_log(AST_LOG_WARNING, "StoreDTMF already set on '%s'\n",
+		        ast_channel_name(chan));
+		return 0;
+	}
+
+	datastore = ast_datastore_alloc(&dtmf_store_datastore, NULL);
+	if (!datastore) {
+		return -1;
+	}
+
+	data = ast_calloc(1, sizeof(*data));
+	if (!data) {
+		ast_datastore_free(datastore);
+		return -1;
+	}
+
+	digit_framehook_interface.data = data;
+
+	data->rx_var = NULL;
+	data->tx_var = NULL;
+	data->maxdigits = 0;
+
+	if (!strcasecmp(args.direction, "tx")) {
+		data->tx_var = ast_strdup(args.varname);
+	} else if (!strcasecmp(args.direction, "rx")) {
+		data->rx_var = ast_strdup(args.varname);
+	} else {
+		ast_log(LOG_ERROR, "Direction must be either RX or TX\n");
+		return -1;
+	}
+
+	if (!ast_strlen_zero(args.maxdigits)) {
+		if (ast_str_to_int(args.maxdigits,&(data->maxdigits))) {
+			ast_log(LOG_ERROR, "Invalid integer: %s\n", args.maxdigits);
+			return -1;
+		}
+		if (data->maxdigits < 0) {
+			ast_log(LOG_ERROR, "Invalid natural number: %d\n", data->maxdigits);
+			return -1;
+		} else if (data->maxdigits == 0) {
+			ast_log(LOG_WARNING, "No maximum digit count set\n");
+		}
+	}
+
+	data->framehook_id = ast_framehook_attach(chan, &digit_framehook_interface);
+	if (data->framehook_id < 0) {
+		ast_log(AST_LOG_WARNING, "Failed to attach StoreDTMF framehook to '%s'\n",
+		        ast_channel_name(chan));
+		ast_datastore_free(datastore);
+		ast_free(data);
+		return -1;
+	}
+	datastore->data = data;
+
+	ast_channel_datastore_add(chan, datastore);
+
+	return 0;
+}
+
+static int unload_module(void)
+{
+	return ast_unregister_application(app);
+}
+
+static int load_module(void)
+{
+	return ast_register_application_xml(app, dtmfstore_exec);
+}
+
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Technology independent async DTMF storage");

apps/app_externalivr.c

@@ -32,6 +32,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -254,9 +255,9 @@ static struct ast_frame *gen_readframe(struct gen_state *state)
 	if (!(state->stream && (f = ast_readframe(state->stream)))) {
 		if (state->current) {
 			/* remove finished file from playlist */
-                        AST_LIST_LOCK(&u->playlist);
-                        AST_LIST_REMOVE_HEAD(&u->playlist, list);
-                        AST_LIST_UNLOCK(&u->playlist);
+			AST_LIST_LOCK(&u->playlist);
+			AST_LIST_REMOVE_HEAD(&u->playlist, list);
+			AST_LIST_UNLOCK(&u->playlist);
 			/* add finished file to finishlist */
 			AST_LIST_LOCK(&u->finishlist);
 			AST_LIST_INSERT_TAIL(&u->finishlist, state->current, list);
@@ -581,7 +582,7 @@ static int app_exec(struct ast_channel *chan, const char *data)
 		}
 	}
 
-	exit:
+  exit:
 	if (u->gen_active) {
 		ast_deactivate_generator(chan);
 	}
@@ -622,21 +623,21 @@ static int app_exec(struct ast_channel *chan, const char *data)
 }
 
 static int eivr_comm(struct ast_channel *chan, struct ivr_localuser *u,
-				struct ast_iostream *eivr_events,
-				struct ast_iostream *eivr_commands,
-				struct ast_iostream *eivr_errors,
-				const struct ast_str *args, const struct ast_flags flags)
+	struct ast_iostream *eivr_events,
+	struct ast_iostream *eivr_commands,
+	struct ast_iostream *eivr_errors,
+	const struct ast_str *args, const struct ast_flags flags)
 {
 	char input[1024];
 	struct playlist_entry *entry;
 	struct ast_frame *f;
 	int ms;
- 	int exception;
- 	int ready_fd;
+	int exception;
+	int ready_fd;
 	int waitfds[2];
 	int r;
- 	struct ast_channel *rchan;
- 	int res = -1;
+	struct ast_channel *rchan;
+	int res = -1;
 	int hangup_info_sent = 0;
 
 	waitfds[0] = ast_iostream_get_fd(eivr_commands);
@@ -645,78 +646,78 @@ static int eivr_comm(struct ast_channel *chan, struct ivr_localuser *u,
 	while (1) {
 		if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
 			ast_chan_log(LOG_ERROR, chan, "Is a zombie\n");
- 			break;
- 		}
- 		if (!hangup_info_sent && !(ast_test_flag(&flags, run_dead)) && ast_check_hangup(chan)) {
+			break;
+		}
+		if (!hangup_info_sent && !(ast_test_flag(&flags, run_dead)) && ast_check_hangup(chan)) {
 			if (ast_test_flag(&flags, ignore_hangup)) {
 				ast_verb(3, "Got check_hangup, but ignore_hangup set so sending 'I' command\n");
 				send_eivr_event(eivr_events, 'I', "HANGUP", chan);
 				hangup_info_sent = 1;
 			} else {
- 				ast_verb(3, "Got check_hangup\n");
- 				send_eivr_event(eivr_events, 'H', NULL, chan);
-	 			break;
+				ast_verb(3, "Got check_hangup\n");
+				send_eivr_event(eivr_events, 'H', NULL, chan);
+				break;
 			}
- 		}
+		}
 
- 		ready_fd = 0;
- 		ms = 100;
- 		errno = 0;
- 		exception = 0;
+		ready_fd = 0;
+		ms = 100;
+		errno = 0;
+		exception = 0;
 
 		rchan = ast_waitfor_nandfds(&chan, 1, waitfds, (eivr_errors) ? 2 : 1, &exception, &ready_fd, &ms);
 
- 		if (ast_channel_state(chan) == AST_STATE_UP && !AST_LIST_EMPTY(&u->finishlist)) {
- 			AST_LIST_LOCK(&u->finishlist);
- 			while ((entry = AST_LIST_REMOVE_HEAD(&u->finishlist, list))) {
- 				send_eivr_event(eivr_events, 'F', entry->filename, chan);
- 				ast_free(entry);
- 			}
- 			AST_LIST_UNLOCK(&u->finishlist);
- 		}
+		if (ast_channel_state(chan) == AST_STATE_UP && !AST_LIST_EMPTY(&u->finishlist)) {
+			AST_LIST_LOCK(&u->finishlist);
+			while ((entry = AST_LIST_REMOVE_HEAD(&u->finishlist, list))) {
+				send_eivr_event(eivr_events, 'F', entry->filename, chan);
+				ast_free(entry);
+			}
+			AST_LIST_UNLOCK(&u->finishlist);
+		}
 
- 		if (ast_channel_state(chan) == AST_STATE_UP && !(ast_check_hangup(chan)) && rchan) {
- 			/* the channel has something */
- 			f = ast_read(chan);
- 			if (!f) {
- 				ast_verb(3, "Returned no frame\n");
- 				send_eivr_event(eivr_events, 'H', NULL, chan);
- 				break;
- 			}
- 			if (f->frametype == AST_FRAME_DTMF) {
- 				send_eivr_event(eivr_events, f->subclass.integer, NULL, chan);
- 				if (u->option_autoclear) {
-  					AST_LIST_LOCK(&u->playlist);
-  					if (!u->abort_current_sound && !u->playing_silence) {
+		if (ast_channel_state(chan) == AST_STATE_UP && !(ast_check_hangup(chan)) && rchan) {
+			/* the channel has something */
+			f = ast_read(chan);
+			if (!f) {
+				ast_verb(3, "Returned no frame\n");
+				send_eivr_event(eivr_events, 'H', NULL, chan);
+				break;
+			}
+			if (f->frametype == AST_FRAME_DTMF) {
+				send_eivr_event(eivr_events, f->subclass.integer, NULL, chan);
+				if (u->option_autoclear) {
+					AST_LIST_LOCK(&u->playlist);
+					if (!u->abort_current_sound && !u->playing_silence) {
 						/* send interrupted file as T data */
- 						if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
-	 						send_eivr_event(eivr_events, 'T', entry->filename, chan);
+						if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+							send_eivr_event(eivr_events, 'T', entry->filename, chan);
 							ast_free(entry);
 						}
 					}
-  					while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
- 						send_eivr_event(eivr_events, 'D', entry->filename, chan);
-  						ast_free(entry);
-  					}
-  					if (!u->playing_silence)
-  						u->abort_current_sound = 1;
-  					AST_LIST_UNLOCK(&u->playlist);
-  				}
- 			} else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass.integer == AST_CONTROL_HANGUP)) {
- 				ast_verb(3, "Got AST_CONTROL_HANGUP\n");
- 				send_eivr_event(eivr_events, 'H', NULL, chan);
+					while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+						send_eivr_event(eivr_events, 'D', entry->filename, chan);
+						ast_free(entry);
+					}
+					if (!u->playing_silence)
+						u->abort_current_sound = 1;
+					AST_LIST_UNLOCK(&u->playlist);
+				}
+			} else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass.integer == AST_CONTROL_HANGUP)) {
+				ast_verb(3, "Got AST_CONTROL_HANGUP\n");
+				send_eivr_event(eivr_events, 'H', NULL, chan);
 				if (f->data.uint32) {
 					ast_channel_hangupcause_set(chan, f->data.uint32);
 				}
- 				ast_frfree(f);
- 				break;
- 			}
- 			ast_frfree(f);
- 		} else if (ready_fd == waitfds[0]) {
- 			if (exception) {
- 				ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
-  				break;
-  			}
+				ast_frfree(f);
+				break;
+			}
+			ast_frfree(f);
+		} else if (ready_fd == waitfds[0]) {
+			if (exception) {
+				ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
+				break;
+			}
 
 			r = ast_iostream_gets(eivr_commands, input, sizeof(input));
 			if (r <= 0) {
@@ -784,112 +785,112 @@ static int eivr_comm(struct ast_channel *chan, struct ivr_localuser *u,
 					u->abort_current_sound = 1;
 				}
 				AST_LIST_UNLOCK(&u->playlist);
- 			} else if (input[0] == EIVR_CMD_SQUE) {
+			} else if (input[0] == EIVR_CMD_SQUE) {
 				if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
 					ast_chan_log(LOG_WARNING, chan, "Queue re'S'et called on unanswered channel\n");
 					send_eivr_event(eivr_events, 'Z', NULL, chan);
 					continue;
 				}
- 				if (!ast_fileexists(&input[2], NULL, ast_channel_language(u->chan))) {
- 					ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
- 					send_eivr_event(eivr_events, 'Z', &input[2], chan);
- 				} else {
- 					AST_LIST_LOCK(&u->playlist);
-	 				if (!u->abort_current_sound && !u->playing_silence) {
+				if (!ast_fileexists(&input[2], NULL, ast_channel_language(u->chan))) {
+					ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
+					send_eivr_event(eivr_events, 'Z', &input[2], chan);
+				} else {
+					AST_LIST_LOCK(&u->playlist);
+					if (!u->abort_current_sound && !u->playing_silence) {
 						/* send interrupted file as T data */
- 						if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
-	 						send_eivr_event(eivr_events, 'T', entry->filename, chan);
+						if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+							send_eivr_event(eivr_events, 'T', entry->filename, chan);
 							ast_free(entry);
 						}
 					}
- 					while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
- 						send_eivr_event(eivr_events, 'D', entry->filename, chan);
- 						ast_free(entry);
+					while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+						send_eivr_event(eivr_events, 'D', entry->filename, chan);
+						ast_free(entry);
 					}
-	 				if (!u->playing_silence) {
- 						u->abort_current_sound = 1;
+					if (!u->playing_silence) {
+						u->abort_current_sound = 1;
 					}
- 					entry = make_entry(&input[2]);
- 					if (entry) {
- 						AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
+					entry = make_entry(&input[2]);
+					if (entry) {
+						AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
 					}
-	 				AST_LIST_UNLOCK(&u->playlist);
+					AST_LIST_UNLOCK(&u->playlist);
 				}
- 			} else if (input[0] == EIVR_CMD_APND) {
+			} else if (input[0] == EIVR_CMD_APND) {
 				if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
 					ast_chan_log(LOG_WARNING, chan, "Queue 'A'ppend called on unanswered channel\n");
 					send_eivr_event(eivr_events, 'Z', NULL, chan);
 					continue;
 				}
- 				if (!ast_fileexists(&input[2], NULL, ast_channel_language(u->chan))) {
- 					ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
- 					send_eivr_event(eivr_events, 'Z', &input[2], chan);
- 				} else {
-	 				entry = make_entry(&input[2]);
- 					if (entry) {
- 						AST_LIST_LOCK(&u->playlist);
- 						AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
- 						AST_LIST_UNLOCK(&u->playlist);
+				if (!ast_fileexists(&input[2], NULL, ast_channel_language(u->chan))) {
+					ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
+					send_eivr_event(eivr_events, 'Z', &input[2], chan);
+				} else {
+					entry = make_entry(&input[2]);
+					if (entry) {
+						AST_LIST_LOCK(&u->playlist);
+						AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
+						AST_LIST_UNLOCK(&u->playlist);
 					}
- 				}
- 			} else if (input[0] == EIVR_CMD_GET) {
- 				char response[2048];
+				}
+			} else if (input[0] == EIVR_CMD_GET) {
+				char response[2048];
 				ast_verb(4, "Retriving Variables from channel: %s\n", &input[2]);
- 				ast_eivr_getvariable(chan, &input[2], response, sizeof(response));
- 				send_eivr_event(eivr_events, 'G', response, chan);
- 			} else if (input[0] == EIVR_CMD_SVAR) {
+				ast_eivr_getvariable(chan, &input[2], response, sizeof(response));
+				send_eivr_event(eivr_events, 'G', response, chan);
+			} else if (input[0] == EIVR_CMD_SVAR) {
 				ast_verb(4, "Setting Variables in channel: %s\n", &input[2]);
- 				ast_eivr_setvariable(chan, &input[2]);
- 			} else if (input[0] == EIVR_CMD_LOG) {
- 				ast_chan_log(LOG_NOTICE, chan, "Log message from EIVR: %s\n", &input[2]);
- 			} else if (input[0] == EIVR_CMD_XIT) {
- 				ast_chan_log(LOG_NOTICE, chan, "Exiting: %s\n", &input[2]);
+				ast_eivr_setvariable(chan, &input[2]);
+			} else if (input[0] == EIVR_CMD_LOG) {
+				ast_chan_log(LOG_NOTICE, chan, "Log message from EIVR: %s\n", &input[2]);
+			} else if (input[0] == EIVR_CMD_XIT) {
+				ast_chan_log(LOG_NOTICE, chan, "Exiting: %s\n", &input[2]);
 				ast_chan_log(LOG_WARNING, chan, "e'X'it command is depricated, use 'E'xit instead\n");
- 				res = 0;
- 				break;
+				res = 0;
+				break;
 			} else if (input[0] == EIVR_CMD_EXIT) {
- 				ast_chan_log(LOG_NOTICE, chan, "Exiting: %s\n", &input[2]);
- 				send_eivr_event(eivr_events, 'E', NULL, chan);
- 				res = 0;
- 				break;
- 			} else if (input[0] == EIVR_CMD_HGUP) {
- 				ast_chan_log(LOG_NOTICE, chan, "Hanging up: %s\n", &input[2]);
- 				send_eivr_event(eivr_events, 'H', NULL, chan);
- 				break;
- 			} else if (input[0] == EIVR_CMD_OPT) {
+				ast_chan_log(LOG_NOTICE, chan, "Exiting: %s\n", &input[2]);
+				send_eivr_event(eivr_events, 'E', NULL, chan);
+				res = 0;
+				break;
+			} else if (input[0] == EIVR_CMD_HGUP) {
+				ast_chan_log(LOG_NOTICE, chan, "Hanging up: %s\n", &input[2]);
+				send_eivr_event(eivr_events, 'H', NULL, chan);
+				break;
+			} else if (input[0] == EIVR_CMD_OPT) {
 				if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
 					ast_chan_log(LOG_WARNING, chan, "Option called on unanswered channel\n");
 					send_eivr_event(eivr_events, 'Z', NULL, chan);
 					continue;
 				}
- 				if (!strcasecmp(&input[2], "autoclear"))
- 					u->option_autoclear = 1;
- 				else if (!strcasecmp(&input[2], "noautoclear"))
- 					u->option_autoclear = 0;
- 				else
- 					ast_chan_log(LOG_WARNING, chan, "Unknown option requested: %s\n", &input[2]);
- 			}
- 		} else if (ready_fd == waitfds[1]) {
- 			if (exception) {
- 				ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
- 				break;
- 			}
-
- 			r = ast_iostream_gets(eivr_errors, input, sizeof(input));
- 			if (r > 0) {
- 				ast_chan_log(LOG_NOTICE, chan, "stderr: %s\n", ast_strip(input));
- 			} else if (r == 0) {
- 				ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
- 				break;
+				if (!strcasecmp(&input[2], "autoclear"))
+					u->option_autoclear = 1;
+				else if (!strcasecmp(&input[2], "noautoclear"))
+					u->option_autoclear = 0;
+				else
+					ast_chan_log(LOG_WARNING, chan, "Unknown option requested: %s\n", &input[2]);
+			}
+		} else if (ready_fd == waitfds[1]) {
+			if (exception) {
+				ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
+				break;
 			}
- 		} else if ((ready_fd < 0) && ms) {
- 			if (errno == 0 || errno == EINTR)
- 				continue;
 
- 			ast_chan_log(LOG_ERROR, chan, "Wait failed (%s)\n", strerror(errno));
- 			break;
- 		}
- 	}
+			r = ast_iostream_gets(eivr_errors, input, sizeof(input));
+			if (r > 0) {
+				ast_chan_log(LOG_NOTICE, chan, "stderr: %s\n", ast_strip(input));
+			} else if (r == 0) {
+				ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
+				break;
+			}
+		} else if ((ready_fd < 0) && ms) {
+			if (errno == 0 || errno == EINTR)
+				continue;
+
+			ast_chan_log(LOG_ERROR, chan, "Wait failed (%s)\n", strerror(errno));
+			break;
+		}
+	}
 
 	return res;
 }

apps/app_fax.c

@@ -13,11 +13,13 @@
  */
 
 /*** MODULEINFO
-	<defaultenabled>no</defaultenabled>
 	<depend>spandsp</depend>
 	<conflict>res_fax</conflict>
+	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
 	<replacement>res_fax</replacement>
+	<deprecated_in>16</deprecated_in>
+	<removed_in>19</removed_in>
 ***/
 
 /* Needed for spandsp headers */

apps/app_festival.c

@@ -37,6 +37,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -433,7 +434,7 @@ static int festival_exec(struct ast_channel *chan, const char *vdata)
 	}
 	readcache = 0;
 	writecache = 0;
-	if (strlen(cachedir) + strlen(MD5Hex) + 1 <= MAXFESTLEN && (usecache == -1)) {
+	if (strlen(cachedir) + sizeof(MD5Hex) + 1 <= MAXFESTLEN && (usecache == -1)) {
 		snprintf(cachefile, sizeof(cachefile), "%s/%s", cachedir, MD5Hex);
 		fdesc = open(cachefile, O_RDWR);
 		if (fdesc == -1) {

apps/app_forkcdr.c

@@ -2,7 +2,7 @@
  * Asterisk -- An open source telephony toolkit.
  *
  * Copyright (C) 1999 - 2005, Anthony Minessale anthmct@yahoo.com
- * Development of this app Sponsered/Funded  by TAAN Softworks Corp
+ * Development of this app Sponsored/Funded  by TAAN Softworks Corp
  *
  * See http://www.asterisk.org for more information about
  * the Asterisk project. Please do not directly contact

apps/app_getcpeid.c

@@ -27,6 +27,7 @@
 
 /*** MODULEINFO
 	<depend>res_adsi</depend>
+	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
  ***/
 

apps/app_ices.c

@@ -28,7 +28,10 @@
  */
 
 /*** MODULEINFO
-	<support_level>deprecated</support_level>
+	<defaultenabled>no</defaultenabled>
+	<support_level>deprecated</support_level>	
+	<deprecated_in>16</deprecated_in>
+	<removed_in>19</removed_in>
  ***/
 
 #include "asterisk.h"

apps/app_image.c

@@ -26,7 +26,10 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
+	<deprecated_in>16</deprecated_in>
+	<removed_in>19</removed_in>
  ***/
 
 #include "asterisk.h"

apps/app_jack.c

@@ -37,6 +37,7 @@
 /*** MODULEINFO
 	<depend>jack</depend>
 	<depend>resample</depend>
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -615,8 +616,6 @@ static int queue_voice_frame(struct jack_data *jack_data, struct ast_frame *f)
  * Read data from the input ringbuffer, which is the properly resampled audio
  * that was read from the jack input port.  Write it to the channel in 20 ms frames,
  * or fill up an output frame instead if one is provided.
- *
- * \return Nothing.
  */
 static void handle_jack_audio(struct ast_channel *chan, struct jack_data *jack_data,
 	struct ast_frame *out_frame)

apps/app_macro.c

@@ -29,6 +29,8 @@
 	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
 	<replacement>app_stack (GoSub)</replacement>
+	<deprecated_in>16</deprecated_in>
+	<removed_in>21</removed_in>
  ***/
 
 #include "asterisk.h"
@@ -73,7 +75,7 @@
 			of nesting (macro calling macro calling macro, etc.); It may be possible that stack-intensive
 			applications in deeply nested macros could cause asterisk to crash earlier than this limit.
 			It is advised that if you need to deeply nest macro calls, that you use the Gosub application
-			(now allows arguments like a Macro) with explict Return() calls instead.</para></warning>
+			(now allows arguments like a Macro) with explicit Return() calls instead.</para></warning>
 			<warning><para>Use of the application <literal>WaitExten</literal> within a macro will not function
 			as expected. Please use the <literal>Read</literal> application in order to read DTMF from a channel
 			currently executing a macro.</para></warning>

apps/app_meetme.c

@@ -43,6 +43,8 @@
 	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
 	<replacement>app_confbridge</replacement>
+	<deprecated_in>19</deprecated_in>
+	<removed_in>21</removed_in>
  ***/
 
 #include "asterisk.h"
@@ -1334,7 +1336,7 @@ static struct ast_json *status_to_json(int on)
  * \brief Generate a stasis message associated with a meetme event
  * \since 12.0.0
  *
- * \param meetme_confere The conference responsible for generating this message
+ * \param meetme_conference The conference responsible for generating this message
  * \param chan The channel involved in the message (NULL allowed)
  * \param user The conference user involved in the message (NULL allowed)
  * \param message_type the type the stasis message being generated
@@ -2834,7 +2836,7 @@ static void meetme_menu_normal(enum menu_modes *menu_mode, int *dtmf, struct ast
 }
 
 /*! \internal
- * \brief Processes menu options for the adminstrator menu (accessible through the 's' option for app_meetme)
+ * \brief Processes menu options for the administrator menu (accessible through the 's' option for app_meetme)
  *
  * \param menu_mode a pointer to the currently active menu_mode.
  * \param dtmf a pointer to the dtmf value currently being processed against the menu.
@@ -2961,7 +2963,8 @@ static void meetme_menu_admin(enum menu_modes *menu_mode, int *dtmf, struct ast_
  * \param confflags flags used by conf for various options
  * \param chan ast_channel belonging to the user who called the menu
  * \param user which meetme conference user invoked the menu
- * \param recordingtmp character buffer which may hold the name of the conference recording file
+ * \param recordingtmp, recordingtmp_size character buffer which may hold the name of the conference recording file
+ * \param cap_slin
  */
 static void meetme_menu_admin_extended(enum menu_modes *menu_mode, int *dtmf,
 	struct ast_conference *conf, struct ast_flags64 *confflags, struct ast_channel *chan,
@@ -3148,7 +3151,8 @@ static void meetme_menu_admin_extended(enum menu_modes *menu_mode, int *dtmf,
  * \param confflags flags used by conf for various options
  * \param chan ast_channel belonging to the user who called the menu
  * \param user which meetme conference user invoked the menu
- * \param recordingtmp character buffer which may hold the name of the conference recording file
+ * \param recordingtmp,recordingtmp_size character buffer which may hold the name of the conference recording file
+ * \param cap_slin
  */
 static void meetme_menu(enum menu_modes *menu_mode, int *dtmf,
 	struct ast_conference *conf, struct ast_flags64 *confflags, struct ast_channel *chan,
@@ -5219,7 +5223,7 @@ static int user_chan_cb(void *obj, void *args, int flags)
 	return 0;
 }
 
-/*! \brief The MeetMeadmin application
+/*! \brief The MeetMeAdmin application
 
   MeetMeAdmin(confno, command, caller) */
 static int admin_exec(struct ast_channel *chan, const char *data) {

apps/app_mf.c

@@ -0,0 +1,362 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2021, Naveen Albert
+ *
+ * Naveen Albert <asterisk@phreaknet.org>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief App to send MF digits
+ *
+ * \author Naveen Albert <asterisk@phreaknet.org>
+ *
+ * \ingroup applications
+ */
+
+/*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
+	<support_level>extended</support_level>
+ ***/
+
+#include "asterisk.h"
+
+#include "asterisk/pbx.h"
+#include "asterisk/module.h"
+#include "asterisk/app.h"
+#include "asterisk/channel.h"
+#include "asterisk/indications.h"
+
+/*** DOCUMENTATION
+	<application name="SendMF" language="en_US">
+		<synopsis>
+			Sends arbitrary MF digits
+		</synopsis>
+		<syntax>
+			<parameter name="digits" required="true">
+				<para>List of digits 0-9,*#ABC to send; also f or F for a flash-hook
+				if the channel supports flash-hook, and w or W for a wink if the channel
+				supports wink.</para>
+				<para>Key pulse and start digits are not included automatically.
+				* is used for KP, # for ST, A for STP, B for ST2P, and C for ST3P.</para>
+			</parameter>
+			<parameter name="timeout_ms" required="false">
+				<para>Amount of time to wait in ms between tones. (defaults to 50ms).</para>
+			</parameter>
+			<parameter name="duration_ms" required="false">
+				<para>Duration of each numeric digit (defaults to 55ms).</para>
+			</parameter>
+			<parameter name="duration_ms_kp" required="false">
+				<para>Duration of KP digits (defaults to 120ms).</para>
+			</parameter>
+			<parameter name="duration_ms_st" required="false">
+				<para>Duration of ST, STP, ST2P, and ST3P digits (defaults to 65ms).</para>
+			</parameter>
+			<parameter name="channel" required="false">
+				<para>Channel where digits will be played</para>
+			</parameter>
+		</syntax>
+		<description>
+			<para>It will send all digits or terminate if it encounters an error.</para>
+		</description>
+		<see-also>
+			<ref type="application">SendDTMF</ref>
+		</see-also>
+	</application>
+	<manager name="PlayMF" language="en_US">
+		<synopsis>
+			Play MF signal on a specific channel.
+		</synopsis>
+		<syntax>
+			<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
+			<parameter name="Channel" required="true">
+				<para>Channel name to send digit to.</para>
+			</parameter>
+			<parameter name="Digit" required="true">
+				<para>The MF digit to play.</para>
+			</parameter>
+			<parameter name="Duration" required="false">
+				<para>The duration, in milliseconds, of the digit to be played.</para>
+			</parameter>
+		</syntax>
+		<description>
+			<para>Plays an MF digit on the specified channel.</para>
+		</description>
+	</manager>
+ ***/
+
+static const char sendmf_name[] = "SendMF";
+
+#define DEFAULT_EMULATE_MF_DURATION 35
+#define MF_BETWEEN_MS 50
+#define MF_DURATION 55
+#define MF_KP_DURATION 120
+#define MF_ST_DURATION 65
+
+static int senddigit_mf_begin(struct ast_channel *chan, char digit)
+{
+	static const char * const mf_tones[] = {
+		"1300+1500", /* 0 */
+		"700+900",   /* 1 */
+		"700+1100",  /* 2 */
+		"900+1100",  /* 3 */
+		"700+1300",  /* 4 */
+		"900+1300",  /* 5 */
+		"1100+1300", /* 6 */
+		"700+1500",  /* 7 */
+		"900+1500",  /* 8 */
+		"1100+1500", /* 9 */
+		"1100+1700", /* * (KP) */
+		"1500+1700", /* # (ST) */
+		"900+1700",  /* A (STP) */
+		"1300+1700", /* B (ST2P) */
+		"700+1700"   /* C (ST3P) */
+	};
+
+	if (digit >= '0' && digit <='9') {
+		ast_playtones_start(chan, 0, mf_tones[digit-'0'], 0);
+	} else if (digit == '*') {
+		ast_playtones_start(chan, 0, mf_tones[10], 0);
+	} else if (digit == '#') {
+		ast_playtones_start(chan, 0, mf_tones[11], 0);
+	} else if (digit == 'A') {
+		ast_playtones_start(chan, 0, mf_tones[12], 0);
+	} else if (digit == 'B') {
+		ast_playtones_start(chan, 0, mf_tones[13], 0);
+	} else if (digit == 'C') {
+		ast_playtones_start(chan, 0, mf_tones[14], 0);
+	} else {
+		/* not handled */
+		ast_log(LOG_WARNING, "Unable to generate MF tone '%c' for '%s'\n", digit, ast_channel_name(chan));
+	}
+
+	return 0;
+}
+
+static int senddigit_mf_end(struct ast_channel *chan)
+{
+	if (ast_channel_generator(chan)) {
+		ast_playtones_stop(chan);
+		return 0;
+	}
+	return -1;
+}
+
+static int mysleep(struct ast_channel *chan, int ms, int is_external)
+{
+	return is_external ? usleep(ms * 1000) : ast_safe_sleep(chan, ms);
+}
+
+static int senddigit_mf(struct ast_channel *chan, char digit, unsigned int duration,
+	unsigned int durationkp, unsigned int durationst, int is_external)
+{
+	if (duration < DEFAULT_EMULATE_MF_DURATION) {
+		duration = DEFAULT_EMULATE_MF_DURATION;
+	}
+	if (ast_channel_tech(chan)->send_digit_begin) {
+		if (digit == '*') {
+			duration = durationkp;
+		} else if (digit == '#' || digit == 'A' || digit == 'B' || digit == 'C') {
+			duration = durationst;
+		}
+		senddigit_mf_begin(chan, digit);
+		mysleep(chan, duration, is_external);
+	}
+	return senddigit_mf_end(chan);
+}
+
+static int mf_stream(struct ast_channel *chan, const char *digits, int between, unsigned int duration,
+	unsigned int durationkp, unsigned int durationst, int is_external)
+{
+	const char *ptr;
+	int res;
+	struct ast_silence_generator *silgen = NULL;
+
+	if (!between) {
+		between = 100;
+	}
+
+	/* Need a quiet time before sending digits. */
+	if (ast_opt_transmit_silence) {
+		silgen = ast_channel_start_silence_generator(chan);
+	}
+	res = mysleep(chan, 100, is_external);
+	if (res) {
+		goto mf_stream_cleanup;
+	}
+
+	for (ptr = digits; *ptr; ptr++) {
+		if (strchr("0123456789*#ABCwWfF", *ptr)) {
+			if (*ptr == 'f' || *ptr == 'F') {
+				/* ignore return values if not supported by channel */
+				ast_indicate(chan, AST_CONTROL_FLASH);
+			} else if (*ptr == 'w' || *ptr == 'W') {
+				/* ignore return values if not supported by channel */
+				ast_indicate(chan, AST_CONTROL_WINK);
+			} else {
+				/* Character represents valid MF */
+				senddigit_mf(chan, *ptr, duration, durationkp, durationst, is_external);
+			}
+			/* pause between digits */
+			/* The DSP code in Asterisk does not currently properly receive repeated tones
+				if no audio is sent in the middle. Simply sending audio (even 0 Hz)
+				works around this limitation and guarantees the correct behavior.
+				*/
+			ast_playtones_start(chan, 0, "0", 0);
+			res = mysleep(chan, between, is_external);
+			senddigit_mf_end(chan);
+			if (res) {
+				break;
+			}
+		} else {
+			ast_log(LOG_WARNING, "Illegal MF character '%c' in string. (0-9*#ABCwWfF allowed)\n", *ptr);
+		}
+	}
+
+mf_stream_cleanup:
+	if (silgen) {
+		ast_channel_stop_silence_generator(chan, silgen);
+	}
+
+	return res;
+}
+
+static int sendmf_exec(struct ast_channel *chan, const char *vdata)
+{
+	int res;
+	char *data;
+	int dinterval = 0, duration = 0, durationkp = 0, durationst = 0;
+	struct ast_channel *chan_found = NULL;
+	struct ast_channel *chan_dest = chan;
+	struct ast_channel *chan_autoservice = NULL;
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(digits);
+		AST_APP_ARG(dinterval);
+		AST_APP_ARG(duration);
+		AST_APP_ARG(durationkp);
+		AST_APP_ARG(durationst);
+		AST_APP_ARG(channel);
+	);
+
+	if (ast_strlen_zero(vdata)) {
+		ast_log(LOG_WARNING, "SendMF requires an argument\n");
+		return 0;
+	}
+
+	data = ast_strdupa(vdata);
+	AST_STANDARD_APP_ARGS(args, data);
+
+	if (ast_strlen_zero(args.digits)) {
+		ast_log(LOG_WARNING, "The digits argument is required (0-9,*#ABC,wf)\n");
+		return 0;
+	}
+	if (!ast_strlen_zero(args.dinterval)) {
+		ast_app_parse_timelen(args.dinterval, &dinterval, TIMELEN_MILLISECONDS);
+	}
+	if (!ast_strlen_zero(args.duration)) {
+		ast_app_parse_timelen(args.duration, &duration, TIMELEN_MILLISECONDS);
+	}
+	if (!ast_strlen_zero(args.durationkp)) {
+		ast_app_parse_timelen(args.durationkp, &durationkp, TIMELEN_MILLISECONDS);
+	}
+	if (!ast_strlen_zero(args.durationst)) {
+		ast_app_parse_timelen(args.durationst, &durationst, TIMELEN_MILLISECONDS);
+	}
+	if (!ast_strlen_zero(args.channel)) {
+		chan_found = ast_channel_get_by_name(args.channel);
+		if (!chan_found) {
+			ast_log(LOG_WARNING, "No such channel: %s\n", args.channel);
+			return 0;
+		}
+		chan_dest = chan_found;
+		if (chan_found != chan) {
+			chan_autoservice = chan;
+		}
+	}
+	if (chan_autoservice && ast_autoservice_start(chan_autoservice)) {
+		ast_channel_cleanup(chan_found);
+		return -1;
+	}
+	res = mf_stream(chan_dest, args.digits, dinterval <= 0 ? MF_BETWEEN_MS : dinterval,
+		duration <= 0 ? MF_DURATION : duration, durationkp <= 0 ? MF_KP_DURATION : durationkp,
+		durationst <= 0 ? MF_ST_DURATION : durationst, 0);
+	if (chan_autoservice && ast_autoservice_stop(chan_autoservice)) {
+		res = -1;
+	}
+	ast_channel_cleanup(chan_found);
+
+	return chan_autoservice ? 0 : res;
+}
+
+static int manager_play_mf(struct mansession *s, const struct message *m)
+{
+	const char *channel = astman_get_header(m, "Channel");
+	const char *digit = astman_get_header(m, "Digit");
+	const char *duration = astman_get_header(m, "Duration");
+	struct ast_channel *chan;
+	unsigned int duration_ms = MF_DURATION;
+
+	if (!(chan = ast_channel_get_by_name(channel))) {
+		astman_send_error(s, m, "Channel not found");
+		return 0;
+	}
+
+	if (ast_strlen_zero(digit)) {
+		astman_send_error(s, m, "No digit specified");
+		chan = ast_channel_unref(chan);
+		return 0;
+	}
+
+	/* Override default duration with KP or ST-specific default durations */
+	if (!strcmp(digit, "*"))
+		duration_ms = MF_KP_DURATION;
+
+	if (!strcmp(digit, "#") || !strcmp(digit, "A") || !strcmp(digit, "B") || !strcmp(digit, "C"))
+		duration_ms = MF_ST_DURATION;
+
+	if (!ast_strlen_zero(duration) && (sscanf(duration, "%30u", &duration_ms) != 1)) {
+		astman_send_error(s, m, "Could not convert Duration parameter");
+		chan = ast_channel_unref(chan);
+		return 0;
+	}
+
+	senddigit_mf(chan, *digit, duration_ms, duration_ms, duration_ms, 1);
+	chan = ast_channel_unref(chan);
+
+	astman_send_ack(s, m, "MF successfully queued");
+
+	return 0;
+}
+
+static int unload_module(void)
+{
+	int res;
+
+	res = ast_unregister_application(sendmf_name);
+	res |= ast_manager_unregister("PlayMF");
+
+	return res;
+}
+
+static int load_module(void)
+{
+	int res;
+
+	res = ast_manager_register_xml("PlayMF", EVENT_FLAG_CALL, manager_play_mf);
+	res |= ast_register_application_xml(sendmf_name, sendmf_exec);
+
+	return res;
+}
+
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Send MF digits Application");

apps/app_milliwatt.c

@@ -40,19 +40,29 @@
 /*** DOCUMENTATION
 	<application name="Milliwatt" language="en_US">
 		<synopsis>
-			Generate a Constant 1004Hz tone at 0dbm (mu-law).
+			Generates a 1004 Hz test tone at 0dbm (mu-law).
 		</synopsis>
 		<syntax>
 			<parameter name="options">
 				<optionlist>
+					<option name="m">
+						<para>Generate a 1004 Hz Milliwatt test tone at 0dbm, with a
+						1 second silent interval. This option must be specified
+						if you are using this for a milliwatt test line.</para>
+					</option>
 					<option name="o">
-						<para>Generate the tone at 1000Hz like previous version.</para>
+						<para>Generate a constant tone at 1000 Hz like previous version.</para>
 					</option>
 				</optionlist>
 			</parameter>
 		</syntax>
 		<description>
-			<para>Previous versions of this application generated the tone at 1000Hz.  If for
+			<para>Generates a 1004 Hz test tone.</para>
+			<para>By default, this application does not provide a Milliwatt test tone. It simply
+			plays a 1004 Hz tone, which is not suitable for performing a milliwatt test.
+			The <literal>m</literal> option should be used so that a real Milliwatt test tone
+			is provided. This will include a 1 second silent interval every 10 seconds.</para>
+			<para>Previous versions of this application generated a constant tone at 1000 Hz. If for
 			some reason you would prefer that behavior, supply the <literal>o</literal> option to get the
 			old behavior.</para>
 		</description>
@@ -155,8 +165,11 @@ static int milliwatt_exec(struct ast_channel *chan, const char *data)
 	if (!ast_strlen_zero(options) && strchr(options, 'o')) {
 		return old_milliwatt_exec(chan);
 	}
-
-	res = ast_playtones_start(chan, 23255, "1004/1000", 0);
+	if (!ast_strlen_zero(options) && strchr(options, 'm')) {
+		res = ast_playtones_start(chan, 23255, "1004/9000,0/1000", 0);
+	} else {
+		res = ast_playtones_start(chan, 23255, "1004/1000", 0);
+	}
 
 	while (!res) {
 		res = ast_safe_sleep(chan, 10000);

apps/app_minivm.c

@@ -26,7 +26,7 @@
  * based on the Comedian Mail voicemail system (app_voicemail.c).
  *
  * \par See also
- * \arg \ref Config_minivm_examples
+ * \arg \ref minivm.conf "Config_minivm"
  * \arg \ref App_minivm
  *
  * \ingroup applications
@@ -78,16 +78,16 @@
  *		- English, GB		en_gb
  *
  * \par See also
- * \arg \ref Config_minivm
+ * \arg \ref minivm.conf "Config_minivm"
  * \arg \ref Config_minivm_examples
  * \arg \ref Minivm_directories
  * \arg \ref app_minivm.c
  * \arg Comedian mail: app_voicemail.c
- * \arg \ref descrip_minivm_accmess
- * \arg \ref descrip_minivm_greet
- * \arg \ref descrip_minivm_record
- * \arg \ref descrip_minivm_delete
- * \arg \ref descrip_minivm_notify
+ * \arg \ref minivm_accmess_exec
+ * \arg \ref minivm_greet_exec
+ * \arg \ref minivm_record_exec
+ * \arg \ref minivm_delete_exec
+ * \arg \ref minivm_notify_exec
  *
  * \arg \ref App_minivm_todo
  */
@@ -113,6 +113,13 @@
  * Back: \ref App_minivm
  */
 
+/*!
+ * \page minivm.conf minivm.conf
+ * \verbinclude minivm.conf.sample
+ *
+ * Back: \ref App_minivm
+ */
+
 /*! \page Config_minivm_examples Example dialplan for Mini-Voicemail
  * \section Example dialplan scripts for Mini-Voicemail
  *  \verbinclude extensions_minivm.conf.sample
@@ -141,6 +148,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -154,7 +162,6 @@
 #include <dirent.h>
 #include <locale.h>
 
-
 #include "asterisk/paths.h"	/* use various paths */
 #include "asterisk/lock.h"
 #include "asterisk/file.h"
@@ -535,8 +542,6 @@
 #define SENDMAIL "/usr/sbin/sendmail -t"
 
 #define SOUND_INTRO		"vm-intro"
-#define B64_BASEMAXINLINE 	256	/*!< Buffer size for Base 64 attachment encoding */
-#define B64_BASELINELEN 	72	/*!< Line length for Base 64 endoded messages */
 #define EOL			"\r\n"
 
 #define MAX_DATETIME_FORMAT	512
@@ -652,15 +657,6 @@ struct leave_vm_options {
 	signed char record_gain;
 };
 
-/*! \brief Structure for base64 encoding */
-struct b64_baseio {
-	int iocp;
-	int iolen;
-	int linelength;
-	int ateof;
-	unsigned char iobuf[B64_BASEMAXINLINE];
-};
-
 /*! \brief Voicemail time zones */
 struct minivm_zone {
 	char name[80];				/*!< Name of this time zone */
@@ -846,134 +842,6 @@ static void message_destroy_list(void)
 	AST_LIST_UNLOCK(&message_templates);
 }
 
-/*!\internal
- * \brief read buffer from file (base64 conversion) */
-static int b64_inbuf(struct b64_baseio *bio, FILE *fi)
-{
-	int l;
-
-	if (bio->ateof)
-		return 0;
-
-	if ((l = fread(bio->iobuf, 1, B64_BASEMAXINLINE, fi)) != B64_BASEMAXINLINE) {
-		bio->ateof = 1;
-		if (l == 0) {
-			/* Assume EOF */
-			return 0;
-		}
-	}
-
-	bio->iolen = l;
-	bio->iocp = 0;
-
-	return 1;
-}
-
-/*!\internal
- * \brief read character from file to buffer (base64 conversion) */
-static int b64_inchar(struct b64_baseio *bio, FILE *fi)
-{
-	if (bio->iocp >= bio->iolen) {
-		if (!b64_inbuf(bio, fi))
-			return EOF;
-	}
-
-	return bio->iobuf[bio->iocp++];
-}
-
-/*!\internal
- * \brief write buffer to file (base64 conversion) */
-static int b64_ochar(struct b64_baseio *bio, int c, FILE *so)
-{
-	if (bio->linelength >= B64_BASELINELEN) {
-		if (fputs(EOL,so) == EOF)
-			return -1;
-
-		bio->linelength= 0;
-	}
-
-	if (putc(((unsigned char) c), so) == EOF)
-		return -1;
-
-	bio->linelength++;
-
-	return 1;
-}
-
-/*!\internal
- * \brief Encode file to base64 encoding for email attachment (base64 conversion) */
-static int base_encode(char *filename, FILE *so)
-{
-	unsigned char dtable[B64_BASEMAXINLINE];
-	int i,hiteof= 0;
-	FILE *fi;
-	struct b64_baseio bio;
-
-	memset(&bio, 0, sizeof(bio));
-	bio.iocp = B64_BASEMAXINLINE;
-
-	if (!(fi = fopen(filename, "rb"))) {
-		ast_log(LOG_WARNING, "Failed to open file: %s: %s\n", filename, strerror(errno));
-		return -1;
-	}
-
-	for (i= 0; i<9; i++) {
-		dtable[i]= 'A'+i;
-		dtable[i+9]= 'J'+i;
-		dtable[26+i]= 'a'+i;
-		dtable[26+i+9]= 'j'+i;
-	}
-	for (i= 0; i < 8; i++) {
-		dtable[i+18]= 'S'+i;
-		dtable[26+i+18]= 's'+i;
-	}
-	for (i= 0; i < 10; i++) {
-		dtable[52+i]= '0'+i;
-	}
-	dtable[62]= '+';
-	dtable[63]= '/';
-
-	while (!hiteof){
-		unsigned char igroup[3], ogroup[4];
-		int c,n;
-
-		igroup[0]= igroup[1]= igroup[2]= 0;
-
-		for (n= 0; n < 3; n++) {
-			if ((c = b64_inchar(&bio, fi)) == EOF) {
-				hiteof= 1;
-				break;
-			}
-			igroup[n]= (unsigned char)c;
-		}
-
-		if (n> 0) {
-			ogroup[0]= dtable[igroup[0]>>2];
-			ogroup[1]= dtable[((igroup[0]&3)<<4) | (igroup[1]>>4)];
-			ogroup[2]= dtable[((igroup[1]&0xF)<<2) | (igroup[2]>>6)];
-			ogroup[3]= dtable[igroup[2]&0x3F];
-
-			if (n<3) {
-				ogroup[3]= '=';
-
-				if (n<2)
-					ogroup[2]= '=';
-			}
-
-			for (i= 0;i<4;i++)
-				b64_ochar(&bio, ogroup[i], so);
-		}
-	}
-
-	/* Put end of line - line feed */
-	if (fputs(EOL, so) == EOF)
-		return 0;
-
-	fclose(fi);
-
-	return 1;
-}
-
 static int get_date(char *s, int len)
 {
 	struct ast_tm tm;
@@ -1474,7 +1342,7 @@ static int sendmail(struct minivm_template *template, struct minivm_account *vmu
 		fprintf(p, "Content-Description: Voicemail sound attachment.\n");
 		fprintf(p, "Content-Disposition: attachment; filename=\"voicemail%s.%s\"\n\n", counter ? counter : "", format);
 
-		base_encode(fname, p);
+		ast_base64_encode_file_path(fname, p, EOL);
 		fprintf(p, "\n\n--%s--\n.\n", bound);
 	}
 	fclose(p);
@@ -1737,7 +1605,7 @@ static int play_record_review(struct ast_channel *chan, char *playfile, char *re
 			}
 			return cmd;
  		default:
-			/* If the caller is an ouside caller, and the review option is enabled,
+			/* If the caller is an outside caller, and the review option is enabled,
 			   allow them to review the message, but let the owner of the box review
 			   their OGM's */
 			if (outsidecaller && !ast_test_flag(vmu, MVM_REVIEW))
@@ -2827,7 +2695,7 @@ static int apply_general_options(struct ast_variable *var)
 		} else if (!strcmp(var->name, "externnotify")) {
 			/* External voicemail notify application */
 			ast_copy_string(global_externnotify, var->value, sizeof(global_externnotify));
-		} else if (!strcmp(var->name, "silencetreshold")) {
+		} else if (!strcmp(var->name, "silencethreshold") || !strcmp(var->name, "silencetreshold")) {
 			/* Silence treshold */
 			global_silencethreshold = atoi(var->value);
 		} else if (!strcmp(var->name, "maxmessage")) {
@@ -2956,6 +2824,8 @@ static int load_config(int reload)
 		ast_copy_string(template->fromaddress, chanvar, sizeof(template->fromaddress));
 	if ((chanvar = ast_variable_retrieve(cfg, "general", "emailaaddress")))
 		ast_copy_string(template->serveremail, chanvar, sizeof(template->serveremail));
+	if ((chanvar = ast_variable_retrieve(cfg, "general", "emailaddress")))
+		ast_copy_string(template->serveremail, chanvar, sizeof(template->serveremail));
 	if ((chanvar = ast_variable_retrieve(cfg, "general", "emailcharset")))
 		ast_copy_string(template->charset, chanvar, sizeof(template->charset));
 	if ((chanvar = ast_variable_retrieve(cfg, "general", "emailsubject")))

apps/app_mixmonitor.c

@@ -51,6 +51,8 @@
 #include "asterisk/channel.h"
 #include "asterisk/autochan.h"
 #include "asterisk/manager.h"
+#include "asterisk/stasis.h"
+#include "asterisk/stasis_channels.h"
 #include "asterisk/callerid.h"
 #include "asterisk/mod_format.h"
 #include "asterisk/linkedlists.h"
@@ -295,6 +297,51 @@
 			</parameter>
 		</syntax>
 	</function>
+	<managerEvent language="en_US" name="MixMonitorStart">
+		<managerEventInstance class="EVENT_FLAG_CALL">
+			<synopsis>Raised when monitoring has started on a channel.</synopsis>
+			<syntax>
+				<channel_snapshot/>
+			</syntax>
+			<see-also>
+				<ref type="managerEvent">MixMonitorStop</ref>
+				<ref type="application">MixMonitor</ref>
+				<ref type="manager">MixMonitor</ref>
+			</see-also>
+		</managerEventInstance>
+	</managerEvent>
+	<managerEvent language="en_US" name="MixMonitorStop">
+		<managerEventInstance class="EVENT_FLAG_CALL">
+		<synopsis>Raised when monitoring has stopped on a channel.</synopsis>
+		<syntax>
+			<channel_snapshot/>
+		</syntax>
+		<see-also>
+			<ref type="managerEvent">MixMonitorStart</ref>
+			<ref type="application">StopMixMonitor</ref>
+			<ref type="manager">StopMixMonitor</ref>
+		</see-also>
+		</managerEventInstance>
+	</managerEvent>
+	<managerEvent language="en_US" name="MixMonitorMute">
+		<managerEventInstance class="EVENT_FLAG_CALL">
+		<synopsis>Raised when monitoring is muted or unmuted on a channel.</synopsis>
+		<syntax>
+			<channel_snapshot/>
+			<parameter name="Direction">
+				<para>Which part of the recording was muted or unmuted: read, write or both
+				(from channel, to channel or both directions).</para>
+			</parameter>
+			<parameter name="State">
+				<para>If the monitoring was muted or unmuted: 1 when muted, 0 when unmuted.</para>
+			</parameter>
+		</syntax>
+		<see-also>
+			<ref type="manager">MixMonitorMute</ref>
+		</see-also>
+		</managerEventInstance>
+	</managerEvent>
+
 
  ***/
 
@@ -584,6 +631,7 @@ static void mixmonitor_free(struct mixmonitor *mixmonitor)
  * \brief Copies the mixmonitor to all voicemail recipients
  * \param mixmonitor The mixmonitor that needs to forward its file to recipients
  * \param ext Format of the file that was saved
+ * \param filename
  */
 static void copy_to_voicemail(struct mixmonitor *mixmonitor, const char *ext, const char *filename)
 {
@@ -865,6 +913,24 @@ static int setup_mixmonitor_ds(struct mixmonitor *mixmonitor, struct ast_channel
 	return 0;
 }
 
+static void mixmonitor_ds_remove_and_free(struct ast_channel *chan, const char *datastore_id)
+{
+	struct ast_datastore *datastore;
+
+	ast_channel_lock(chan);
+
+	datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, datastore_id);
+
+	/*
+	 * Currently the one place this function is called from guarantees a
+	 * datastore is present, thus return checks can be avoided here.
+	 */
+	ast_channel_datastore_remove(chan, datastore);
+	ast_datastore_free(datastore);
+
+	ast_channel_unlock(chan);
+}
+
 static int launch_monitor_thread(struct ast_channel *chan, const char *filename,
 				  unsigned int flags, int readvol, int writevol,
 				  const char *post_process, const char *filename_write,
@@ -940,7 +1006,6 @@ static int launch_monitor_thread(struct ast_channel *chan, const char *filename,
 			pbx_builtin_setvar_helper(chan, uid_channel_var, datastore_id);
 		}
 	}
-	ast_free(datastore_id);
 
 	mixmonitor->name = ast_strdup(ast_channel_name(chan));
 
@@ -990,12 +1055,16 @@ static int launch_monitor_thread(struct ast_channel *chan, const char *filename,
 	if (startmon(chan, &mixmonitor->audiohook)) {
 		ast_log(LOG_WARNING, "Unable to add '%s' spy to channel '%s'\n",
 			mixmonitor_spy_type, ast_channel_name(chan));
+		mixmonitor_ds_remove_and_free(chan, datastore_id);
+		ast_free(datastore_id);
 		ast_autochan_destroy(mixmonitor->autochan);
 		ast_audiohook_destroy(&mixmonitor->audiohook);
 		mixmonitor_free(mixmonitor);
 		return -1;
 	}
 
+	ast_free(datastore_id);
+
 	/* reference be released at mixmonitor destruction */
 	mixmonitor->callid = ast_read_threadstorage_callid();
 
@@ -1056,6 +1125,7 @@ static int mixmonitor_exec(struct ast_channel *chan, const char *data)
 	struct ast_flags flags = { 0 };
 	char *recipients = NULL;
 	char *parse;
+	RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
 	AST_DECLARE_APP_ARGS(args,
 		AST_APP_ARG(filename);
 		AST_APP_ARG(options);
@@ -1176,6 +1246,12 @@ static int mixmonitor_exec(struct ast_channel *chan, const char *data)
 		ast_module_unref(ast_module_info->self);
 	}
 
+	message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
+		ast_channel_mixmonitor_start_type(), NULL);
+	if (message) {
+		stasis_publish(ast_channel_topic(chan), message);
+	}
+
 	return 0;
 }
 
@@ -1185,6 +1261,7 @@ static int stop_mixmonitor_full(struct ast_channel *chan, const char *data)
 	char *parse = "";
 	struct mixmonitor_ds *mixmonitor_ds;
 	const char *beep_id = NULL;
+	RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
 
 	AST_DECLARE_APP_ARGS(args,
 		AST_APP_ARG(mixmonid);
@@ -1242,6 +1319,13 @@ static int stop_mixmonitor_full(struct ast_channel *chan, const char *data)
 		ast_beep_stop(chan, beep_id);
 	}
 
+	message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
+	                                             ast_channel_mixmonitor_stop_type(),
+	                                             NULL);
+	if (message) {
+		stasis_publish(ast_channel_topic(chan), message);
+	}
+
 	return 0;
 }
 
@@ -1319,6 +1403,50 @@ static char *handle_cli_mixmonitor(struct ast_cli_entry *e, int cmd, struct ast_
 	return CLI_SUCCESS;
 }
 
+/*! \brief  Mute / unmute  an individual MixMonitor by id */
+static int mute_mixmonitor_instance(struct ast_channel *chan, const char *data,
+									enum ast_audiohook_flags flag, int clearmute)
+{
+	struct ast_datastore *datastore = NULL;
+	char *parse = "";
+	struct mixmonitor_ds *mixmonitor_ds;
+
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(mixmonid);
+	);
+
+	if (!ast_strlen_zero(data)) {
+		parse = ast_strdupa(data);
+	}
+
+	AST_STANDARD_APP_ARGS(args, parse);
+
+	ast_channel_lock(chan);
+
+	datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info,
+		S_OR(args.mixmonid, NULL));
+	if (!datastore) {
+		ast_channel_unlock(chan);
+		return -1;
+	}
+	mixmonitor_ds = datastore->data;
+
+	ast_mutex_lock(&mixmonitor_ds->lock);
+
+	if (mixmonitor_ds->audiohook) {
+		if (clearmute) {
+			ast_clear_flag(mixmonitor_ds->audiohook, flag);
+		} else {
+			ast_set_flag(mixmonitor_ds->audiohook, flag);
+		}
+	}
+
+	ast_mutex_unlock(&mixmonitor_ds->lock);
+	ast_channel_unlock(chan);
+
+	return 0;
+}
+
 /*! \brief  Mute / unmute  a MixMonitor channel */
 static int manager_mute_mixmonitor(struct mansession *s, const struct message *m)
 {
@@ -1327,8 +1455,11 @@ static int manager_mute_mixmonitor(struct mansession *s, const struct message *m
 	const char *id = astman_get_header(m, "ActionID");
 	const char *state = astman_get_header(m, "State");
 	const char *direction = astman_get_header(m,"Direction");
-	int clearmute = 1;
+	const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
+	int clearmute = 1, mutedcount = 0;
 	enum ast_audiohook_flags flag;
+	RAII_VAR(struct stasis_message *, stasis_message, NULL, ao2_cleanup);
+	RAII_VAR(struct ast_json *, stasis_message_blob, NULL, ast_json_unref);
 
 	if (ast_strlen_zero(direction)) {
 		astman_send_error(s, m, "No direction specified. Must be read, write or both");
@@ -1364,10 +1495,34 @@ static int manager_mute_mixmonitor(struct mansession *s, const struct message *m
 		return AMI_SUCCESS;
 	}
 
-	if (ast_audiohook_set_mute(c, mixmonitor_spy_type, flag, clearmute)) {
-		ast_channel_unref(c);
-		astman_send_error(s, m, "Cannot set mute flag");
-		return AMI_SUCCESS;
+	if (ast_strlen_zero(mixmonitor_id)) {
+		mutedcount = ast_audiohook_set_mute_all(c, mixmonitor_spy_type, flag, clearmute);
+		if (mutedcount < 0) {
+			ast_channel_unref(c);
+			astman_send_error(s, m, "Cannot set mute flag");
+			return AMI_SUCCESS;
+		}
+	} else {
+		if (mute_mixmonitor_instance(c, mixmonitor_id, flag, clearmute)) {
+			ast_channel_unref(c);
+			astman_send_error(s, m, "Cannot set mute flag");
+			return AMI_SUCCESS;
+		}
+		mutedcount = 1;
+	}
+
+
+	stasis_message_blob = ast_json_pack("{s: s, s: b, s: s, s: i}",
+		"direction", direction,
+		"state", ast_true(state),
+		"mixmonitorid", mixmonitor_id,
+		"count", mutedcount);
+
+	stasis_message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(c),
+		ast_channel_mixmonitor_mute_type(), stasis_message_blob);
+
+	if (stasis_message) {
+		stasis_publish(ast_channel_topic(c), stasis_message);
 	}
 
 	astman_append(s, "Response: Success\r\n");

apps/app_morsecode.c

@@ -3,6 +3,8 @@
  *
  * Copyright (c) 2006, Tilghman Lesher.  All rights reserved.
  *
+ * Updated by Naveen Albert <asterisk@phreaknet.org>
+ *
  * Tilghman Lesher <app_morsecode__v001@the-tilghman.com>
  *
  * This code is released by the author with no restrictions on usage.
@@ -20,11 +22,13 @@
  * \brief Morsecode application
  *
  * \author Tilghman Lesher <app_morsecode__v001@the-tilghman.com>
+ * \author Naveen Albert <asterisk@phreaknet.org>
  *
  * \ingroup applications
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -58,6 +62,14 @@
 				<variable name="MORSETONE">
 					<para>The pitch of the tone in (Hz), default is 800</para>
 				</variable>
+				<variable name="MORSESPACETONE">
+					<para>The pitch of the spaces in (Hz), default is 0</para>
+				</variable>
+				<variable name="MORSETYPE">
+					<para>The code type to use (AMERICAN for standard American Morse
+					or INTERNATIONAL for international code.
+					Default is INTERNATIONAL).</para>
+				</variable>
 			</variablelist>
 		</description>
 		<see-also>
@@ -68,7 +80,7 @@
  ***/
 static const char app_morsecode[] = "Morsecode";
 
-static const char * const morsecode[] = {
+static const char * const internationalcode[] = {
 	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", /*  0-15 */
 	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", /* 16-31 */
 	" ",      /* 32 - <space> */
@@ -95,16 +107,16 @@ static const char * const morsecode[] = {
 	"",       /* 62 - > */
 	"..--..", /* 63 - ? */
 	".--.-.", /* 64 - @ */
-	".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
-	"-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..",
+	".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", /* A-M */
+	"-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", /* N-Z */
 	"-.--.-", /* 91 - [ (really '(') */
 	"-..-.",  /* 92 - \ (really '/') */
 	"-.--.-", /* 93 - ] (really ')') */
 	"",       /* 94 - ^ */
 	"..--.-", /* 95 - _ */
 	".----.", /* 96 - ` */
-	".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
-	"-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..",
+	".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", /* a-m */
+	"-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", /* n-z */
 	"-.--.-", /* 123 - { (really '(') */
 	"",       /* 124 - | */
 	"-.--.-", /* 125 - } (really ')') */
@@ -112,63 +124,159 @@ static const char * const morsecode[] = {
 	". . .",  /* 127 - <del> (error) */
 };
 
-static void playtone(struct ast_channel *chan, int tone, int len)
+static const char * const americanmorsecode[] = {
+	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", /*  0-15 */
+	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", /* 16-31 */
+	"  ",    /* 32 - <space> */
+	"---.",   /* 33 - ! */
+	"..-. -.",/* 34 - " (QN)*/
+	"",       /* 35 - # */
+	"... .-..",/* 36 - $ (SX) */
+	"",       /* 37 - % */
+	". ...",  /* 38 - & (ES) */
+	"..-. .-..",/* 39 - ' (QX) */
+	"..... -.", /* 40 - ( (PN) */
+	"..... .. ..", /* 41 - ) (PY) */
+	"",       /* 42 - * */
+	"",       /* 43 - + */
+	".-.-",   /* 44 - , */
+	".... .-..",/* 45 - (HX) */
+	"..--..", /* 46 - . */
+	"..- -",  /* 47 - / (UT) */
+	".--.", "..-..", "...-.", "....-", "---", "......", "--..", "-....", "-..-", "0", /* 48-57 - 0-9 */
+	"-.- . .",/* 58 - : (KO) */
+	"... ..", /* 59 - ; */
+	"",       /* 60 - < */
+	"-...-",  /* 61 - = (paragraph mark) */
+	"",       /* 62 - > */
+	"-..-.",  /* 63 - ? */
+	".--.-.", /* 64 - @ */
+	".-", "-...", ".. .", "-..", ".", ".-.", "--.", "....", "..", ".-.-", "-.-", "L", "--", /* A-M */
+	"-.", ". .", ".....", "..-.", ". ..", "...", "-", "..-", "...-", ".--", ".-..", ".. ..", "... .", /* N-Z */
+	"..... -.", /* 91 - [ (really '(') */
+	"..- -",  /* 92 - \ (really '/') */
+	"..... .. ..", /* 93 - ] (really ')') */
+	"",       /* 94 - ^ */
+	"..--.-", /* 95 - _ */
+	".----.", /* 96 - ` */
+	".-", "-...", ".. .", "-..", ".", ".-.", "--.", "....", "..", ".-.-", "-.-", "L", "--", /* a-m */
+	"-.", ". .", ".....", "..-.", ". ..", "...", "-", "..-", "...-", ".--", ".-..", ".. ..", "... .", /* n-z */
+	"..... -.", /* 123 - { (really '(') */
+	"",       /* 124 - | */
+	"..... .. ..", /* 125 - } (really ')') */
+	"..- -",  /* 126 - ~ (really bar) */
+	". . .",  /* 127 - <del> (error) */
+};
+
+static int playtone(struct ast_channel *chan, int tone, int len)
 {
+	int res;
 	char dtmf[20];
 	snprintf(dtmf, sizeof(dtmf), "%d/%d", tone, len);
 	ast_playtones_start(chan, 0, dtmf, 0);
-	ast_safe_sleep(chan, len);
+	res = ast_safe_sleep(chan, len);
 	ast_playtones_stop(chan);
+	return res;
 }
 
 static int morsecode_exec(struct ast_channel *chan, const char *data)
 {
-	int res=0, ditlen, tone;
+	int res = 0, ditlen, tone, toneoff, digit2;
 	const char *digit;
-	const char *ditlenc, *tonec;
+	const char *ditlenc, *tonec, *toneb, *codetype;
 
 	if (ast_strlen_zero(data)) {
 		ast_log(LOG_WARNING, "Syntax: Morsecode(<string>) - no argument found\n");
 		return 0;
 	}
 
-	/* Use variable MORESEDITLEN, if set (else 80) */
 	ast_channel_lock(chan);
+	/* Use variable MORESEDITLEN, if set (else 80) */
 	ditlenc = pbx_builtin_getvar_helper(chan, "MORSEDITLEN");
 	if (ast_strlen_zero(ditlenc) || (sscanf(ditlenc, "%30d", &ditlen) != 1)) {
 		ditlen = 80;
 	}
-	ast_channel_unlock(chan);
 
 	/* Use variable MORSETONE, if set (else 800) */
-	ast_channel_lock(chan);
 	tonec = pbx_builtin_getvar_helper(chan, "MORSETONE");
 	if (ast_strlen_zero(tonec) || (sscanf(tonec, "%30d", &tone) != 1)) {
 		tone = 800;
 	}
+
+	/* Use variable MORSESPACETONE, if set (else 0) */
+	toneb = pbx_builtin_getvar_helper(chan, "MORSESPACETONE");
+	if (ast_strlen_zero(toneb) || (sscanf(toneb, "%30d", &toneoff) != 1)) {
+		toneoff = 0;
+	}
+
+	/* Use variable MORSETYPE, if set (else INTERNATIONAL) */
+	codetype = pbx_builtin_getvar_helper(chan, "MORSETYPE");
+	if (!codetype || strcmp(codetype, "AMERICAN")) {
+		codetype = "INTERNATIONAL";
+	}
+
 	ast_channel_unlock(chan);
-
-	for (digit = data; *digit; digit++) {
-		int digit2 = *digit;
-		const char *dahdit;
-		if (digit2 < 0) {
-			continue;
-		}
-		for (dahdit = morsecode[digit2]; *dahdit; dahdit++) {
-			if (*dahdit == '-') {
-				playtone(chan, tone, 3 * ditlen);
-			} else if (*dahdit == '.') {
-				playtone(chan, tone, 1 * ditlen);
-			} else {
-				/* Account for ditlen of silence immediately following */
-				playtone(chan, 0, 2 * ditlen);
+	if (!strcmp(codetype, "AMERICAN")) {
+		for (digit = data; *digit; digit++) {
+			const char *dahdit;
+			digit2 = *digit;
+			if (digit2 < 0 || digit2 > 127) {
+				continue;
 			}
+			for (dahdit = americanmorsecode[digit2]; *dahdit; dahdit++) {
+				if (*dahdit == '-') {
+					res = playtone(chan, tone, 3 * ditlen);
+				} else if (*dahdit == '.') {
+					res = playtone(chan, tone, 1 * ditlen);
+				} else if (*dahdit == 'L' || *dahdit == 'l') {
+					res = playtone(chan, tone, 6 * ditlen); /* long dash */
+				} else if (*dahdit == '0') {
+					res = playtone(chan, tone, 9 * ditlen); /* extra long dash */
+				} else if (*dahdit == ' ') { /* space char (x20) = 6 dot lengths */
+					/* Intra-char pauses, specific to American Morse */
+					res = playtone(chan, toneoff, 3 * ditlen);
+				} else {
+					/* Account for ditlen of silence immediately following */
+					res = playtone(chan, toneoff, 2 * ditlen);
+				}
 
-			/* Pause slightly between each dit and dah */
-			playtone(chan, 0, 1 * ditlen);
+				/* Pause slightly between each dit and dah */
+				res = playtone(chan, toneoff, 1 * ditlen);
+				if (res)
+					break;
+			}
+			/* Pause between characters */
+			res = playtone(chan, toneoff, 3 * ditlen);
+			if (res)
+				break;
+		}
+	} else { /* International */
+		for (digit = data; *digit; digit++) {
+			const char *dahdit;
+			digit2 = *digit;
+			if (digit2 < 0 || digit2 > 127) {
+				continue;
+			}
+			for (dahdit = internationalcode[digit2]; *dahdit; dahdit++) {
+				if (*dahdit == '-') {
+					res = playtone(chan, tone, 3 * ditlen);
+				} else if (*dahdit == '.') {
+					res = playtone(chan, tone, 1 * ditlen);
+				} else {
+					/* Account for ditlen of silence immediately following */
+					res = playtone(chan, toneoff, 2 * ditlen);
+				}
+
+				/* Pause slightly between each dit and dah */
+				res = playtone(chan, toneoff, 1 * ditlen);
+				if (res)
+					break;
+			}
+			/* Pause between characters */
+			res = playtone(chan, toneoff, 2 * ditlen);
+			if (res)
+				break;
 		}
-		/* Pause between characters */
-		playtone(chan, 0, 2 * ditlen);
 	}
 
 	return res;

apps/app_mp3.c

@@ -29,6 +29,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 
@@ -65,9 +66,11 @@
 		<description>
 			<para>Executes mpg123 to play the given location, which typically would be a mp3 filename
 			or m3u playlist filename or a URL. Please read http://en.wikipedia.org/wiki/M3U
-			to see how M3U playlist file format is like, Example usage would be
+			to see what the M3U playlist file format is like.</para>
+			<para>User can exit by pressing any key on the dialpad, or by hanging up.</para>
+			<example title="Play an MP3 playlist">
 			exten => 1234,1,MP3Player(/var/lib/asterisk/playlist.m3u)
-			User can exit by pressing any key on the dialpad, or by hanging up.</para>
+			</example>
 			<para>This application does not automatically answer and should be preceeded by an
 			application such as Answer() or Progress().</para>
 		</description>
@@ -100,37 +103,37 @@ static int mp3play(const char *filename, unsigned int sampling_rate, int fd)
 	    char buffer_size_str[8];
 	    snprintf(buffer_size_str, 8, "%u", (int) 0.5*2*sampling_rate/1000); // 0.5 seconds for a live stream
 		/* Most commonly installed in /usr/local/bin */
-	    execl(LOCAL_MPG_123, "mpg123", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
+	    execl(LOCAL_MPG_123, "mpg123", "-e", "s16", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
 		/* But many places has it in /usr/bin */
-	    execl(MPG_123, "mpg123", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
+	    execl(MPG_123, "mpg123", "-e", "s16", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
 		/* As a last-ditch effort, try to use PATH */
-	    execlp("mpg123", "mpg123", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
+	    execlp("mpg123", "mpg123", "-e", "s16", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
 	}
 	else if (!strncasecmp(filename, "http://", 7)) {
 	    char buffer_size_str[8];
 	    snprintf(buffer_size_str, 8, "%u", 6*2*sampling_rate/1000); // 6 seconds for a remote MP3 file
 		/* Most commonly installed in /usr/local/bin */
-	    execl(LOCAL_MPG_123, "mpg123", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
+	    execl(LOCAL_MPG_123, "mpg123", "-e", "s16", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
 		/* But many places has it in /usr/bin */
-	    execl(MPG_123, "mpg123", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
+	    execl(MPG_123, "mpg123", "-e", "s16", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
 		/* As a last-ditch effort, try to use PATH */
-	    execlp("mpg123", "mpg123", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
+	    execlp("mpg123", "mpg123", "-e", "s16", "-q", "-s", "-b", buffer_size_str, "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
 	}
 	else if (strstr(filename, ".m3u")) {
 		/* Most commonly installed in /usr/local/bin */
-	    execl(LOCAL_MPG_123, "mpg123", "-q", "-z", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
+	    execl(LOCAL_MPG_123, "mpg123", "-e", "s16", "-q", "-z", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
 		/* But many places has it in /usr/bin */
-	    execl(MPG_123, "mpg123", "-q", "-z", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
+	    execl(MPG_123, "mpg123", "-e", "s16", "-q", "-z", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
 		/* As a last-ditch effort, try to use PATH */
-	    execlp("mpg123", "mpg123", "-q", "-z", "-s",  "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
+	    execlp("mpg123", "mpg123", "-e", "s16", "-q", "-z", "-s",  "-f", "8192", "--mono", "-r", sampling_rate_str, "-@", filename, (char *)NULL);
 	}
 	else {
 		/* Most commonly installed in /usr/local/bin */
-	    execl(MPG_123, "mpg123", "-q", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
+	    execl(MPG_123, "mpg123", "-e", "s16", "-q", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
 		/* But many places has it in /usr/bin */
-	    execl(LOCAL_MPG_123, "mpg123", "-q", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
+	    execl(LOCAL_MPG_123, "mpg123", "-e", "s16", "-q", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
 		/* As a last-ditch effort, try to use PATH */
-	    execlp("mpg123", "mpg123", "-q", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
+	    execlp("mpg123", "mpg123", "-e", "s16", "-q", "-s", "-f", "8192", "--mono", "-r", sampling_rate_str, filename, (char *)NULL);
 	}
 	/* Can't use ast_log since FD's are closed */
 	fprintf(stderr, "Execute of mpg123 failed\n");

apps/app_nbscat.c

@@ -26,7 +26,10 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>deprecated</support_level>
+	<deprecated_in>16</deprecated_in>
+	<removed_in>19</removed_in>
  ***/
 
 #include "asterisk.h"

apps/app_originate.c

@@ -27,9 +27,6 @@
  *
  * \ingroup applications
  *
- * \todo Make a way to be able to set variables (and functions) on the outbound
- *       channel, similar to the Variable headers for the AMI Originate, and the
- *       Set options for call files.
  */
 
 /*** MODULEINFO
@@ -98,12 +95,30 @@ static const char app_originate[] = "Originate";
 						<argument name="argN" />
 					</argument>
 				</option>
+				<option name="C">
+					<para>Comma-separated list of codecs to use for this call.
+					Default is <literal>slin</literal>.</para>
+				</option>
+				<option name="c">
+					<para>The caller ID number to use for the called channel. Default is
+					the current channel's Caller ID number.</para>
+				</option>
+				<option name="n">
+					<para>The caller ID name to use for the called channel. Default is
+					the current channel's Caller ID name.</para>
+				</option>
+				<option name="v" argsep="^">
+					<para>A series of channel variables to set on the destination channel.</para>
+					<argument name="var1" multiple="true" argsep="=">
+						<argument name="name" required="true" />
+						<argument name="value" required="true" />
+					</argument>
+				</option>
 				</optionlist>
 			</parameter>
 		</syntax>
 		<description>
-		<para>This application originates an outbound call and connects it to a specified extension or application.  This application will block until the outgoing call fails or gets answered.  At that point, this application will exit with the status variable set and dialplan processing will continue.</para>
-
+		<para>This application originates an outbound call and connects it to a specified extension or application.  This application will block until the outgoing call fails or gets answered, unless the async option is used.  At that point, this application will exit with the status variable set and dialplan processing will continue.</para>
 		<para>This application sets the following channel variable before exiting:</para>
 		<variablelist>
 			<variable name="ORIGINATE_STATUS">
@@ -128,11 +143,19 @@ enum {
 	OPT_PREDIAL_CALLEE =    (1 << 0),
 	OPT_PREDIAL_CALLER =    (1 << 1),
 	OPT_ASYNC =             (1 << 2),
+	OPT_CALLER_NUM =        (1 << 3),
+	OPT_CALLER_NAME =       (1 << 4),
+	OPT_CODECS =            (1 << 5),
+	OPT_VARIABLES =         (1 << 6),
 };
 
 enum {
 	OPT_ARG_PREDIAL_CALLEE,
 	OPT_ARG_PREDIAL_CALLER,
+	OPT_ARG_CALLER_NUM,
+	OPT_ARG_CALLER_NAME,
+	OPT_ARG_CODECS,
+	OPT_ARG_VARIABLES,
 	/* note: this entry _MUST_ be the last one in the enum */
 	OPT_ARG_ARRAY_SIZE,
 };
@@ -141,9 +164,12 @@ AST_APP_OPTIONS(originate_exec_options, BEGIN_OPTIONS
 	AST_APP_OPTION('a', OPT_ASYNC),
 	AST_APP_OPTION_ARG('b', OPT_PREDIAL_CALLEE, OPT_ARG_PREDIAL_CALLEE),
 	AST_APP_OPTION_ARG('B', OPT_PREDIAL_CALLER, OPT_ARG_PREDIAL_CALLER),
+	AST_APP_OPTION_ARG('C', OPT_CODECS, OPT_ARG_CODECS),
+	AST_APP_OPTION_ARG('c', OPT_CALLER_NUM, OPT_ARG_CALLER_NUM),
+	AST_APP_OPTION_ARG('n', OPT_CALLER_NAME, OPT_ARG_CALLER_NAME),
+	AST_APP_OPTION_ARG('v', OPT_VARIABLES, OPT_ARG_VARIABLES),
 END_OPTIONS );
 
-
 static int originate_exec(struct ast_channel *chan, const char *data)
 {
 	AST_DECLARE_APP_ARGS(args,
@@ -158,29 +184,24 @@ static int originate_exec(struct ast_channel *chan, const char *data)
 	struct ast_flags64 opts = { 0, };
 	char *opt_args[OPT_ARG_ARRAY_SIZE];
 	char *predial_callee = NULL;
-	char *parse;
+	char *parse, *cnum = NULL, *cname = NULL;
+
+	struct ast_variable *vars = NULL;
 	char *chantech, *chandata;
 	int res = -1;
 	int continue_in_dialplan = 0;
 	int outgoing_status = 0;
 	unsigned int timeout = 30;
 	static const char default_exten[] = "s";
-	struct ast_format_cap *cap_slin = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
+	struct ast_format_cap *capabilities;
+	capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
 	ast_autoservice_start(chan);
-	if (!cap_slin) {
+	if (!capabilities) {
 		goto return_cleanup;
 	}
 
-	ast_format_cap_append(cap_slin, ast_format_slin, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin12, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin16, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin24, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin32, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin44, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin48, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin96, 0);
-	ast_format_cap_append(cap_slin, ast_format_slin192, 0);
+	ast_format_cap_append(capabilities, ast_format_slin, 0);
 
 	if (ast_strlen_zero(data)) {
 		ast_log(LOG_ERROR, "Originate() requires arguments\n");
@@ -236,7 +257,57 @@ static int originate_exec(struct ast_channel *chan, const char *data)
 		goto return_cleanup;
 	}
 
+	if (ast_test_flag64(&opts, OPT_CODECS)) {
+		if (!ast_strlen_zero(opt_args[OPT_ARG_CODECS])) {
+			ast_format_cap_remove_by_type(capabilities, AST_MEDIA_TYPE_UNKNOWN);
+			ast_format_cap_update_by_allow_disallow(capabilities, opt_args[OPT_ARG_CODECS], 1);
+		}
+	}
+
+	if (ast_test_flag64(&opts, OPT_CALLER_NUM)) {
+		if (!ast_strlen_zero(opt_args[OPT_ARG_CALLER_NUM])) {
+			cnum = opt_args[OPT_ARG_CALLER_NUM];
+		} else if (ast_channel_caller(chan)->id.number.str) {
+			cnum = ast_channel_caller(chan)->id.number.str;
+		}
+	}
+
+	if (ast_test_flag64(&opts, OPT_CALLER_NAME)) {
+		if (!ast_strlen_zero(opt_args[OPT_ARG_CALLER_NAME])) {
+			cname = opt_args[OPT_ARG_CALLER_NAME];
+		} else if (ast_channel_caller(chan)->id.name.str) {
+			cname = ast_channel_caller(chan)->id.name.str;
+		}
+	}
+
+	/* Assign variables */
+	if (ast_test_flag64(&opts, OPT_VARIABLES)
+		&& !ast_strlen_zero(opt_args[OPT_ARG_VARIABLES])) {
+		char *vartext;
+		char *text = opt_args[OPT_ARG_VARIABLES];
+		while ((vartext = ast_strsep(&text, '^', 0))) {
+			struct ast_variable *var;
+			char *varname, *varvalue;
+			if (!(varname = ast_strsep(&vartext, '=', 0))) {
+				ast_log(LOG_ERROR, "Variable syntax error: %s\n", vartext);
+				goto return_cleanup;
+			}
+			if (!(varvalue = ast_strsep(&vartext, '=', 0))) {
+				varvalue = ""; /* empty values are allowed */
+			}
+			var = ast_variable_new(varname, varvalue, "");
+			if (!var) {
+				ast_log(LOG_ERROR, "Failed to allocate variable: %s\n", varname);
+				goto return_cleanup;
+			}
+			ast_debug(1, "Appending variable '%s' with value '%s'", varname, varvalue);
+			ast_variable_list_append(&vars, var);
+		}
+	}
+
 	if (!strcasecmp(args.type, "exten")) {
+		const char *cid_num = cnum;
+		const char *cid_name = cname;
 		int priority = 1; /* Initialized in case priority not specified */
 		const char *exten = args.arg2;
 
@@ -254,19 +325,21 @@ static int originate_exec(struct ast_channel *chan, const char *data)
 		ast_debug(1, "Originating call to '%s/%s' and connecting them to extension %s,%s,%d\n",
 				chantech, chandata, args.arg1, exten, priority);
 
-		res = ast_pbx_outgoing_exten_predial(chantech, cap_slin, chandata,
+		res = ast_pbx_outgoing_exten_predial(chantech, capabilities, chandata,
 				timeout * 1000, args.arg1, exten, priority, &outgoing_status,
 				ast_test_flag64(&opts, OPT_ASYNC) ? AST_OUTGOING_NO_WAIT : AST_OUTGOING_WAIT,
-				NULL, NULL, NULL, NULL, NULL, 0, NULL,
+				cid_num, cid_name, vars, NULL, NULL, 0, NULL,
 				predial_callee);
 	} else {
+		const char *cid_num = cnum;
+		const char *cid_name = cname;
 		ast_debug(1, "Originating call to '%s/%s' and connecting them to %s(%s)\n",
 				chantech, chandata, args.arg1, S_OR(args.arg2, ""));
 
-		res = ast_pbx_outgoing_app_predial(chantech, cap_slin, chandata,
+		res = ast_pbx_outgoing_app_predial(chantech, capabilities, chandata,
 				timeout * 1000, args.arg1, args.arg2, &outgoing_status,
 				ast_test_flag64(&opts, OPT_ASYNC) ? AST_OUTGOING_NO_WAIT : AST_OUTGOING_WAIT,
-				NULL, NULL, NULL, NULL, NULL, NULL,
+				cid_num, cid_name, vars, NULL, NULL, NULL,
 				predial_callee);
 	}
 
@@ -311,7 +384,10 @@ return_cleanup:
 			break;
 		}
 	}
-	ao2_cleanup(cap_slin);
+	if (vars) {
+		ast_variables_destroy(vars);
+	}
+	ao2_cleanup(capabilities);
 	ast_autoservice_stop(chan);
 
 	return continue_in_dialplan ? 0 : -1;

apps/app_osplookup.c

@@ -31,7 +31,10 @@
 /*** MODULEINFO
 	<depend>osptk</depend>
 	<depend>openssl</depend>
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
+	<deprecated_in>19</deprecated_in>
+	<removed_in>21</removed_in>
  ***/
 
 #include "asterisk.h"

apps/app_page.c

@@ -160,6 +160,8 @@ AST_APP_OPTIONS(page_opts, {
 	AST_APP_OPTION('n', PAGE_NOCALLERANNOUNCE),
 });
 
+#define PAGE_BEEP "beep"
+
 /* We use this structure as a way to pass this to all dialed channels */
 struct page_options {
 	char *opts[OPT_ARG_ARRAY_SIZE];
@@ -172,8 +174,6 @@ struct page_options {
  *
  * \param chan Setup bridge profile on this channel.
  * \param options Options to setup bridge profile.
- *
- * \return Nothing
  */
 static void setup_profile_bridge(struct ast_channel *chan, struct page_options *options)
 {
@@ -190,8 +190,6 @@ static void setup_profile_bridge(struct ast_channel *chan, struct page_options *
  *
  * \param chan Setup user profile on this channel.
  * \param options Options to setup paged user profile.
- *
- * \return Nothing
  */
 static void setup_profile_paged(struct ast_channel *chan, struct page_options *options)
 {
@@ -214,8 +212,6 @@ static void setup_profile_paged(struct ast_channel *chan, struct page_options *o
  *
  * \param chan Setup user profile on this channel.
  * \param options Options to setup caller user profile.
- *
- * \return Nothing
  */
 static void setup_profile_caller(struct ast_channel *chan, struct page_options *options)
 {
@@ -402,9 +398,14 @@ static int page_exec(struct ast_channel *chan, const char *data)
 	ast_free(predial_callee);
 
 	if (!ast_test_flag(&options.flags, PAGE_QUIET)) {
-		res = ast_streamfile(chan, "beep", ast_channel_language(chan));
-		if (!res)
-			res = ast_waitstream(chan, "");
+		if (!ast_fileexists(PAGE_BEEP, NULL, NULL)) {
+			ast_log(LOG_WARNING, "Missing required sound file: '" PAGE_BEEP "'\n");
+		} else {
+			res = ast_streamfile(chan, PAGE_BEEP, ast_channel_language(chan));
+			if (!res) {
+				res = ast_waitstream(chan, "");
+			}
+		}
 	}
 
 	if (!res) {

apps/app_playback.c

@@ -35,7 +35,7 @@
 #include "asterisk/pbx.h"
 #include "asterisk/module.h"
 #include "asterisk/app.h"
-/* This file provides config-file based 'say' functions, and implenents
+/* This file provides config-file based 'say' functions, and implements
  * some CLI commands.
  */
 #include "asterisk/say.h"	/*!< provides config-file based 'say' functions */
@@ -62,6 +62,12 @@
 						be answered before the sound is played.</para>
 						<note><para>Not all channel types support playing messages while still on hook.</para></note>
 					</option>
+					<option name="say">
+						<para>Play using the say.conf file.</para>
+					</option>
+					<option name="mix">
+						<para>Play using a mix of filename and the say.conf file.</para>
+					</option>
 				</optionlist>
 			</parameter>
 		</syntax>
@@ -446,6 +452,7 @@ static int playback_exec(struct ast_channel *chan, const char *data)
 	char *tmp;
 	int option_skip=0;
 	int option_say=0;
+	int option_mix=0;
 	int option_noanswer = 0;
 
 	AST_DECLARE_APP_ARGS(args,
@@ -466,6 +473,8 @@ static int playback_exec(struct ast_channel *chan, const char *data)
 			option_skip = 1;
 		if (strcasestr(args.options, "say"))
 			option_say = 1;
+		if (strcasestr(args.options, "mix"))
+			option_mix = 1;
 		if (strcasestr(args.options, "noanswer"))
 			option_noanswer = 1;
 	}
@@ -486,6 +495,13 @@ static int playback_exec(struct ast_channel *chan, const char *data)
 		while (!res && (front = strsep(&back, "&"))) {
 			if (option_say)
 				res = say_full(chan, front, "", ast_channel_language(chan), NULL, -1, -1);
+			else if (option_mix){
+				/* Check if it is in say format but not remote audio file */
+				if (strcasestr(front, ":") && !strcasestr(front, "://"))
+					res = say_full(chan, front, "", ast_channel_language(chan), NULL, -1, -1);
+				else
+					res = ast_streamfile(chan, front, ast_channel_language(chan));
+			}
 			else
 				res = ast_streamfile(chan, front, ast_channel_language(chan));
 			if (!res) {

apps/app_read.c

@@ -75,6 +75,23 @@
 					<option name="n">
 						<para>to read digits even if the line is not up.</para>
 					</option>
+					<option name="t">
+						<para>Terminator digit(s) to use for ending input.
+						Default is <literal>#</literal>. If you need to read
+						the digit <literal>#</literal> literally, you should
+						remove or change the terminator character. Multiple
+						terminator characters may be specified. If no terminator
+						digit is present, input cannot be ended using digits
+						and you will need to rely on duration and max digits
+						for ending input.</para>
+					</option>
+					<option name="e">
+						<para>to read the terminator as the digit string if the
+						only digit read is the terminator. This is for cases
+						where the terminator is a valid digit, but only by itself.
+						ie; <literal>1234</literal> and <literal>#</literal> are
+						valid, but <literal>1234#</literal> is not.</para>
+					</option>
 				</optionlist>
 			</parameter>
 			<parameter name="attempts">
@@ -114,12 +131,22 @@ enum read_option_flags {
 	OPT_SKIP = (1 << 0),
 	OPT_INDICATION = (1 << 1),
 	OPT_NOANSWER = (1 << 2),
+	OPT_TERMINATOR = (1 << 3),
+	OPT_KEEP_TERMINATOR = (1 << 4),
+};
+
+enum {
+	OPT_ARG_TERMINATOR,
+	/* note: this entry _MUST_ be the last one in the enum */
+	OPT_ARG_ARRAY_SIZE,
 };
 
 AST_APP_OPTIONS(read_app_options, {
 	AST_APP_OPTION('s', OPT_SKIP),
 	AST_APP_OPTION('i', OPT_INDICATION),
 	AST_APP_OPTION('n', OPT_NOANSWER),
+	AST_APP_OPTION_ARG('t', OPT_TERMINATOR, OPT_ARG_TERMINATOR),
+	AST_APP_OPTION('e', OPT_KEEP_TERMINATOR),
 });
 
 static char *app = "Read";
@@ -132,9 +159,11 @@ static int read_exec(struct ast_channel *chan, const char *data)
 	int tries = 1, to = 0, x = 0;
 	double tosec;
 	char *argcopy = NULL;
+	char *opt_args[OPT_ARG_ARRAY_SIZE];
 	struct ast_tone_zone_sound *ts = NULL;
 	struct ast_flags flags = {0};
 	const char *status = "ERROR";
+	char *terminator = "#"; /* use default terminator # by default */
 
 	AST_DECLARE_APP_ARGS(arglist,
 		AST_APP_ARG(variable);
@@ -156,7 +185,7 @@ static int read_exec(struct ast_channel *chan, const char *data)
 	AST_STANDARD_APP_ARGS(arglist, argcopy);
 
 	if (!ast_strlen_zero(arglist.options)) {
-		ast_app_parse_options(read_app_options, &flags, NULL, arglist.options);
+		ast_app_parse_options(read_app_options, &flags, opt_args, arglist.options);
 	}
 
 	if (!ast_strlen_zero(arglist.attempts)) {
@@ -192,9 +221,19 @@ static int read_exec(struct ast_channel *chan, const char *data)
 			ts = ast_get_indication_tone(ast_channel_zone(chan), arglist.filename);
 		}
 	}
+	if (ast_test_flag(&flags, OPT_TERMINATOR)) {
+		if (!ast_strlen_zero(opt_args[OPT_ARG_TERMINATOR])) {
+			terminator = opt_args[OPT_ARG_TERMINATOR];
+		} else {
+			terminator = ""; /* no digit inherently will terminate input */
+		}
+	}
 	if (ast_channel_state(chan) != AST_STATE_UP) {
 		if (ast_test_flag(&flags, OPT_SKIP)) {
 			/* At the user's option, skip if the line is not up */
+			if (ts) {
+				ts = ast_tone_zone_sound_unref(ts);
+			}
 			pbx_builtin_setvar_helper(chan, arglist.variable, "");
 			pbx_builtin_setvar_helper(chan, "READSTATUS", "SKIPPED");
 			return 0;
@@ -220,7 +259,7 @@ static int read_exec(struct ast_channel *chan, const char *data)
 						break;
 					}
 					tmp[x++] = res;
-					if (tmp[x-1] == '#') {
+					if (terminator && strchr(terminator, tmp[x-1])) {
 						tmp[x-1] = '\0';
 						status = "OK";
 						break;
@@ -230,13 +269,21 @@ static int read_exec(struct ast_channel *chan, const char *data)
 					}
 				}
 			} else {
-				res = ast_app_getdata(chan, arglist.filename, tmp, maxdigits, to);
-				if (res == AST_GETDATA_COMPLETE || res == AST_GETDATA_EMPTY_END_TERMINATED)
+				res = ast_app_getdata_terminator(chan, arglist.filename, tmp, maxdigits, to, terminator);
+				if (res == AST_GETDATA_COMPLETE) {
 					status = "OK";
-				else if (res == AST_GETDATA_TIMEOUT)
+				} else if (res == AST_GETDATA_EMPTY_END_TERMINATED) {
+					if (ast_test_flag(&flags, OPT_KEEP_TERMINATOR)) {
+						/* if the option is set to do so, read the
+						   returned string as the terminator string */
+						ast_copy_string(tmp, terminator, sizeof(tmp));
+					}
+					status = "OK";
+				} else if (res == AST_GETDATA_TIMEOUT) {
 					status = "TIMEOUT";
-				else if (res == AST_GETDATA_INTERRUPTED)
+				} else if (res == AST_GETDATA_INTERRUPTED) {
 					status = "INTERRUPTED";
+				}
 			}
 			if (res > -1) {
 				pbx_builtin_setvar_helper(chan, arglist.variable, tmp);

apps/app_reload.c

@@ -0,0 +1,111 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2021, Naveen Albert
+ *
+ * Naveen Albert <asterisk@phreaknet.org>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Reload Asterisk modules
+ *
+ * \author Naveen Albert <asterisk@phreaknet.org>
+ *
+ * \ingroup applications
+ */
+
+/*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
+	<support_level>extended</support_level>
+ ***/
+
+#include "asterisk.h"
+
+#include "asterisk/logger.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/module.h"
+#include "asterisk/app.h"
+
+/*** DOCUMENTATION
+	<application name="Reload" language="en_US">
+		<synopsis>
+			Reloads an Asterisk module, blocking the channel until the reload has completed.
+		</synopsis>
+		<syntax>
+			<parameter name="module" required="false">
+				<para>The full name(s) of the target module(s) or resource(s) to reload.
+				If omitted, everything will be reloaded.</para>
+				<para>The full names MUST be specified (e.g. <literal>chan_iax2</literal>
+				to reload IAX2 or <literal>pbx_config</literal> to reload the dialplan.</para>
+			</parameter>
+		</syntax>
+		<description>
+			<para>Reloads the specified (or all) Asterisk modules and reports success or failure.
+			Success is determined by each individual module, and if all reloads are successful,
+			that is considered an aggregate success. If multiple modules are specified and any
+			module fails, then FAILURE will be returned. It is still possible that other modules
+			did successfully reload, however.</para>
+			<para>Sets <variable>RELOADSTATUS</variable> to one of the following values:</para>
+			<variablelist>
+				<variable name="RELOADSTATUS">
+					<value name="SUCCESS">
+						Specified module(s) reloaded successfully.
+					</value>
+					<value name="FAILURE">
+						Some or all of the specified modules failed to reload.
+					</value>
+				</variable>
+			</variablelist>
+		</description>
+	</application>
+ ***/
+
+static char *app = "Reload";
+
+static int reload_exec(struct ast_channel *chan, const char *data)
+{
+	char *targets, *target = NULL;
+	enum ast_module_reload_result res = AST_MODULE_RELOAD_SUCCESS;
+
+	targets = ast_strdupa(data);
+	ast_autoservice_start(chan);
+	if (ast_strlen_zero(targets)) { /* Reload everything */
+		res = ast_module_reload(targets);
+	} else {
+		while((target = ast_strsep(&targets, ',', AST_STRSEP_ALL))) {
+			res |= ast_module_reload(target);
+		}
+	}
+	ast_autoservice_stop(chan);
+
+	if (res == AST_MODULE_RELOAD_SUCCESS) {
+		pbx_builtin_setvar_helper(chan, "RELOADSTATUS", "SUCCESS");
+	} else {
+		pbx_builtin_setvar_helper(chan, "RELOADSTATUS", "FAILURE");
+	}
+	return 0;
+}
+
+static int unload_module(void)
+{
+	return ast_unregister_application(app);
+}
+
+static int load_module(void)
+{
+	return ast_register_application_xml(app, reload_exec);
+}
+
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Reload module(s)");

apps/app_senddtmf.c

@@ -57,6 +57,15 @@
 			<parameter name="channel" required="false">
 				<para>Channel where digits will be played</para>
 			</parameter>
+			<parameter name="options">
+				<optionlist>
+					<option name="a">
+						<para>Answer the channel specified by the <literal>channel</literal>
+						parameter if it is not already up. If no <literal>channel</literal>
+						parameter is provided, the current channel will be answered.</para>
+					</option>
+				</optionlist>
+			</parameter>
 		</syntax>
 		<description>
 			<para>It will send all digits or terminate if it encounters an error.</para>
@@ -90,6 +99,19 @@
 	</manager>
  ***/
 
+enum read_option_flags {
+	OPT_ANSWER = (1 << 0),
+};
+
+AST_APP_OPTIONS(senddtmf_app_options, {
+	AST_APP_OPTION('a', OPT_ANSWER),
+});
+
+enum {
+	/* note: this entry _MUST_ be the last one in the enum */
+	OPT_ARG_ARRAY_SIZE,
+};
+
 static const char senddtmf_name[] = "SendDTMF";
 
 static int senddtmf_exec(struct ast_channel *chan, const char *vdata)
@@ -100,11 +122,14 @@ static int senddtmf_exec(struct ast_channel *chan, const char *vdata)
 	struct ast_channel *chan_found = NULL;
 	struct ast_channel *chan_dest = chan;
 	struct ast_channel *chan_autoservice = NULL;
+	char *opt_args[OPT_ARG_ARRAY_SIZE];
+	struct ast_flags flags = {0};
 	AST_DECLARE_APP_ARGS(args,
 		AST_APP_ARG(digits);
 		AST_APP_ARG(dinterval);
 		AST_APP_ARG(duration);
 		AST_APP_ARG(channel);
+		AST_APP_ARG(options);
 	);
 
 	if (ast_strlen_zero(vdata)) {
@@ -136,6 +161,12 @@ static int senddtmf_exec(struct ast_channel *chan, const char *vdata)
 			chan_autoservice = chan;
 		}
 	}
+	if (!ast_strlen_zero(args.options)) {
+		ast_app_parse_options(senddtmf_app_options, &flags, opt_args, args.options);
+	}
+	if (ast_test_flag(&flags, OPT_ANSWER)) {
+		ast_auto_answer(chan_dest);
+	}
 	res = ast_dtmf_stream(chan_dest, chan_autoservice, args.digits,
 		dinterval <= 0 ? 250 : dinterval, duration);
 	if (chan_found) {

apps/app_sms.c

@@ -35,6 +35,7 @@
  */
 
 /*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
 	<support_level>extended</support_level>
  ***/
 

apps/app_speech_utils.c

@@ -26,8 +26,8 @@
  */
 
 /*** MODULEINFO
-	<support_level>core</support_level>
 	<depend>res_speech</depend>
+	<support_level>core</support_level>
  ***/
 
 #include "asterisk.h"

apps/app_stack.c

@@ -590,8 +590,8 @@ static int gosub_exec(struct ast_channel *chan, const char *data)
 	ast_channel_unlock(chan);
 
 	if (!ast_exists_extension(chan, dest_context, dest_exten, dest_priority, caller_id)) {
-		ast_log(LOG_ERROR, "Attempt to reach a non-existent destination for %s: (Context:%s, Extension:%s, Priority:%d)\n",
-			app_gosub, dest_context, dest_exten, dest_priority);
+		ast_log(LOG_ERROR, "%s attempted to reach non-existent destination '%s,%s,%d' from '%s,%s,%d'",
+			app_gosub, dest_context, dest_exten, dest_priority, orig_context, orig_exten, orig_priority);
 		goto error_exit;
 	}
 
@@ -924,8 +924,6 @@ static struct ast_custom_function stackpeek_function = {
  * \param chan Channel to balance stack on.
  *
  * \note The channel is already locked when called.
- *
- * \return Nothing
  */
 static void balance_stack(struct ast_channel *chan)
 {