.travis.yml

dist: xenial
language: c

env:
  global:
    - secure: "QD09MuUxftXRXtz7ZrB7S0NV/3O9yVhjvIlCSbXN8B87rNSDC8wxMThKMT7iZewnqGk53m+Up19PiMw5ERlHose5tm2cmY1FO/l+c9oAyWZaAL+4XNXryq6zI5F5FX5I61NbfqV3xcnfLTI2QIJF6WqDojNxhPjTbNzQGxIDuqw="

matrix:
  include:

    # linux build
    - os: linux
      env:
        - TEST="linux (gcc / valgrind)"
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
          packages:
            - gcc-6
            - valgrind
      install:
        - pyenv global 3.7.1
        - pip3 install meson ninja
      script:
        - CC=gcc-6 EXTRA_CFLAGS=-Werror ./configure
        - make
        - make runtest
        - make runtest-valgrind
        - make distclean
        - mkdir build && cd build
        - cmake ..
        - make
        - make test
        - cd ..
        - CC=gcc-6 meson setup --werror builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # linux build with openssl
    - os: linux
      env:
        - TEST="linux openssl (gcc / valgrind)"
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
          packages:
            - gcc-6
            - valgrind
      install:
        - pyenv global 3.7.1
        - pip3 install meson ninja
      script:
        - CC=gcc-6 EXTRA_CFLAGS=-Werror ./configure --enable-openssl
        - make
        - make runtest
        - make runtest-valgrind
        - make distclean
        - mkdir build && cd build
        - cmake -DENABLE_OPENSSL=ON ..
        - make
        - make test
        - cd ..
        - mkdir build_shared && cd build_shared
        - cmake -DENABLE_OPENSSL=ON -DBUILD_SHARED_LIBS=ON ..
        - make
        - make test
        - cd ..
        - meson setup --werror -Dcrypto-library=openssl builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # linux build with openssl and clang
    - os: linux
      env:
        - TEST="linux openssl (clang)"
      addons:
        apt:
          packages:
            - clang
      install:
        - pyenv global 3.7.1
        - pip3 install meson ninja
      script:
        - CC=clang EXTRA_CFLAGS=-Werror ./configure --enable-openssl
        - make
        - make runtest
        - CC=clang meson setup --werror -Dcrypto-library=openssl builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # linux build with nss
    - os: linux
      env:
        - TEST="linux nss (gcc / valgrind)"
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
          packages:
            - gcc-6
            - valgrind
            - libnss3-dev
      install:
        - pyenv global 3.7.1
        - pip3 install meson ninja
      script:
        - CC=gcc-6 EXTRA_CFLAGS=-Werror ./configure --enable-nss
        - make
        - make runtest
        - make runtest-valgrind
        - CC=gcc-6 meson setup --werror -Dcrypto-library=nss builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # default osx build
    - os: osx
      env:
        - TEST="osx"
      before_install:
        - pip3 install meson ninja
      script:
        - EXTRA_CFLAGS=-Werror ./configure
        - make
        - make runtest
        - make distclean
        - mkdir build && cd build
        - cmake ..
        - make
        - make test
        - cd ..
        - meson setup --werror builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # osx build with openssl
    - os: osx
      osx_image: xcode11.2
      env:
        - TEST="osx openssl"
      before_install:
        - pip3 install meson ninja
        - brew install openssl@1.1
      script:
        - PKG_CONFIG_PATH=$(brew --prefix openssl@1.1)/lib/pkgconfig EXTRA_CFLAGS=-Werror ./configure --enable-openssl
        - make
        - make runtest
        - make distclean
        - mkdir build && cd build
        - cmake -DOPENSSL_ROOT_DIR=$(brew --prefix openssl@1.1) -DENABLE_OPENSSL=ON ..
        - make
        - make test
        - cd ..
        - PKG_CONFIG_PATH=$(brew --prefix openssl@1.1)/lib/pkgconfig meson setup --werror -Dcrypto-library=openssl builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # osx build with nss
    - os: osx
      osx_image: xcode11.2
      env:
        - TEST="osx nss"
      before_install:
        - pip3 install meson ninja
      script:
        - PKG_CONFIG_PATH=$(brew --prefix nss)/lib/pkgconfig EXTRA_CFLAGS=-Werror ./configure --enable-nss
        - make
        - make runtest
        - PKG_CONFIG_PATH=$(brew --prefix nss)/lib/pkgconfig meson setup --werror -Dcrypto-library=nss builddir
        - meson compile -C builddir
        - meson test -v -C builddir

    # code format check
    - os: linux
      env:
        - TEST="clang-format"
      addons:
        apt:
          packages:
            - clang-format-3.9
      script:
        - CLANG_FORMAT=clang-format-3.9 ./format.sh -d

    # big-endian
    - os: linux
      env:
        - TEST="big-endian"
      services:
        - docker
      addons:
        apt:
          packages:
            - qemu-user-static
            - qemu-system-mips
      before_install:
        - sudo docker run --volume $(pwd):/src --workdir /src --name mipsX --tty --detach ubuntu:16.04 tail
        - sudo docker exec --tty mipsX apt-get update
        - sudo docker exec --tty mipsX apt-get install build-essential -y
        - sudo docker exec --tty mipsX apt-get install qemu-user-static qemu-system-mips gcc-mips-linux-gnu python3-pip -y
        - sudo docker exec --tty mipsX pip3 install meson ninja
      script:
        - sudo docker exec --tty mipsX bash -c 'EXTRA_CFLAGS=-static CC=mips-linux-gnu-gcc ./configure --host=mips-linux-gnu'
        - sudo docker exec --tty mipsX make
        - file test/srtp_driver
        - make runtest
        - |
          cat > mips-cross-file.txt <<EOF
          [host_machine]
          system = 'linux'
          cpu_family = 'mips'
          cpu = 'mips'
          endian = 'big'

          [properties]
          c_args = ['-static', '-static-libgcc']
          c_link_args = ['-static', '-static-libgcc']

          [binaries]
          ar          = 'mips-linux-gnu-gcc-ar'
          c           = 'mips-linux-gnu-gcc'
          ranlib      = 'mips-linux-gnu-gcc-ranlib'
          exe_wrapper = 'qemu-mips-static'
          pkgconfig   = 'false'
          EOF
        - sudo docker exec --tty mipsX meson setup --cross-file mips-cross-file.txt -Ddefault_library=static -Db_staticpic=false builddir
        - sudo docker exec --tty mipsX meson compile -C builddir
        - sudo docker exec --tty mipsX meson test -v --timeout-multiplier 10 -C builddir
        - sudo docker kill mipsX

    # linux build of fuzzer
    - os: linux
      env:
        - TEST="fuzzer (build only)"
      addons:
        apt:
          packages:
            - clang
      script:
        - CC=clang CXX=clang++ CXXFLAGS="-fsanitize=fuzzer-no-link,address,undefined -g -O3" CFLAGS="-fsanitize=fuzzer-no-link,address,undefined -g -O3" LDFLAGS="-fsanitize=fuzzer-no-link,address,undefined" ./configure
        - LIBFUZZER="-fsanitize=fuzzer" make srtp-fuzzer

    # coverity scan
    - os: linux
      env:
        - TEST="Coverity Scan"
      addons:
        coverity_scan:
          project:
            name: "cisco-libSRTP"
            description: "Build submitted via Travis CI"
            version: 2
          notification_email: pabuhler@cisco.com
          build_command_prepend: "./configure"
          build_command: "make"
          branch_pattern: master
      script:
        - echo -n | openssl s_client -connect scan.coverity.com:443 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | sudo tee -a /etc/ssl/certs/ca-

    # windows build
    - os: windows
      before_install:
        - choco install python --version 3.8.0
        - choco install ninja
        - pip3 install meson
      env:
        - TEST="windows"
        - PATH=/c/Python38:/c/Python38/Scripts:$PATH
      script:
        - export PATH="c:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin":$PATH
        - mkdir build && cd build
        - cmake -G "Visual Studio 15 2017" ..
        - msbuild.exe libsrtp2.sln -p:Configuration=Release
        - msbuild.exe RUN_TESTS.vcxproj -p:Configuration=Release
        - cd ..
        - mkdir build_shared && cd build_shared
        - cmake -G "Visual Studio 15 2017" -DBUILD_SHARED_LIBS=ON ..
        - msbuild.exe libsrtp2.sln -p:Configuration=Release
        - msbuild.exe RUN_TESTS.vcxproj -p:Configuration=Release
        # Test mingw build
        - cd ..
        - meson setup builddir-gcc
        - meson compile -C builddir-gcc
        - meson test -v -C builddir-gcc
        # Test MSVC 64-bit build
        - cmd.exe //C 'C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvarsall.bat' amd64 \& set CC=cl \& meson setup --werror builddir-msvc-amd64 \& meson compile -C builddir-msvc-amd64 \& meson test -v -C builddir-msvc-amd64
        # Test MSVC 32-bit build
        - cmd.exe //C 'C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvarsall.bat' x86 \& set CC=cl \& meson setup --werror builddir-msvc-x86 \& meson compile -C builddir-msvc-x86 \& meson test -v -C builddir-msvc-x86
        # Test MSVC 64-bit UWP build. This is a cross build because we cannot run UWP binaries natively.
        #- |
        #  cat > uwp-amd64-cross-file.txt <<EOF
        #  [host_machine]
        #  system = 'windows'
        #  cpu_family = 'x86_64'
        #  cpu = 'x86_64'
        #  endian = 'little'
        #
        #  [properties]
        #  c_args = ['-DWINAPI_FAMILY=WINAPI_FAMILY_APP']
        #  c_link_args = ['-APPCONTAINER', 'WindowsApp.lib']
        #  needs_exe_wrapper = true
        #
        #  [binaries]
        #  ar        = 'lib'
        #  c         = 'cl'
        #  cpp       = 'cl'
        #  pkgconfig = 'false'
        #  EOF
        #- cmd.exe //C 'C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvarsall.bat' amd64 uwp \& meson setup --werror --cross-file uwp-amd64-cross-file.txt builddir-uwp-amd64 \& meson compile -C builddir-uwp-amd64
        # Test MSVC ARM64 UWP build. This is a cross build.
        #- |
        #  cat > uwp-arm64-cross-file.txt <<EOF
        #  [host_machine]
        #  system = 'windows'
        #  cpu_family = 'aarch64'
        #  cpu = 'aarch64'
        #  endian = 'little'
        #
        #  [properties]
        #  c_args = ['-DWINAPI_FAMILY=WINAPI_FAMILY_APP']
        #  c_link_args = ['-APPCONTAINER', 'WindowsApp.lib']
        #  needs_exe_wrapper = true
        #
        #  [binaries]
        #  ar        = 'lib'
        #  c         = 'cl'
        #  cpp       = 'cl'
        #  pkgconfig = 'false'
        #  EOF
        #- cmd.exe //C 'C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvarsall.bat' amd64_arm64 uwp \& meson setup --werror --cross-file uwp-arm64-cross-file.txt builddir-uwp-arm64 \& meson compile -C builddir-uwp-arm64

    # android build
    - os: linux
      env:
        - TEST="android"
      install:
        - pyenv global 3.7.1
        - pip3 install meson ninja
      script:
        - wget -q https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip
        - unzip -qq android-ndk-r20b-linux-x86_64.zip
        - ANDROID_NDK=`pwd`/android-ndk-r20b
        - mkdir build_android
        - cd build_android
        - cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake -DANDROID_ABI=arm64-v8a ..
        - make
        - cd ..
        - TOOLCHAIN=$ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64
        - AR=$TOOLCHAIN/bin/aarch64-linux-android-ar
          AS=$TOOLCHAIN/bin/aarch64-linux-android-as
          CC=$TOOLCHAIN/bin/aarch64-linux-android21-clang
          CXX=$TOOLCHAIN/bin/aarch64-linux-android21-clang++
          LD=$TOOLCHAIN/bin/aarch64-linux-android-ld
          RANLIB=$TOOLCHAIN/bin/aarch64-linux-android-ranlib
          STRIP=$TOOLCHAIN/bin/aarch64-linux-android-strip
          ./configure --host aarch64-linux-android
        - make
        - |
          cat > android-cross-file.txt <<EOF
          [host_machine]
          system = 'android'
          cpu_family = 'aarch64'
          cpu = 'aarch64'
          endian = 'little'

          [properties]
          sys_root = '$ANDROID_NDK/sysroot'

          [binaries]
          ar        = '$TOOLCHAIN/bin/aarch64-linux-android-ar'
          c         = '$TOOLCHAIN/bin/aarch64-linux-android21-clang'
          cpp       = '$TOOLCHAIN/bin/aarch64-linux-android21-clang++'
          ranlib    = '$TOOLCHAIN/bin/aarch64-linux-android-ranlib'
          strip     = '$TOOLCHAIN/bin/aarch64-linux-android-strip'
          pkgconfig = 'false'
          EOF
        - meson setup --werror --cross-file android-cross-file.txt builddir
        - meson compile -C builddir

    # ios build
    - os: osx
      osx_image: xcode11.2
      env:
        - TEST="ios"
      before_install:
        - pip3 install meson ninja
      script:
        - wget -q https://raw.githubusercontent.com/leetal/ios-cmake/master/ios.toolchain.cmake
        - mkdir build && cd build
        - cmake -DCMAKE_TOOLCHAIN_FILE=../ios.toolchain.cmake  -DPLATFORM=OS64 ..
        - make
        - cd ..
        - CFLAGS="-arch arm64 --sysroot=$(xcrun --sdk iphoneos --show-sdk-path) -miphoneos-version-min=8.0 -fembed-bitcode"
          LDFLAGS="-arch arm64 --sysroot=$(xcrun --sdk iphoneos --show-sdk-path) -miphoneos-version-min=8.0 -fembed-bitcode"
          AR="$(xcrun --find --sdk iphoneos ar)"
          AS="$(xcrun --find --sdk iphoneos as)"
          CC="$(xcrun --find --sdk iphoneos clang)"
          CXX="$(xcrun --find --sdk iphoneos clang++)"
          LD="$(xcrun --find --sdk iphoneos ld)"
          RANLIB="$(xcrun --find --sdk iphoneos ranlib)"
          STRIP="$(xcrun --find --sdk iphoneos strip)"
          ./configure --host arm-apple-darwin
        - make
        - make shared_library
        - |
          cat > ios-cross-file.txt <<EOF
          [host_machine]
          system = 'darwin'
          cpu_family = 'aarch64'
          cpu = 'aarch64'
          endian = 'little'

          [properties]
          c_args =      ['-arch', 'arm64', '--sysroot=$(xcrun --sdk iphoneos --show-sdk-path)', '-miphoneos-version-min=8.0']
          c_link_args = ['-arch', 'arm64', '--sysroot=$(xcrun --sdk iphoneos --show-sdk-path)', '-miphoneos-version-min=8.0']

          [binaries]
          ar        = '$(xcrun --find --sdk iphoneos ar)'
          c         = '$(xcrun --find --sdk iphoneos clang)'
          cpp       = '$(xcrun --find --sdk iphoneos clang++)'
          ranlib    = '$(xcrun --find --sdk iphoneos ranlib)'
          strip     = '$(xcrun --find --sdk iphoneos strip)'
          pkgconfig = 'false'
          EOF
        - meson setup --werror -Db_bitcode=true --cross-file ios-cross-file.txt builddir
        - meson compile -C builddir