pax_global_header00006660000000000000000000000064145557377000014527gustar00rootroot0000000000000052 comment=21bdd9636c3daba84c9b1f7277eb0881655fe528 azure-uamqp-python-1.6.8/000077500000000000000000000000001455573770000153315ustar00rootroot00000000000000azure-uamqp-python-1.6.8/.azure-pipelines/000077500000000000000000000000001455573770000205235ustar00rootroot00000000000000azure-uamqp-python-1.6.8/.azure-pipelines/.prettierrc.yml000066400000000000000000000000221455573770000235010ustar00rootroot00000000000000singleQuote: true azure-uamqp-python-1.6.8/.azure-pipelines/client.openssl.yml000066400000000000000000000016141455573770000242100ustar00rootroot00000000000000trigger: none pr: none variables: OpenSSLVersion: '1.1.1q' MacOSXDeploymentTarget: '10.9' jobs: - job: 'OpenSSL' pool: vmImage: 'macOS-10.15' steps: - script: sudo xcode-select --switch /Applications/Xcode_11.3.1.app displayName: 'Select Xcode 11.3.1' - script: source ./build_openssl_osx.sh displayName: 'Build OpenSSL' env: CFLAGS: -mmacosx-version-min=$(MacOSXDeploymentTarget) DEST: $(Build.ArtifactStagingDirectory) LDFLAGS: -mmacosx-version-min=$(MacOSXDeploymentTarget) MACOSX_DEPLOYMENT_TARGET: $(MacOSXDeploymentTarget) OPENSSL_VERSION: $(OpenSSLVersion) - task: PublishPipelineArtifact@0 displayName: 'Publish OpenSSL artifact' inputs: artifactName: openssl-macosx$(MacOSXDeploymentTarget) targetPath: $(Build.ArtifactStagingDirectory)/openssl azure-uamqp-python-1.6.8/.azure-pipelines/client.test.live.yml000066400000000000000000000400121455573770000244350ustar00rootroot00000000000000trigger: - main variables: PythonVersion38: '3.8' PythonVersion39: '3.9' PythonVersion310: '3.10.0' PythonVersion311: '3.11.0' PythonVersion312: '3.12.0' GetPip: 'https://bootstrap.pypa.io/get-pip.py' jobs: - job: 'Windows' pool: name: azsdk-pool-mms-win-2022-general vmImage: MMS2022 variables: VS_INSTALLER_URL: "https://aka.ms/vs/17/release/vs_enterprise.exe" VS_INSTALLER_PATH: "$(Build.BinariesDirectory)/vs_enterprise.exe" VS_ENTERPRISE_PATH: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise" timeoutInMinutes: 120 strategy: maxParallel: 1 matrix: x64 Python 3.8: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-win_amd64' x64 Python 3.9: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-win_amd64' x64 Python 3.10: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-win_amd64' x64 Python 3.11: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-win_amd64' x64 Python 3.12: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-win_amd64' steps: - template: /.azure-pipelines/use-python-version.yml parameters: architecture: '$(PythonArchitecture)' versionSpec: '$(PythonVersion)' - powershell: | python --version Invoke-WebRequest -UseBasicParsing -Uri $(GetPip) | Select-Object -ExpandProperty Content | python python -m pip --version python -m pip install -r dev_requirements.txt displayName: 'Install dependencies' env: PYTHONWARNINGS: ignore:DEPRECATION - pwsh: | Invoke-WebRequest "$(VS_INSTALLER_URL)" -OutFile "$(VS_INSTALLER_PATH)" # In order of component appearance in the install command below, these are the names of the components # as they in the VS Installer UI. (What you would do locally.) # C# and Visual Basic Roslyn Compilers (components pane) # C++ 2022 Redistributable Update (components pane) # C++ CMake tools for Windows (components pane) # MSBuild (components pane) # MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest) (components pane) # Native Desktop Workload (workloads pane) $(VS_INSTALLER_PATH) --installPath $(VS_ENTERPRISE_PATH) ` --add Microsoft.VisualStudio.Component.Roslyn.Compiler ` --add Microsoft.VisualStudio.Component.VC.Redist.14.Latest ` --add Microsoft.VisualStudio.Component.VC.CMake.Project ` --add Microsoft.Component.MSBuild ` --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 ` --add Microsoft.VisualStudio.Workload.NativeDesktop ` --quiet --wait --norestart displayName: Install build script requirements - script: | call "$(VS_ENTERPRISE_PATH)\VC\Auxiliary\Build\vcvars64.bat" python -m pip install cibuildwheel==2.16.2 displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_PRERELEASE_PYTHONS: True CIBW_BUILD: $(BWFilter) - script: dir dist displayName: 'Check output' - powershell: | $whlfile = Get-ChildItem -Filter *.whl dist | Select-Object -First 1 -ExpandProperty Name python -m pip install --ignore-installed ./dist/$whlfile pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' env: EVENT_HUB_HOSTNAME: $(python-eh-livetest-event-hub-hostname) EVENT_HUB_NAME: $(python-eh-livetest-event-hub-name) EVENT_HUB_SAS_POLICY: $(python-eh-livetest-event-hub-sas-policy) EVENT_HUB_SAS_KEY: $(python-eh-livetest-event-hub-sas-key) IOTHUB_HOSTNAME: $(python-iothub-livetest-host-name) IOTHUB_HUB_NAME: $(python-iothub-livetest-hub-name) IOTHUB_DEVICE: $(python-eh-livetest-event-hub-iothub-device) IOTHUB_ENDPOINT: $(python-iothub-livetest-endpoint) IOTHUB_SAS_POLICY: $(python-iothub-livetest-sas-policy) IOTHUB_SAS_KEY: $(python-iothub-livetest-sas-key) - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'Windows $(PythonArchitecture) Python $(PythonVersion)' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifact' inputs: artifactName: uamqp-win$(PythonArchitecture)-$(PythonVersion)-whl pathToPublish: 'dist' - job: 'MacOS' timeoutInMinutes: 120 dependsOn: 'Windows' pool: vmImage: 'macOS-11' strategy: maxParallel: 1 matrix: Python 3.8: PythonBin: 'python3' PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-macosx_x86_64' Python 3.9: PythonBin: 'python3' PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-macosx_x86_64' Python 3.10: PythonBin: 'python3' PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-macosx_x86_64' Python 3.11: PythonBin: 'python3' PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-macosx_x86_64' Python 3.12: PythonBin: 'python3' PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-macosx_x86_64' variables: MacOSXDeploymentTarget: '10.9' OpenSSLDir: $(Agent.BuildDirectory)/openssl-macosx$(MacOSXDeploymentTarget) PythonVersion38: '3.8.2' PythonVersion39: '3.9.0' PythonVersion310: '3.10.0' PythonVersion311: '3.11.0' PythonVersion312: '3.12.0' steps: - task: DownloadPipelineArtifact@1 displayName: 'Download OpenSSL artifact' inputs: artifactName: openssl-macosx$(MacOSXDeploymentTarget) buildType: specific buildVersionToDownload: latest downloadPath: $(Agent.BuildDirectory) pipeline: 119 # azure-uamqp-python - openssl project: '29ec6040-b234-4e31-b139-33dc4287b756' # public - script: sudo xcode-select --switch /Applications/Xcode_13.1.app displayName: 'Select Xcode 13.1' - script: source ./install_python_osx.sh displayName: 'Install Official Python' - script: | echo "Prepending PATH environment variable with directory: /usr/local/bin" echo "##vso[task.prependpath]/usr/local/bin" echo "$(PythonVersion)" export PYTHON_SHORT_VER=`echo $(PythonVersion) | cut -d . -f 1,2` echo "Prepending PATH environment variable with directory: $HOME/Library/Python/$PYTHON_SHORT_VER/bin" echo "##vso[task.prependpath]$HOME/Library/Python/$PYTHON_SHORT_VER/bin" displayName: 'Prepare PATH' - script: | $(PythonBin) --version curl -sS $(GetPip) | $(PythonBin) - --user python -m pip --version $(PythonBin) -m pip install --user -r dev_requirements.txt displayName: 'Install dependencies' - bash: | set -o errexit $(PythonBin) -m pip install --user cibuildwheel==2.16.2 --force displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_PRERELEASE_PYTHONS: True CIBW_ARCHS_MACOS: x86_64 CIBW_BUILD: $(BWFilter) UAMQP_USE_OPENSSL: true UAMQP_REBUILD_PYX: true UAMQP_SUPPRESS_LINK_FLAGS: true OPENSSL_ROOT_DIR: "/tmp/openssl" OPENSSL_INCLUDE_DIR: "/tmp/openssl/include" LDFLAGS: "-mmacosx-version-min=10.9 -L/tmp/openssl/lib" CFLAGS: "-mmacosx-version-min=10.9 -I/tmp/openssl/include" - script: ls ./dist displayName: 'Check output' - script: | $(PythonBin) -m pip install --user --ignore-installed ./dist/*.whl $(PythonBin) -m pip install --user pytest==6.2.4 --force $(PythonBin) -m pip install --user pytest-asyncio==0.12.0 --force pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' env: EVENT_HUB_HOSTNAME: $(python-eh-livetest-event-hub-hostname) EVENT_HUB_NAME: $(python-eh-livetest-event-hub-name) EVENT_HUB_SAS_POLICY: $(python-eh-livetest-event-hub-sas-policy) EVENT_HUB_SAS_KEY: $(python-eh-livetest-event-hub-sas-key) IOTHUB_HOSTNAME: $(python-iothub-livetest-host-name) IOTHUB_HUB_NAME: $(python-iothub-livetest-hub-name) IOTHUB_DEVICE: $(python-eh-livetest-event-hub-iothub-device) IOTHUB_ENDPOINT: $(python-iothub-livetest-endpoint) IOTHUB_SAS_POLICY: $(python-iothub-livetest-sas-policy) IOTHUB_SAS_KEY: $(python-iothub-livetest-sas-key) - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'MacOS Python $(PythonVersion)' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifact' inputs: artifactName: uamqp-macosx$(MacOSXDeploymentTarget)-$(PythonVersion)-whl pathToPublish: 'dist' - job: 'Linux' timeoutInMinutes: 120 dependsOn: 'MacOS' pool: vmImage: 'ubuntu-20.04' strategy: maxParallel: 1 matrix: Python 3.8: PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-manylinux_x86_64' Python 3.9: PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-manylinux_x86_64' Python 3.10: PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-manylinux_x86_64' Python 3.11: PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-manylinux_x86_64' Python 3.12: PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-manylinux_x86_64' steps: - template: /.azure-pipelines/use-python-version.yml parameters: versionSpec: '$(PythonVersion)' - script: | echo "Prepending PATH environment variable with directory: $HOME/.local/bin" echo "##vso[task.prependpath]$HOME/.local/bin" displayName: 'Prepare PATH' - script: | python --version curl -sS $(GetPip) | python - --user python -m pip --version python -m pip install setuptools --force curl -LO http://archive.ubuntu.com/ubuntu/pool/main/libf/libffi/libffi6_3.2.1-8_amd64.deb && sudo dpkg -i libffi6_3.2.1-8_amd64.deb python -m pip install --user -r dev_requirements.txt displayName: 'Install dependencies' - bash: | set -o errexit python -m pip install cibuildwheel==2.16.2 displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_BUILD: $(BWFilter) CIBW_PRERELEASE_PYTHONS: True CIBW_BEFORE_BUILD_LINUX: bash utils/install_openssl.sh CIBW_ENVIRONMENT_LINUX: OPENSSL_ROOT_DIR="/opt/pyca/cryptography/openssl" LIBRARY_PATH="/opt/pyca/cryptography/openssl/lib" CPATH="/opt/pyca/cryptography/openssl/include" CIBW_ARCHS_LINUX="x86_64" - script: ls ./dist displayName: 'Check output' - script: | python -m pip install --user --ignore-installed ./dist/*.whl python -m pip install --user pytest==6.2.4 --force pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' env: EVENT_HUB_HOSTNAME: $(python-eh-livetest-event-hub-hostname) EVENT_HUB_NAME: $(python-eh-livetest-event-hub-name) EVENT_HUB_SAS_POLICY: $(python-eh-livetest-event-hub-sas-policy) EVENT_HUB_SAS_KEY: $(python-eh-livetest-event-hub-sas-key) IOTHUB_HOSTNAME: $(python-iothub-livetest-host-name) IOTHUB_HUB_NAME: $(python-iothub-livetest-hub-name) IOTHUB_DEVICE: $(python-eh-livetest-event-hub-iothub-device) IOTHUB_ENDPOINT: $(python-iothub-livetest-endpoint) IOTHUB_SAS_POLICY: $(python-iothub-livetest-sas-policy) IOTHUB_SAS_KEY: $(python-iothub-livetest-sas-key) - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'Linux Python $(PythonVersion)' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifact' inputs: artifactName: uamqp-linux-$(PythonVersion)-whl pathToPublish: 'dist' - job: 'SDK_LiveTest_windows2019_37' timeoutInMinutes: 300 dependsOn: 'Windows' pool: name: azsdk-pool-mms-win-2022-general vmImage: windows-2022 strategy: matrix: EventHub x64 Python 3.8: PythonVersion: '$(PythonVersion38)' SDK: 'EventHub' EventHub x64 Python 3.12: PythonVersion: '$(PythonVersion312)' SDK: 'EventHub' ServiceBus x64 Python 3.8: PythonVersion: '$(PythonVersion38)' SDK: 'ServiceBus' ServiceBus x64 Python 3.12: PythonVersion: '$(PythonVersion312)' SDK: 'ServiceBus' variables: PythonArchitecture: 'x64' OSArch: 'Windows' DownloadArtifactFolder: 'uamqp-win$(PythonArchitecture)-$(PythonVersion)-whl' steps: - template: /.azure-pipelines/use-python-version.yml parameters: architecture: '$(PythonArchitecture)' versionSpec: '$(PythonVersion)' - template: /.azure-pipelines/test-eh-sb-sdk.yml - job: 'SDK_LiveTest_macOS1015_38' timeoutInMinutes: 300 dependsOn: 'MacOS' pool: name: 'Azure Pipelines' vmImage: 'macOS-11' strategy: matrix: EventHub Python 3.12: SDK: 'EventHub' ServiceBus Python 3.12: SDK: 'ServiceBus' variables: PythonBin: 'python3' PythonVersion: '3.12.0' MacOSXDeploymentTarget: '10.9' PythonVersion382: '3.12' OSArch: 'MacOS' DownloadArtifactFolder: 'uamqp-macosx$(MacOSXDeploymentTarget)-$(PythonVersion)-whl' steps: - template: /.azure-pipelines/use-python-version.yml parameters: versionSpec: '$(PythonVersion)' - template: /.azure-pipelines/test-eh-sb-sdk.yml - job: 'SDK_LiveTest_ubuntu1804_39' timeoutInMinutes: 300 dependsOn: 'Linux' pool: name: 'azsdk-pool-mms-ubuntu-2004-general' vmImage: 'ubuntu-20.04' strategy: matrix: EventHub Python 3.9: PythonVersion: '$(PythonVersion39)' SDK: 'EventHub' EventHub Python 3.12: PythonVersion: '$(PythonVersion312)' SDK: 'EventHub' ServiceBus Python 3.9: PythonVersion: '$(PythonVersion39)' SDK: 'ServiceBus' ServiceBus Python 3.12: PythonVersion: '$(PythonVersion312)' SDK: 'ServiceBus' variables: OSArch: 'Linux' DownloadArtifactFolder: 'uamqp-linux-$(PythonVersion)-whl' steps: - template: /.azure-pipelines/use-python-version.yml parameters: versionSpec: '$(PythonVersion)' - template: /.azure-pipelines/test-eh-sb-sdk.yml azure-uamqp-python-1.6.8/.azure-pipelines/client.yml000066400000000000000000000367261455573770000225420ustar00rootroot00000000000000trigger: - main variables: PythonVersion38: '3.8' PythonVersion39: '3.9' PythonVersion310: '3.10.0' PythonVersion311: '3.11.0' PythonVersion312: '3.12.0' GetPip: 'https://bootstrap.pypa.io/get-pip.py' jobs: - job: 'sdist' displayName: 'Source Distribution' pool: vmImage: 'ubuntu-20.04' steps: - template: /.azure-pipelines/use-python-version.yml parameters: versionSpec: '$(PythonVersion38)' - script: | echo "Prepending PATH environment variable with directory: $HOME/.local/bin" echo "##vso[task.prependpath]$HOME/.local/bin" displayName: 'Prepare PATH' - script: | python --version curl -sS $(GetPip) | python - --user python -m pip --version python -m pip install --user -r dev_requirements.txt displayName: 'Install dependencies' - script: python setup.py sdist displayName: 'Build uAMQP sdist' - script: ls ./dist displayName: 'Check output' - task: PublishBuildArtifacts@1 displayName: 'Publish sdist artifact' inputs: artifactName: uamqp-sdist pathToPublish: 'dist' - job: 'MacOS' pool: vmImage: 'macOS-11' strategy: matrix: Python 3.8: PythonBin: 'python3' PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-*' Python 3.9: PythonBin: 'python3' PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-*' Python 3.10: PythonBin: 'python3' PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-*' Python 3.11: PythonBin: 'python3' PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-*' Python 3.12: PythonBin: 'python3' PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-*' variables: MacOSXDeploymentTarget: '10.9' OpenSSLDir: $(Agent.BuildDirectory)/openssl-macosx$(MacOSXDeploymentTarget) PythonVersion38: '3.8.2' PythonVersion39: '3.9.0' PythonVersion310: '3.10.0' PythonVersion311: '3.11.0' PythonVersion312: '3.12.0' steps: - task: DownloadPipelineArtifact@1 displayName: 'Download OpenSSL artifact' inputs: artifactName: openssl-macosx$(MacOSXDeploymentTarget) buildType: specific buildVersionToDownload: latest downloadPath: $(Agent.BuildDirectory) pipeline: 119 # azure-uamqp-python - openssl project: '29ec6040-b234-4e31-b139-33dc4287b756' # public - script: sudo ls /Applications/ displayName: 'List All apps' - script: sudo xcode-select --switch /Applications/Xcode_13.1.app displayName: 'Select Xcode 13.1' - script: source ./install_python_osx.sh displayName: 'Install Official Python' - script: | echo "Prepending PATH environment variable with directory: /usr/local/bin" echo "##vso[task.prependpath]/usr/local/bin" export PYTHON_SHORT_VER=`echo $(PythonVersion) | cut -d . -f 1,2` echo "Prepending PATH environment variable with directory: $HOME/Library/Python/$PYTHON_SHORT_VER/bin" echo "##vso[task.prependpath]$HOME/Library/Python/$PYTHON_SHORT_VER/bin" displayName: 'Prepare PATH' - script: | $(PythonBin) --version curl -sS $(GetPip) | $(PythonBin) - --user $(PythonBin) -m pip --version $(PythonBin) -m pip install --user -r dev_requirements.txt displayName: 'Install dependencies' - bash: | set -o errexit $(PythonBin) -m pip install --user cibuildwheel==2.16.2 --force displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_PRERELEASE_PYTHONS: True CIBW_ARCHS_MACOS: x86_64 CIBW_BUILD: $(BWFilter) - script: ls ./dist displayName: 'Check output' - script: | $(PythonBin) -m pip install --user --ignore-installed ./dist/*.whl $(PythonBin) -m pip install --user pytest==6.2.4 --force $(PythonBin) -m pip install --user pytest-asyncio==0.12.0 --force pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'MacOS Python $(PythonVersion)' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifact' inputs: artifactName: uamqp-macosx$(MacOSXDeploymentTarget)-$(PythonVersion)-whl pathToPublish: 'dist' - job: 'Windows' pool: name: azsdk-pool-mms-win-2022-general vmImage: MMS2022 variables: VS_INSTALLER_URL: "https://aka.ms/vs/17/release/vs_enterprise.exe" VS_INSTALLER_PATH: "$(Build.BinariesDirectory)/vs_enterprise.exe" VS_ENTERPRISE_PATH: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise" strategy: matrix: x64 Python 3.8: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-win_amd64' x64 Python 3.9: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-win_amd64' x64 Python 3.10: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-win_amd64' x64 Python 3.11: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-win_amd64' x64 Python 3.12: PythonArchitecture: 'x64' PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-win_amd64' x86 Python 3.8: PythonArchitecture: 'x86' PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-win32' x86 Python 3.9: PythonArchitecture: 'x86' PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-win32' x86 Python 3.10: PythonArchitecture: 'x86' PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-win32' x86 Python 3.11: PythonArchitecture: 'x86' PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-win32' x86 Python 3.12: PythonArchitecture: 'x86' PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-win32' steps: - template: /.azure-pipelines/use-python-version.yml parameters: architecture: '$(PythonArchitecture)' versionSpec: '$(PythonVersion)' - powershell: | python --version Invoke-WebRequest -UseBasicParsing -Uri $(GetPip) | Select-Object -ExpandProperty Content | python python -m pip --version python -m pip install -r dev_requirements.txt displayName: 'Install dependencies' env: PYTHONWARNINGS: ignore:DEPRECATION - pwsh: | Invoke-WebRequest "$(VS_INSTALLER_URL)" -OutFile "$(VS_INSTALLER_PATH)" # In order of component appearance in the install command below, these are the names of the components # as they in the VS Installer UI. (What you would do locally.) # C# and Visual Basic Roslyn Compilers (components pane) # C++ 2022 Redistributable Update (components pane) # C++ CMake tools for Windows (components pane) # MSBuild (components pane) # MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest) (components pane) # Native Desktop Workload (workloads pane) $(VS_INSTALLER_PATH) --installPath $(VS_ENTERPRISE_PATH) ` --add Microsoft.VisualStudio.Component.Roslyn.Compiler ` --add Microsoft.VisualStudio.Component.VC.Redist.14.Latest ` --add Microsoft.VisualStudio.Component.VC.CMake.Project ` --add Microsoft.Component.MSBuild ` --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 ` --add Microsoft.VisualStudio.Workload.NativeDesktop ` --quiet --wait --norestart displayName: Install build script requirements - script: | call "$(VS_ENTERPRISE_PATH)\VC\Auxiliary\Build\vcvars64.bat" python -m pip install cibuildwheel==2.16.2 displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_PRERELEASE_PYTHONS: True CIBW_BUILD: $(BWFilter) - script: dir dist displayName: 'Check output' - powershell: | $whlfile = Get-ChildItem -Filter *.whl dist | Select-Object -First 1 -ExpandProperty Name python -m pip install --ignore-installed ./dist/$whlfile pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'Windows $(PythonArchitecture) Python $(PythonVersion)' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifact' inputs: artifactName: uamqp-win$(PythonArchitecture)-$(PythonVersion)-whl pathToPublish: 'dist' - job: 'Linux' pool: vmImage: 'ubuntu-20.04' strategy: matrix: Python 3.8: PythonVersion: '$(PythonVersion38)' BWFilter: 'cp38-*' Python 3.9: PythonVersion: '$(PythonVersion39)' BWFilter: 'cp39-*' Python 3.10: PythonVersion: '$(PythonVersion310)' BWFilter: 'cp310-*' Python 3.11: PythonVersion: '$(PythonVersion311)' BWFilter: 'cp311-*' Python 3.12: PythonVersion: '$(PythonVersion312)' BWFilter: 'cp312-*' steps: - template: /.azure-pipelines/use-python-version.yml parameters: versionSpec: '$(PythonVersion)' - script: | echo "Prepending PATH environment variable with directory: $HOME/.local/bin" echo "##vso[task.prependpath]$HOME/.local/bin" displayName: 'Prepare PATH' - script: | python --version curl -sS $(GetPip) | python - --user python -m pip --version python -m pip install setuptools --force curl -LO http://archive.ubuntu.com/ubuntu/pool/main/libf/libffi/libffi6_3.2.1-8_amd64.deb && sudo dpkg -i libffi6_3.2.1-8_amd64.deb python -m pip install --user -r dev_requirements.txt displayName: 'Install dependencies' - bash: | set -o errexit python -m pip install cibuildwheel==2.16.2 displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_BUILD: $(BWFilter) CIBW_PRERELEASE_PYTHONS: True CIBW_BEFORE_BUILD_LINUX: bash utils/install_openssl.sh CIBW_ENVIRONMENT_LINUX: OPENSSL_ROOT_DIR="/opt/pyca/cryptography/openssl" LIBRARY_PATH="/opt/pyca/cryptography/openssl/lib" CPATH="/opt/pyca/cryptography/openssl/include" CIBW_ARCHS_LINUX="x86_64" - script: ls ./dist displayName: 'Check output' - script: | python -m pip install --user --ignore-installed ./dist/*.whl pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'Linux Python $(PythonVersion)' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifact' inputs: artifactName: uamqp-linux-$(PythonVersion)-whl pathToPublish: 'dist' - job: 'ManyLinux' condition: ne(variables['System.TeamProject'], 'public') pool: vmImage: 'ubuntu-20.04' strategy: matrix: Python38-manylinux2014: PythonVersion: '$(PythonVersion38)' Platform: 'manylinux2014_x86_64' BWFilter: 'cp38-*' Python39-manylinux2014: PythonVersion: '$(PythonVersion39)' Platform: 'manylinux2014_x86_64' BWFilter: 'cp39-*' Python310-manylinux2014: PythonVersion: '$(PythonVersion310)' Platform: 'manylinux2014_x86_64' BWFilter: 'cp310-*' Python311-manylinux2014: PythonVersion: '$(PythonVersion311)' Platform: 'manylinux2014_x86_64' BWFilter: 'cp311-*' Python312-manylinux2014: PythonVersion: '$(PythonVersion312)' Platform: 'manylinux2014_x86_64' BWFilter: 'cp312-*' steps: - template: /.azure-pipelines/use-python-version.yml parameters: versionSpec: '$(PythonVersion)' - script: | echo "Prepending PATH environment variable with directory: $HOME/.local/bin" echo "##vso[task.prependpath]$HOME/.local/bin" displayName: 'Prepare PATH' - script: | python --version curl -sS $(GetPip) | python - --user python -m pip --version python -m pip install setuptools --force curl -LO http://archive.ubuntu.com/ubuntu/pool/main/libf/libffi/libffi6_3.2.1-8_amd64.deb && sudo dpkg -i libffi6_3.2.1-8_amd64.deb python -m pip install --user -r dev_requirements.txt displayName: 'Install dependencies' - bash: | set -o errexit python -m pip install cibuildwheel==2.16.2 displayName: Install cibuildwheel 2.16.2 - pwsh: | cibuildwheel --output-dir dist . displayName: 'Build uAMQP Wheel' env: CIBW_BUILD: $(BWFilter) CIBW_PRERELEASE_PYTHONS: True CIBW_BEFORE_BUILD_LINUX: bash utils/install_openssl.sh CIBW_ENVIRONMENT_LINUX: OPENSSL_ROOT_DIR="/opt/pyca/cryptography/openssl" LIBRARY_PATH="/opt/pyca/cryptography/openssl/lib" CPATH="/opt/pyca/cryptography/openssl/include" CIBW_ARCHS_LINUX="x86_64" CIBW_MANYLINUX_*_IMAGE: manylinux2014 - script: ls ./dist displayName: 'Check output' - script: | python -m pip install --user --ignore-installed ./dist/*.whl pytest tests --doctest-modules --junitxml=junit/test-results-c.xml pytest samples --doctest-modules --junitxml=junit/test-results-live.xml displayName: 'Run tests' - task: PublishBuildArtifacts@1 displayName: 'Publish wheel artifacts' inputs: artifactName: uamqp-$(Platform)-$(PythonVersion)-x64-whl pathToPublish: 'dist' - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/test-results-*.xml' testResultsFormat: 'JUnit' testRunTitle: 'ManyLinux2014 Python $(PythonVersion)' azure-uamqp-python-1.6.8/.azure-pipelines/install_python_version.py000066400000000000000000000120061455573770000257100ustar00rootroot00000000000000import platform import json import argparse import urllib import urllib.request from subprocess import check_call, CalledProcessError import sys import os import zipfile import tarfile import time from packaging.version import Version from packaging.version import parse from packaging.version import InvalidVersion import pdb # SOURCE OF THIS FILE: https://github.com/actions/python-versions # this is the official mapping file for gh-actions to retrieve python installers MANIFEST_LOCATION = "https://raw.githubusercontent.com/actions/python-versions/main/versions-manifest.json" MAX_INSTALLER_RETRY = 3 CURRENT_UBUNTU_VERSION = "20.04" # full title is ubuntu-20.04 UNIX_INSTALL_ARRAY = ["sh", "setup.sh"] WIN_INSTALL_ARRAY = ["pwsh", "setup.ps1"] def download_installer(remote_path, local_path): retries = 0 while True: try: urllib.request.urlretrieve(remote_path, local_path) break except Exception as e: print(e) retries += 1 if retries >= MAX_INSTALLER_RETRY: print( "Unable to recover after attempting to download {} {} times".format( remote_path, retries ) ) exit(1) time.sleep(10) def install_selected_python_version(installer_url, installer_folder): current_plat = platform.system().lower() installer_folder = os.path.normpath(os.path.abspath(installer_folder)) if not os.path.exists(installer_folder): os.mkdir(installer_folder) local_installer_ref = os.path.join( installer_folder, "local" + (".zip" if installer_folder.endswith("zip") else ".tar.gz"), ) download_installer(installer_url, local_installer_ref) if current_plat == "windows": with zipfile.ZipFile(local_installer_ref, "r") as zip_file: zip_file.extractall(installer_folder) try: check_call(WIN_INSTALL_ARRAY, cwd=installer_folder) except CalledProcessError as err: print(err) exit(1) else: with tarfile.open(local_installer_ref) as tar_file: tar_file.extractall(installer_folder) try: check_call(UNIX_INSTALL_ARRAY, cwd=installer_folder) except CalledProcessError as err: print(err) exit(1) def get_installer_url(requested_version, requested_arch, version_manifest): current_plat = platform.system().lower() print("Current Platform Is {}".format(platform.platform())) if version_manifest[requested_version]: found_installers = version_manifest[requested_version]["files"] # filter anything that's not our requested architecture. arch_installers = [ file_def for file_def in found_installers if file_def["arch"] == requested_arch ] if current_plat == "windows": return [ installer for installer in arch_installers if installer["platform"] == "win32" ][0] elif current_plat == "darwin": return [ installer for installer in arch_installers if installer["platform"] == current_plat ][0] else: return [ installer for installer in arch_installers if installer["platform"] == "linux" and installer["platform_version"] == CURRENT_UBUNTU_VERSION ][0] if __name__ == "__main__": parser = argparse.ArgumentParser( description="Takes the incoming request and attempts to resolve the version spec." ) parser.add_argument( "version_spec", nargs="?", help=("The version specifier passed in to the UsePythonVersion extended task."), ) parser.add_argument( "--arch", dest="arch", default="x64", help=("The architecture passed in to the UsePythonVersion extended task."), ) parser.add_argument( "--installer_folder", dest="installer_folder", help=( "The folder where the found installer will be extracted into and run from." ), ) args = parser.parse_args() max_precached_version = Version("3.9.7") try: version_from_spec = Version(args.version_spec) except InvalidVersion: print("Invalid Version Spec. Skipping custom install.") exit(0) with urllib.request.urlopen(MANIFEST_LOCATION) as url: version_manifest = json.load(url) version_dict = {i["version"]: i for i in version_manifest} if version_from_spec > max_precached_version: print( "Requested version {} is newer than versions pre-cached on agent. Invoking.".format( args.version_spec ) ) install_file_details = get_installer_url(args.version_spec, args.arch, version_dict) install_selected_python_version( install_file_details["download_url"], args.installer_folder ) azure-uamqp-python-1.6.8/.azure-pipelines/test-eh-sb-sdk.yml000066400000000000000000000110271455573770000240010ustar00rootroot00000000000000steps: - pwsh: | $EHSdkPath='azure-sdk-for-python/sdk/eventhub/azure-eventhub' $EHTestResultsPath='eventhub/azure-eventhub/test-results-live.xml' $EHIgnoreTests='--ignore=tests/perfstress_tests --ignore=tests/scripts' $EHSdkType='eventhub' Write-Output "##vso[task.setvariable variable=SdkType;]$EHSdkType" Write-Output "##vso[task.setvariable variable=SdkPath;]$EHSdkPath" Write-Output "##vso[task.setvariable variable=TestResultsPath;]$EHTestResultsPath" Write-Output "##vso[task.setvariable variable=IgnoreTests;]$EHIgnoreTests" condition: eq(variables['SDK'], 'EventHub') displayName: 'Get variables if EventHub' - pwsh: | $SBSdkPath='azure-sdk-for-python/sdk/servicebus/azure-servicebus' $SBTestResultsPath='servicebus/azure-servicebus/test-results-live.xml' $SBIgnoreTests='--ignore=tests/perf_tests --ignore=tests/stress_tests' $SBSdkType='servicebus' Write-Output "##vso[task.setvariable variable=SdkType;]$SBSdkType" Write-Output "##vso[task.setvariable variable=SdkPath;]$SBSdkPath" Write-Output "##vso[task.setvariable variable=TestResultsPath;]$SBTestResultsPath" Write-Output "##vso[task.setvariable variable=IgnoreTests;]$SBIgnoreTests" condition: eq(variables['SDK'], 'ServiceBus') displayName: 'Get variables if ServiceBus' - script: | echo "SDKPath: $(SdkPath)" echo "Tests: $(TestResultsPath)" git clone https://github.com/Azure/azure-sdk-for-python.git --single-branch --depth 1 displayName: 'Clone azure-sdk-for-python' - pwsh: | eng/common/scripts/Import-AzModules.ps1 $subscriptionConfiguration = @' $(sub-config-azure-cloud-test-resources) '@ | ConvertFrom-Json -AsHashtable; eng/common/TestResources/New-TestResources.ps1 ` -ResourceType test ` -ServiceDirectory $(SDKType) ` -Location westus ` -DeleteAfterHours 8 ` @subscriptionConfiguration ` -CI ` -Force ` -Verbose | Out-Null workingDirectory: azure-sdk-for-python displayName: Deploy test resources env: TEMP: $(Agent.TempDirectory) - task: DownloadPipelineArtifact@2 displayName: 'Downloading artifact' inputs: source: 'current' patterns: '$(DownloadArtifactFolder)/*.whl' - pwsh: | $whlfile = Get-ChildItem -Filter *.whl $(Pipeline.Workspace)/$(DownloadArtifactFolder) | Select-Object -First 1 -ExpandProperty Name Write-Output "##vso[task.setvariable variable=DownloadArtifactWhl]$whlfile" Get-ChildItem $(Pipeline.Workspace)/$(DownloadArtifactFolder) displayName: 'Get name of whl file to install' - template: /.azure-pipelines/test-proxy-tool.yml parameters: runProxy: true rootFolder: azure-sdk-for-python templateRoot: azure-sdk-for-python - script: | python --version echo "Installing $DownloadArtifactWhl" echo "Full name $(Pipeline.Workspace)/$(DownloadArtifactFolder)/$(DownloadArtifactWhl)" python -m pip install $(Pipeline.Workspace)/$(DownloadArtifactFolder)/$(DownloadArtifactWhl) --force python -m pip install pytest cd $(SdkPath) python -m pip install futures python -m pip install . python -m pip install -r dev_requirements.txt python -m pip list python -m pytest tests -v --doctest-modules $(IgnoreTests) --junitxml=junit/$(TestResultsPath) displayName: 'Run tests' env: AZURE_SUBSCRIPTION_ID: $(azure-subscription-id) AZURE_TENANT_ID: $(aad-azure-sdk-test-tenant-id) AZURE_CLIENT_ID: $(aad-azure-sdk-test-client-id) AZURE_CLIENT_SECRET: $(aad-azure-sdk-test-client-secret) AZURE_TEST_RUN_LIVE: 'true' - pwsh: | eng/common/scripts/Import-AzModules.ps1 $subscriptionConfiguration = @' $(sub-config-azure-cloud-test-resources) '@ | ConvertFrom-Json -AsHashtable; eng/common/TestResources/Remove-TestResources.ps1 ` @subscriptionConfiguration ` -ResourceType test ` -ServiceDirectory $(SDKType) ` -CI ` -Force ` -Verbose workingDirectory: azure-sdk-for-python displayName: Remove test resources condition: and(eq(variables['CI_HAS_DEPLOYED_RESOURCES'], 'true'), ne(variables['Skip.RemoveTestResources'], 'true')) continueOnError: true - task: PublishTestResults@2 displayName: 'Publish test results' condition: succeededOrFailed() inputs: testResultsFiles: '**/$(TestResultsPath)' testResultsFormat: 'JUnit' testRunTitle: '$(OSArch) $(SDK) Python $(PythonVersion)' azure-uamqp-python-1.6.8/.azure-pipelines/test-proxy-tool.yml000066400000000000000000000062571455573770000243710ustar00rootroot00000000000000parameters: rootFolder: '$(Build.SourcesDirectory)' runProxy: true targetVersion: '' templateRoot: '$(Build.SourcesDirectory)' condition: true steps: - pwsh: | python -m pip install requests --force ${{ parameters.templateRoot }}/eng/common/scripts/trust-proxy-certificate.ps1 displayName: 'Language Specific Certificate Trust' condition: and(succeeded(), ${{ parameters.condition }}) - pwsh: | $version = $(Get-Content "${{ parameters.templateRoot }}/eng/common/testproxy/target_version.txt" -Raw).Trim() $overrideVersion = "${{ parameters.targetVersion }}" if($overrideVersion) { Write-Host "Overriding default target proxy version of '$version' with override $overrideVersion." $version = $overrideVersion } dotnet tool install azure.sdk.tools.testproxy ` --tool-path $(Build.BinariesDirectory)/test-proxy ` --add-source https://pkgs.dev.azure.com/azure-sdk/public/_packaging/azure-sdk-for-net/nuget/v3/index.json ` --version $version - pwsh: | displayName: "Install test-proxy" condition: and(succeeded(), ${{ parameters.condition }}) - pwsh: | Write-Host "##vso[task.prependpath]$(Build.BinariesDirectory)/test-proxy" displayName: "Prepend path with test-proxy tool install location" - ${{ if eq(parameters.runProxy, 'true') }}: - pwsh: | Write-Host "##vso[task.setvariable variable=ASPNETCORE_Kestrel__Certificates__Default__Path]${{ parameters.templateRoot }}/eng/common/testproxy/dotnet-devcert.pfx" Write-Host "##vso[task.setvariable variable=ASPNETCORE_Kestrel__Certificates__Default__Password]password" Write-Host "##vso[task.setvariable variable=PROXY_MANUAL_START]true" displayName: 'Configure Kestrel and PROXY_MANUAL_START Variables' condition: and(succeeded(), ${{ parameters.condition }}) - pwsh: | Start-Process $(Build.BinariesDirectory)/test-proxy/test-proxy.exe ` -ArgumentList "--storage-location ${{ parameters.rootFolder }}" ` -NoNewWindow -PassThru -RedirectStandardOutput ${{ parameters.templateRoot }}/test-proxy.log displayName: 'Run the testproxy - windows' condition: and(succeeded(), eq(variables['Agent.OS'],'Windows_NT'), ${{ parameters.condition }}) # nohup does NOT continue beyond the current session if you use it within powershell - bash: | nohup $(Build.BinariesDirectory)/test-proxy/test-proxy --storage-location ${{ parameters.rootFolder }} > ${{ parameters.templateRoot }}/test-proxy.log & displayName: "Run the testproxy - linux/mac" condition: and(succeeded(), ne(variables['Agent.OS'],'Windows_NT'), ${{ parameters.condition }}) - pwsh: | for ($i = 0; $i -lt 10; $i++) { try { Invoke-WebRequest -Uri "http://localhost:5000/Admin/IsAlive" | Out-Null exit 0 } catch { Write-Warning "Failed to successfully connect to test proxy. Retrying..." Start-Sleep 6 } } Write-Error "Could not connect to test proxy." exit 1 displayName: Test Proxy IsAlive condition: and(succeeded(), ${{ parameters.condition }}) azure-uamqp-python-1.6.8/.azure-pipelines/use-python-version.yml000066400000000000000000000014741455573770000250520ustar00rootroot00000000000000parameters: versionSpec: '3.x' architecture: 'x64' steps: # use python 3.8 for tooling. packaging. platform. - task: UsePythonVersion@0 displayName: "Use Python 3.8" inputs: versionSpec: 3.8 - pwsh: | pip install packaging displayName: Prep Environment # select the appropriate version from manifest if present - task: PythonScript@0 displayName: 'Check Version Spec Against Known Versions' inputs: scriptPath: '.azure-pipelines/install_python_version.py' arguments: '${{ parameters.versionSpec }} --arch ${{ parameters.architecture }} --installer_folder="../_pyinstaller' # use - task: UsePythonVersion@0 displayName: "Use Python $(PythonVersion)" inputs: versionSpec: ${{ parameters.versionSpec }} architecture: ${{ parameters.architecture }} azure-uamqp-python-1.6.8/.gitattributes000066400000000000000000000000211455573770000202150ustar00rootroot00000000000000*.sh text eol=lfazure-uamqp-python-1.6.8/.github/000077500000000000000000000000001455573770000166715ustar00rootroot00000000000000azure-uamqp-python-1.6.8/.github/ISSUE_TEMPLATE/000077500000000000000000000000001455573770000210545ustar00rootroot00000000000000azure-uamqp-python-1.6.8/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000010411455573770000235420ustar00rootroot00000000000000--- name: Bug report about: Create a report to help us improve title: '' labels: '' assignees: '' --- - **UAMQP Package Version**: - **Operating System**: - **Python Version**: **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behavior: 1. **Expected behavior** A clear and concise description of what you expected to happen. **Screenshots** If applicable, add screenshots to help explain your problem. **Additional context** Add any other context about the problem here. azure-uamqp-python-1.6.8/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000011231455573770000245760ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for this project title: '' labels: '' assignees: '' --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. azure-uamqp-python-1.6.8/.github/workflows/000077500000000000000000000000001455573770000207265ustar00rootroot00000000000000azure-uamqp-python-1.6.8/.github/workflows/wheel.yml000066400000000000000000000011201455573770000225470ustar00rootroot00000000000000name: Wheels on: push: branches: [ main ] pull_request: branches: [ main ] jobs: build_wheels: name: Build wheels on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: os: ["macos-11","windows-2019","ubuntu-20.04"] steps: - uses: actions/checkout@v3 - name: Build wheels uses: pypa/cibuildwheel@v2.16.2 env: CIBW_PRERELEASE_PYTHONS: True CIBW_ARCHS_MACOS: x86_64 universal2 - uses: actions/upload-artifact@v2 with: path: ./wheelhouse/*.whl azure-uamqp-python-1.6.8/.gitignore000066400000000000000000000026111455573770000173210ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python env/ env*/ build/ wheelhouse/ cython_debug/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ .pytest_cache/ recordings/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # dotenv .env # virtualenv .venv venv/ ENV/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ # uamqp uamqp/c_uamqp.c uamqp/c_uamqp.pyx src/vendor/azure-uamqp-c/deps/azure-ctest/ src/vendor/azure-uamqp-c/deps/azure-c-testrunnerswitcher/ tests/test_dont_merge.py .vscode/settings.json .DS_Store azure-uamqp-python-1.6.8/HISTORY.rst000066400000000000000000000630001455573770000172230ustar00rootroot00000000000000.. :changelog: Release History =============== 1.6.8 (2024-01-29) +++++++++++++++++++ - Incorporate fixes from `PR `__ 1.6.7 (2024-01-17) +++++++++++++++++++ - Fixes for CVE-2024-21646 1.6.6 (2023-11-16) +++++++++++++++++++ - Added support for python 3.11 1.6.5 (2023-07-12) +++++++++++++++++++ - Few more updates to submodules to support OpenSSL 3.0 compilation 1.6.4 (2023-02-09) +++++++++++++++++++ - Updated OpenSSL dependency to 1.1.1t - Updated submodules to support OpenSSL 3.0 compilation - Removed dependency on six - Fixed a bug that caused the wrong port to selected for websockets when a port was not passed in 1.6.3 (2022-10-27) +++++++++++++++++++ - Publish 3.11 wheels 1.6.2 (2022-10-27) +++++++++++++++++++ - Added support for python 3.11 - Updated OpenSSL dependency to 1.1.1q - Updated cython dependency to 0.29.32 - Dropped support for manylinux2010 - Using cibuildwheel to generate wheels 1.6.1 (2022-10-11) +++++++++++++++++++ - Added support for handling of duplicate certificates in `azure-c-shared-utility` dependency by using `CERT_STORE_ADD_REPLACE_EXISTING` parameter in the `CertAddEncodedCertificateToStore` function call. (azure-sdk-for-python issue #26034) 1.6.0 (2022-08-18) +++++++++++++++++++ This version and all future versions will require Python 3.7+, Python 3.6 is no longer supported. - Added `data`, `value`, `sequence` properties to `uamqp.Message`, which return the body if the body type corresponds. - Added `message_annotations` property to `uamqp.Message`, which is an alias for the `annotations` instance variable. - Added `data` property to `uamqp.BatchMessage`, which returns the iterable body of the batch. - Added `ttl` property to `uamqp.MessageHeader`, which is an alias for the `time_to_live` instance variable. 1.5.3 (2022-03-23) +++++++++++++++++++ - Updated OpenSSL dependency to 1.1.1n for wheels of manylinux and macOS. 1.5.2 (2022-03-15) +++++++++++++++++++ - Fixed bug that resulted in an error when deepcopying BatchMessage objects (azure-sdk-for-python issue #22529). 1.5.1 (2022-01-12) +++++++++++++++++++ - Added back the support for Python 3.6. 1.5.0 (2022-01-05) +++++++++++++++++++ This version and all future versions will require Python 3.7+, Python 2.7 and Python 3.6 are no longer supported. - `SASTokenAuth`, `JWTTokenAuth`, `SASTokenAsync`, and `JWTTokenAsync` now takes keyword argument `refresh_window` to override default token refresh timing in constructors. - Fixed bug that `SendClientAsync` might run into infinite loop while sending when it is shutdown unexpectedly. - Updated dependencies Azure uAMQP C @ `2021-11-16 `__ and Azure C Shared Utility @ `2021-11-15 `__. - Fixed bug that the `keep_alive_thread` of `AMQPClient` should not keep program from exiting in the case of `AMQPClient` not being closed properly. 1.4.3 (2021-10-06) +++++++++++++++++++ - Added support for Python 3.10. 1.4.2 (2021-09-21) +++++++++++++++++++ - Fixed memory leak in win32 socketio and tlsio (azure-sdk-for-python issue #19777). - Fixed memory leak in the process of converting AMQPValue into string (azure-sdk-for-python issue #19777). 1.4.1 (2021-06-28) +++++++++++++++++++ - Fixed bug that JWTTokenAuth and JWTTokenAsync do not initialize token for token types other than b'jwt'. - Fixed bug that attibutes `creation_time`, `absolute_expiry_time` and `group_sequence` on `MessageProperties` should be compatible with integer types on Python 2.7. 1.4.0 (2021-05-03) +++++++++++++++++++ This version and all future versions will require Python 2.7 or Python 3.6+, Python 3.5 is no longer supported. - Fixed memory leaks in the process of link attach where source and target cython objects are not properly deallocated (azure-sdk-for-python issue #15747). - Improved management operation callback not to parse description value of non AMQP_TYPE_STRING type as string (azure-sdk-for-python issue #18361). 1.3.0 (2021-04-05) +++++++++++++++++++ This version will be the last version to officially support Python 3.5, future versions will require Python 2.7 or Python 3.6+. - Added support for AMQP Sequence as the body type of an amqp message. - Added new class `uamqp.MessageBodyType` to represent the body type of an amqp message, including: - `Data`: The body consists of one or more data sections and each section contains opaque binary data. - `Sequence`: The body consists of one or more sequence sections and each section contains an arbitrary number of structured data elements. - `Value`: The body consists of one amqp-value section and the section contains a single AMQP value. - Added new parameters to the constructor of `uamqp.Message`: - `body_type` which takes `uamqp.MessageBodyType` to specify the body type of an amqp message. - `footer` which takes a dict to set the footer of an amqp message. - `delivery_annotations` which takes a dict to set the delivery annotations of an amqp message. - Added support for pickling `uamqp.Message`. - Fixed bug that sending message of large size triggering segmentation fault when the underlying socket connection is lost. - Fixed bug in link flow control where link credit and delivery count should be calculated based on per message instead of per transfer frame. 1.2.15 (2021-03-02) +++++++++++++++++++ - Added desired-capabilities for `SendClient(Async)` and `MessageSender(Async)` as part of the AMQP protocol. - Added types for AMQPShort and AMQPuShort for explicit handling of short and unsigned short encoding. 1.2.14 (2021-02-01) +++++++++++++++++++ - Updated Azure uAMQP C and Azure C Shared Utility dependencies. - Fixed memory leak with SAS Token creation. 1.2.13 (2021-01-06) +++++++++++++++++++ - Fixed bug in accessing `MessageProperties.user_id` triggering segmentation fault when the underlying C bytes are NULL. - Fixed bug in `MessageProperties.user_id` being limited to 8 bytes. - Fixed bug where connection establishment on macOS with Clang 12 triggering unrecognized selector exception. - Fixed bug that macOS was unable to detect network error. - Fixed bug that `ReceiveClient` and `ReceiveClientAsync` receive messages during connection establishment. 1.2.12 (2020-10-09) +++++++++++++++++++ - Updated cython dependency to 0.29.21. - Added support for Python 3.9. 1.2.11 (2020-10-01) +++++++++++++++++++ - Updated tlsio_openssl module to send SNI when establishing tls connection (Thanks to milope). - Fixed bug where `Message.footer` and `Message.delivery_annotation` were not encoded into the outgoing payload. - Fixed bug where message sending timeout error didn't get raised out. 1.2.10 (2020-08-05) +++++++++++++++++++ - Added parameter `shutdown_after_timeout` to `ReceiveClient` and `ReceiveClientAsync` which gives control over whether to shutdown receiver after timeout. 1.2.9 (2020-07-06) ++++++++++++++++++ - Added method `MessageReceiver.reset_link_credit` which is responsible for resetting current available link credit on the receiver link and send update to the sender. 1.2.8 (2020-05-19) ++++++++++++++++++ - Fix to initialize delivery_count header at 0 instead of None (azure-sdk-for-python issue #9708) - Added info fields to rejected delivery disposition. 1.2.7 (2020-05-04) ++++++++++++++++++ - Fixed bug in setting certificate of tlsio on MacOS (azure-sdk-for-python issue #7201). - Fixed seg fault in logging network tracing on MacOS (PR#147, Thanks to malthe). - Fixed typos in log messages (PR#146, Thanks to bluca). - Improved reproducibility of the generated c_uamqp.c file (PR#144, Thanks to bluca). 1.2.6 (2020-02-13) ++++++++++++++++++ - Fixed seg fault in tearing down a failed link with unsent pending messages. 1.2.5 (2019-12-10) ++++++++++++++++++ - Fixed garbage collection of C objects to prevent crashing on uncontrolled shutdown. - Fixed missing event loop references passed into asyncio functions. - Fixed bug in noneffective flow control when large messages are received. - Demote link redirect logging from warning to info. 1.2.4 (2019-12-02) ++++++++++++++++++ - Fixed bug in calculating send timeout. - Removed `ThreadPoolExecutor` in `ConnectionAsync`. - Added support for Python 3.8 1.2.3 (2019-10-07) ++++++++++++++++++ - Fixed bug in dropping received messages at the moment when the connection just started working. - Fixed bug where underlying io type wasn't set to WebSocket when http_proxy was applied (PR#92, Thanks to skoop22). - Fixed bug in noneffective timeout when sending messages. - Added desired-capabilities for `ReceiveClient(Async)` and `MessageReceiver(Async)` as part of the AMQP protocol. - Added delivery-tag to `Message` (azure-sdk-for-python issue #7336). - Added method `work` to `MessageReceiver` and `work_async` to `MessageReceiverAsync` responsible for updating link status. 1.2.2 (2019-07-02) ++++++++++++++++++ - Made bug fix in asyncio.get_event_loop backwards-compatible for now by just printing a warning rather than raising an error. In the next major version bump we can disable entirely. 1.2.1 (2019-06-20) ++++++++++++++++++ - Updated the implementation of `update_token()` in `JWTTokenAuth` and `JWTTokenAsync` (issue #80). 1.2.0 (2019-04-16) ++++++++++++++++++ - Fixed bug in batched messages missing application_properties (azure-event-hubs-python issue #97). - Fixed bug in datetime object parsing (issue #63). - Fixed bug in unexposed send/receive settle modes. - Fixed bug where retried messages were not added back to the send queue. - Fixed bug in using asyncio.get_event_loop. - Added type objects for AMQP Byte and uBytes types. - Added async locking around pending messages queue (PR#54, Thanks to zach-b) - Added WebSocket(AMQP over WebSocket) support (azure-sdk-for-python issue #5318). - Added new token class `JWTTokenAuth` and `JWTTokenAsync` to support OAuth. 1.1.0 (2018-11-12) ++++++++++++++++++ - Support for Python 2.7 \(>_<)/ - Where ever a `TimeoutError` is raised in Python 3.x, this will be replaced with a new ~uamqp.errors.ClientTimeout exception in Python 2.7. - A Python 2 `str` object will be treated as `bytes` in Python 3 and a Python 2 `unicode` object will be treated like a Python 3 `str`. - Added uamqp.compat module for handling Py 2 vs 3 imports and types (PR#46, Thanks to maxkrivich). - AMQP encoding of an integer type will now automatically failover into a Long type or a double type if the value is too large. - Improved support for promptly detecting invalid ATTACH handles and raising the appropriate error. - Added types for AMQPDescribed, AMQPInt and AMQPuInt for explicit handling of int and unsigned int encoding. - Added new error `errors.AMQPClientShutdown` as a wrapper for `KeyboardInterrupt` to better handle interrupt handling. - Added better handling of keyboard interrupts during C callbacks to better facilitate clean client shutdown. - Added additional handling of keyboard interrupt at the C level to clean up annoying warnings. - Added classmethod `Message.decode_from_bytes` to create a message from AMQP wire-encoded data. - Added `Message.encode_message` method to retrieve the AMQP wire-encoded byte representation of the current message. - Fixed behaviour of `Message.get_message_encoded_size()` to return accurate size. - Added new optional `callback` argument to `client.mgmt_request` to allow for custom handling of different status codes. - Added new client methods `auth_complete()` and `client_ready()` to allow for more fine-tuned monitoring or the client opening stages. - Client message handler is now a public attribute `client.message_handler` (`SendClient._message_sender` and `ReceiveClient._message_receiver` are now deprecated). - Added automatic encoding of `datetime.datetime` objects into AMQP timestamp. - Better support for Source filters with optional `descriptor` argument in `Source.set_filter()` and new `Source.get_filter()` method. - Fixed Session settings not being passed to CBS session. - Added support for a callback on receipt on a Link ATTACH frame. Can be supplied to a client through the `on_attach` keyword argument. - Removed unsued message.SequenceBody class. - Exposed BatchMessage.size_offset property for batch size customization. 1.0.3 (2018-09-14) ++++++++++++++++++ - Reduced CPU load during idle receive. - Updated Azure uAMQP C and Azure C Shared Utility dependencies. 1.0.2 (2018-09-05) ++++++++++++++++++ - Fixed additional bugs in setting MessageProperties as string or bytes. - Removed auth locking to prevent locking issues on keyboard interrupt. 1.0.1 (2018-08-29) ++++++++++++++++++ - Added some more checks in place to prevent lock hanging on a keybaord interrupt. - Fixed bug in setting MessageProperties.subject as string or bytes. - `uamqp.send_message` now returns a list of `uamqp.constants.MessageState` to indicate the success of each message sent. 1.0.0 (2018-08-20) ++++++++++++++++++ - API settled. - **Behaviour change** When a SendClient or SendClientAsync is shutdown, any remaining pending messages (that is messages in the states `WaitingToBeSent` and `WaitingForSendAck`) will no longer be cleared, but can be retrieved from a new attribute `SendClient.pending_messages` in order to be re-processed as needed. - **Behaviour change** The function `SendClient.queue_message` now allows for queueing multiple messages at once by simply passing in additional message instances: - `send_client.queue_message(my_message)` - `send_client.queue_message(message_1, message_2, message_3)` - `send_client.queue_message(*my_message_list)` - An authentication object will now raise a `ValueError` if one attempts to use it for more than one connection. - Renamed internal `_async` module to non-private `async_ops` to allow for docs generation. - Reformatted logging for better performance. - Added additional logging. 0.2.1 (2018-08-06) ++++++++++++++++++ - Fixed potential crashing in bindings for amqpvalue. - Fixed bindings fault in cbs PUT token complete callback. - Updated uAMQP-C. - Added additional auth and connection locking for thread/async safety. - Increased INFO level logging. - Removed platform deinitialization until it can be improved. - Added handling for a connection reaching a client-caused error state. 0.2.0 (2018-07-25) ++++++++++++++++++ - **Breaking change** `MessageSender.send_async` has been renamed to `MessageSender.send`, and `MessageSenderAsync.send_async` is now a coroutine. - **Breaking change** Removed `detach_received` callback argument from MessageSender, MessageReceiver, MessageSenderAsync, and MessageReceiverAsync in favour of new `error_policy` argument. - Added ErrorPolicy class to determine how the client should respond to both generic AMQP errors and custom or vendor-specific errors. A default policy will be used, but a custom policy can be added to any client by using a new `error_policy` argument. Value must be either an instance or subclass of ErrorPolicy. - The `error_policy` argument has also been added to MessageSender, MessageReceiver, Connection, and their async counterparts to allow for handling of link DETACH and connection CLOSE events. - The error policy passed to a SendClient determines the number of message send retry attempts. This replaces the previous `constants.MESSAGE_SEND_RETRIES` value which is now deprecated. - Added new ErrorAction object to determine how a client should respond to an error. It has three properties: `retry` (a boolean to determine whether the error is retryable), `backoff` (an integer to determine how long the client should wait before retrying, default is 0) and `increment_retries` (a boolean to determine whether the error should count against the maximum retry attempts, default is `True`). Currently `backoff` and `increment_retries` are only considered for message send failures. - Added `VendorConnectionClose` and `VendorLinkDetach` exceptions for non-standard (unrecognized) connection/link errors. - Added support for HTTP proxy configuration. - Added support for running async clients synchronously. - Added keep-alive support for connection - this is a background thread for a synchronous client, and a background async function for an async client. The keep-alive feature is disabled by default, to enable, set the `keep_alive_interval` argument on the client to an integer representing the number of seconds between connection pings. - Added support for catching a Connection CLOSE event. - Added support for `Connection.sleep` and `ConnectionAsync.sleep_async` to pause the connection. - Added support for surfacing message disposition delivery-state (with error information). - Added `constants.ErrorCodes` enum to map standard AMQP error conditions. This replaces the previous `constants.ERROR_CONNECTION_REDIRECT` and `constants.ERROR_LINK_REDIRECT` which are now both deprecated. - Added new super error `AMQPError` from which all exceptions inherit. - Added new `MessageHandlerError` exception, a subclass of `AMQPConnectionError`, for Senders/Receivers that enter an indeterminate error state. - `MessageException` is now a subclass of `MessageResponse`. - Added `ClientMessageError` exception, a subclass of `MessageException` for send errors raised client-side. - Catching Link DETACH event will now work regardless of whether service returns delivery-state. - Fixed bug where received messages attempting to settle on a detached link crashed the client. - Fixed bug in amqp C DescribedValue. - Fixed bug where client crashed on deallocating failed management operation. 0.1.1 (2018-07-14) ++++++++++++++++++ - Removed circular dependency in Python 3.4 with types.py/utils.py - When a header properties is not set, returns `None` rather than raising ValueError. - Fixed bug in receiving messages with application properties. 0.1.0 (2018-07-05) ++++++++++++++++++ - Fixed bug in error handling for CBS auth to invalid hostname. - Changed C error logging to debug level. - Bumped uAMQP C version to 1.2.7 - Fixed memory leaks and deallocation bugs with Properties and Annotations. 0.1.0rc2 (2018-07-02) +++++++++++++++++++++ - **Breaking change** Submodule `async` has been renamed to the internal `_async`. All asynchronous classes in the submodule can now be accessed from uamqp or uamqp.authentication directly. - **Breaking change** Anything returned by a callback supplied to receive messages will now be ignored. - **Breaking change** Changed message state enum values: - `Complete -> SendComplete` - `Failed -> SendFailed` - `WaitingForAck -> WaitingForSendAck` - Added new message state enum values: - `ReceivedUnsettled` - `ReceivedSettled` - **Breaking change** Changes to message settlement exceptions: - Combined the `AbandonMessage` and `DeferMessage` exceptions as `MessageModified` to be in keeping with the AMQP specification. - Renamed `AcceptMessage` to `MessageAccepted`. - Renamed `RejectMessage` to `MessageRejected` which now takes `condition` and `description` arguments rather than `message`. - Added `errors.LinkDetach` exception as new subclass of `AMQPConnectionError` as a wrapped for data in a Link DETACH dispostition. - Added `errors.LinkRedirect` as a specific subclass of `LinkDetach` to decode the specific redirect fields of a Link Redirect response. - Added `errors.MessageAlreadySettled` exception for operations performed on a received message that has already returned a receipt dispostition. - Added `errors.MessageReleased` exception. - Added `errors.ErrorResponse` exception. - A received Message can now be explicitly settled through a set of new functions on the message: - `Message.accept()` - `Message.reject(condition:str, description:str)` - `Message.release()` - `Message.modify(failed:bool, deliverable:bool, annotations:dict)` - Added explicit `auto_complete` argument to `ReceiveClient` and `ReceiveClientAsync`. If `auto_complete` is set to `False` then all messages must be explicitly "accepted" or "rejected" by the user otherwise they will timeout and be released. The default is `True`, which is the exiting behaviour for each receive mechanism: - Received messages processed by callback (`ReceiveClient.receive_messages()`) will be automatically "accepted" if no explicit response has been set on completion of the callback. - Received messages processed by batch (`ReceiveClient.receive_message_batch()`) will by automatically "accepted" before being returned to the user. - Received messages processed by iterator (`ReceiveClient.receive_message_iter()`) will by automatically "accepted" if no explicit response has been set once the generator is incremented. - Added new methods to clients and connections to allow to redirect to an alternative endpoint when a LinkRedirect exception is raised. The client redirect helper cannot be used for clients that use a shared connection - the clients must be closed before the connection can be redirected. New credentials must be supplied for the new endpoint. The new methods are: - `uamqp.Connection.redirect(redirect_info, auth)` - `uamqp.async.ConnectionAsync.redirect_async(redirect_info, auth)` - `uamqp.SendClient.redirect(redirect_info, auth)` - `uamqp.ReceiveClient.redirect(redirect_info, auth)` - `uamqp.async.SendClientAsync.redirect_async(redirect_info, auth)` - `uamqp.async.ReceiveClientAsync.redirect_async(redirect_info, auth)` - Added `on_detach_received` argument to `Sender` and `Receiver` classes to pass in callback to run on Link DETACH. - Removed automatic char encoding for strings of length 1, and added `types.AMQPChar` for explicit encoding. - Bumped uAMQP C version to 1.2.5 - Bumped Azure C Shared Utility to 1.1.5 - Fixed memory leaks in MessageProperties, MessageHeader and message annotations. 0.1.0rc1 (2018-05-29) +++++++++++++++++++++ - Fixed import error in async receiver. - Exposed sender/receiver destroy function. - Moved receiver.open on_message_received argument to constructor. - Removed sasl module and moved internal classes into authentication module. - Added encoding parameter everywhere where strings are encoded. - Started documentation. - Updated uAMQP-C to 1.2.4 and C Shared Utility to 1.1.4 (includes fix for issue #12). - Fixed return type of MgmtOperation.execute - now returns ~uamqp.message.Message. - Made AMQP connection/session/sender/receiver types in a client overridable. - Added debug trace to management operations. - Fixed error in management callback on failed operation. - Default AMQP encoding of bytes is now a String type and a bytearray is a Binary type. - Added AMQP Array type and fixed Long type range validation. - Added `header` argument to Message and BatchMessage for setting a MessageHeader. - Fixed MessageHeader attribute setters. 0.1.0b5 (2018-04-27) ++++++++++++++++++++ - Added Certifi as a depedency to make OpenSSL certs dynamic. - Added `verify` option to authentication classes to allow setting custom certificate path (for Linux and OSX). 0.1.0b4 (2018-04-19) ++++++++++++++++++++ - Fixed memory leak in async receive. - Removed close_on_done argument from client receive functions. - Added receive iterator to synchronous client. - Made async iter receive compatible with Python 3.5. 0.1.0b3 (2018-04-14) ++++++++++++++++++++ - Fixed SSL errors in manylinux wheels. - Fixed message annoations attribute. - Fixed bugs in batched messages and sending batched messages. - Fixed conflicting receiver link ID. - Fixed hanging receiver by removing queue max size in sync clients. - Added support for sending messages with None and empty bodies. 0.1.0b2 (2018-04-06) ++++++++++++++++++++ - Added message send retry. - Added timeouts and better error handling for management requests. - Improved connection and auth error handling and error messages. - Fixed message annotations type. - SendClient.send_all_messages() now returns a list of message send statuses. - Fixed OpenSSL platform being initialized multiple times. - Fixed auto-refresh of SAS tokens. - Altered `receive_batch` behaviour to return messages as soon as they're available. - Parameter `batch_size` in `receive_batch` renamed to `max_batch_size`. - Fixed message `application_properties` decode error. - Removed MacOS dependency on OpenSSL and libuuid. 0.1.0b1 (2018-03-24) ++++++++++++++++++++ - Added management request support. - Fixed message-less C operation ValueError. - Store message metadata in Python rather than C. - Refactored Send and Receive clients to create a generic parent AMQPClient. - Fixed None receive timestamp bug. - Removed async iterator queue due to instabilities - all callbacks are now synchronous. 0.1.0a3 (2018-03-19) ++++++++++++++++++++ - Added support for asynchronous message receive by iterator or batch. - Removed synchronous receive iterator, and replaced with synchronous batch receive. - Added sync and async context managers for Send and Receive Clients. - Fixed token instability and added put token retry policy. - Exposed Link ATTACH properties. - A connection now has a single $cbs session that can be reused between clients. - Added C debug trace logging to the Python logger ('uamqp.c_uamqp') 0.1.0a2 (2018-03-12) ++++++++++++++++++++ - Exposed OPEN performative properties for connection telemetry. - Exposed setters for message.message_annotations and message.application_properties. - Made adjustments to connection open and close to facilitate sharing a connection object between send/receive clients. - Support for username/password embedded in connection URI. - Clients can now optionally leave connection/session/link open for re-use. - Updated build process and installation instructions. - Various bug fixes to increase stability. 0.1.0a1 (2018-03-04) ++++++++++++++++++++ - Initial release azure-uamqp-python-1.6.8/LICENSE000066400000000000000000000022121455573770000163330ustar00rootroot00000000000000 MIT License Copyright (c) Microsoft Corporation. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE azure-uamqp-python-1.6.8/MANIFEST.in000066400000000000000000000000461455573770000170670ustar00rootroot00000000000000include *.rst recursive-include src * azure-uamqp-python-1.6.8/README.rst000066400000000000000000000105731455573770000170260ustar00rootroot00000000000000uAMQP for Python ================ .. image:: https://img.shields.io/pypi/v/uamqp.svg :target: https://pypi.python.org/pypi/uamqp/ .. image:: https://img.shields.io/pypi/pyversions/uamqp.svg :target: https://pypi.python.org/pypi/uamqp/ .. image:: https://dev.azure.com/azure-sdk/public/_apis/build/status/python/azure-uamqp-python%20-%20client?branchName=main :target: https://dev.azure.com/azure-sdk/public/_build?definitionId=89 An AMQP 1.0 client library for Python. Disclaimer ============ uAMQP for Python requires Python 3.6+ starting from v1.5, and Python 2.7 is no longer supported. If Python 2.7 is required, please install uAMQP v1.4.3: .. code:: shell $ pip install uamqp==1.4.3 Installation ============ Wheels are provided for most major operating systems, so you can install directly with pip: .. code:: shell $ pip install uamqp If you are running a Linux distro that does not support `ManyLinux1 `__ or you need to customize the build based on your system settings and packages, you can install from source: .. code:: shell $ apt-get update $ apt-get install -y build-essential libssl-dev uuid-dev cmake libcurl4-openssl-dev pkg-config python3-dev python3-pip $ pip3 install uamqp --no-binary :all: If you are running Alpine, you can install from source: .. code:: shell $ apk add --update python3 py-pip python3-dev cmake gcc g++ openssl-dev build-base $ pip3 install uamqp --no-binary :all: If you are running Red Hat, you can install from source: .. code:: shell $ yum install cmake gcc gcc-c++ make openssl-devel python3-devel $ pip3 install uamqp --no-binary :all: Documentation +++++++++++++ Reference documentation can be found here: `docs.microsoft.com/python/api/uamqp/uamqp `__. Developer Setup =============== In order to run the code directly, the Cython extension will need to be build first. Pre-requisites ++++++++++++++ - Windows: Setup a `build environment `__. - Linux: Install dependencies as descriped above in the installation instructions. - MacOS: Install cmake using Homebrew: .. code:: shell $ brew install cmake Building the extension ++++++++++++++++++++++ This project has two C library dependencies. They are vendored in this repository in these versions: - `Azure uAMQP for C `__ @ `2021-11-16 `__ - `Azure C Shared Utility `__ @ `2021-11-15 `__ To build, start by creating a virtual environment and installing the required Python packages: .. code:: shell $ python -m venv env $ env/Scripts/activate (env)$ pip install -r dev_requirements.txt Next, run the build command: .. code:: shell $ python setup.py build_ext --inplace Tests +++++ The tests can be run from within the virtual environment. The extension must be built first using the instructions above. .. code:: shell (env)$ pytest Provide Feedback ================ If you encounter any bugs or have suggestions, please file an issue in the `Issues `__ section of the project. Contributing ============ This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit `https://cla.microsoft.com `__. When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA. This project has adopted the `Microsoft Open Source Code of Conduct `__. For more information see the `Code of Conduct FAQ `__ or contact `opencode@microsoft.com `__ with any additional questions or comments. azure-uamqp-python-1.6.8/SECURITY.md000066400000000000000000000053051455573770000171250ustar00rootroot00000000000000 ## Security Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/). If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below. ## Reporting Security Issues **Please do not report security vulnerabilities through public GitHub issues.** Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report). If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey). You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue: * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.) * Full paths of source file(s) related to the manifestation of the issue * The location of the affected source code (tag/branch/commit or direct URL) * Any special configuration required to reproduce the issue * Step-by-step instructions to reproduce the issue * Proof-of-concept or exploit code (if possible) * Impact of the issue, including how an attacker might exploit the issue This information will help us triage your report more quickly. If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs. ## Preferred Languages We prefer all communications to be in English. ## Policy Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd). azure-uamqp-python-1.6.8/build_armv7l.sh000066400000000000000000000016141455573770000202560ustar00rootroot00000000000000#!/bin/bash set -e # To execute this script: # docker run --rm -v $PWD:/data local/armv7l /data/build_armv7l.sh # docker run --rm -v $PWD:/data local/armv7l_wheezy /data/build_armv7l.sh export UAMQP_VERSION="1.0.2" export CPATH="/opt/uamqp/openssl/include" export LIBRARY_PATH="/opt/uamqp/openssl/lib" export OPENSSL_ROOT_DIR="/opt/uamqp/openssl" export OPENSSL_INCLUDE_DIR="/opt/uamqp/openssl/include" export UAMQP_SUPPRESS_LINK_FLAGS=True export LDFLAGS="-L/opt/uamqp/openssl/lib/libssl.a -L/opt/uamqp/openssl/lib/libcrypto.a" export CFLAGS="-I/opt/uamqp/openssl/include" # Build the wheels pushd /data #/usr/local/bin/python3.4 setup.py bdist_wheel /usr/local/bin/python3.5 setup.py bdist_wheel auditwheel repair -w /data/wheelhouse dist/uamqp-${UAMQP_VERSION}-cp35-cp35m-linux_armv7l.whl #/usr/local/bin/python3.6 setup.py bdist_wheel --plat linux_armv7l #/usr/local/bin/python3.7 setup.py bdist_wheelazure-uamqp-python-1.6.8/build_linux_sdist.sh000066400000000000000000000005441455573770000214140ustar00rootroot00000000000000#!/bin/bash set -e # To execute this script: # docker run --rm -v %cd%:/data --entrypoint="/bin/bash" -e "UAMQP_REBUILD_PYX=True" fnndsc/ubuntu-python3 /data/build_linux_sdist.sh apt-get update apt-get install -y build-essential libssl-dev uuid-dev cmake libcurl4-openssl-dev pkg-config cd /data pip3 install cython==0.29.21 wheel python3 setup.py sdistazure-uamqp-python-1.6.8/build_many_linux.sh000077500000000000000000000033461455573770000212400ustar00rootroot00000000000000#!/bin/bash set -e # Inspired by https://github.com/pypa/python-manylinux-demo/blob/a615d78e5042c01a03e1bbb1ca78603c90dbce1f/travis/build-wheels.sh # To build a 64bit manylinux1 wheel (for e.g. Python 3.8), run: # docker run --rm -v $PWD:/data -e "PYTHON_VERSION=cp38-cp38" -e "PLATFORM=manylinux1_x86_64" -e "UAMQP_REBUILD_PYX=True" azuresdkimages.azurecr.io/manylinux_crypto_x64 /data/build_many_linux.sh # To build a 64bit manylinux2010 wheel (for e.g. Python 3.8), run: # docker run --rm -v $PWD:/data -e "PYTHON_VERSION=cp38-cp38" -e "PLATFORM=manylinux2010_x86_64" -e "UAMQP_REBUILD_PYX=True" azuresdkimages.azurecr.io/manylinux2010_crypto_x64 /data/build_many_linux.sh export CPATH="/opt/pyca/cryptography/openssl/include" export LIBRARY_PATH="/opt/pyca/cryptography/openssl/lib" export OPENSSL_ROOT_DIR="/opt/pyca/cryptography/openssl" export PYBIN="/opt/python/$PYTHON_VERSION/bin" # Build the wheel pushd /data; $PYBIN/pip install cython==0.29.21 wheel; $PYBIN/python setup.py bdist_wheel -d /wheelhouse; rm -rf build/; popd; # Repair the wheel for WHL in /wheelhouse/*; do auditwheel repair --plat $PLATFORM $WHL -w /data/wheelhouse/; done; # Set up env vars to run live tests - otherwise they will be skipped. export EVENT_HUB_HOSTNAME="" export EVENT_HUB_NAME="" export EVENT_HUB_SAS_POLICY="" export EVENT_HUB_SAS_KEY="" export IOTHUB_HOSTNAME="" export IOTHUB_HUB_NAME="" export IOTHUB_DEVICE="" export IOTHUB_ENDPOINT="" export IOTHUB_SAS_POLICY="" export IOTHUB_SAS_KEY="" # Test the wheel $PYBIN/pip install "certifi>=2017.4.17" "pytest" "pylint"; $PYBIN/pip install uamqp --no-index -f /data/wheelhouse; $PYBIN/python -c 'import uamqp;print("*****Importing uamqp from wheel successful*****")'; pushd /data; $PYBIN/pytest -v; popd; azure-uamqp-python-1.6.8/build_openssl_armv7l.sh000066400000000000000000000005241455573770000220200ustar00rootroot00000000000000#!/bin/bash export OPENSSL_VERSION="1.0.2o" curl -O https://www.openssl.org/source/openssl-$OPENSSL_VERSION.tar.gz tar -xvzf openssl-$OPENSSL_VERSION.tar.gz mv openssl-$OPENSSL_VERSION openssl_armv7l_src cd openssl_armv7l_src ./Configure linux-armv4 shared --prefix=/opt/uamqp/openssl make make install rm openssl-$OPENSSL_VERSION.tar.gzazure-uamqp-python-1.6.8/build_openssl_osx.sh000066400000000000000000000010751455573770000214230ustar00rootroot00000000000000#!/bin/bash # Acquire sources curl -sSO https://www.openssl.org/source/openssl-$OPENSSL_VERSION.tar.gz tar -xzf openssl-$OPENSSL_VERSION.tar.gz rm -f openssl-$OPENSSL_VERSION.tar.gz mv openssl-$OPENSSL_VERSION openssl_src # Compile x86_64 cd openssl_src ./Configure darwin64-x86_64-cc enable-ec_nistp_64_gcc_128 no-ssl2 no-ssl3 no-zlib no-shared no-comp --prefix=$DEST/openssl --openssldir=$DEST/openssl make depend make make install_sw # Move files into place cd $DEST mv openssl/lib/libcrypto.a openssl/lib/libazcrypto.a mv openssl/lib/libssl.a openssl/lib/libazssl.a azure-uamqp-python-1.6.8/build_osx.sh000066400000000000000000000011751455573770000176610ustar00rootroot00000000000000#!/bin/bash set -e export MACOSX_DEPLOYMENT_TARGET=10.9 export CMAKE_OSX_DEPLOYMENT_TARGET=10.9 export CMAKE_OSX_ARCHITECTURES="x86_64" export UAMQP_USE_OPENSSL=True export UAMQP_REBUILD_PYX=True export UAMQP_SUPPRESS_LINK_FLAGS=True export OPENSSL_ROOT_DIR="/tmp/openssl" export OPENSSL_INCLUDE_DIR="/tmp/openssl/include" export LDFLAGS="-mmacosx-version-min=10.9 -L/tmp/openssl/lib" export CFLAGS="-mmacosx-version-min=10.9 -I/tmp/openssl/include" python2.7 setup.py bdist_wheel python3.4 setup.py bdist_wheel python3.5 setup.py bdist_wheel python3.6 setup.py bdist_wheel python3.7 setup.py bdist_wheel python3.8 setup.py bdist_wheel azure-uamqp-python-1.6.8/dev_requirements.txt000066400000000000000000000004471455573770000214600ustar00rootroot00000000000000cython==0.29.32 setuptools>=27.1.2 wheel>=0.32.0 pytest==6.2.4; python_version >= '3.10' pytest==5.4.1; python_version >= '3.7' and python_version < '3.10' pytest-asyncio==0.12.0; python_version >= '3.7' docutils>=0.14 pygments>=2.2.0 pylint==2.3.1; python_version >= '3.7' cibuildwheel==2.16.2 azure-uamqp-python-1.6.8/install_python_osx.sh000066400000000000000000000012371455573770000216300ustar00rootroot00000000000000#!/bin/bash # Python 3.5 is only built for OSX 10.6+ PACKAGE_TYPE="macosx10.9" if [[ "$PYTHONVERSION" =~ ^3.5 ]]; then PACKAGE_TYPE="macosx10.6" fi if [[ "$PYTHONVERSION" =~ ^3.10 ]]; then PACKAGE_TYPE="macos11" fi if [[ "$PYTHONVERSION" =~ ^3.11 ]]; then PACKAGE_TYPE="macos11" fi # Handle prerelease versions PACKAGE_DIR="$PYTHONVERSION" if [[ "$PYTHONVERSION" =~ ^([0-9.]+)[A-Za-z] ]]; then PACKAGE_DIR="${BASH_REMATCH[1]}" fi curl -sSO https://www.python.org/ftp/python/$PACKAGE_DIR/python-$PYTHONVERSION-$PACKAGE_TYPE.pkg sudo installer -allowUntrusted -pkg python-$PYTHONVERSION-$PACKAGE_TYPE.pkg -target / rm -f python-$PYTHONVERSION-$PACKAGE_TYPE.pkg azure-uamqp-python-1.6.8/pylintrc000066400000000000000000000032151455573770000171210ustar00rootroot00000000000000[MASTER] ignore-patterns=test_* reports=no [MESSAGES CONTROL] # For all codes, run 'pylint --list-msgs' or go to 'https://pylint.readthedocs.io/en/latest/reference_guide/features.html' # locally-disabled: Warning locally suppressed using disable-msg # cyclic-import: because of https://github.com/PyCQA/pylint/issues/850 disable=useless-object-inheritance,missing-docstring,locally-disabled,fixme,cyclic-import,too-many-arguments,invalid-name,duplicate-code,logging-format-interpolation,too-many-instance-attributes,too-few-public-methods,raising-bad-type [FORMAT] max-line-length=120 [VARIABLES] # Tells whether we should check for unused import in __init__ files. init-import=no [DESIGN] # Maximum number of locals for function / method body max-locals=25 # Maximum number of branch for function / method body max-branches=20 [SIMILARITIES] min-similarity-lines=10 [BASIC] # Naming hints based on PEP 8 (https://www.python.org/dev/peps/pep-0008/#naming-conventions). # Consider these guidelines and not hard rules. Read PEP 8 for more details. # The invalid-name checker must be **enabled** for these hints to be used. include-naming-hint=yes module-name-hint=lowercase (keep short; underscores are discouraged) const-name-hint=UPPER_CASE_WITH_UNDERSCORES class-name-hint=CapitalizedWords class-attribute-name-hint=lower_case_with_underscores attr-name-hint=lower_case_with_underscores method-name-hint=lower_case_with_underscores function-name-hint=lower_case_with_underscores argument-name-hint=lower_case_with_underscores variable-name-hint=lower_case_with_underscores inlinevar-name-hint=lower_case_with_underscores (short is OK) extension-pkg-whitelist=c_uamqp azure-uamqp-python-1.6.8/pyproject.toml000066400000000000000000000017221455573770000202470ustar00rootroot00000000000000[build-system] requires = [ "setuptools>=42", "wheel", "Cython<3.0.0", "cmake", ] [tool.cibuildwheel] # skip musl and pypy skip = ["*-musllinux*", "pp*"] #test-requires = "pytest" #test-command = "python -X dev -m pytest {project}/tests" [tool.cibuildwheel.macos.environment] MACOSX_DEPLOYMENT_TARGET = "10.9" CMAKE_OSX_DEPLOYMENT_TARGET = "10.9" CMAKE_OSX_ARCHITECTURES = "x86_64" UAMQP_USE_OPENSSL = true UAMQP_REBUILD_PYX = true UAMQP_SUPPRESS_LINK_FLAGS = true OPENSSL_ROOT_DIR = "/tmp/openssl" OPENSSL_INCLUDE_DIR = "/tmp/openssl/include" LDFLAGS = "-mmacosx-version-min=10.9 -L/tmp/openssl/lib" CFLAGS = "-mmacosx-version-min=10.9 -I/tmp/openssl/include" [tool.cibuildwheel.linux] archs = ["x86_64"] manylinux-x86_64-image = "manylinux2014" before-build = "bash utils/install_openssl.sh" environment = {OPENSSL_ROOT_DIR="/opt/pyca/cryptography/openssl", LIBRARY_PATH="/opt/pyca/cryptography/openssl/lib", CPATH="/opt/pyca/cryptography/openssl/include"}azure-uamqp-python-1.6.8/pytest.ini000066400000000000000000000000511455573770000173560ustar00rootroot00000000000000[pytest] norecursedirs = .git build env* azure-uamqp-python-1.6.8/samples/000077500000000000000000000000001455573770000167755ustar00rootroot00000000000000azure-uamqp-python-1.6.8/samples/asynctests/000077500000000000000000000000001455573770000211755ustar00rootroot00000000000000azure-uamqp-python-1.6.8/samples/asynctests/sample_uamqp_authentication_client_by_jwt_async.py000066400000000000000000000033251455573770000334460ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #------------------------------------------------------------------------- """ Examples to show how to authenticate Client by jwt token asynchronously. """ import asyncio from collections import namedtuple from uamqp import authentication, SendClientAsync, Message AccessToken = namedtuple("AccessToken", ["token", "expires_on"]) # Define get_token callback which shall be passed to the JWTTokenAsync for token generation async def get_token(): token = "" # the token used for authentication. expires_on = 253402261199 # The timestamp at which the JWT token will expire formatted as seconds since epoch. return AccessToken(token, expires_on) async def authenticate_client_by_jwt(): # Create the JWTTokenAsync object auth_uri = "" # The AMQP endpoint URI for authentication. token_audience = "" # The token audience field. auth = authentication.JWTTokenAsync( audience=token_audience, uri=auth_uri, get_token=get_token ) # Instantiate the SendClient with the JWTTokenAsync object target = "" # The target AMQP service endpoint. send_client = SendClientAsync(target=target, auth=auth) # Send a message message = Message(b'data') await send_client.send_message_async(message) await send_client.close_async() if __name__ == "__main__": loop = asyncio.get_event_loop() loop.run_until_complete(authenticate_client_by_jwt()) azure-uamqp-python-1.6.8/samples/asynctests/test_azure_event_hubs_mgmt_op_async.py000066400000000000000000000032621455573770000311000ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import asyncio import pytest import sys import uamqp from uamqp import authentication def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) @pytest.mark.asyncio async def test_event_hubs_mgmt_op_async(live_eventhub_config): plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) async with uamqp.AMQPClientAsync(target, auth=plain_auth, debug=False) as send_client: mgmt_msg = uamqp.Message(application_properties={'name': live_eventhub_config['event_hub']}) response = await send_client.mgmt_request_async( mgmt_msg, b'READ', op_type=b'com.microsoft:eventhub', status_code_field=b'status-code', description_fields=b'status-description', timeout=3000) output = response.get_data() assert output[b'partition_ids'] == [b"0", b"1"]azure-uamqp-python-1.6.8/samples/asynctests/test_azure_event_hubs_receive_async.py000066400000000000000000000673231455573770000310700ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import logging import os import pytest import asyncio import sys import time import uamqp from uamqp import address, types, utils, authentication, MessageBodyType from uamqp.message import DataBody, ValueBody, SequenceBody def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def on_message_received(message): annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) return message def send_single_message(live_eventhub_config, partition, msg_content): target = "amqps://{}/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], partition ) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) uamqp.send_message(target, msg_content, auth=sas_auth, debug=False) def send_multiple_message(live_eventhub_config, msg_count): def data_generator(): for i in range(msg_count): msg_content = "Hello world {}".format(i).encode('utf-8') yield msg_content uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['partition']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) message_batch = uamqp.message.BatchMessage(data_generator()) send_client.queue_message(message_batch) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] send_client.close() @pytest.mark.asyncio async def test_event_hubs_callback_async_receive(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receive_client = uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=1000, prefetch=10) log.info("Created client, receiving...") await receive_client.receive_messages_async(on_message_received) log.info("Finished receiving") @pytest.mark.asyncio async def test_event_hubs_callback_async_receive_no_shutdown_after_timeout(live_eventhub_config): received_cnt = {'cnt': 0} def on_message_received_internal(message): annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) log.info(str(message)) message.accept() received_cnt['cnt'] += 1 uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source) source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'") receive_client = uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=3000, prefetch=10, shutdown_after_timeout=False) log.info("Created client, receiving...") try: await receive_client.open_async() while not await receive_client.client_ready_async(): await asyncio.sleep(0.05) await asyncio.sleep(1) # sleep for 1s await receive_client._connection.work_async() # do a single connection iteration to see if there're incoming transfers # make sure no messages are received assert not receive_client._was_message_received assert receive_client._received_messages.empty() send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') await receive_client.receive_messages_async(on_message_received_internal) message_handler_before = receive_client.message_handler assert received_cnt['cnt'] == 1 send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') await receive_client.receive_messages_async(on_message_received_internal) message_handler_after = receive_client.message_handler assert message_handler_before == message_handler_after assert received_cnt['cnt'] == 2 log.info("Finished receiving") finally: await receive_client.close_async() @pytest.mark.asyncio async def test_event_hubs_filter_receive_async(live_eventhub_config): plain_auth = authentication.SASLPlain( live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) source_url = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source_url) source.set_filter(b"amqp.annotation.x-opt-enqueuedtimeutc > 1518731960545") receive_client = uamqp.ReceiveClientAsync(source, auth=plain_auth, timeout=5000) await receive_client.receive_messages_async(on_message_received) @pytest.mark.asyncio async def test_event_hubs_iter_receive_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receive_client = uamqp.ReceiveClientAsync(source, debug=False, auth=sas_auth, timeout=3000, prefetch=10) count = 0 message_generator = receive_client.receive_messages_iter_async() async for message in message_generator: log.info("No. {} : {}".format(message.annotations.get(b'x-opt-sequence-number'), message)) count += 1 if count >= 10: log.info("Got {} messages. Breaking.".format(count)) message.accept() break count = 0 async for message in message_generator: count += 1 if count >= 10: log.info("Got {} more messages. Shutting down.".format(count)) message.accept() break await receive_client.close_async() @pytest.mark.asyncio async def test_event_hubs_iter_receive_no_shutdown_after_timeout_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source) source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'") receive_client = uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=5000, debug=False, shutdown_after_timeout=False) count = 0 try: await receive_client.open_async() while not await receive_client.client_ready_async(): await asyncio.sleep(0.05) await asyncio.sleep(1) # sleep for 1s await receive_client._connection.work_async() # do a single connection iteration to see if there're incoming transfers # make sure no messages are received assert not receive_client._was_message_received assert receive_client._received_messages.empty() gen = receive_client.receive_messages_iter_async() send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') async for message in gen: log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) count += 1 assert count == 1 count = 0 message_handler_before = receive_client.message_handler send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') gen = receive_client.receive_messages_iter_async() async for message in gen: log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) count += 1 assert count == 1 message_handler_after = receive_client.message_handler assert message_handler_before == message_handler_after finally: await receive_client.close_async() @pytest.mark.asyncio async def test_event_hubs_batch_receive_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) async with uamqp.ReceiveClientAsync(source, debug=False, auth=sas_auth, timeout=3000, prefetch=10) as receive_client: message_batch = await receive_client.receive_message_batch_async(10) log.info("got batch: {}".format(len(message_batch))) for message in message_batch: annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) next_batch = await receive_client.receive_message_batch_async(10) log.info("got another batch: {}".format(len(next_batch))) for message in next_batch: annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) next_batch = await receive_client.receive_message_batch_async(10) log.info("got another batch: {}".format(len(next_batch))) for message in next_batch: annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) @pytest.mark.asyncio async def test_event_hubs_batch_receive_async_no_shutdown_after_timeout_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source) source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'") async with uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=3000, prefetch=10, shutdown_after_timeout=False) as receive_client: received_cnt = 0 received_cnt += len(await receive_client.receive_message_batch_async(10)) assert received_cnt == 0 message_handler_before = receive_client.message_handler send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') received_cnt += len(await receive_client.receive_message_batch_async(10)) assert received_cnt == 1 received_cnt += len(await receive_client.receive_message_batch_async(10)) assert received_cnt == 1 send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') received_cnt += len(await receive_client.receive_message_batch_async(10)) message_handler_after = receive_client.message_handler assert message_handler_before == message_handler_after assert received_cnt == 2 @pytest.mark.asyncio async def test_event_hubs_client_web_socket_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key'], transport_type=uamqp.TransportType.AmqpOverWebsocket) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) async with uamqp.ReceiveClientAsync(source, auth=sas_auth, debug=False, timeout=5000, prefetch=50) as receive_client: receive_client.receive_message_batch(max_batch_size=10) @pytest.mark.asyncio async def test_event_hubs_receive_with_runtime_metric_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receiver_runtime_metric_symbol = b'com.microsoft:enable-receiver-runtime-metric' symbol_array = [types.AMQPSymbol(receiver_runtime_metric_symbol)] desired_capabilities = utils.data_factory(types.AMQPArray(symbol_array)) async with uamqp.ReceiveClientAsync(source, debug=False, auth=sas_auth, timeout=1000, prefetch=10, desired_capabilities=desired_capabilities) as receive_client: message_batch = await receive_client.receive_message_batch_async(10) log.info("got batch: {}".format(len(message_batch))) for message in message_batch: annotations = message.annotations delivery_annotations = message.delivery_annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) assert b'last_enqueued_sequence_number' in delivery_annotations assert b'last_enqueued_offset' in delivery_annotations assert b'last_enqueued_time_utc' in delivery_annotations assert b'runtime_info_retrieval_time_utc' in delivery_annotations @pytest.mark.asyncio async def test_event_hubs_shared_connection_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group']) async with uamqp.ConnectionAsync(live_eventhub_config['hostname'], sas_auth, debug=False) as conn: partition_0 = uamqp.ReceiveClientAsync(source + "0", debug=False, auth=sas_auth, timeout=3000, prefetch=10) partition_1 = uamqp.ReceiveClientAsync(source + "1", debug=False, auth=sas_auth, timeout=3000, prefetch=10) await partition_0.open_async(connection=conn) await partition_1.open_async(connection=conn) tasks = [ partition_0.receive_message_batch_async(1), partition_1.receive_message_batch_async(1) ] try: messages = await asyncio.gather(*tasks) assert len(messages[0]) == 1 and len(messages[1]) == 1 except: raise finally: await partition_0.close_async() await partition_1.close_async() async def receive_ten(partition, receiver): messages = [] count = 0 while count < 10: print("Receiving {} on partition {}".format(count, partition)) batch = await receiver.receive_message_batch_async(1) print("Received {} messages on partition {}".format(len(batch), partition)) messages.extend(batch) count += 1 print("Finished receiving on partition {}".format(partition)) return messages @pytest.mark.asyncio async def test_event_hubs_multiple_receiver_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth_a = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) sas_auth_b = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group']) partition_0 = uamqp.ReceiveClientAsync(source + "0", debug=False, auth=sas_auth_a, timeout=3000, prefetch=10) partition_1 = uamqp.ReceiveClientAsync(source + "1", debug=False, auth=sas_auth_b, timeout=3000, prefetch=10) try: await partition_0.open_async() await partition_1.open_async() tasks = [ receive_ten("0", partition_0), receive_ten("1", partition_1) ] messages = await asyncio.gather(*tasks) assert len(messages) == 2 assert len(messages[0]) >= 10 assert len(messages[1]) >= 10 print(messages) finally: await partition_0.close_async() await partition_1.close_async() @pytest.mark.asyncio async def test_event_hubs_dynamic_issue_link_credit_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) msg_sent_cnt = 200 send_multiple_message(live_eventhub_config, msg_sent_cnt) def message_received_callback(message): message_received_callback.received_msg_cnt += 1 message_received_callback.received_msg_cnt = 0 async with uamqp.ReceiveClientAsync(source, debug=True, auth=sas_auth, prefetch=1) as receive_client: receive_client._message_received_callback = message_received_callback while not await receive_client.client_ready_async(): await asyncio.sleep(0.05) await asyncio.sleep(1) # sleep for 1s await receive_client._connection.work_async() # do a single connection iteration to see if there're incoming transfers # make sure no messages are received assert not receive_client._was_message_received assert receive_client._received_messages.empty() await receive_client.message_handler.reset_link_credit_async(msg_sent_cnt) now = start = time.time() wait_time = 5 while now - start <= wait_time: await receive_client._connection.work_async() now = time.time() assert message_received_callback.received_msg_cnt == msg_sent_cnt log.info("Finished receiving") @pytest.mark.asyncio async def test_event_hubs_not_receive_events_during_connection_establishment_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receive_client = uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=1000, debug=False, prefetch=10) try: await receive_client.open_async() while not await receive_client.client_ready_async(): await asyncio.sleep(0.05) await asyncio.sleep(1) # sleep for 1s await receive_client._connection.work_async() # do a single connection iteration to see if there're incoming transfers # make sure no messages are received assert not receive_client._was_message_received assert receive_client._received_messages.empty() messages_0 = await receive_client.receive_message_batch_async() assert len(messages_0) > 0 finally: await receive_client.close_async() @pytest.mark.asyncio async def event_hubs_send_different_amqp_body_type_async(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) data_body_1 = [b'data1', b'data2'] data_body_message_1 = uamqp.message.Message(body=data_body_1) data_body_message_1.application_properties = {'body_type': 'data_body_1'} send_client.queue_message(data_body_message_1) data_body_2 = b'data1' data_body_message_2 = uamqp.message.Message(body=data_body_2, body_type=MessageBodyType.Data) data_body_message_2.application_properties = {'body_type': 'data_body_2'} send_client.queue_message(data_body_message_2) value_body_1 = [b'data1', -1.23, True, {b'key': b'value'}, [1, False, 1.23, b'4']] value_body_message_1 = uamqp.message.Message(body=value_body_1) value_body_message_1.application_properties = {'body_type': 'value_body_1'} send_client.queue_message(value_body_message_1) value_body_2 = {b'key1': {b'sub_key': b'sub_value'}, b'key2': b'value', 3: -1.23} value_body_message_2 = uamqp.message.Message(body=value_body_2, body_type=MessageBodyType.Value) value_body_message_2.application_properties = {'body_type': 'value_body_2'} send_client.queue_message(value_body_message_2) sequence_body_1 = [b'data1', -1.23, True, {b'key': b'value'}, [b'a', 1.23, True]] sequence_body_message_1 = uamqp.message.Message(body=sequence_body_1, body_type=MessageBodyType.Sequence) sequence_body_message_1.application_properties = {'body_type': 'sequence_body_1'} send_client.queue_message(sequence_body_message_1) sequence_body_2 = [[1, 2, 3], [b'aa', b'bb', b'cc'], [True, False, True], [{b'key1': b'value'}, {b'key2': 123}]] sequence_body_message_2 = uamqp.message.Message(body=sequence_body_2, body_type=MessageBodyType.Sequence) sequence_body_message_2.application_properties = {'body_type': 'sequence_body_2'} send_client.queue_message(sequence_body_message_2) results = await send_client.send_all_messages_async(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], 0) result_dic = {} receive_client = uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=5000, debug=False, prefetch=10) gen = receive_client.receive_messages_iter_async() async for message in gen: if message.application_properties and message.application_properties.get(b'body_type'): if message.application_properties.get(b'body_type') == b'data_body_1': check_list = [data for data in message.get_data()] assert isinstance(message._body, DataBody) assert check_list == data_body_1 result_dic['data_body_1'] = 1 elif message.application_properties.get(b'body_type') == b'data_body_2': check_list = [data for data in message.get_data()] assert isinstance(message._body, DataBody) assert check_list == [data_body_2] result_dic['data_body_2'] = 1 elif message.application_properties.get(b'body_type') == b'value_body_1': assert message.get_data() == value_body_1 assert isinstance(message._body, ValueBody) result_dic['value_body_1'] = 1 elif message.application_properties.get(b'body_type') == b'value_body_2': assert message.get_data() == value_body_2 assert isinstance(message._body, ValueBody) result_dic['value_body_2'] = 1 elif message.application_properties.get(b'body_type') == b'sequence_body_1': check_list = [data for data in message.get_data()] assert check_list == [sequence_body_1] assert isinstance(message._body, SequenceBody) result_dic['sequence_body_1'] = 1 elif message.application_properties.get(b'body_type') == b'sequence_body_2': check_list = [data for data in message.get_data()] assert check_list == sequence_body_2 assert isinstance(message._body, SequenceBody) result_dic['sequence_body_2'] = 1 log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) await send_client.close_async() await receive_client.close_async() assert len(results) == 6 if __name__ == '__main__': config = {} config['hostname'] = os.environ['EVENT_HUB_HOSTNAME'] config['event_hub'] = os.environ['EVENT_HUB_NAME'] config['key_name'] = os.environ['EVENT_HUB_SAS_POLICY'] config['access_key'] = os.environ['EVENT_HUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" loop = asyncio.get_event_loop() loop.run_until_complete(event_hubs_send_different_amqp_body_type_async(config)) azure-uamqp-python-1.6.8/samples/asynctests/test_azure_event_hubs_send_async.py000066400000000000000000000323061455573770000303700ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import asyncio import time from datetime import timedelta import pytest import sys import types import collections import uamqp from uamqp import types as uamqp_types, utils, authentication, constants _AccessToken = collections.namedtuple("AccessToken", "token expires_on") def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) @pytest.mark.asyncio async def test_event_hubs_client_send_async(live_eventhub_config): properties = {b"SendData": b"Property_String_Value_1"} msg_content = b"hello world" message = uamqp.Message(msg_content, application_properties=properties) plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=plain_auth, debug=False) send_client.queue_message(message) results = await send_client.send_all_messages_async() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] @pytest.mark.asyncio async def test_event_hubs_single_send_async(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} msg_content = b"hello world" message = uamqp.Message(msg_content, annotations=annotations) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key(uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) for _ in range(10): message = uamqp.Message(msg_content, application_properties=annotations, annotations=annotations) await send_client.send_message_async(message) await send_client.close_async() @pytest.mark.asyncio async def test_event_hubs_async_sender_sync(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} msg_content = b"hello world" message = uamqp.Message(msg_content, annotations=annotations) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key(uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) for _ in range(10): message = uamqp.Message(msg_content, application_properties=annotations, annotations=annotations) send_client.send_message(message) send_client.close() @pytest.mark.asyncio async def test_event_hubs_client_send_multiple_async(live_eventhub_config): properties = {b"SendData": b"Property_String_Value_1"} msg_content = b"hello world" plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) assert not plain_auth.consumed target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=plain_auth, debug=False) messages = [] for i in range(10): messages.append(uamqp.Message(msg_content, application_properties=properties)) send_client.queue_message(*messages) assert len(send_client.pending_messages) == 10 results = await send_client.send_all_messages_async() assert len(results) == 10 assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] assert plain_auth.consumed assert send_client.pending_messages == [] @pytest.mark.asyncio async def test_event_hubs_batch_send_async(live_eventhub_config): for _ in range(10): def data_generator(): for i in range(50): msg_content = "Hello world {}".format(i).encode('utf-8') yield msg_content message_batch = uamqp.message.BatchMessage(data_generator()) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key(uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) send_client.queue_message(message_batch) results = await send_client.send_all_messages_async() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] @pytest.mark.asyncio async def test_event_hubs_send_timeout_async(live_eventhub_config): async def _hack_client_run(cls): """MessageSender Link is now open - perform message send on all pending messages. Will return True if operation successful and client can remain open for further work. :rtype: bool """ # pylint: disable=protected-access await asyncio.sleep(6) await cls.message_handler.work_async() cls._waiting_messages = 0 cls._pending_messages = cls._filter_pending() if cls._backoff and not cls._waiting_messages: log.info("Client told to backoff - sleeping for %r seconds", cls._backoff) await cls._connection.sleep_async(cls._backoff) cls._backoff = 0 await cls._connection.work_async() return True uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False, msg_timeout=5000) send_client._client_run_async = types.MethodType(_hack_client_run, send_client) await send_client.open_async() with pytest.raises(uamqp.errors.ClientMessageError): await send_client.send_message_async(uamqp.message.Message(body='Hello World')) await send_client.close_async() @pytest.mark.asyncio async def test_event_hubs_custom_end_point(): sas_token = authentication.SASTokenAsync("fake_audience", "fake_uri", "fake_token", expires_in=timedelta(10), custom_endpoint_hostname="123.45.67.89") assert sas_token.hostname == b"123.45.67.89" sas_token = authentication.SASTokenAsync.from_shared_access_key("fake_uri", "fake_key_name", "fake_key", custom_endpoint_hostname="123.45.67.89") assert sas_token.hostname == b"123.45.67.89" async def fake_get_token(): return "fake get token" jwt_token = authentication.JWTTokenAsync("fake_audience", "fake_uri", fake_get_token, custom_endpoint_hostname="123.45.67.89") assert jwt_token.hostname == b"123.45.67.89" @pytest.mark.asyncio async def test_event_hubs_idempotent_producer(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) symbol_array = [uamqp_types.AMQPSymbol(b"com.microsoft:idempotent-producer")] desired_capabilities = utils.data_factory(uamqp_types.AMQPArray(symbol_array)) link_properties = { uamqp_types.AMQPSymbol(b"com.microsoft:timeout"): uamqp_types.AMQPLong(int(60 * 1000)) } def on_attach(attach_source, attach_target, properties, error): if str(attach_target) == target: on_attach.owner_level = properties.get(b"com.microsoft:producer-epoch") on_attach.producer_group_id = properties.get(b"com.microsoft:producer-id") on_attach.starting_sequence_number = properties.get(b"com.microsoft:producer-sequence-number") send_client = uamqp.SendClientAsync( target, auth=sas_auth, desired_capabilities=desired_capabilities, link_properties=link_properties, on_attach=on_attach, debug=True ) await send_client.open_async() while not await send_client.client_ready_async(): await asyncio.sleep(0.05) assert on_attach.owner_level is not None assert on_attach.producer_group_id is not None assert on_attach.starting_sequence_number is not None await send_client.close_async() @pytest.mark.asyncio async def test_event_hubs_send_large_message_after_socket_lost(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=True) try: await send_client.open_async() while not await send_client.client_ready_async(): await send_client.do_work_async() # the connection idle timeout setting on the EH service is 240s, after 240s no activity # on the connection, the service would send detach to the client, the underlying socket on the client # is still able to work to receive the frame. # HOWEVER, after no activity on the client socket > 300s, the underlying socket would get completely lost: # the socket reports "Failure: sending socket failed 10054" on windows # or "Failure: sending socket failed. errno=104" on linux which indicates the socket is lost await asyncio.sleep(350) with pytest.raises(uamqp.errors.AMQPConnectionError): await send_client.send_message_async(uamqp.message.Message(b't'*1024*700)) finally: await send_client.close_async() @pytest.mark.asyncio async def test_event_hubs_send_override_token_refresh_window(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) token = None async def get_token(): nonlocal token return _AccessToken(token, expiry) jwt_auth = authentication.JWTTokenAsync( uri, uri, get_token, refresh_window=300 # set refresh window to be 5 mins ) send_client = uamqp.SendClientAsync(target, auth=jwt_auth, debug=False) # use token of which the valid remaining time < refresh window expiry = int(time.time()) + (60 * 4 + 30) # 4.5 minutes token = utils.create_sas_token( live_eventhub_config['key_name'].encode(), live_eventhub_config['access_key'].encode(), uri.encode(), expiry=timedelta(minutes=4, seconds=30) ) for _ in range(3): message = uamqp.message.Message(body='Hello World') await send_client.send_message_async(message) auth_status = constants.CBSAuthStatus(jwt_auth._cbs_auth.get_status()) assert auth_status == constants.CBSAuthStatus.RefreshRequired # update token, the valid remaining time > refresh window expiry = int(time.time()) + (60 * 5 + 30) # 5.5 minutes token = utils.create_sas_token( live_eventhub_config['key_name'].encode(), live_eventhub_config['access_key'].encode(), uri.encode(), expiry=timedelta(minutes=5, seconds=30) ) for _ in range(3): message = uamqp.message.Message(body='Hello World') await send_client.send_message_async(message) auth_status = constants.CBSAuthStatus(jwt_auth._cbs_auth.get_status()) assert auth_status == constants.CBSAuthStatus.Ok await send_client.close_async() if __name__ == '__main__': config = {} config['hostname'] = os.environ['EVENT_HUB_HOSTNAME'] config['event_hub'] = os.environ['EVENT_HUB_NAME'] config['key_name'] = os.environ['EVENT_HUB_SAS_POLICY'] config['access_key'] = os.environ['EVENT_HUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" loop = asyncio.get_event_loop() loop.run_until_complete(test_event_hubs_send_override_token_refresh_window(config)) azure-uamqp-python-1.6.8/samples/asynctests/test_azure_iothub_cli_extension.py000066400000000000000000000343621455573770000302410ustar00rootroot00000000000000# coding=utf-8 # -------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # -------------------------------------------------------------------------------------------- import asyncio import json import sys import os import logging import pytest from base64 import b64encode, b64decode from hashlib import sha256 from hmac import HMAC from time import time from datetime import datetime from uuid import uuid4 import concurrent import uamqp def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger DEBUG = True logger = get_logger(logging.INFO) def _generate_sas_token(uri, policy, key, expiry=None): if not expiry: expiry = time() + 3600 # Default to 1 hour. encoded_uri = quote_plus(uri) ttl = int(expiry) sign_key = '%s\n%d' % (encoded_uri, ttl) signature = b64encode(HMAC(b64decode(key), sign_key.encode('utf-8'), sha256).digest()) result = { 'sr': uri, 'sig': signature, 'se': str(ttl)} if policy: result['skn'] = policy return 'SharedAccessSignature ' + urlencode(result) def _build_iothub_amqp_endpoint_from_target(target): hub_name = target['entity'].split('.')[0] username = "{}@sas.root.{}".format(target['policy'], hub_name) sas_token = _generate_sas_token(target['entity'], target['policy'], target['primarykey'], time() + 360) return username, sas_token def _unicode_binary_map(target): # Assumes no iteritems() result = {} for k in target: key = k if isinstance(k, bytes): key = str(k, 'utf8') if isinstance(target[k], bytes): result[key] = str(target[k], 'utf8') else: result[key] = target[k] return result def _parse_entity(entity, filter_none=False): result = {} attributes = [attr for attr in dir(entity) if not attr.startswith('_')] for attribute in attributes: value = getattr(entity, attribute, None) if filter_none and not value: continue value_behavior = dir(value) if '__call__' not in value_behavior: result[attribute] = value return result def executor(target, consumer_group, enqueued_time, device_id=None, properties=None, timeout=0): coroutines = [] coroutines.append(initiate_event_monitor(target, consumer_group, enqueued_time, device_id, properties, timeout)) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) future = asyncio.gather(*coroutines, return_exceptions=True) result = None try: device_filter_txt = None if device_id: device_filter_txt = ' filtering on device: {},'.format(device_id) def stop_and_suppress_eloop(): try: loop.stop() except Exception: # pylint: disable=broad-except pass print('Starting event monitor,{} use ctrl-c to stop...'.format(device_filter_txt if device_filter_txt else '')) result = loop.run_until_complete(future) except KeyboardInterrupt: print('Stopping event monitor...') remaining_tasks = [t for t in asyncio.Task.all_tasks() if not t.done()] remaining_future = asyncio.gather(*remaining_tasks, return_exceptions=True) try: loop.run_until_complete(asyncio.wait_for(remaining_future, 5)) except concurrent.futures.TimeoutError: print("Timed out before tasks could finish. Shutting down anyway.") print("Finished event monitor shutdown.") finally: if result: error = next(res for res in result if result) if error: logger.error(error) raise RuntimeError(error) async def initiate_event_monitor(target, consumer_group, enqueued_time, device_id=None, properties=None, timeout=0): def _get_conn_props(): properties = {} properties["product"] = "az.cli.iot.extension" properties["framework"] = "Python {}.{}.{}".format(*sys.version_info[0:3]) properties["platform"] = sys.platform return properties if not target.get('events'): endpoint = _build_iothub_amqp_endpoint_from_target(target) _, update = await evaluate_redirect(endpoint) target['events'] = update['events'] auth = _build_auth_container(target) meta_data = await query_meta_data(target['events']['address'], target['events']['path'], auth) partition_count = meta_data[b'partition_count'] partition_ids = [] for i in range(int(partition_count)): partition_ids.append(str(i)) target['events']['partition_ids'] = partition_ids partitions = target['events']['partition_ids'] if not partitions: logger.debug('No Event Hub partitions found to listen on.') return coroutines = [] auth = _build_auth_container(target) async with uamqp.ConnectionAsync(target['events']['endpoint'], sasl=auth, debug=DEBUG, container_id=str(uuid4()), properties=_get_conn_props()) as conn: for p in partitions: coroutines.append(monitor_events(endpoint=target['events']['endpoint'], connection=conn, path=target['events']['path'], auth=auth, partition=p, consumer_group=consumer_group, enqueuedtimeutc=enqueued_time, properties=properties, device_id=device_id, timeout=timeout)) results = await asyncio.gather(*coroutines, return_exceptions=True) logger.warning("Finished all event monitors") logger.warning("Finished initiate_event_monitor") async def monitor_events(endpoint, connection, path, auth, partition, consumer_group, enqueuedtimeutc, properties, device_id=None, timeout=0): source = uamqp.address.Source('amqps://{}/{}/ConsumerGroups/{}/Partitions/{}'.format(endpoint, path, consumer_group, partition)) source.set_filter( bytes('amqp.annotation.x-opt-enqueuedtimeutc > ' + str(enqueuedtimeutc), 'utf8')) def _output_msg_kpi(msg): # TODO: Determine if amqp filters can support boolean operators for multiple conditions origin = str(msg.annotations.get(b'iothub-connection-device-id'), 'utf8') if device_id and origin != device_id: return event_source = {'event': {}} event_source['event']['origin'] = origin event_source['event']['payload'] = str(next(msg.get_data()), 'utf8') if 'anno' in properties or 'all' in properties: event_source['event']['annotations'] = _unicode_binary_map(msg.annotations) if 'sys' in properties or 'all' in properties: if not event_source['event'].get('properties'): event_source['event']['properties'] = {} event_source['event']['properties']['system'] = _unicode_binary_map(_parse_entity(msg.properties, True)) if 'app' in properties or 'all' in properties: if not event_source['event'].get('properties'): event_source['event']['properties'] = {} app_prop = msg.application_properties if msg.application_properties else None if app_prop: event_source['event']['properties']['application'] = _unicode_binary_map(app_prop) exp_cancelled = False receive_client = uamqp.ReceiveClientAsync(source, auth=auth, timeout=timeout, prefetch=0, debug=DEBUG) try: await receive_client.open_async(connection=connection) msg_iter = receive_client.receive_messages_iter_async() async for msg in msg_iter: _output_msg_kpi(msg) except asyncio.CancelledError: exp_cancelled = True await receive_client.close_async() except KeyboardInterrupt: logger.warning("Keyboard interrupt, closing monitor {}.".format(partition)) exp_cancelled = True await receive_client.close_async() raise except uamqp.errors.LinkDetach as ld: if isinstance(ld.description, bytes): ld.description = str(ld.description, 'utf8') raise RuntimeError(ld.description) finally: if not exp_cancelled: await receive_client.close_async() logger.warning("Finished MonitorEvents for partition {}".format(partition)) def _build_auth_container(target): sas_uri = 'sb://{}/{}'.format(target['events']['endpoint'], target['events']['path']) return uamqp.authentication.SASTokenAsync.from_shared_access_key(sas_uri, target['policy'], target['primarykey']) async def evaluate_redirect(endpoint): source = uamqp.address.Source('amqps://{}/messages/events/$management'.format(endpoint)) receive_client = uamqp.ReceiveClientAsync(source, timeout=30000, prefetch=1, debug=DEBUG) try: await receive_client.open_async() await receive_client.receive_message_batch_async(max_batch_size=1) except uamqp.errors.LinkRedirect as redirect: redirect = _unicode_binary_map(_parse_entity(redirect)) result = {} result['events'] = {} result['events']['endpoint'] = redirect['hostname'] result['events']['path'] = redirect['address'].replace('amqps://', '').split('/')[1] result['events']['address'] = redirect['address'] return redirect, result finally: await receive_client.close_async() async def query_meta_data(endpoint, path, auth): source = uamqp.address.Source(endpoint) receive_client = uamqp.ReceiveClientAsync(source, auth=auth, timeout=30000, debug=DEBUG) try: await receive_client.open_async() message = uamqp.Message(application_properties={'name': path}) response = await receive_client.mgmt_request_async( message, b'READ', op_type=b'com.microsoft:eventhub', status_code_field=b'status-code', description_fields=b'status-description', timeout=30000 ) test = response.get_data() return test finally: await receive_client.close_async() def monitor_feedback(target, device_id, wait_on_id=None, token_duration=3600): def handle_msg(msg): payload = next(msg.get_data()) if isinstance(payload, bytes): payload = str(payload, 'utf8') # assume json [] based on spec payload = json.loads(payload) for p in payload: if device_id and p.get('deviceId') and p['deviceId'].lower() != device_id.lower(): return None if wait_on_id: msg_id = p['originalMessageId'] if msg_id == wait_on_id: return msg_id return None operation = '/messages/servicebound/feedback' endpoint = _build_iothub_amqp_endpoint_from_target(target, duration=token_duration) endpoint = endpoint + operation device_filter_txt = None if device_id: device_filter_txt = ' filtering on device: {},'.format(device_id) print('Starting C2D feedback monitor,{} use ctrl-c to stop...'.format(device_filter_txt if device_filter_txt else '')) try: client = uamqp.ReceiveClient('amqps://' + endpoint, debug=DEBUG) message_generator = client.receive_messages_iter() for msg in message_generator: match = handle_msg(msg) if match: logger.info('requested msg id has been matched...') msg.accept() return match except uamqp.errors.AMQPConnectionError: logger.debug('amqp connection has expired...') finally: client.close() def get_target(config): target = {} target['cs'] = 'HostName={};SharedAccessKeyName={};SharedAccessKey={}'.format( config['hostname'], config['key_name'], config['access_key']) target['entity'] = config['hostname'] target['policy'] = config['key_name'] target['primarykey'] = config['access_key'] events = {} events['endpoint'] = config['endpoint'] events['partition_count'] = config.get('partition_count', 4) events['path'] = config['hub_name'] events['partition_ids'] = config.get('partition_ids', ["0", "1", "2"])#, "3", "4", "5", "6", "7", "8", "9", "10"]) target['events'] = events return target def test_iothub_monitor_events(live_iothub_config): properties = [] timeout = 30000 now = datetime.utcnow() epoch = datetime.utcfromtimestamp(0) enqueued_time = int(1000 * (now - epoch).total_seconds()) target = get_target(live_iothub_config) executor(target, consumer_group=live_iothub_config['consumer_group'], enqueued_time=enqueued_time, properties=properties, timeout=timeout, device_id=live_iothub_config['device']) def test_iothub_monitor_feedback(live_iothub_config): pytest.skip("Not yet implemented") def test_iothub_c2d_message_send(live_iothub_config): pytest.skip("Not yet implemented") if __name__ == '__main__': try: config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['hub_name'] = os.environ['IOTHUB_HUB_NAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['endpoint'] = os.environ['IOTHUB_ENDPOINT'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" except KeyError: pytest.skip("Live IoTHub configuration not found.") else: test_iothub_monitor_events(config)azure-uamqp-python-1.6.8/samples/asynctests/test_azure_iothub_receive_async.py000066400000000000000000000076541455573770000302210ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import asyncio import pytest import sys from base64 import b64encode, b64decode from hashlib import sha256 from hmac import HMAC from time import time from uuid import uuid4 try: from urllib import quote, quote_plus, urlencode #Py2 except Exception: from urllib.parse import quote, quote_plus, urlencode import uamqp from uamqp import authentication, errors, address def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def _generate_sas_token(uri, policy, key, expiry=None): if not expiry: expiry = time() + 3600 # Default to 1 hour. encoded_uri = quote_plus(uri) ttl = int(expiry) sign_key = '%s\n%d' % (encoded_uri, ttl) signature = b64encode(HMAC(b64decode(key), sign_key.encode('utf-8'), sha256).digest()) result = { 'sr': uri, 'sig': signature, 'se': str(ttl)} if policy: result['skn'] = policy return 'SharedAccessSignature ' + urlencode(result) def _build_iothub_amqp_endpoint_from_target(target): hub_name = target['hostname'].split('.')[0] username = "{}@sas.root.{}".format(target['key_name'], hub_name) sas_token = _generate_sas_token(target['hostname'], target['key_name'], target['access_key'], time() + 360) return username, sas_token async def _receive_mesages(conn, source, auth): receive_client = uamqp.ReceiveClientAsync(source, auth=auth, debug=False, timeout=1000, prefetch=1) try: await receive_client.open_async(connection=conn) batch = await receive_client.receive_message_batch_async(max_batch_size=1) except errors.LinkRedirect as redirect: return redirect else: return batch finally: await receive_client.close_async() @pytest.mark.asyncio async def test_iothub_client_receive_async(live_iothub_config): operation = '/messages/events/ConsumerGroups/{}/Partitions/'.format(live_iothub_config['consumer_group']) auth = authentication.SASLPlain( live_iothub_config['hostname'], *_build_iothub_amqp_endpoint_from_target(live_iothub_config)) source = 'amqps://' + live_iothub_config['hostname'] + operation log.info("Source: {}".format(source)) async with uamqp.ConnectionAsync(live_iothub_config['hostname'], auth, debug=False) as conn: tasks = [ _receive_mesages(conn, source + '0', auth), _receive_mesages(conn, source + '1', auth) ] results = await asyncio.gather(*tasks) redirect = results[0] new_auth = authentication.SASLPlain( redirect.hostname, live_iothub_config['key_name'], live_iothub_config['access_key']) await conn.redirect_async(redirect, new_auth) tasks = [] for t in results: tasks.append(_receive_mesages(conn, t.address, auth)) messages = await asyncio.gather(*tasks) if __name__ == '__main__': config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" loop = asyncio.get_event_loop() loop.run_until_complete(test_iothub_client_receive_async(config)) azure-uamqp-python-1.6.8/samples/asynctests/test_azure_iothub_send_async.py000066400000000000000000000061701455573770000275200ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import asyncio import pytest import sys from base64 import b64encode, b64decode from hashlib import sha256 from hmac import HMAC from time import time from uuid import uuid4 try: from urllib import quote, quote_plus, urlencode #Py2 except Exception: from urllib.parse import quote, quote_plus, urlencode import uamqp def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def _generate_sas_token(uri, policy, key, expiry=None): if not expiry: expiry = time() + 3600 # Default to 1 hour. encoded_uri = quote_plus(uri) ttl = int(expiry) sign_key = '%s\n%d' % (encoded_uri, ttl) signature = b64encode(HMAC(b64decode(key), sign_key.encode('utf-8'), sha256).digest()) result = { 'sr': uri, 'sig': signature, 'se': str(ttl)} if policy: result['skn'] = policy return 'SharedAccessSignature ' + urlencode(result) def _build_iothub_amqp_endpoint_from_target(target): hub_name = target['hostname'].split('.')[0] endpoint = "{}@sas.root.{}".format(target['key_name'], hub_name) endpoint = quote_plus(endpoint) sas_token = _generate_sas_token(target['hostname'], target['key_name'], target['access_key'], time() + 360) endpoint = endpoint + ":{}@{}".format(quote_plus(sas_token), target['hostname']) return endpoint @pytest.mark.asyncio async def test_iot_hub_send_async(live_iothub_config): msg_content = b"hello world" msg_props = uamqp.message.MessageProperties() msg_props.to = '/devices/{}/messages/devicebound'.format(live_iothub_config['device']) msg_props.message_id = str(uuid4()) message = uamqp.Message(msg_content, properties=msg_props) operation = '/messages/devicebound' endpoint = _build_iothub_amqp_endpoint_from_target(live_iothub_config) target = 'amqps://' + endpoint + operation log.info("Target: {}".format(target)) send_client = uamqp.SendClientAsync(target, debug=False) send_client.queue_message(message) results = await send_client.send_all_messages_async() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] if __name__ == '__main__': config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] loop = asyncio.get_event_loop() loop.run_until_complete(test_iot_hub_send_async(config))azure-uamqp-python-1.6.8/samples/asynctests/test_loop_param_async.py000066400000000000000000000050161455573770000261360ustar00rootroot00000000000000import sys import pytest import asyncio from uamqp.async_ops.mgmt_operation_async import MgmtOperationAsync from uamqp.async_ops.receiver_async import MessageReceiverAsync from uamqp.authentication.cbs_auth_async import CBSAsyncAuthMixin from uamqp.async_ops.sender_async import MessageSenderAsync from uamqp.async_ops.client_async import ( AMQPClientAsync, SendClientAsync, ReceiveClientAsync, ConnectionAsync, ) @pytest.mark.asyncio @pytest.mark.skipif(sys.version_info < (3, 10), reason="raise error if loop passed in >=3.10") async def test_error_loop_arg_async(): with pytest.raises(ValueError) as e: AMQPClientAsync("fake_addr", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e client_async = AMQPClientAsync("sb://resourcename.servicebus.windows.net/") assert len(client_async._internal_kwargs) == 0 # pylint:disable=protected-access with pytest.raises(ValueError) as e: SendClientAsync("fake_addr", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e client_async = SendClientAsync("sb://resourcename.servicebus.windows.net/") assert len(client_async._internal_kwargs) == 0 # pylint:disable=protected-access with pytest.raises(ValueError) as e: ReceiveClientAsync("fake_addr", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e client_async = ReceiveClientAsync("sb://resourcename.servicebus.windows.net/") assert len(client_async._internal_kwargs) == 0 # pylint:disable=protected-access with pytest.raises(ValueError) as e: ConnectionAsync("fake_addr", sasl='fake_sasl', loop=asyncio.get_event_loop()) assert "no longer supports loop" in e with pytest.raises(ValueError) as e: MgmtOperationAsync("fake_addr", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e with pytest.raises(ValueError) as e: MessageReceiverAsync("fake_addr", "session", "target", "on_message_received", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e with pytest.raises(ValueError) as e: MessageSenderAsync("fake_addr", "source", "target", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e async def auth_async_loop(): auth_async = CBSAsyncAuthMixin() with pytest.raises(ValueError) as e: await auth_async.create_authenticator_async("fake_conn", loop=asyncio.get_event_loop()) assert "no longer supports loop" in e await auth_async_loop() azure-uamqp-python-1.6.8/samples/conftest.py000066400000000000000000000041021455573770000211710ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import pytest import sys # Ignore async tests for Python < 3.5 collect_ignore = [] if sys.version_info < (3, 5): collect_ignore.append("asynctests") @pytest.fixture() def live_eventhub_config(): try: config = {} config['hostname'] = os.environ['EVENT_HUB_HOSTNAME'] config['event_hub'] = os.environ['EVENT_HUB_NAME'] config['key_name'] = os.environ['EVENT_HUB_SAS_POLICY'] config['access_key'] = os.environ['EVENT_HUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" except KeyError: pytest.skip("Live EventHub configuration not found.") else: if not all(config.values()): pytest.skip("Live EventHub configuration empty.") return config @pytest.fixture() def live_iothub_config(): try: config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['hub_name'] = os.environ['IOTHUB_HUB_NAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['endpoint'] = os.environ['IOTHUB_ENDPOINT'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" except KeyError: pytest.skip("Live IoTHub configuration not found.") else: if not all(config.values()): pytest.skip("Live IoTHub configuration empty.") return config @pytest.fixture() def rabbit_mq_config(): try: config = {} config['hostname'] = os.environ['RABBITMQ_HOSTNAME'] config['path'] = os.environ['RABBITMQ_PATH'] except KeyError: pytest.skip("Live RabbitMQ configuration not found.") else: return config azure-uamqp-python-1.6.8/samples/sample_uamqp_authenticate_client_by_jwt.py000066400000000000000000000031071455573770000275060ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #------------------------------------------------------------------------- """ Examples to show how to authenticate Client by jwt token. """ from collections import namedtuple from uamqp import authentication, SendClient, Message AccessToken = namedtuple("AccessToken", ["token", "expires_on"]) # Define get_token callback which shall be passed to the JWTTokenAuth for token generation def get_token(): token = "" # the token used for authentication. expires_on = 253402261199 # The timestamp at which the JWT token will expire formatted as seconds since epoch. return AccessToken(token, expires_on) def authenticate_client_by_jwt(): # Create the JWTTokenAuth object auth_uri = "" # The AMQP endpoint URI for authentication. token_audience = "" # The token audience field. auth = authentication.JWTTokenAuth( audience=token_audience, uri=auth_uri, get_token=get_token ) # Instantiate the SendClient with the JWTTokenAuth object target = "" # The target AMQP service endpoint. send_client = SendClient(target=target, auth=auth) # Send a message message = Message(b'data') send_client.send_message(message) send_client.close() if __name__ == "__main__": authenticate_client_by_jwt()azure-uamqp-python-1.6.8/samples/sample_uamqp_receive_simple.py000066400000000000000000000016221455573770000251070ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os try: from urlparse import urlparse except ImportError: from urllib.parse import urlparse import uamqp from uamqp import authentication uri = os.environ.get("AMQP_SERVICE_URI") key_name = os.environ.get("AMQP_SERVICE_KEY_NAME") access_key = os.environ.get("AMQP_SERVICE_ACCESS_KEY") def uamqp_receive_simple(): parsed_uri = urlparse(uri) plain_auth = authentication.SASLPlain(parsed_uri.hostname, key_name, access_key) message = uamqp.receive_message(uri, auth=plain_auth) print("Received: {}".format(message)) if __name__ == "__main__": uamqp_receive_simple() azure-uamqp-python-1.6.8/samples/sample_uamqp_send_simple.py000066400000000000000000000016361455573770000244230ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os try: from urlparse import urlparse except ImportError: from urllib.parse import urlparse import uamqp from uamqp import authentication uri = os.environ.get("AMQP_SERVICE_URI") key_name = os.environ.get("AMQP_SERVICE_KEY_NAME") access_key = os.environ.get("AMQP_SERVICE_ACCESS_KEY") def uamqp_send_simple(): msg_content = b"Hello world" parsed_uri = urlparse(uri) plain_auth = authentication.SASLPlain(parsed_uri.hostname, key_name, access_key) uamqp.send_message(uri, msg_content, auth=plain_auth) print("Message sent!") if __name__ == "__main__": uamqp_send_simple() azure-uamqp-python-1.6.8/samples/test_azure_event_hubs_mgmt_op.py000066400000000000000000000024331455573770000255020ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import sys import uamqp from uamqp import authentication def test_event_hubs_mgmt_op(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) with uamqp.AMQPClient(target, auth=sas_auth, debug=False) as send_client: mgmt_msg = uamqp.Message(application_properties={'name': live_eventhub_config['event_hub']}) response = send_client.mgmt_request( mgmt_msg, b'READ', op_type=b'com.microsoft:eventhub', status_code_field=b'status-code', description_fields=b'status-description') output = response.get_data() assert output[b'partition_ids'] == [b"0", b"1"] azure-uamqp-python-1.6.8/samples/test_azure_event_hubs_receive.py000066400000000000000000001001301455573770000254530ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import logging import os import pytest import sys import time try: from urllib import quote_plus #Py2 except Exception: from urllib.parse import quote_plus import uamqp from uamqp import address, types, utils, authentication, MessageBodyType from uamqp.message import DataBody, SequenceBody, ValueBody def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def get_plain_auth(config): return authentication.SASLPlain( config['hostname'], config['key_name'], config['access_key']) def send_single_message(live_eventhub_config, partition, msg_content): target = "amqps://{}/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], partition ) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) uamqp.send_message(target, msg_content, auth=sas_auth, debug=False) def send_multiple_message(live_eventhub_config, msg_count): def data_generator(): for i in range(msg_count): msg_content = "Hello world {}".format(i).encode('utf-8') yield msg_content uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['partition']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) message_batch = uamqp.message.BatchMessage(data_generator()) send_client.queue_message(message_batch) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] send_client.close() def test_event_hubs_simple_receive(live_eventhub_config): source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) msg_content = b"Hello world" target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) result = uamqp.send_message(target, msg_content, auth=get_plain_auth(live_eventhub_config)) message = uamqp.receive_message(source, auth=get_plain_auth(live_eventhub_config), timeout=10000) assert message log.info("Received: {}".format(message.get_data())) def test_event_hubs_simple_batch_receive(live_eventhub_config): source = "amqps://{}:{}@{}/{}/ConsumerGroups/{}/Partitions/{}".format( quote_plus(live_eventhub_config['key_name']), quote_plus(live_eventhub_config['access_key']), live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) messages = uamqp.receive_messages(source, max_batch_size=10) assert len(messages) <= 10 message = uamqp.receive_messages(source, max_batch_size=1) assert len(message) == 1 def test_event_hubs_single_batch_receive(live_eventhub_config): plain_auth = authentication.SASLPlain( live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) message = uamqp.receive_messages(source, auth=plain_auth, timeout=5000) assert len(message) <= 300 def test_event_hubs_client_web_socket(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key'], transport_type=uamqp.TransportType.AmqpOverWebsocket) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) with uamqp.ReceiveClient(source, auth=sas_auth, debug=False, timeout=5000, prefetch=50) as receive_client: receive_client.receive_message_batch(max_batch_size=10) def test_event_hubs_client_proxy_settings(live_eventhub_config): pytest.skip("skipping the test in CI due to no proxy server") proxy_settings={'proxy_hostname': '127.0.0.1', 'proxy_port': 12345} uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key'], http_proxy=proxy_settings) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) with uamqp.ReceiveClient(source, auth=sas_auth, debug=False, timeout=5000, prefetch=50) as receive_client: receive_client.receive_message_batch(max_batch_size=10) def test_event_hubs_client_receive_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) with uamqp.ReceiveClient(source, auth=sas_auth, debug=False, timeout=5000, prefetch=50) as receive_client: log.info("Created client, receiving...") with pytest.raises(ValueError): batch = receive_client.receive_message_batch(max_batch_size=100) batch = receive_client.receive_message_batch(max_batch_size=10) while batch: log.info("Got batch: {}".format(len(batch))) assert len(batch) <= 10 for message in batch: annotations = message.annotations log.info("Sequence Number: {}, Delivery tag: {}".format( annotations.get(b'x-opt-sequence-number'), message.delivery_tag)) batch = receive_client.receive_message_batch(max_batch_size=10) log.info("Finished receiving") def test_event_hubs_client_receive_no_shutdown_after_timeout_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source) source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'") received_cnt = 0 with uamqp.ReceiveClient(source, auth=sas_auth, timeout=2000, debug=False, shutdown_after_timeout=False) as receive_client: log.info("Created client, receiving...") received_cnt += len(receive_client.receive_message_batch(max_batch_size=10)) assert received_cnt == 0 message_handler_before = receive_client.message_handler send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') received_cnt += len(receive_client.receive_message_batch(max_batch_size=10)) assert received_cnt == 1 received_cnt += len(receive_client.receive_message_batch(max_batch_size=10)) assert received_cnt == 1 send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') received_cnt += len(receive_client.receive_message_batch(max_batch_size=10)) message_handler_after = receive_client.message_handler assert message_handler_before == message_handler_after assert received_cnt == 2 def test_event_hubs_client_receive_with_runtime_metric_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receiver_runtime_metric_symbol = b'com.microsoft:enable-receiver-runtime-metric' symbol_array = [types.AMQPSymbol(receiver_runtime_metric_symbol)] desired_capabilities = utils.data_factory(types.AMQPArray(symbol_array)) with uamqp.ReceiveClient(source, auth=sas_auth, debug=False, timeout=50, prefetch=50, desired_capabilities=desired_capabilities) as receive_client: log.info("Created client, receiving...") with pytest.raises(ValueError): batch = receive_client.receive_message_batch(max_batch_size=100) batch = receive_client.receive_message_batch(max_batch_size=10) log.info("Got batch: {}".format(len(batch))) assert len(batch) <= 10 for message in batch: annotations = message.annotations delivery_annotations = message.delivery_annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) assert b'last_enqueued_sequence_number' in delivery_annotations assert b'last_enqueued_offset' in delivery_annotations assert b'last_enqueued_time_utc' in delivery_annotations assert b'runtime_info_retrieval_time_utc' in delivery_annotations log.info("Finished receiving") def test_event_hubs_callback_receive_sync(live_eventhub_config): def on_message_received(message): annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) log.info(str(message)) message.accept() uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=1000, debug=False) log.info("Created client, receiving...") receive_client.receive_messages(on_message_received) log.info("Finished receiving") def test_event_hubs_callback_receive_no_shutdown_after_timeout_sync(live_eventhub_config): received_cnt = {'cnt': 0} def on_message_received(message): annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) log.info(str(message)) message.accept() received_cnt['cnt'] += 1 uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source) source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'") receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=2000, debug=False, shutdown_after_timeout=False) log.info("Created client, receiving...") try: receive_client.open() while not receive_client.client_ready(): time.sleep(0.05) time.sleep(1) receive_client._connection.work() assert not receive_client._was_message_received assert receive_client._received_messages.empty() send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') receive_client.receive_messages(on_message_received) message_handler_before = receive_client.message_handler assert received_cnt['cnt'] == 1 send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') receive_client.receive_messages(on_message_received) message_handler_after = receive_client.message_handler assert message_handler_before == message_handler_after assert received_cnt['cnt'] == 2 log.info("Finished receiving") finally: receive_client.close() def test_event_hubs_iter_receive_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=1000, debug=False, prefetch=10) count = 0 gen = receive_client.receive_messages_iter() for message in gen: log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) count += 1 if count >= 10: log.info("Got {} messages. Breaking.".format(count)) message.accept() break count = 0 for message in gen: count += 1 if count >= 10: log.info("Got {} more messages. Shutting down.".format(count)) message.accept() break receive_client.close() def test_event_hubs_iter_receive_no_shutdown_after_timeout_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source) source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'") receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=2000, debug=False, shutdown_after_timeout=False) count = 0 try: receive_client.open() while not receive_client.client_ready(): time.sleep(0.05) time.sleep(1) receive_client._connection.work() assert not receive_client._was_message_received assert receive_client._received_messages.empty() gen = receive_client.receive_messages_iter() send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') for message in gen: log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) count += 1 assert count == 1 count = 0 message_handler_before = receive_client.message_handler send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message') gen = receive_client.receive_messages_iter() for message in gen: log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) count += 1 assert count == 1 message_handler_after = receive_client.message_handler assert message_handler_before == message_handler_after finally: receive_client.close() def test_event_hubs_shared_connection(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group']) send_single_message(live_eventhub_config, "0", "Message") send_single_message(live_eventhub_config, "1", "Message") with uamqp.Connection(live_eventhub_config['hostname'], sas_auth, debug=False) as conn: partition_0 = uamqp.ReceiveClient(source + "0", debug=False, auth=sas_auth, timeout=3000, prefetch=10) partition_1 = uamqp.ReceiveClient(source + "1", debug=False, auth=sas_auth, timeout=3000, prefetch=10) partition_0.open(connection=conn) partition_1.open(connection=conn) try: messages_0 = partition_0.receive_message_batch(1) messages_1 = partition_1.receive_message_batch(1) assert len(messages_0) == 1 and len(messages_1) == 1 except: raise finally: partition_0.close() partition_1.close() def test_event_hubs_filter_receive(live_eventhub_config): plain_auth = authentication.SASLPlain( live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) source_url = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) source = address.Source(source_url) source.set_filter(b"amqp.annotation.x-opt-sequence-number > 1500") with uamqp.ReceiveClient(source, auth=plain_auth, timeout=5000, prefetch=50) as receive_client: log.info("Created client, receiving...") batch = receive_client.receive_message_batch(max_batch_size=10) while batch: for message in batch: annotations = message.annotations log.info("Partition Key: {}".format(annotations.get(b'x-opt-partition-key'))) log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) log.info("Offset: {}".format(annotations.get(b'x-opt-offset'))) log.info("Enqueued Time: {}".format(annotations.get(b'x-opt-enqueued-time'))) log.info("Message format: {}".format(message._message.message_format)) log.info("{}".format(list(message.get_data()))) batch = receive_client.receive_message_batch(max_batch_size=10) log.info("Finished receiving") def test_event_hubs_dynamic_issue_link_credit(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) msg_sent_cnt = 200 send_multiple_message(live_eventhub_config, msg_sent_cnt) def message_received_callback(message): message_received_callback.received_msg_cnt += 1 message_received_callback.received_msg_cnt = 0 with uamqp.ReceiveClient(source, auth=sas_auth, debug=True, prefetch=1) as receive_client: receive_client._message_received_callback = message_received_callback while not receive_client.client_ready(): time.sleep(0.05) time.sleep(1) receive_client._connection.work() assert not receive_client._was_message_received assert receive_client._received_messages.empty() receive_client.message_handler.reset_link_credit(msg_sent_cnt) now = start = time.time() wait_time = 5 while now - start <= wait_time: receive_client._connection.work() now = time.time() assert message_received_callback.received_msg_cnt == msg_sent_cnt log.info("Finished receiving") def test_event_hubs_send_event_with_amqp_attributes_sync(live_eventhub_config): def data_generator(): for i in range(2): msg = uamqp.message.Message(body='Data') # header is only used on received msg, not set on messages being sent msg.application_properties = {'msg_type': 'rich_batch'} msg.properties = uamqp.message.MessageProperties(message_id='richid', user_id=b'!@qwe\0?123') msg.footer = {'footerkey':'footervalue'} msg.delivery_annotations = {'deliveryannkey':'deliveryannvalue'} msg.annotations = {'annkey':'annvalue'} yield msg uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) message = uamqp.message.Message(body='Data') # header is only used on received msg, not set on messages being sent message.application_properties = {'msg_type': 'rich_single'} message.properties = uamqp.message.MessageProperties(message_id='richid') message.footer = {'footerkey':'footervalue'} message.delivery_annotations = {'deliveryannkey':'deliveryannvalue'} message.annotations = {'annkey':'annvalue'} send_client.queue_message(message) message_batch = uamqp.message.BatchMessage(data_generator()) send_client.queue_message(message_batch) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] rich_single_received = rich_batch_received = False uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], 0) receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=5000, debug=False, prefetch=10) gen = receive_client.receive_messages_iter() for message in gen: if message.application_properties and message.application_properties.get(b'msg_type'): if not rich_single_received: rich_single_received = message.application_properties.get(b'msg_type') == b'rich_single' if not rich_batch_received: rich_batch_received = message.application_properties.get(b'msg_type') == b'rich_batch' if message.application_properties.get(b'msg_type') == b'rich_single': assert message.properties.user_id is None elif message.application_properties.get(b'msg_type') == b'rich_batch': assert message.properties.user_id == b'!@qwe\0?123' assert message.properties.message_id == b'richid' assert message.delivery_annotations assert message.delivery_annotations.get(b'deliveryannkey') == b'deliveryannvalue' assert message.footer assert message.footer.get(b'footerkey') == b'footervalue' assert message.annotations assert message.annotations.get(b'annkey') == b'annvalue' log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) send_client.close() receive_client.close() assert rich_single_received assert rich_batch_received def test_event_hubs_not_receive_events_during_connection_establishment(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], live_eventhub_config['partition']) receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=1000, debug=False, prefetch=10) try: receive_client.open() while not receive_client.client_ready(): time.sleep(0.05) time.sleep(1) # sleep for 1s receive_client._connection.work() # do a single connection iteration to see if there're incoming transfers # make sure no messages are received assert not receive_client._was_message_received assert receive_client._received_messages.empty() messages_0 = receive_client.receive_message_batch() assert len(messages_0) > 0 finally: receive_client.close() def event_hubs_send_different_amqp_body_type_sync(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) data_body_1 = [b'data1', b'data2'] data_body_message_1 = uamqp.message.Message(body=data_body_1) data_body_message_1.application_properties = {'body_type': 'data_body_1'} send_client.queue_message(data_body_message_1) data_body_2 = b'data1' data_body_message_2 = uamqp.message.Message(body=data_body_2, body_type=MessageBodyType.Data) data_body_message_2.application_properties = {'body_type': 'data_body_2'} send_client.queue_message(data_body_message_2) value_body_1 = [b'data1', -1.23, True, {b'key': b'value'}, [1, False, 1.23, b'4']] value_body_message_1 = uamqp.message.Message(body=value_body_1) value_body_message_1.application_properties = {'body_type': 'value_body_1'} send_client.queue_message(value_body_message_1) value_body_2 = {b'key1': {b'sub_key': b'sub_value'}, b'key2': b'value', 3: -1.23} value_body_message_2 = uamqp.message.Message(body=value_body_2, body_type=MessageBodyType.Value) value_body_message_2.application_properties = {'body_type': 'value_body_2'} send_client.queue_message(value_body_message_2) sequence_body_1 = [b'data1', -1.23, True, {b'key': b'value'}, [b'a', 1.23, True]] sequence_body_message_1 = uamqp.message.Message(body=sequence_body_1, body_type=MessageBodyType.Sequence) sequence_body_message_1.application_properties = {'body_type': 'sequence_body_1'} send_client.queue_message(sequence_body_message_1) sequence_body_2 = [[1, 2, 3], [b'aa', b'bb', b'cc'], [True, False, True], [{b'key1': b'value'}, {b'key2': 123}]] sequence_body_message_2 = uamqp.message.Message(body=sequence_body_2, body_type=MessageBodyType.Sequence) sequence_body_message_2.application_properties = {'body_type': 'sequence_body_2'} send_client.queue_message(sequence_body_message_2) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format( live_eventhub_config['hostname'], live_eventhub_config['event_hub'], live_eventhub_config['consumer_group'], 0) result_dic = {} receive_client = uamqp.ReceiveClient(source, auth=sas_auth, timeout=5000, debug=False, prefetch=10) gen = receive_client.receive_messages_iter() for message in gen: if message.application_properties and message.application_properties.get(b'body_type'): if message.application_properties.get(b'body_type') == b'data_body_1': check_list = [data for data in message.get_data()] assert isinstance(message._body, DataBody) assert check_list == data_body_1 result_dic['data_body_1'] = 1 elif message.application_properties.get(b'body_type') == b'data_body_2': check_list = [data for data in message.get_data()] assert isinstance(message._body, DataBody) assert check_list == [data_body_2] result_dic['data_body_2'] = 1 elif message.application_properties.get(b'body_type') == b'value_body_1': assert message.get_data() == value_body_1 assert isinstance(message._body, ValueBody) result_dic['value_body_1'] = 1 elif message.application_properties.get(b'body_type') == b'value_body_2': assert message.get_data() == value_body_2 assert isinstance(message._body, ValueBody) result_dic['value_body_2'] = 1 elif message.application_properties.get(b'body_type') == b'sequence_body_1': check_list = [data for data in message.get_data()] assert check_list == [sequence_body_1] assert isinstance(message._body, SequenceBody) result_dic['sequence_body_1'] = 1 elif message.application_properties.get(b'body_type') == b'sequence_body_2': check_list = [data for data in message.get_data()] assert check_list == sequence_body_2 assert isinstance(message._body, SequenceBody) result_dic['sequence_body_2'] = 1 log.info(message.annotations.get(b'x-opt-sequence-number')) log.info(str(message)) send_client.close() receive_client.close() assert len(result_dic) == 6 if __name__ == '__main__': config = {} config['hostname'] = os.environ['EVENT_HUB_HOSTNAME'] config['event_hub'] = os.environ['EVENT_HUB_NAME'] config['key_name'] = os.environ['EVENT_HUB_SAS_POLICY'] config['access_key'] = os.environ['EVENT_HUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" event_hubs_send_different_amqp_body_type_sync(config) azure-uamqp-python-1.6.8/samples/test_azure_event_hubs_send.py000066400000000000000000000341561455573770000250000ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import sys import time from datetime import timedelta import types import pytest import collections import uamqp from uamqp import types as uamqp_types, utils, authentication, constants _AccessToken = collections.namedtuple("AccessToken", "token expires_on") def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def test_event_hubs_simple_send(live_eventhub_config): msg_content = b"Hello world" uri = "sb://{}/{}".format(live_eventhub_config['hostname'],live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) result = uamqp.send_message(target, msg_content, auth=sas_auth, debug=False) assert result == [uamqp.constants.MessageState.SendComplete] def test_event_hubs_client_send_sync(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) for _ in range(10): header = uamqp.message.MessageHeader() header.durable = True assert header.get_header_obj() props = uamqp.message.MessageProperties(message_id=b"message id", subject="test_subject") assert props.get_properties_obj() msg_content = b"hello world" message = uamqp.Message( msg_content, properties=props, header=header, application_properties=annotations, annotations=annotations) assert message.get_message_encoded_size() == 151 assert message.encode_message() == b'\x00Sp\xc0\x06\x05A@@@C\x00Sr\xc1(\x02\xa1\x13x-opt-partition-key\xa1\x10PartitionKeyInfo\x00Ss\xc0\x1d\x04\xa1\nmessage id@@\xa1\x0ctest_subject\x00St\xc1(\x02\xa1\x13x-opt-partition-key\xa1\x10PartitionKeyInfo\x00Su\xa0\x0bhello world' send_client.queue_message(message) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] send_client.close() def test_event_hubs_client_send_multiple_sync(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) assert not sas_auth.consumed target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) messages = [] for _ in range(10): header = uamqp.message.MessageHeader() header.durable = True header.delivery_count = 5 header.time_to_live = 500000 header.first_acquirer = True header.priority = 3 assert header.get_header_obj() props = uamqp.message.MessageProperties( message_id=b"message id", user_id="user_id", to="to", subject="test", reply_to="reply_to", correlation_id="correlation_id", content_type="content_type", content_encoding="content_encoding", creation_time=12345, absolute_expiry_time=12345, group_id="group_id", group_sequence=1234, reply_to_group_id="reply_to_group_id") assert props.get_properties_obj() msg_content = b"hello world" message = uamqp.Message( msg_content, properties=props, header=header, application_properties=annotations, annotations=annotations) messages.append(message) send_client.queue_message(*messages) assert len(send_client.pending_messages) == 10 results = send_client.send_all_messages() assert len(results) == 10 assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] assert sas_auth.consumed assert send_client.pending_messages == [] def test_event_hubs_single_send_sync(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} msg_content = b"hello world" uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) for _ in range(10): message = uamqp.Message(msg_content, application_properties=annotations, annotations=annotations) send_client.send_message(message) send_client.close() def test_event_hubs_batch_send_sync(live_eventhub_config): def data_generator(): for i in range(50): msg_content = "Hello world {}".format(i).encode('utf-8') yield msg_content uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) for _ in range(10): message_batch = uamqp.message.BatchMessage(data_generator()) send_client.queue_message(message_batch) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] send_client.close() def test_event_hubs_send_timeout_sync(live_eventhub_config): def _hack_client_run(cls): """MessageSender Link is now open - perform message send on all pending messages. Will return True if operation successful and client can remain open for further work. :rtype: bool """ # pylint: disable=protected-access time.sleep(6) cls.message_handler.work() cls._waiting_messages = 0 cls._pending_messages = cls._filter_pending() if cls._backoff and not cls._waiting_messages: log.info("Client told to backoff - sleeping for %r seconds", cls._backoff) cls._connection.sleep(cls._backoff) cls._backoff = 0 cls._connection.work() return True uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False, msg_timeout=5000) send_client._client_run = types.MethodType(_hack_client_run, send_client) send_client.open() with pytest.raises(uamqp.errors.ClientMessageError): send_client.send_message(uamqp.message.Message(body='Hello World')) send_client.close() def test_event_hubs_custom_end_point(): sas_token = authentication.SASTokenAuth("fake_audience", "fake_uri", "fake_token", expires_in=timedelta(10), custom_endpoint_hostname="123.45.67.89") assert sas_token.hostname == b"123.45.67.89" sas_token = authentication.SASTokenAuth.from_shared_access_key("fake_uri", "fake_key_name", "fake_key", custom_endpoint_hostname="123.45.67.89") assert sas_token.hostname == b"123.45.67.89" def fake_get_token(): return "fake get token" jwt_token = authentication.JWTTokenAuth("fake_audience", "fake_uri", fake_get_token, custom_endpoint_hostname="123.45.67.89") assert jwt_token.hostname == b"123.45.67.89" def test_event_hubs_idempotent_producer(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) symbol_array = [uamqp_types.AMQPSymbol(b"com.microsoft:idempotent-producer")] desired_capabilities = utils.data_factory(uamqp_types.AMQPArray(symbol_array)) link_properties = { uamqp_types.AMQPSymbol(b"com.microsoft:timeout"): uamqp_types.AMQPLong(int(60 * 1000)) } def on_attach(attach_source, attach_target, properties, error): if str(attach_target) == target: on_attach.owner_level = properties.get(b"com.microsoft:producer-epoch") on_attach.producer_group_id = properties.get(b"com.microsoft:producer-id") on_attach.starting_sequence_number = properties.get(b"com.microsoft:producer-sequence-number") send_client = uamqp.SendClient( target, auth=sas_auth, desired_capabilities=desired_capabilities, link_properties=link_properties, on_attach=on_attach, debug=True ) send_client.open() while not send_client.client_ready(): time.sleep(0.05) assert on_attach.owner_level is not None assert on_attach.producer_group_id is not None assert on_attach.starting_sequence_number is not None send_client.close() def test_event_hubs_send_large_message_after_socket_lost(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=True) try: send_client.open() while not send_client.client_ready(): send_client.do_work() # the connection idle timeout setting on the EH service is 240s, after 240s no activity # on the connection, the service would send detach to the client, the underlying socket on the client # is still able to work to receive the frame. # HOWEVER, after no activity on the client socket > 300s, the underlying socket would get completely lost: # the socket reports "Failure: sending socket failed 10054" on windows # or "Failure: sending socket failed. errno=104" on linux which indicates the socket is lost time.sleep(350) with pytest.raises(uamqp.errors.AMQPConnectionError): send_client.send_message(uamqp.message.Message(b't'*1024*700)) finally: send_client.close() def test_event_hubs_send_override_token_refresh_window(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) target = "amqps://{}/{}/Partitions/0".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) token = [None] def get_token(): return _AccessToken(token[0], expiry) jwt_auth = authentication.JWTTokenAuth( uri, uri, get_token, refresh_window=300 # set refresh window to be 5 mins ) send_client = uamqp.SendClient(target, auth=jwt_auth, debug=False) # use token of which the valid remaining time < refresh window expiry = int(time.time()) + (60 * 4 + 30) # 4.5 minutes token[0] = utils.create_sas_token( live_eventhub_config['key_name'].encode(), live_eventhub_config['access_key'].encode(), uri.encode(), expiry=timedelta(minutes=4, seconds=30) ) for _ in range(3): message = uamqp.message.Message(body='Hello World') send_client.send_message(message) auth_status = constants.CBSAuthStatus(jwt_auth._cbs_auth.get_status()) assert auth_status == constants.CBSAuthStatus.RefreshRequired # update token, the valid remaining time > refresh window expiry = int(time.time()) + (60 * 5 + 30) # 5.5 minutes token[0] = utils.create_sas_token( live_eventhub_config['key_name'].encode(), live_eventhub_config['access_key'].encode(), uri.encode(), expiry=timedelta(minutes=5, seconds=30) ) for _ in range(3): message = uamqp.message.Message(body='Hello World') send_client.send_message(message) auth_status = constants.CBSAuthStatus(jwt_auth._cbs_auth.get_status()) assert auth_status == constants.CBSAuthStatus.Ok send_client.close() if __name__ == '__main__': config = {} config['hostname'] = os.environ['EVENT_HUB_HOSTNAME'] config['event_hub'] = os.environ['EVENT_HUB_NAME'] config['key_name'] = os.environ['EVENT_HUB_SAS_POLICY'] config['access_key'] = os.environ['EVENT_HUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" test_event_hubs_send_override_token_refresh_window(config) azure-uamqp-python-1.6.8/samples/test_azure_iothub_receive.py000066400000000000000000000117111455573770000246110ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import sys from base64 import b64encode, b64decode from hashlib import sha256 from hmac import HMAC from time import time try: from urllib import quote, quote_plus, urlencode #Py2 except Exception: from urllib.parse import quote, quote_plus, urlencode import uamqp from uamqp import utils, errors from uamqp import authentication ### IotHub CLI Extension SAS token implementation class SasTokenAuthentication(): """ Shared Access Signature authorization for Azure IoT Hub. Args: uri (str): Uri of target resource. shared_access_policy_name (str): Name of shared access policy. shared_access_key (str): Shared access key. expiry (int): Expiry of the token to be generated. Input should be seconds since the epoch, in UTC. Default is an hour later from now. """ def __init__(self, uri, shared_access_policy_name, shared_access_key, expiry=None): self.uri = uri self.policy = shared_access_policy_name self.key = shared_access_key if expiry is None: self.expiry = time() + 3600 # Default expiry is an hour later else: self.expiry = expiry def generate_sas_token(self): """ Create a shared access signiture token as a string literal. Returns: result (str): SAS token as string literal. """ encoded_uri = quote_plus(self.uri) ttl = int(self.expiry) sign_key = '%s\n%d' % (encoded_uri, ttl) signature = b64encode(HMAC(b64decode(self.key), sign_key.encode('utf-8'), sha256).digest()) result = { 'sr': self.uri, 'sig': signature, 'se': str(ttl) } if self.policy: result['skn'] = self.policy return 'SharedAccessSignature ' + urlencode(result) def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def _build_iothub_amqp_endpoint_from_target(target): hub_name = target['hostname'].split('.')[0] endpoint = "{}@sas.root.{}".format(target['key_name'], hub_name) endpoint = quote_plus(endpoint) sas_token = SasTokenAuthentication(target['hostname'], target['key_name'], target['access_key'], time() + 360).generate_sas_token() endpoint = endpoint + ":{}@{}".format(quote_plus(sas_token), target['hostname']) return endpoint def _receive_message(receive_client, target): try: batch = receive_client.receive_message_batch(max_batch_size=10) except errors.LinkRedirect as redirect: new_auth = authentication.SASLPlain(redirect.hostname, target['key_name'], target['access_key']) #new_auth = authentication.SASTokenAuth.from_shared_access_key(redirect.address.decode('utf-8'), target['key_name'], target['access_key']) receive_client.redirect(redirect, new_auth) batch = receive_client.receive_message_batch(max_batch_size=10) while batch: log.info("Got batch: {}".format(len(batch))) assert len(batch) <= 10 for message in batch: annotations = message.annotations log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number'))) batch = receive_client.receive_message_batch(max_batch_size=10) def test_iothub_client_receive_sync(live_iothub_config): operation = '/messages/events/ConsumerGroups/{}/Partitions/{}'.format( live_iothub_config['consumer_group'], live_iothub_config['partition']) endpoint = _build_iothub_amqp_endpoint_from_target(live_iothub_config) source = 'amqps://' + endpoint + operation log.info("Source: {}".format(source)) receive_client = uamqp.ReceiveClient(source, debug=False, timeout=5000, prefetch=50) try: log.info("Created client, receiving...") _receive_message(receive_client, live_iothub_config) except Exception as e: print(e) raise finally: receive_client.close() log.info("Finished receiving") if __name__ == '__main__': config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" test_iothub_client_receive_sync(config) azure-uamqp-python-1.6.8/samples/test_azure_iothub_receive2.py000066400000000000000000000070771455573770000247050ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import sys from base64 import b64encode, b64decode from hashlib import sha256 from hmac import HMAC from time import time try: from urllib import quote, quote_plus, urlencode #Py2 except Exception: from urllib.parse import quote, quote_plus, urlencode import uamqp from uamqp import utils, errors from uamqp import authentication def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def _generate_sas_token(uri, policy, key, expiry=None): if not expiry: expiry = time() + 3600 # Default to 1 hour. encoded_uri = quote_plus(uri) ttl = int(expiry) sign_key = '%s\n%d' % (encoded_uri, ttl) signature = b64encode(HMAC(b64decode(key), sign_key.encode('utf-8'), sha256).digest()) result = { 'sr': uri, 'sig': signature, 'se': str(ttl)} if policy: result['skn'] = policy return 'SharedAccessSignature ' + urlencode(result) def _build_iothub_amqp_endpoint_from_target(target): hub_name = target['hostname'].split('.')[0] username = "{}@sas.root.{}".format(target['key_name'], hub_name) sas_token = _generate_sas_token(target['hostname'], target['key_name'], target['access_key'], time() + 360) return username, sas_token def _receive_message(conn, source, auth): batch = [] receive_client = uamqp.ReceiveClient(source, auth=auth, debug=False, timeout=5000, prefetch=50) try: receive_client.open(connection=conn) batch = receive_client.receive_message_batch(max_batch_size=10) except errors.LinkRedirect as redirect: return redirect finally: receive_client.close() return batch def test_iothub_client_receive_sync(live_iothub_config): operation = '/messages/events/ConsumerGroups/{}/Partitions/{}'.format( live_iothub_config['consumer_group'], live_iothub_config['partition']) auth = authentication.SASLPlain( live_iothub_config['hostname'], *_build_iothub_amqp_endpoint_from_target(live_iothub_config)) source = 'amqps://' + live_iothub_config['hostname'] + operation log.info("Source: {}".format(source)) with uamqp.Connection(live_iothub_config['hostname'], auth, debug=False) as conn: result = _receive_message(conn, source, auth) new_auth = authentication.SASLPlain( result.hostname, live_iothub_config['key_name'], live_iothub_config['access_key']) conn.redirect(result, new_auth) result = _receive_message(conn, result.address, new_auth) log.info("Finished receiving") if __name__ == '__main__': config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] config['consumer_group'] = "$Default" config['partition'] = "0" test_iothub_client_receive_sync(config) azure-uamqp-python-1.6.8/samples/test_azure_iothub_send.py000066400000000000000000000062171455573770000241250ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import sys from base64 import b64encode, b64decode from hashlib import sha256 from hmac import HMAC from time import time from uuid import uuid4 try: from urllib import quote, quote_plus, urlencode #Py2 except Exception: from urllib.parse import quote, quote_plus, urlencode import uamqp from uamqp import utils, errors def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def _generate_sas_token(uri, policy, key, expiry=None): if not expiry: expiry = time() + 3600 # Default to 1 hour. encoded_uri = quote_plus(uri) ttl = int(expiry) sign_key = '%s\n%d' % (encoded_uri, ttl) signature = b64encode(HMAC(b64decode(key), sign_key.encode('utf-8'), sha256).digest()) result = { 'sr': uri, 'sig': signature, 'se': str(ttl)} if policy: result['skn'] = policy return 'SharedAccessSignature ' + urlencode(result) def _build_iothub_amqp_endpoint_from_target(target): hub_name = target['hostname'].split('.')[0] endpoint = "{}@sas.root.{}".format(target['key_name'], hub_name) endpoint = quote_plus(endpoint) sas_token = _generate_sas_token(target['hostname'], target['key_name'], target['access_key'], time() + 360) endpoint = endpoint + ":{}@{}".format(quote_plus(sas_token), target['hostname']) return endpoint def test_iot_hub_send(live_iothub_config): msg_content = b"hello world" app_properties = {"test_prop_1": "value", "test_prop_2": "X"} msg_props = uamqp.message.MessageProperties() msg_props.to = '/devices/{}/messages/devicebound'.format(live_iothub_config['device']) msg_props.message_id = str(uuid4()) message = uamqp.Message(msg_content, properties=msg_props, application_properties=app_properties) operation = '/messages/devicebound' endpoint = _build_iothub_amqp_endpoint_from_target(live_iothub_config) target = 'amqps://' + endpoint + operation log.info("Target: {}".format(target)) send_client = uamqp.SendClient(target, debug=False) send_client.queue_message(message) results = send_client.send_all_messages() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] log.info("Message sent.") if __name__ == '__main__': config = {} config['hostname'] = os.environ['IOTHUB_HOSTNAME'] config['device'] = os.environ['IOTHUB_DEVICE'] config['key_name'] = os.environ['IOTHUB_SAS_POLICY'] config['access_key'] = os.environ['IOTHUB_SAS_KEY'] test_iot_hub_send(config) azure-uamqp-python-1.6.8/samples/test_rabbitmq_send.py000066400000000000000000000032031455573770000232160ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import logging import sys import datetime import uuid import pytest import uamqp from uamqp import authentication def get_logger(level): uamqp_logger = logging.getLogger("uamqp") if not uamqp_logger.handlers: handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) uamqp_logger.addHandler(handler) uamqp_logger.setLevel(level) return uamqp_logger log = get_logger(logging.INFO) def test_rabbitmq_client_send_sync(rabbit_mq_config): pytest.skip("Not working yet") uri = "amqp://{}/{}/".format(rabbit_mq_config['hostname'], rabbit_mq_config['path']) sas_auth = uamqp.authentication.SASLAnonymous(hostname=rabbit_mq_config['hostname'], port=5672) send_client = uamqp.SendClient(uri, auth=sas_auth, debug=False) try: message = uamqp.Message("content") send_client.queue_message(message) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] finally: send_client.close() if __name__ == '__main__': config = {} config['hostname'] = os.environ['RABBITMQ_HOSTNAME'] config['path'] = os.environ['RABBITMQ_PATH'] test_rabbitmq_client_send_sync(config) azure-uamqp-python-1.6.8/setup.py000066400000000000000000000231021455573770000170410ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import os import sys import re import distutils import subprocess import platform from setuptools import find_packages, monkey, setup, Extension from setuptools.command.build_ext import build_ext as build_ext_orig from distutils.extension import Extension from distutils.version import LooseVersion from distutils import log as logger try: from Cython.Build import cythonize USE_CYTHON = True except ImportError: USE_CYTHON = False # If the C file doesn't exist and no Cython is available, die if not os.path.exists("uamqp/c_uamqp.c") and not USE_CYTHON: raise ValueError("You need to install cython==0.29.21 in order to execute this setup.py if 'uamqp/c_uamqp.c' does not exists") is_x64 = platform.architecture()[0] == '64bit' is_win = sys.platform.startswith('win') is_mac = sys.platform.startswith('darwin') rebuild_pyx = os.environ.get('UAMQP_REBUILD_PYX', False) use_openssl = not (is_win or is_mac) # use_openssl = os.environ.get('UAMQP_USE_OPENSSL', not (is_win or is_mac)) supress_link_flags = os.environ.get("UAMQP_SUPPRESS_LINK_FLAGS", False) # Version extraction inspired from 'requests' with open(os.path.join('uamqp', '__init__.py'), 'r') as fd: version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1) cwd = os.path.abspath('.') # Headers # Do not use an absolute path in include_dirs, otherwise the build # will vary depending on the build path pxd_inc_dir = os.path.join(".", "src", "vendor", "inc") sys.path.insert(0, os.path.join(cwd, pxd_inc_dir)) latest_windows_sdk_shared_include_path = None include_dirs = [ pxd_inc_dir, # azure-macro-utils inc "./src/vendor/azure-uamqp-c/deps/azure-macro-utils-c/inc", # umock-c inc "./src/vendor/azure-uamqp-c/deps/umock-c/inc", # azure-c-shared-utility inc "./src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/pal/inc", "./src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/inc", # azure-uamqp-c inc "./src/vendor/azure-uamqp-c/inc", ] if is_win: include_dirs.append("./src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/pal/windows") else: include_dirs.append("./src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/pal/linux") # Build unique source pyx def create_cython_file(): content_includes = "" # Sort the pyx files otherwise the build will vary # depending on the filesystem for f in sorted(os.listdir("./src")): if f.endswith(".pyx"): print("Adding {}".format(f)) content_includes += "include \"src/" + f + "\"\n" c_uamqp_src = os.path.join("uamqp", "c_uamqp.pyx") with open(c_uamqp_src, 'w') as lib_file: lib_file.write(content_includes) return c_uamqp_src def get_build_env(): build_env = os.environ.copy() return {k.upper(): v for k, v in build_env.items()} def get_generator_flags(): flags = ["-G"] if is_win: flags.append("\"Visual Studio 17 2022\"") flags.append("-A") flags.append("ARM64" if platform.machine() == "ARM64" else "x64" if is_x64 else "Win32") else: flags.append("\"Unix Makefiles\"") return " ".join(flags) def get_msvc_env(vc_ver): arch = "amd64" if is_x64 else "x86" msvc_env = distutils.msvc9compiler.query_vcvarsall(vc_ver, arch) return {str(k.upper()): str(v) for k, v in msvc_env.items()} # Compile uamqp # Inspired by https://stackoverflow.com/a/48015772/4074838 class UAMQPExtension(Extension): def __init__(self, name): # don't invoke the original build_ext for this special extension Extension.__init__(self, name, sources=[]) def create_folder_no_exception(foldername): try: os.makedirs(foldername) except Exception: # Assume it's already there, and not impossible to create pass class build_ext(build_ext_orig): def run(self): monkey.patch_all() cmake_build_dir = None for ext in self.extensions: if isinstance(ext, UAMQPExtension): self.build_cmake(ext) # Now I have built in ext.cmake_build_dir cmake_build_dir = self.cmake_build_dir else: ext.library_dirs += [ cmake_build_dir, cmake_build_dir + "/deps/azure-c-shared-utility/", cmake_build_dir + "/Debug/", cmake_build_dir + "/Release/", cmake_build_dir + "/deps/azure-c-shared-utility/Debug/", cmake_build_dir + "/deps/azure-c-shared-utility/Release/" ] build_ext_orig.run(self) def build_cmake(self, ext): cwd = os.getcwd() # these dirs will be created in build_py, so if you don't have # any python sources to bundle, the dirs will be missing self.cmake_build_dir = self.build_temp + "/cmake" create_folder_no_exception(self.cmake_build_dir) extdir = self.get_ext_fullpath(ext.name) create_folder_no_exception(extdir) logger.info("will build uamqp in %s", self.cmake_build_dir) os.chdir(cwd + "/" + self.cmake_build_dir) generator_flags = get_generator_flags() logger.info("Building with generator flags: {}".format(generator_flags)) build_env = get_build_env() # Configure configure_command = [ "cmake", cwd + "/src/vendor/azure-uamqp-c/", generator_flags, "-Duse_openssl:bool={}".format("ON" if use_openssl else "OFF"), "-Duse_default_uuid:bool=ON ", # Should we use libuuid in the system or light one? "-Duse_builtin_httpapi:bool=ON ", # Should we use libcurl in the system or light one? "-Dskip_samples:bool=ON", # Don't compile uAMQP samples binaries "-DCMAKE_POSITION_INDEPENDENT_CODE=TRUE", # ask for -fPIC "-DCMAKE_BUILD_TYPE=Release" ] joined_cmd = " ".join(configure_command) logger.info("calling %s", joined_cmd) subprocess.check_call(joined_cmd, shell=True, universal_newlines=True, env=build_env) compile_command = ["cmake", "--build", ".", "--config", "Release"] joined_cmd = " ".join(compile_command) logger.info("calling %s", joined_cmd) subprocess.check_call(joined_cmd, shell=True, universal_newlines=True, env=build_env) os.chdir(cwd) if USE_CYTHON: create_cython_file() # Libraries and extra compile args kwargs = {} if is_win: kwargs['libraries'] = [ 'uamqp', 'aziotsharedutil', 'AdvAPI32', 'Crypt32', 'ncrypt', 'Secur32', 'schannel', 'RpcRT4', 'WSock32', 'WS2_32'] elif is_mac: kwargs['extra_compile_args'] = ['-g', '-O0', "-std=gnu99", "-fPIC"] kwargs['libraries'] = ['uamqp', 'aziotsharedutil'] if use_openssl and not supress_link_flags: kwargs['libraries'].extend(['azssl', 'azcrypto']) elif not use_openssl: kwargs['extra_link_args'] = [ '-framework', 'CoreFoundation', '-framework', 'CFNetwork', '-framework', 'Security'] else: kwargs['extra_compile_args'] = ['-g', '-O0', "-std=gnu99", "-fPIC"] # SSL before crypto matters: https://bugreports.qt.io/browse/QTBUG-62692 kwargs['libraries'] = ['uamqp', 'aziotsharedutil'] if sys.version_info < (3, 5): kwargs['libraries'].append('rt') if not supress_link_flags: kwargs['libraries'].extend(['ssl', 'crypto']) # If the C file doesn't exist, build the "c_uamqp.c" file # That's not perfect, since we build it on a "--help", but should be if cloned from source only. c_uamqp_src = "uamqp/c_uamqp.c" if not os.path.exists(c_uamqp_src) or rebuild_pyx: c_uamqp_src = create_cython_file() sources = [ c_uamqp_src ] # Configure the extension extensions = [ UAMQPExtension("cmake_uamqp"), Extension( "uamqp.c_uamqp", sources=sources, include_dirs=include_dirs, **kwargs ) ] with open('README.rst') as f: # , encoding='utf-8' readme = f.read() with open('HISTORY.rst') as f: # , encoding='utf-8' history = f.read() if USE_CYTHON: extensions = cythonize(extensions) setup( name='uamqp', version=version, description='AMQP 1.0 Client Library for Python', long_description=readme + '\n\n' + history, license='MIT License', author='Microsoft Corporation', author_email='azpysdkhelp@microsoft.com', url='https://github.com/Azure/azure-uamqp-python', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Programming Language :: Cython', 'Programming Language :: Python', 'Programming Language :: Python :: 3 :: Only', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'License :: OSI Approved :: MIT License' ], zip_safe=False, include_package_data=True, packages=find_packages(exclude=["tests"]), ext_modules=extensions, install_requires=[ "certifi>=2017.4.17", ], cmdclass={ 'build_ext': build_ext, }, python_requires=">=3.7", ) azure-uamqp-python-1.6.8/src/000077500000000000000000000000001455573770000161205ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/amqp_definitions.pyx000066400000000000000000000022431455573770000222140ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports from libc cimport stdint cimport c_amqpvalue cimport c_amqp_definitions cimport c_utils _logger = logging.getLogger(__name__) cpdef create_data(char* binary_data): cdef c_amqpvalue.AMQP_VALUE body_data cdef c_amqpvalue.amqp_binary _binary length = len(binary_data) _binary.length = length _binary.bytes = binary_data body_data = c_amqp_definitions.amqpvalue_create_data(_binary) if body_data == NULL: raise ValueError("Unable to create payload data") return value_factory(body_data) cpdef create_sequence(AMQPValue sequence_data): body_data = c_amqp_definitions.amqpvalue_create_amqp_sequence(sequence_data._c_value) if body_data == NULL: raise ValueError("Unable to create payload data") return value_factory(body_data) azure-uamqp-python-1.6.8/src/amqp_management.pyx000066400000000000000000000120601455573770000220130ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_amqp_management cimport c_message _logger = logging.getLogger(__name__) cpdef create_management_operation(cSession session, const char* management_node): mgr_op = cManagementOperation() mgr_op.create(session, management_node) return mgr_op cdef class cManagementOperation(StructBase): cdef c_amqp_management.AMQP_MANAGEMENT_HANDLE _c_value cdef _session def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cManagementOperation") self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cManagementOperation") c_amqp_management.amqp_management_destroy(self._c_value) self._c_value = NULL self._session = None cdef wrap(self, cManagementOperation value): self.destroy() self._session = value._session self._c_value = value._c_value self._validate() cdef create(self, cSession session, const char* management_node): self.destroy() self._session = session self._c_value = c_amqp_management.amqp_management_create(session._c_value, management_node) self._validate() cpdef set_trace(self, bint value): c_amqp_management.amqp_management_set_trace(self._c_value, value) cpdef set_response_field_names(self, const char* status_code, const char* status_description): if c_amqp_management.amqp_management_set_override_status_code_key_name(self._c_value, status_code) != 0: self._value_error("Failed to set status code field name.") if c_amqp_management.amqp_management_set_override_status_description_key_name(self._c_value, status_description) != 0: self._value_error("Failed to set status description field name.") cpdef open(self, callback_context): cdef void *context if callback_context is None: context = NULL else: context = callback_context if c_amqp_management.amqp_management_open_async(self._c_value, on_amqp_management_open_complete, context, on_amqp_management_error, context) != 0: self._value_error("Unable to open management link.") cpdef close(self): if c_amqp_management.amqp_management_close(self._c_value) != 0: self._value_error("Unable to close management link.") cpdef execute(self, const char* operation, const char* type, locales, cMessage message, callback_context): cdef const char* c_locales cdef void *context if locales is None: c_locales = NULL else: c_locales = locales if callback_context is None: context = NULL else: context = callback_context if c_amqp_management.amqp_management_execute_operation_async(self._c_value, operation, type, c_locales, message._c_value, on_execute_operation_complete, context) == NULL: self._value_error("Unable to execute management operation.") #### Management Link Callbacks cdef void on_amqp_management_open_complete(void* context, c_amqp_management.AMQP_MANAGEMENT_OPEN_RESULT_TAG open_result): _logger.debug("Management link open: %r", open_result) if context != NULL: context_obj = context context_obj._management_open_complete(open_result) cdef void on_amqp_management_error(void* context): _logger.debug("Management link error") if context != NULL: context_obj = context context_obj._management_operation_error() cdef void on_execute_operation_complete(void* context, c_amqp_management.AMQP_MANAGEMENT_EXECUTE_OPERATION_RESULT_TAG execute_operation_result, unsigned int status_code, const char* status_description, c_message.MESSAGE_HANDLE message): cdef c_message.MESSAGE_HANDLE cloned description = "None" if status_description == NULL else status_description _logger.debug("Management op complete: %r, status code: %r, description: %r", execute_operation_result, status_code, description) if context != NULL: context_obj = context if status_code == 0: context_obj(execute_operation_result, status_code, description, None) else: if message != NULL: cloned = c_message.message_clone(message) wrapped_message = message_factory(cloned) else: wrapped_message = None context_obj(execute_operation_result, status_code, description, wrapped_message) azure-uamqp-python-1.6.8/src/amqp_string.pyx000066400000000000000000000061671455573770000212200ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_strings _logger = logging.getLogger(__name__) cpdef create_empty_string(): new_string = AMQPString() return new_string cpdef create_string_from_value(value, encoding='UTF-8'): if isinstance(value, str): value = value.encode(encoding) new_string = AMQPString() new_string.construct(value) return new_string cdef class AMQPString(StructBase): cdef c_strings.STRING_HANDLE _c_value def __cinit__(self): self._c_value = c_strings.STRING_new() self._validate() def __dealloc__(self): _logger.debug("Deallocating AMQPString") self.destroy() def __bytes__(self): return c_strings.STRING_c_str(self._c_value) def __str__(self): as_bytes = c_strings.STRING_c_str(self._c_value) return str(as_bytes, encoding="UTF-8", errors="ignore" ) def __unicode__(self): as_bytes = c_strings.STRING_c_str(self._c_value) try: return str(as_bytes.decode('UTF-8')) except UnicodeDecodeError: return str(as_bytes) def __eq__(self, AMQPString other): if c_strings.STRING_compare(self._c_value, other._c_value) == 0: return True return False def __ne__(self, AMQPString other): if c_strings.STRING_compare(self._c_value, other._c_value) == 0: return False return True cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): try: if self._c_value is not NULL: _logger.debug("Destroying AMQPString") c_strings.STRING_delete(self._c_value) except KeyboardInterrupt: pass finally: self._c_value = NULL cdef wrap(self, c_strings.STRING_HANDLE value): self.destroy() self._c_value = value self._validate() cdef construct(self, const char* value): self.destroy() self._c_value = c_strings.STRING_construct(value) self._validate() cpdef append(self, other): if isinstance(other, AMQPString): if c_strings.STRING_concat_with_STRING(self._c_value, other._c_value) != 0: self._value_error("Failed to append AMQPString value.") else: if c_strings.STRING_concat(self._c_value, other) != 0: self._value_error("Failed to append string.") cpdef clone(self): cdef c_strings.STRING_HANDLE value value = c_strings.STRING_clone(self._c_value) if value == NULL: self._null_error("Failed to clone AMQPString value.") cloned_value = AMQPString() cloned_value.wrap(value) return cloned_value azure-uamqp-python-1.6.8/src/amqpvalue.pyx000066400000000000000000000641621455573770000206660ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports from enum import Enum import logging import uuid import copy # C improts from libc cimport stdint from libc.stdlib cimport malloc, realloc, free from libc.string cimport memcpy cimport cython cimport c_amqpvalue cimport c_amqp_definitions _logger = logging.getLogger(__name__) cdef int encode_bytes_callback(void* context, const unsigned char* encoded_bytes, size_t length): context_obj = context context_obj.append(encoded_bytes[:length]) return 0 cdef get_amqp_value_type(c_amqpvalue.AMQP_VALUE value): type_val = c_amqpvalue.amqpvalue_get_type(value) try: return AMQPType(type_val) except ValueError: _logger.info("Received unrecognized type value: %r", type_val) return AMQPType.ErrorType cpdef enocde_batch_value(AMQPValue value, message_body): if c_amqpvalue.amqpvalue_encode(value._c_value, encode_bytes_callback, message_body) != 0: raise ValueError("Failed to encode batched message data.") class AMQPType(Enum): NullValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_NULL BoolValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_BOOL UByteValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_UBYTE UShortValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_USHORT UIntValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_UINT ULongValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_ULONG ByteValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_BYTE ShortValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_SHORT IntValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_INT LongValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_LONG FloatValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_FLOAT DoubleValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_DOUBLE CharValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_CHAR TimestampValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_TIMESTAMP UUIDValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_UUID BinaryValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_BINARY StringValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_STRING SymbolValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_SYMBOL ListValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_LIST DictValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_MAP ArrayValue = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_ARRAY DescribedType = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_DESCRIBED CompositeType = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_COMPOSITE UnknownType = c_amqpvalue.AMQP_TYPE_TAG.AMQP_TYPE_UNKNOWN ErrorType = 999 cdef value_factory(c_amqpvalue.AMQP_VALUE value): type_val = get_amqp_value_type(value) _logger.debug("Wrapping value type: %r", type_val) if type_val == AMQPType.NullValue: new_obj = AMQPValue() elif type_val == AMQPType.BoolValue: new_obj = BoolValue() elif type_val == AMQPType.UByteValue: new_obj = UByteValue() elif type_val == AMQPType.UShortValue: new_obj = UShortValue() elif type_val == AMQPType.UIntValue: new_obj = UIntValue() elif type_val == AMQPType.ULongValue: new_obj = ULongValue() elif type_val == AMQPType.ByteValue: new_obj = ByteValue() elif type_val == AMQPType.ShortValue: new_obj = ShortValue() elif type_val == AMQPType.IntValue: new_obj = IntValue() elif type_val == AMQPType.LongValue: new_obj = LongValue() elif type_val == AMQPType.FloatValue: new_obj = FloatValue() elif type_val == AMQPType.DoubleValue: new_obj = DoubleValue() elif type_val == AMQPType.CharValue: new_obj = CharValue() elif type_val == AMQPType.TimestampValue: new_obj = TimestampValue() elif type_val == AMQPType.UUIDValue: new_obj = UUIDValue() elif type_val == AMQPType.BinaryValue: new_obj = BinaryValue() elif type_val == AMQPType.StringValue: new_obj = StringValue() elif type_val == AMQPType.SymbolValue: new_obj = SymbolValue() elif type_val == AMQPType.ListValue: new_obj = ListValue() elif type_val == AMQPType.DictValue: new_obj = DictValue() elif type_val == AMQPType.ArrayValue: # Do checking new_obj = ArrayValue() elif type_val == AMQPType.CompositeType: new_obj = CompositeValue() elif type_val == AMQPType.DescribedType: new_obj = DescribedValue() else: error = "Unrecognized AMQPType: {}".format(type_val) _logger.info(error) raise TypeError(error) new_obj.wrap(value) return new_obj cpdef null_value(): new_obj = AMQPValue() new_obj.create() return new_obj cpdef bool_value(bint value): value = 1 if value else 0 new_obj = BoolValue() new_obj.create(value) return new_obj cpdef ubyte_value(unsigned char value): new_obj = UByteValue() new_obj.create(value) return new_obj cpdef ushort_value(stdint.uint16_t value): new_obj = UShortValue() new_obj.create(value) return new_obj cpdef uint_value(stdint.uint32_t value): new_obj = UIntValue() new_obj.create(value) return new_obj cpdef ulong_value(stdint.uint64_t value): new_obj = ULongValue() new_obj.create(value) return new_obj cpdef byte_value(char value): new_obj = ByteValue() new_obj.create(value) return new_obj cpdef short_value(stdint.int16_t value): new_obj = ShortValue() new_obj.create(value) return new_obj cpdef int_value(stdint.int32_t value): new_obj = IntValue() new_obj.create(value) return new_obj cpdef long_value(stdint.int64_t value): new_obj = LongValue() new_obj.create(value) return new_obj cpdef float_value(float value): new_obj = FloatValue() new_obj.create(value) return new_obj cpdef double_value(double value): new_obj = DoubleValue() new_obj.create(value) return new_obj cpdef char_value(stdint.uint32_t value): new_obj = CharValue() new_obj.create(value) return new_obj cpdef timestamp_value(stdint.int64_t value): new_obj = TimestampValue() new_obj.create(value) return new_obj cpdef uuid_value(value): if not isinstance(value, uuid.UUID): raise TypeError("Input value must be type UUID.") new_obj = UUIDValue() new_obj.create(value.bytes) return new_obj cpdef binary_value(value): bytes_value = bytes(value) new_obj = BinaryValue() new_obj.create(bytes_value) return new_obj cpdef string_value(char* value): new_obj = StringValue() new_obj.create(value) return new_obj cpdef symbol_value(char* value): new_obj = SymbolValue() new_obj.create(value) return new_obj cpdef list_value(): new_obj = ListValue() new_obj.create() return new_obj cpdef dict_value(): new_obj = DictValue() new_obj.create() return new_obj cpdef array_value(): new_obj = ArrayValue() new_obj.create() return new_obj cpdef described_value(AMQPValue descriptor, AMQPValue value): new_obj = DescribedValue() new_obj.create(descriptor, value) return new_obj cdef class AMQPValue(StructBase): _type = AMQPType.NullValue cdef c_amqpvalue.AMQP_VALUE _c_value def __cinit__(self): pass def __dealloc__(self): if _logger: _logger.debug("Deallocating %r", self.__class__.__name__) self.destroy() def __eq__(self, AMQPValue other): return c_amqpvalue.amqpvalue_are_equal(self._c_value, other._c_value) def __ne__(self, AMQPValue other): return not c_amqpvalue.amqpvalue_are_equal(self._c_value, other._c_value) def __bytes__(self): return self._as_string() def __str__(self): as_bytes = self._as_string() return str(as_bytes, encoding="UTF-8", errors="ignore" ) def __unicode__(self): as_bytes = self._as_string() try: return str(as_bytes.decode('UTF-8')) except UnicodeDecodeError: return str(as_bytes) cpdef _as_string(self): cdef c_amqpvalue.AMQP_VALUE value cdef const char* as_string value = c_amqpvalue.amqpvalue_clone(self._c_value) if value == NULL: self._value_error() as_string = c_amqpvalue.amqpvalue_to_string(value) py_string = as_string free(as_string) c_amqpvalue.amqpvalue_destroy(self._c_value) return py_string cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): try: if self._c_value is not NULL: if _logger: _logger.debug("Destroying %r", self.__class__.__name__) c_amqpvalue.amqpvalue_destroy(self._c_value) except KeyboardInterrupt: pass finally: self._c_value = NULL cdef wrap(self, c_amqpvalue.AMQP_VALUE value): self.destroy() self._c_value = value self._validate() def create(self): new_value = c_amqpvalue.amqpvalue_create_null() self.wrap(new_value) @property def type(self): if self._c_value is NULL: self._null_error() obj_type = get_amqp_value_type(self._c_value) return obj_type @property def value(self): return None cpdef get_encoded_size(self): cdef size_t length if c_amqpvalue.amqpvalue_get_encoded_size(self._c_value, &length) != 0: self._value_error("Failed to get encoded size.") return length cpdef clone(self): cdef c_amqpvalue.AMQP_VALUE value value = c_amqpvalue.amqpvalue_clone(self._c_value) if value == NULL: self._value_error() return value_factory(value) cdef class BoolValue(AMQPValue): _type = AMQPType.BoolValue cpdef _bool_value(self): cdef bint _value if c_amqpvalue.amqpvalue_get_boolean(self._c_value, &_value) == 0: return _value else: self._value_error() def create(self, bint value): new_value = c_amqpvalue.amqpvalue_create_boolean(value) self.wrap(new_value) @property def value(self): assert self.type str_value = str(self) if str_value in ["false"]: return False elif str_value in ["true"]: return True else: self._value_error() cdef class UByteValue(AMQPValue): _type = AMQPType.UByteValue def create(self, unsigned char value): new_value = c_amqpvalue.amqpvalue_create_ubyte(value) self.wrap(new_value) @property def value(self): assert self.type cdef unsigned char _value if c_amqpvalue.amqpvalue_get_ubyte(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class UShortValue(AMQPValue): _type = AMQPType.UShortValue def create(self, stdint.uint16_t value): new_value = c_amqpvalue.amqpvalue_create_ushort(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.uint16_t _value if c_amqpvalue.amqpvalue_get_ushort(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class UIntValue(AMQPValue): _type = AMQPType.UIntValue def create(self, stdint.uint32_t value): new_value = c_amqpvalue.amqpvalue_create_uint(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.uint32_t _value if c_amqpvalue.amqpvalue_get_uint(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class ULongValue(AMQPValue): _type = AMQPType.ULongValue def create(self, stdint.uint64_t value): new_value = c_amqpvalue.amqpvalue_create_ulong(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.uint64_t _value if c_amqpvalue.amqpvalue_get_ulong(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class ByteValue(AMQPValue): _type = AMQPType.ByteValue def create(self, char value): new_value = c_amqpvalue.amqpvalue_create_byte(value) self.wrap(new_value) @property def value(self): assert self.type cdef char _value if c_amqpvalue.amqpvalue_get_byte(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class ShortValue(AMQPValue): _type = AMQPType.ShortValue def create(self, stdint.int16_t value): new_value = c_amqpvalue.amqpvalue_create_short(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.int16_t _value if c_amqpvalue.amqpvalue_get_short(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class IntValue(AMQPValue): _type = AMQPType.IntValue def create(self, stdint.int32_t value): new_value = c_amqpvalue.amqpvalue_create_int(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.int32_t _value if c_amqpvalue.amqpvalue_get_int(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class LongValue(AMQPValue): _type = AMQPType.LongValue def create(self, stdint.int64_t value): new_value = c_amqpvalue.amqpvalue_create_long(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.int64_t _value if c_amqpvalue.amqpvalue_get_long(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class FloatValue(AMQPValue): _type = AMQPType.FloatValue def create(self, float value): new_value = c_amqpvalue.amqpvalue_create_float(value) self.wrap(new_value) @property def value(self): assert self.type cdef float _value if c_amqpvalue.amqpvalue_get_float(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class DoubleValue(AMQPValue): _type = AMQPType.DoubleValue def create(self, double value): new_value = c_amqpvalue.amqpvalue_create_double(value) self.wrap(new_value) @property def value(self): assert self.type cdef double _value if c_amqpvalue.amqpvalue_get_double(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class CharValue(AMQPValue): _type = AMQPType.CharValue def create(self, stdint.uint32_t value): new_value = c_amqpvalue.amqpvalue_create_char(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.uint32_t _value if c_amqpvalue.amqpvalue_get_char(self._c_value, &_value) == 0: return chr(_value) else: self._value_error() cdef class TimestampValue(AMQPValue): _type = AMQPType.TimestampValue def create(self, stdint.int64_t value): new_value = c_amqpvalue.amqpvalue_create_timestamp(value) self.wrap(new_value) @property def value(self): assert self.type cdef stdint.int64_t _value if c_amqpvalue.amqpvalue_get_timestamp(self._c_value, &_value) == 0: return _value else: self._value_error() cdef class UUIDValue(AMQPValue): _type = AMQPType.UUIDValue def create(self, bytes value): new_value = c_amqpvalue.amqpvalue_create_uuid(value) self.wrap(new_value) @property def value(self): assert self.type str_val = str(self) return uuid.UUID(str_val) # TODO: Get proper value cdef class BinaryValue(AMQPValue): _type = AMQPType.BinaryValue def create(self, bytes value): cdef c_amqpvalue.amqp_binary _binary length = len(list(value)) _binary.length = length _binary.bytes = value new_value = c_amqpvalue.amqpvalue_create_binary(_binary) self.wrap(new_value) def __len__(self): assert self.type cdef c_amqpvalue.amqp_binary _value if c_amqpvalue.amqpvalue_get_binary(self._c_value, &_value) == 0: return _value.length else: self._value_error() @property def value(self): assert self.type cdef c_amqpvalue.amqp_binary _value cdef char* bytes_value if c_amqpvalue.amqpvalue_get_binary(self._c_value, &_value) == 0: bytes_value = _value.bytes return bytes_value[:_value.length] else: self._value_error() cdef class StringValue(AMQPValue): _type = AMQPType.StringValue def create(self, char* value): new_value = c_amqpvalue.amqpvalue_create_string(value) self.wrap(new_value) @property def value(self): assert self.type cdef const char* _value if c_amqpvalue.amqpvalue_get_string(self._c_value, &_value) == 0: return copy.deepcopy(_value) else: self._value_error() cdef class SymbolValue(AMQPValue): _type = AMQPType.SymbolValue def create(self, char* value): new_value = c_amqpvalue.amqpvalue_create_symbol(value) self.wrap(new_value) @property def value(self): assert self.type cdef const char* _value if c_amqpvalue.amqpvalue_get_symbol(self._c_value, &_value) == 0: return copy.deepcopy(_value) else: self._value_error() cdef class ListValue(AMQPValue): _type = AMQPType.ListValue def create(self): new_value = c_amqpvalue.amqpvalue_create_list() self.wrap(new_value) def __len__(self): return self.size def __getitem__(self, size_t index): if index >= self.size: raise IndexError("Index is out of range.") cdef c_amqpvalue.AMQP_VALUE value value = c_amqpvalue.amqpvalue_get_list_item(self._c_value, index) if value == NULL: self._value_error() try: return value_factory(value) except TypeError: return None def __setitem__(self, stdint.uint32_t index, AMQPValue value): assert value.type if index >= self.size: raise IndexError("Index is out of range.") if c_amqpvalue.amqpvalue_set_list_item(self._c_value, index, value._c_value) != 0: self._value_error() @property def size(self): assert self.type cdef stdint.uint32_t _value if c_amqpvalue.amqpvalue_get_list_item_count(self._c_value, &_value) == 0: return _value else: self._value_error() @size.setter def size(self, stdint.uint32_t length): assert self.type if c_amqpvalue.amqpvalue_set_list_item_count(self._c_value, length) != 0: self._value_error() @property def value(self): assert self.type value = [] for i in range(self.size): value.append(copy.deepcopy(self[i].value)) return value cdef class DictValue(AMQPValue): _type = AMQPType.DictValue def create(self): new_value = c_amqpvalue.amqpvalue_create_map() self.wrap(new_value) def __len__(self): return self.size def __getitem__(self, AMQPValue key): cdef c_amqpvalue.AMQP_VALUE value value = c_amqpvalue.amqpvalue_get_map_value(self._c_value, key._c_value) if value == NULL: raise KeyError("No value found for key: {}".format(key.value)) try: return value_factory(value) except TypeError: return None def __setitem__(self, AMQPValue key, AMQPValue value): if c_amqpvalue.amqpvalue_set_map_value(self._c_value, key._c_value, value._c_value) != 0: self._value_error() def get(self, stdint.uint32_t index): if index >= self.size: raise IndexError("Index is out of range.") cdef c_amqpvalue.AMQP_VALUE key cdef c_amqpvalue.AMQP_VALUE value if c_amqpvalue.amqpvalue_get_map_key_value_pair(self._c_value, index, &key, &value) != 0: self._value_error() return (value_factory(key), value_factory(value)) @property def size(self): assert self.type cdef stdint.uint32_t _value if c_amqpvalue.amqpvalue_get_map_pair_count(self._c_value, &_value) == 0: return _value else: self._value_error() @property def value(self): assert self.type value = {} for i in range(self.size): key, item = self.get(i) value[copy.deepcopy(key.value)] = copy.deepcopy(item.value) return value cdef class ArrayValue(AMQPValue): _type = AMQPType.ArrayValue def create(self): self._c_value = c_amqpvalue.amqpvalue_create_array() self._validate() def __len__(self): return self.size def __getitem__(self, stdint.uint32_t index): if index >= self.size: raise IndexError("Index is out of range.") cdef c_amqpvalue.AMQP_VALUE value value = c_amqpvalue.amqpvalue_get_array_item(self._c_value, index) if value == NULL: self._value_error() return value_factory(value) @property def size(self): assert self.type cdef stdint.uint32_t _value if c_amqpvalue.amqpvalue_get_array_item_count(self._c_value, &_value) == 0: return _value else: self._value_error() cpdef append(self, AMQPValue value): assert self.type cdef c_amqpvalue.AMQP_VALUE _value _value = value._c_value if c_amqpvalue.amqpvalue_add_array_item(self._c_value, value._c_value) != 0: self._value_error() @property def value(self): assert self.type value = [] for i in range(self.size): value.append(copy.deepcopy(self[i].value)) return value cdef class CompositeValue(AMQPValue): _type = AMQPType.CompositeType def create(self, AMQPValue descriptor, stdint.uint32_t list_size): new_value = c_amqpvalue.amqpvalue_create_composite(descriptor._c_value, list_size) self.wrap(new_value) def create_from_long(self, stdint.uint64_t descriptor): new_value = c_amqpvalue.amqpvalue_create_composite_with_ulong_descriptor(descriptor) self.wrap(new_value) def __len__(self): return self.size def __getitem__(self, stdint.uint32_t index): if index >= self.size: raise IndexError("Index is out of range.") cdef c_amqpvalue.AMQP_VALUE value value = c_amqpvalue.amqpvalue_get_composite_item(self._c_value, index) if value == NULL: self._value_error() try: return value_factory(value) except TypeError: raise IndexError("No item found at index {}".format(index)) def __setitem__(self, stdint.uint32_t index, AMQPValue value): assert value.type if index >= self.size: raise IndexError("Index is out of range.") if c_amqpvalue.amqpvalue_set_composite_item(self._c_value, index, value._c_value) != 0: self._value_error() @property def size(self): assert self.type cdef stdint.uint32_t _value if c_amqpvalue.amqpvalue_get_composite_item_count(self._c_value, &_value) == 0: return _value else: self._value_error() def pop(self, stdint.uint32_t index): if index >= self.size: raise IndexError("Index is out of range.") cdef c_amqpvalue.AMQP_VALUE value value = c_amqpvalue.amqpvalue_get_composite_item(self._c_value, index) if value == NULL: self._value_error() try: return value_factory(value) except TypeError: raise IndexError("No item found at index {}".format(index)) cdef class DescribedValue(AMQPValue): _type = AMQPType.DescribedType def create(self, AMQPValue descriptor, AMQPValue value): cdef c_amqpvalue.AMQP_VALUE cloned_descriptor cdef c_amqpvalue.AMQP_VALUE cloned_value cloned_descriptor = c_amqpvalue.amqpvalue_clone(descriptor._c_value) if cloned_descriptor == NULL: self._value_error() cloned_value = c_amqpvalue.amqpvalue_clone(value._c_value) if cloned_value == NULL: self._value_error() new_value = c_amqpvalue.amqpvalue_create_described(cloned_descriptor, cloned_value) self.wrap(new_value) @property def description(self): cdef c_amqpvalue.AMQP_VALUE value cdef c_amqpvalue.AMQP_VALUE cloned value = c_amqpvalue.amqpvalue_get_inplace_descriptor(self._c_value) if value == NULL: self._value_error() cloned = c_amqpvalue.amqpvalue_clone(value) if cloned == NULL: self._value_error() return value_factory(cloned) @property def data(self): cdef c_amqpvalue.AMQP_VALUE value cdef c_amqpvalue.AMQP_VALUE cloned value = c_amqpvalue.amqpvalue_get_inplace_described_value(self._c_value) if value == NULL: self._value_error() cloned = c_amqpvalue.amqpvalue_clone(value) if cloned == NULL: self._value_error() return value_factory(cloned) @property def value(self): assert self.type #descriptor = self.description described = self.data return copy.deepcopy(described.value) azure-uamqp-python-1.6.8/src/annotations.pyx000066400000000000000000000143371455573770000212270ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging import copy # C imports from libc cimport stdint cimport c_amqpvalue cimport c_amqp_definitions cimport c_utils _logger = logging.getLogger(__name__) cdef annotations_factory(c_amqpvalue.AMQP_VALUE value): try: wrapped = value_factory(value) except TypeError: return None if c_amqp_definitions.is_delivery_annotations_type_by_descriptor(value): new_obj = create_delivery_annotations(wrapped) elif c_amqp_definitions.is_message_annotations_type_by_descriptor(value): new_obj = create_message_annotations(wrapped) elif c_amqp_definitions.is_footer_type_by_descriptor(value): new_obj = create_footer(wrapped) else: new_obj = create_annotations(wrapped) return new_obj cpdef create_annotations(AMQPValue value): annotations = cAnnotations() annotations.create(value) return annotations cpdef create_application_properties(AMQPValue value): annotations = cApplicationProperties() annotations.create(value) return annotations cpdef create_delivery_annotations(AMQPValue value): annotations = cDeliveryAnnotations() annotations.create(value) return annotations cpdef create_message_annotations(AMQPValue value): annotations = cMessageAnnotations() annotations.create(value) return annotations cpdef create_fields(AMQPValue value): annotations = cFields() annotations.create(value) return annotations cpdef create_footer(AMQPValue value): annotations = cFooter() annotations.create(value) return annotations cdef class cAnnotations(StructBase): cdef c_amqpvalue.AMQP_VALUE _c_value def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating %r", self.__class__.__name__) self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): try: if self._c_value is not NULL: _logger.debug("Destroying %r", self.__class__.__name__) c_amqpvalue.amqpvalue_destroy(self._c_value) except KeyboardInterrupt: pass finally: self._c_value = NULL cpdef clone(self): cdef c_amqp_definitions.annotations value value = c_amqpvalue.amqpvalue_clone(self._c_value) if value == NULL: self._value_error() amqp_value = value_factory(value) return cAnnotations(amqp_value) cpdef get_encoded_size(self): cdef size_t length if c_amqpvalue.amqpvalue_get_encoded_size(self._c_value, &length) != 0: self._value_error("Failed to get encoded size.") return length cpdef create(self, AMQPValue value): self.destroy() self._c_value = c_amqp_definitions.amqpvalue_create_annotations(value._c_value) self._validate() cdef wrap(self, c_amqp_definitions.annotations value): self.destroy() self._c_value = value self._validate() @property def value(self): try: return value_factory(self._c_value) except TypeError: return None @property def map(self): cdef c_amqpvalue.AMQP_VALUE unmapped cdef c_amqpvalue.AMQP_VALUE mapped unmapped = c_amqpvalue.amqpvalue_clone(self._c_value) if c_amqpvalue.amqpvalue_get_map(unmapped, &mapped) == 0: if mapped == NULL: return None return copy.deepcopy(value_factory(mapped).value) else: return None cdef class cApplicationProperties(cAnnotations): cpdef create(self, AMQPValue value): self.destroy() self._c_value = c_amqp_definitions.amqpvalue_create_application_properties( value._c_value) self._validate() @property def map(self): cdef c_amqpvalue.AMQP_VALUE unmapped cdef c_amqpvalue.AMQP_VALUE mapped cdef c_amqpvalue.AMQP_VALUE unextracted cdef c_amqpvalue.AMQP_VALUE extracted unextracted = c_amqpvalue.amqpvalue_clone(self._c_value) extracted = c_amqpvalue.amqpvalue_get_inplace_described_value(unextracted) unmapped = c_amqpvalue.amqpvalue_clone(extracted) if unmapped == NULL: result = None elif c_amqpvalue.amqpvalue_get_map(unmapped, &mapped) == 0: if mapped == NULL: result = None else: result = copy.deepcopy(value_factory(mapped).value) else: result = None c_amqpvalue.amqpvalue_destroy(unextracted) return result cdef class cDeliveryAnnotations(cAnnotations): cpdef create(self, AMQPValue value): self.destroy() self._c_value = c_amqp_definitions.amqpvalue_create_delivery_annotations( value._c_value) self._validate() cdef class cMessageAnnotations(cAnnotations): cpdef create(self, AMQPValue value): self.destroy() self._c_value = c_amqp_definitions.amqpvalue_create_message_annotations( value._c_value) self._validate() cdef class cFields(cAnnotations): cpdef create(self, AMQPValue value): self.destroy() self._c_value = c_amqp_definitions.amqpvalue_create_fields(value._c_value) self._validate() cdef class cFooter(cAnnotations): cpdef create(self, AMQPValue value): self.destroy() self._c_value = c_amqp_definitions.amqpvalue_create_footer(value._c_value) self._validate() azure-uamqp-python-1.6.8/src/async_operation.pyx000066400000000000000000000022651455573770000220640ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_async_operation _logger = logging.getLogger(__name__) cdef class AsyncOperation(StructBase): cdef c_async_operation.ASYNC_OPERATION_HANDLE _c_value def __cinit__(self): pass cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying AsyncOperation") c_async_operation.async_operation_destroy(self._c_value) self._c_value = NULL cdef wrap(self, c_async_operation.ASYNC_OPERATION_HANDLE value): self.destroy() self._c_value = value self._create() cpdef cancel(self): if c_async_operation.async_operation_cancel(self._c_value) != 0: self._value_error() azure-uamqp-python-1.6.8/src/base.pyx000066400000000000000000000036521455573770000176020ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_tlsio cimport c_utils _logger = logging.getLogger(__name__) cdef class StructBase(object): """Base class for wrapped C structs.""" def _memory_error(self): message = "Failed to allocate memory to create {}" raise MemoryError(message.format(self.__class__.__name__)) def _value_error(self, error_message=None, error_code=None): message = "Operation failed." if error_message: message += "\nError: {}".format(error_message) if error_code: message += "\nErrorCode: {}".format(error_code) raise ValueError(message) def _null_error(self, error_message=None): message = "NULL error occurred in {}.".format(self.__class__.__name__) if error_message: message += "\nError: {}".format(error_message) raise ValueError(message) cdef class TickCounter(object): cdef c_utils.TICK_COUNTER_HANDLE _c_value def __cinit__(self): self._c_value = c_utils.tickcounter_create() if self._c_value == NULL: raise MemoryError("Failed to create tick counter.") def __dealloc__(self): self.destroy() cpdef destroy(self): if self._c_value != NULL: c_utils.tickcounter_destroy(self._c_value) self._c_value = NULL cpdef get_current_ms(self): cdef c_utils.tickcounter_ms_t current_ms if c_utils.tickcounter_get_current_ms(self._c_value, ¤t_ms) != 0: raise ValueError("Failed to get current ms time.") return current_ms azure-uamqp-python-1.6.8/src/cbs.pyx000066400000000000000000000220661455573770000174370ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports from enum import Enum import time import logging # C imports from libc cimport stdint from libc.stdlib cimport malloc, free from libc.string cimport memset cimport c_cbs cimport c_utils cimport c_strings cimport c_session _logger = logging.getLogger(__name__) cpdef create_sas_token(const char* key, const char* scope, const char* keyname, size_t expiry): cdef c_strings.STRING_HANDLE str_value str_value = c_utils.SASToken_CreateString(key, scope, keyname, expiry) if str_value == NULL: raise ValueError("Failed to create SAS token.") if c_utils.SASToken_Validate(str_value) != True: raise ValueError("Generated invalid SAS token") cdef bytes py_str = c_strings.STRING_c_str(str_value) c_strings.STRING_delete(str_value) return py_str cdef class CBSTokenAuth(object): cdef const char* audience cdef const char* token_type cdef const char* token cdef stdint.uint64_t expires_at cdef stdint.uint64_t _refresh_window cdef c_cbs.CBS_HANDLE _cbs_handle cdef c_cbs.AUTH_STATUS state cdef stdint.uint64_t auth_timeout cdef stdint.uint64_t _token_put_time cdef unsigned int token_status_code cdef const char* token_status_description cdef const char* connection_id cdef cSession _session def __cinit__(self, const char* audience, const char* token_type, const char* token, stdint.uint64_t expires_at, cSession session, stdint.uint64_t timeout, const char* connection_id, stdint.uint64_t refresh_window): self.state = AUTH_STATUS_IDLE self.audience = audience self.token_type = token_type self.token = token self.expires_at = expires_at self.auth_timeout = timeout self.connection_id = connection_id self._token_put_time = 0 if refresh_window > 0: self._refresh_window = refresh_window else: current_time = int(time.time()) remaining_time = expires_at - current_time self._refresh_window = int(float(remaining_time) * 0.1) self._cbs_handle = c_cbs.cbs_create(session._c_value) self._session = session if self._cbs_handle == NULL: raise MemoryError("Unable to create CBS Handle.") if c_cbs.cbs_open_async(self._cbs_handle, on_cbs_open_complete, self, on_cbs_error, self) != 0: raise ValueError("Unable to open CBS link.") def __dealloc__(self): _logger.debug("Deallocating CBSTokenAuth") self.destroy() cpdef destroy(self): if self._cbs_handle is not NULL: _logger.debug("Destroying CBSTokenAuth for connection %r", self.connection_id) c_cbs.cbs_destroy(self._cbs_handle) self._cbs_handle = NULL self._session = None cpdef close(self): if c_cbs.cbs_close(self._cbs_handle) != 0: self._value_error("Unable to close CBS link.") cpdef set_trace(self, bint trace_on): if c_cbs.cbs_set_trace(self._cbs_handle, trace_on) != 0: raise ValueError("Unable to set debug trace.") cpdef authenticate(self): if self.state == AUTH_STATUS_IN_PROGRESS: return current_time = int(time.time()) if current_time >= self.expires_at: raise ValueError("Token has expired") self._token_put_time = current_time if c_cbs.cbs_put_token_async( self._cbs_handle, self.token_type, self.audience, self.token, on_cbs_put_token_complete, self) == NULL: raise ValueError("Put-Token request failed.") else: self.state = AUTH_STATUS_IN_PROGRESS cpdef get_status(self): self._update_status() return self.state cpdef get_failure_info(self): return self.token_status_code, self.token_status_description cpdef refresh(self, const char* refresh_token, stdint.uint64_t expires_at): self._update_status() if self.state == AUTH_STATUS_REFRESH_REQUIRED: self.token = refresh_token self.authenticate() self.expires_at = expires_at cpdef _update_status(self): error_code = 0 is_refresh_required = False if self.state == AUTH_STATUS_OK or self.state == AUTH_STATUS_REFRESH_REQUIRED: is_expired, is_refresh_required = self._check_expiration_and_refresh_status() if is_expired: self.state = AUTH_STATUS_EXPIRED elif is_refresh_required: self.state = AUTH_STATUS_REFRESH_REQUIRED elif self.state == AUTH_STATUS_IN_PROGRESS: put_timeout = self._check_put_timeout_status() if put_timeout: self.state = AUTH_STATUS_TIMEOUT cpdef _check_put_timeout_status(self): seconds_since_epoc = int(time.time()) if self.auth_timeout > 0: return (seconds_since_epoc - self._token_put_time) >= self.auth_timeout else: return False cpdef _check_expiration_and_refresh_status(self): seconds_since_epoc = int(time.time()) is_expired = seconds_since_epoc >= self.expires_at is_refresh_required = (self.expires_at - seconds_since_epoc) <= self._refresh_window return is_expired, is_refresh_required cpdef _cbs_open_complete(self, result): self.on_cbs_open_complete(result) cpdef on_cbs_open_complete(self, result): _logger.info("CBS for connection %r completed opening with status: %r", self.connection_id, result) if result == c_cbs.CBS_OPEN_COMPLETE_RESULT_TAG.CBS_OPEN_ERROR: self.state = AUTH_STATUS_FAILURE cpdef _cbs_error(self): self.on_cbs_error() cpdef on_cbs_error(self): _logger.info("CBS error occurred on connection %r.", self.connection_id) cpdef _cbs_put_token_compelete(self, c_cbs.CBS_OPERATION_RESULT_TAG result, unsigned int status_code, const char* status_description): if result == CBS_OPERATION_RESULT_OK: self.state = AUTH_STATUS_OK else: self.state = AUTH_STATUS_ERROR self.token_status_code = status_code self.token_status_description = status_description self.on_cbs_put_token_complete(result, status_code, status_description) cpdef on_cbs_put_token_complete(self, c_cbs.CBS_OPERATION_RESULT_TAG result, unsigned int status_code, const char* status_description): _logger.info("Token put complete with result: %r, status: %r, description: %r, connection: %r", result, status_code, status_description, self.connection_id) #### Callbacks cdef void on_cbs_open_complete(void *context, c_cbs.CBS_OPEN_COMPLETE_RESULT_TAG open_complete_result): if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call on_cbs_open_complete during garbage collection.") return context_obj = context context_obj._cbs_open_complete(open_complete_result) cdef void on_cbs_error(void* context): if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call on_cbs_error during garbage collection.") return context_obj = context context_obj._cbs_error() cdef void on_cbs_put_token_complete(void* context, c_cbs.CBS_OPERATION_RESULT_TAG complete_result, unsigned int status_code, const char* status_description): cdef unsigned int verified_status_code cdef const char* verified_description if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call on_cbs_put_token_complete during garbage collection.") return context_obj = context try: if status_code != NULL: verified_status_code = status_code else: verified_status_code = 0 if status_description != NULL: verified_description = status_description else: verified_description = b"CBS Session closed." context_obj._cbs_put_token_compelete(complete_result, verified_status_code, verified_description) except KeyboardInterrupt: context_obj._cbs_put_token_compelete( CBS_OPERATION_RESULT_INSTANCE_CLOSED, 1, b"Client shutdown with keyboard interrupt.") azure-uamqp-python-1.6.8/src/connection.pyx000066400000000000000000000201121455573770000210150ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging from enum import Enum # C imports from libc cimport stdint cimport c_amqp_definitions cimport c_connection cimport c_xio _logger = logging.getLogger(__name__) cpdef create_connection(XIO sasl_client, const char* hostname, const char* container_id, callback_context): conn = Connection() conn.create(sasl_client, hostname, container_id, on_connection_state_changed, on_io_error, callback_context) return conn class ConnectionState(Enum): START = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_START HDR_RCVD = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_HDR_RCVD HDR_SENT = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_HDR_SENT HDR_EXCH = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_HDR_EXCH OPEN_PIPE = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_OPEN_PIPE OC_PIPE = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_OC_PIPE OPEN_RCVD = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_OPEN_RCVD OPEN_SENT = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_OPEN_SENT CLOSE_PIPE = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_CLOSE_PIPE OPENED = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_OPENED CLOSE_RCVD = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_CLOSE_RCVD CLOSE_SENT = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_CLOSE_SENT DISCARDING = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_DISCARDING END = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_END ERROR = c_connection.CONNECTION_STATE_TAG.CONNECTION_STATE_ERROR UNKNOWN = 999 cdef class Connection(StructBase): cdef c_connection.CONNECTION_HANDLE _c_value cdef c_connection.ON_CONNECTION_CLOSED_EVENT_SUBSCRIPTION_HANDLE _close_event cdef XIO _sasl_client def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating Connection") self.destroy() def __enter__(self): return self def __exit__(self, *args): self.destroy() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying Connection") c_connection.connection_destroy(self._c_value) self._c_value = NULL self._sasl_client = None cdef wrap(self, Connection value): self.destroy() self._sasl_client = value._sasl_client self._c_value = value._c_value self._create() cdef create(self, XIO sasl_client, const char* hostname, const char* container_id, c_connection.ON_CONNECTION_STATE_CHANGED on_connection_state_changed, c_xio.ON_IO_ERROR on_io_error, void* callback_context): self.destroy() self._sasl_client = sasl_client self._c_value = c_connection.connection_create2(sasl_client._c_value, hostname, container_id, NULL, NULL, on_connection_state_changed, callback_context, on_io_error, callback_context) self._create() cpdef open(self): if c_connection.connection_open(self._c_value) != 0: self._value_error() cpdef close(self, const char* condition_value, const char* description): if c_connection.connection_close(self._c_value, condition_value, description, NULL) != 0: self._value_error() cpdef set_trace(self, bint value): c_connection.connection_set_trace(self._c_value, value) cpdef do_work(self): c_connection.connection_dowork(self._c_value) cpdef subscribe_to_close_event(self, on_close_received): self._close_event = c_connection.connection_subscribe_on_connection_close_received( self._c_value, on_connection_close_received, on_close_received) if self._close_event == NULL: self._value_error("Unable to register CLOSE event handler.") cpdef unsubscribe_to_close_event(self): c_connection.connection_unsubscribe_on_connection_close_received(self._close_event) @property def max_frame_size(self): cdef stdint.uint32_t _value if c_connection.connection_get_max_frame_size(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: self._value_error() @max_frame_size.setter def max_frame_size(self, stdint.uint32_t value): if c_connection.connection_set_max_frame_size(self._c_value, value) != 0: self._value_error() @property def channel_max(self): cdef stdint.uint16_t _value if c_connection.connection_get_channel_max(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: self._value_error() @channel_max.setter def channel_max(self, stdint.uint16_t value): if c_connection.connection_set_channel_max(self._c_value, value) != 0: self._value_error() @property def idle_timeout(self): cdef c_amqp_definitions.milliseconds _value if c_connection.connection_get_idle_timeout(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: self._value_error() @idle_timeout.setter def idle_timeout(self, c_amqp_definitions.milliseconds value): if c_connection.connection_set_idle_timeout(self._c_value, value) != 0: self._value_error() @property def properties(self): cdef c_amqp_definitions.fields _value if c_connection.connection_get_properties(self._c_value, &_value) == 0: if _value == NULL: return None return value_factory(_value) else: self._value_error() @properties.setter def properties(self, AMQPValue value): if c_connection.connection_set_properties(self._c_value, value._c_value) != 0: self._value_error() @property def remote_max_frame_size(self): cdef stdint.uint32_t _value if c_connection.connection_get_remote_max_frame_size(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: self._value_error() #### Callback cdef void on_connection_state_changed(void* context, c_connection.CONNECTION_STATE_TAG new_connection_state, c_connection.CONNECTION_STATE_TAG previous_connection_state): if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call on_connection_state_changed during garbage collection") return context_obj = context try: context_obj._state_changed(previous_connection_state, new_connection_state) except AttributeError: _logger.info("Unknown connection state changed: %r to %r", previous_connection_state, new_connection_state) cdef void on_io_error(void* context): if context != NULL: context_obj = context if hasattr(context_obj, '_io_error'): context_obj._io_error() cdef void on_connection_close_received(void* context, c_amqp_definitions.ERROR_HANDLE error): cdef c_amqp_definitions.ERROR_HANDLE cloned context_obj = context if error != NULL: cloned = c_amqp_definitions.error_clone(error) wrapped_error = error_factory(cloned) else: wrapped_error = None if hasattr(context_obj, '_close_received'): context_obj._close_received(wrapped_error) azure-uamqp-python-1.6.8/src/constants.pyx000066400000000000000000000144741455573770000207100ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports from enum import Enum import logging # C imports cimport c_amqp_definitions cimport c_message_receiver cimport c_cbs cimport c_xio cimport c_amqp_management APACHE = "apache.org" AMQP_BATCH_MESSAGE_FORMAT = 0x80013700 AMQPS_PORT = 5671 AMQP_WSS_PORT = 443 AUTH_EXPIRATION_SECS = 60 * 60 AUTH_REFRESH_SECS = 48 * 60 # 80% of expiration period MAX_PARTITION_KEY_LENGTH = 128 MAX_MESSAGE_LENGTH_BYTES = 1024 * 1024 MAX_FRAME_SIZE_BYTES = 64 * 1024 ROLE_SENDER = c_amqp_definitions.role_sender ROLE_RECEIVER = c_amqp_definitions.role_receiver SENDER_SETTLE_MODE_UNSETTLED = c_amqp_definitions.sender_settle_mode_unsettled SENDER_SETTLE_MODE_SETTLED = c_amqp_definitions.sender_settle_mode_settled SENDER_SETTLE_MODE_MIXED = c_amqp_definitions.sender_settle_mode_mixed RECEIVER_SETTLE_MODE_RECEIVEANDDELETE = c_amqp_definitions.receiver_settle_mode_first RECEIVER_SETTLE_MODE_PEEKLOCK = c_amqp_definitions.receiver_settle_mode_second CBS_OPERATION_RESULT_OK = c_cbs.CBS_OPERATION_RESULT_TAG.CBS_OPERATION_RESULT_OK CBS_OPERATION_RESULT_CBS_ERROR = c_cbs.CBS_OPERATION_RESULT_TAG.CBS_OPERATION_RESULT_CBS_ERROR CBS_OPERATION_RESULT_OPERATION_FAILED = c_cbs.CBS_OPERATION_RESULT_TAG.CBS_OPERATION_RESULT_OPERATION_FAILED CBS_OPERATION_RESULT_INSTANCE_CLOSED = c_cbs.CBS_OPERATION_RESULT_TAG.CBS_OPERATION_RESULT_INSTANCE_CLOSED CBS_OPEN_COMPLETE_OK = c_cbs.CBS_OPEN_COMPLETE_RESULT_TAG.CBS_OPEN_OK CBS_OPEN_COMPLETE_ERROR = c_cbs.CBS_OPEN_COMPLETE_RESULT_TAG.CBS_OPEN_ERROR CBS_OPEN_COMPLETE_CANCELLED = c_cbs.CBS_OPEN_COMPLETE_RESULT_TAG.CBS_OPEN_CANCELLED MESSAGE_RECEIVER_STATE_IDLE = c_message_receiver.MESSAGE_RECEIVER_STATE_TAG.MESSAGE_RECEIVER_STATE_IDLE MESSAGE_RECEIVER_STATE_OPENING = c_message_receiver.MESSAGE_RECEIVER_STATE_TAG.MESSAGE_RECEIVER_STATE_OPENING MESSAGE_RECEIVER_STATE_OPEN = c_message_receiver.MESSAGE_RECEIVER_STATE_TAG.MESSAGE_RECEIVER_STATE_OPEN MESSAGE_RECEIVER_STATE_CLOSING = c_message_receiver.MESSAGE_RECEIVER_STATE_TAG.MESSAGE_RECEIVER_STATE_CLOSING MESSAGE_RECEIVER_STATE_ERROR = c_message_receiver.MESSAGE_RECEIVER_STATE_TAG.MESSAGE_RECEIVER_STATE_ERROR MESSAGE_SEND_OK = c_message_sender.MESSAGE_SEND_RESULT_TAG.MESSAGE_SEND_OK MESSAGE_SEND_ERROR = c_message_sender.MESSAGE_SEND_RESULT_TAG.MESSAGE_SEND_ERROR MESSAGE_SEND_TIMEOUT = c_message_sender.MESSAGE_SEND_RESULT_TAG.MESSAGE_SEND_TIMEOUT MESSAGE_SEND_CANCELLED = c_message_sender.MESSAGE_SEND_RESULT_TAG.MESSAGE_SEND_CANCELLED MESSAGE_SENDER_STATE_IDLE = c_message_sender.MESSAGE_SENDER_STATE_TAG.MESSAGE_SENDER_STATE_IDLE MESSAGE_SENDER_STATE_OPENING = c_message_sender.MESSAGE_SENDER_STATE_TAG.MESSAGE_SENDER_STATE_OPENING MESSAGE_SENDER_STATE_OPEN = c_message_sender.MESSAGE_SENDER_STATE_TAG.MESSAGE_SENDER_STATE_OPEN MESSAGE_SENDER_STATE_CLOSING = c_message_sender.MESSAGE_SENDER_STATE_TAG.MESSAGE_SENDER_STATE_CLOSING MESSAGE_SENDER_STATE_ERROR = c_message_sender.MESSAGE_SENDER_STATE_TAG.MESSAGE_SENDER_STATE_ERROR IO_SEND_RESULT_OK = c_xio.IO_SEND_RESULT_TAG.IO_SEND_OK IO_SEND_RESULT_ERROR = c_xio.IO_SEND_RESULT_TAG.IO_SEND_ERROR IO_SEND_RESULT_CANCELLED = c_xio.IO_SEND_RESULT_TAG.IO_SEND_CANCELLED IO_OPEN_RESULT_OK = c_xio.IO_OPEN_RESULT_TAG.IO_OPEN_OK IO_OPEN_RESULT_ERROR = c_xio.IO_OPEN_RESULT_TAG.IO_OPEN_ERROR IO_OPEN_RESULT_CANCELLED = c_xio.IO_OPEN_RESULT_TAG.IO_OPEN_CANCELLED AMQP_MANAGEMENT_EXECUTE_OPERATION_OK = c_amqp_management.AMQP_MANAGEMENT_EXECUTE_OPERATION_RESULT_TAG.AMQP_MANAGEMENT_EXECUTE_OPERATION_OK AMQP_MANAGEMENT_EXECUTE_OPERATION_ERROR = c_amqp_management.AMQP_MANAGEMENT_EXECUTE_OPERATION_RESULT_TAG.AMQP_MANAGEMENT_EXECUTE_OPERATION_ERROR AMQP_MANAGEMENT_EXECUTE_OPERATION_FAILED_BAD_STATUS = c_amqp_management.AMQP_MANAGEMENT_EXECUTE_OPERATION_RESULT_TAG.AMQP_MANAGEMENT_EXECUTE_OPERATION_FAILED_BAD_STATUS AMQP_MANAGEMENT_EXECUTE_OPERATION_INSTANCE_CLOSED = c_amqp_management.AMQP_MANAGEMENT_EXECUTE_OPERATION_RESULT_TAG.AMQP_MANAGEMENT_EXECUTE_OPERATION_INSTANCE_CLOSED AMQP_MANAGEMENT_OPEN_OK = c_amqp_management.AMQP_MANAGEMENT_OPEN_RESULT_TAG.AMQP_MANAGEMENT_OPEN_OK AMQP_MANAGEMENT_OPEN_ERROR = c_amqp_management.AMQP_MANAGEMENT_OPEN_RESULT_TAG.AMQP_MANAGEMENT_OPEN_ERROR AMQP_MANAGEMENT_OPEN_CANCELLED = c_amqp_management.AMQP_MANAGEMENT_OPEN_RESULT_TAG.AMQP_MANAGEMENT_OPEN_CANCELLED AUTH_STATUS_OK = c_cbs.AUTH_STATUS.AUTH_STATUS_OK AUTH_STATUS_IDLE = c_cbs.AUTH_STATUS.AUTH_STATUS_IDLE AUTH_STATUS_IN_PROGRESS = c_cbs.AUTH_STATUS.AUTH_STATUS_IN_PROGRESS AUTH_STATUS_TIMEOUT = c_cbs.AUTH_STATUS.AUTH_STATUS_TIMEOUT AUTH_STATUS_REFRESH_REQUIRED = c_cbs.AUTH_STATUS.AUTH_STATUS_REFRESH_REQUIRED AUTH_STATUS_EXPIRED = c_cbs.AUTH_STATUS.AUTH_STATUS_EXPIRED AUTH_STATUS_ERROR = c_cbs.AUTH_STATUS.AUTH_STATUS_ERROR AUTH_STATUS_FAILURE = c_cbs.AUTH_STATUS.AUTH_STATUS_FAILURE #### Errors SESSION_ERROR_WINDOW_VIOLATION = "amqp:session:window-violation" SESSION_ERROR_ERRANT_LINK = "amqp:session:errant-link" SESSION_ERROR_HANDLE_IN_USE = "amqp:session:handle-in-use" SESSION_ERROR_UNATTACHED_HANDLE = "amqp:session:unattached-handle" LINK_ERROR_DETACH_FORCED = "amqp:link:detach-forced" LINK_ERROR_TRANSFER_LIMIT_EXCEEDED = "amqp:link:transfer-limit-exceeded" LINK_ERROR_MESSAGE_SIZE_EXCEEDED = "amqp:link:message-size-exceeded" LINK_ERROR_REDIRECT = "amqp:link:redirect" LINK_ERROR_STOLEN = "amqp:link:stolen" CONNECTION_ERROR_CONNECTION_FORCED = "amqp:connection:forced" CONNECTION_ERROR_FRAMING_ERROR = "amqp:connection:framing-error" CONNECTION_ERROR_REDIRECT = "amqp:connection:redirect" AMQP_ERROR_INTERNAL_ERROR = "amqp:internal-error" AMQP_ERROR_NOT_FOUND = "amqp:not-found" AMQP_ERROR_UNAUTHORIZED_ACCESS = "amqp:unauthorized-access" AMQP_ERROR_DECODE_ERROR = "amqp:decode-error" AMQP_ERROR_RESOURCE_LIMIT_EXCEEDED = "amqp:resource-limit-exceeded" AMQP_ERROR_NOT_ALLOWED = "amqp:not-allowed" AMQP_ERROR_INVALID_FIELD = "amqp:invalid-field" AMQP_ERROR_NOT_IMPLEMENTED = "amqp:not-implemented" AMQP_ERROR_RESOURCE_LOCKED = "amqp:resource-locked" AMQP_ERROR_PRECONDITION_FAILED = "amqp:precondition-failed" AMQP_ERROR_RESOURCE_DELETED = "amqp:resource-deleted" AMQP_ERROR_ILLEGAL_STATE = "amqp:illegal-state" AMQP_ERROR_FRAME_SIZE_TOO_SMALL = "amqp:frame-size-too-small" azure-uamqp-python-1.6.8/src/error.pyx000066400000000000000000000056771455573770000200320ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging import copy # C imports cimport c_amqp_definitions cimport c_amqpvalue _logger = logging.getLogger(__name__) cpdef create_error(const char* condition_value): new_error = cError() new_error.create(condition_value) return new_error cdef error_factory(c_amqp_definitions.ERROR_HANDLE error): wrapper = cError() wrapper.wrap(error) return wrapper cdef class cError(StructBase): cdef c_amqp_definitions.ERROR_HANDLE _c_value def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cError") #self.destroy() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cError") c_amqp_definitions.error_destroy(self._c_value) self._c_value = NULL cdef wrap(self, c_amqp_definitions.ERROR_HANDLE value): self.destroy() self._c_value = value self._create() cdef create(self, const char* condition_value): self.destroy() self._c_value = c_amqp_definitions.error_create(condition_value) self._create() @property def condition(self): cdef const char* condition_value if c_amqp_definitions.error_get_condition(self._c_value, &condition_value) != 0: self._value_error() return condition_value @condition.setter def condition(self, const char* condition_value): if c_amqp_definitions.error_set_condition(self._c_value, condition_value) != 0: self._value_error() @property def description(self): cdef const char* description_value if c_amqp_definitions.error_get_description(self._c_value, &description_value) != 0: return None return description_value @description.setter def description(self, const char* description_value): if c_amqp_definitions.error_set_description(self._c_value, description_value) != 0: self._value_error() @property def info(self): cdef c_amqp_definitions.fields info_value if c_amqp_definitions.error_get_info(self._c_value, &info_value) != 0: return None try: info = value_factory(info_value) return copy.deepcopy(info.value) except TypeError: return None @info.setter def info(self, AMQPValue info_value): if c_amqp_definitions.error_set_info(self._c_value, info_value._c_value) != 0: self._value_error()azure-uamqp-python-1.6.8/src/header.pyx000066400000000000000000000103021455573770000201060ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports from libc cimport stdint cimport c_amqpvalue cimport c_amqp_definitions _logger = logging.getLogger(__name__) cpdef create_header(): new_header = cHeader() return new_header cdef class cHeader(StructBase): cdef c_amqp_definitions.HEADER_HANDLE _c_value def __cinit__(self): self._c_value = c_amqp_definitions.header_create() self._validate() def __dealloc__(self): _logger.debug("Deallocating cHeader") self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): try: if self._c_value is not NULL: _logger.debug("Destroying cHeader") c_amqp_definitions.header_destroy(self._c_value) except KeyboardInterrupt: pass finally: self._c_value = NULL cdef wrap(self, c_amqp_definitions.HEADER_HANDLE value): self.destroy() self._c_value = value self._validate() cpdef clone(self): cdef c_amqp_definitions.HEADER_HANDLE value value = c_amqp_definitions.header_clone(self._c_value) if value == NULL: self._value_error() new_obj = cHeader() new_obj.wrap(value) return new_obj @property def delivery_count(self): cdef stdint.uint32_t _value if c_amqp_definitions.header_get_delivery_count(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @delivery_count.setter def delivery_count(self, stdint.uint32_t value): if c_amqp_definitions.header_set_delivery_count( self._c_value, value) != 0: self._value_error("Couldn't set 'delivery_count'.") @property def time_to_live(self): cdef c_amqp_definitions.milliseconds _value if c_amqp_definitions.header_get_ttl(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @time_to_live.setter def time_to_live(self, c_amqp_definitions.milliseconds value): if c_amqp_definitions.header_set_ttl( self._c_value, value) != 0: self._value_error("Couldn't set 'time_to_live'.") @property def durable(self): cdef bint _value if c_amqp_definitions.header_get_durable(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @durable.setter def durable(self, bint value): if c_amqp_definitions.header_set_durable( self._c_value, value) != 0: self._value_error("Couldn't set 'durable'.") @property def first_acquirer(self): cdef bint _value if c_amqp_definitions.header_get_first_acquirer(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @first_acquirer.setter def first_acquirer(self, bint value): if c_amqp_definitions.header_set_first_acquirer( self._c_value, value) != 0: self._value_error("Couldn't set 'first_acquirer'.") @property def priority(self): cdef stdint.uint8_t _value if c_amqp_definitions.header_get_priority(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @priority.setter def priority(self, stdint.uint8_t value): if c_amqp_definitions.header_set_priority( self._c_value, value) != 0: self._value_error("Couldn't set 'priority'.")azure-uamqp-python-1.6.8/src/link.pyx000066400000000000000000000147701455573770000176300ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports from libc cimport stdint cimport c_link cimport c_session cimport c_amqp_definitions cimport c_amqpvalue _logger = logging.getLogger(__name__) cpdef create_link(cSession session, const char* name, bint role, AMQPValue source, AMQPValue target): new_link = cLink() new_link.create(session, name, role, source._c_value, target._c_value) return new_link cdef class cLink(StructBase): cdef c_link.LINK_HANDLE _c_value cdef c_link.ON_LINK_DETACH_EVENT_SUBSCRIPTION_HANDLE _detach_event cdef cSession _session def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cLink") self.destroy() def __enter__(self): return self def __exit__(self, *args): self.destroy() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cLink") c_link.link_destroy(self._c_value) self._c_value = NULL self._session = None cdef wrap(self, cLink value): self.destroy() self._session = value._session self._c_value = value._c_value self._create() cdef create(self, cSession session, const char* name, c_amqp_definitions.role role, c_amqpvalue.AMQP_VALUE source, c_amqpvalue.AMQP_VALUE target): self.destroy() self._session = session self._c_value = c_link.link_create(session._c_value, name, role, source, target) self._create() cpdef subscribe_to_detach_event(self, on_detch_received): self._detach_event = c_link.link_subscribe_on_link_detach_received( self._c_value, on_link_detach_received, on_detch_received) if self._detach_event == NULL: self._value_error("Unable to register DETACH event handler.") cpdef unsubscribe_to_detach_event(self): c_link.link_unsubscribe_on_link_detach_received(self._detach_event) cpdef reset_link_credit(self, stdint.uint32_t link_credit, bint drain): _logger.debug("send flow, reset link credit to %r and drain to %r", link_credit, drain) if c_link.link_reset_link_credit(self._c_value, link_credit, drain) != 0: self._value_error("Unable to reset link credit and send flow.") @property def send_settle_mode(self): cdef c_amqp_definitions.sender_settle_mode snd_settle_mode if c_link.link_get_snd_settle_mode(self._c_value, &snd_settle_mode) != 0: self._value_error() return snd_settle_mode @send_settle_mode.setter def send_settle_mode(self, stdint.uint8_t value): if c_link.link_set_snd_settle_mode(self._c_value, value) != 0: self._value_error() @property def receive_settle_mode(self): cdef c_amqp_definitions.receiver_settle_mode rcv_settle_mode if c_link.link_get_rcv_settle_mode(self._c_value, &rcv_settle_mode) != 0: self._value_error() return rcv_settle_mode @receive_settle_mode.setter def receive_settle_mode(self, stdint.uint8_t value): if c_link.link_set_rcv_settle_mode(self._c_value, value) != 0: self._value_error() @property def max_message_size(self): cdef stdint.uint64_t value if c_link.link_get_max_message_size(self._c_value, &value) != 0: self._value_error() return value @max_message_size.setter def max_message_size(self, stdint.uint64_t value): if c_link.link_set_max_message_size(self._c_value, value) != 0: self._value_error() @property def initial_delivery_count(self): cdef c_amqp_definitions.sequence_no value if c_link.link_get_initial_delivery_count(self._c_value, &value) != 0: self._value_error() return value @initial_delivery_count.setter def initial_delivery_count(self, c_amqp_definitions.sequence_no value): if c_link.link_set_initial_delivery_count(self._c_value, value) != 0: self._value_error() @property def peer_max_message_size(self): cdef stdint.uint64_t value if c_link.link_get_peer_max_message_size(self._c_value, &value) != 0: self._value_error() return value @property def name(self): cdef const char* value if c_link.link_get_name(self._c_value, &value) != 0: self._value_error() return value @property def desired_capabilities(self): cdef c_amqpvalue.AMQP_VALUE value if c_link.link_get_desired_capabilities(self._c_value, &value) != 0: self._value_error() return value_factory(value) cpdef do_work(self): c_link.link_dowork(self._c_value) cpdef set_prefetch_count(self, stdint.uint32_t prefetch): if c_link.link_set_max_link_credit(self._c_value, prefetch) != 0: self._value_error("Unable to set link credit.") cpdef set_attach_properties(self, AMQPValue properties): if c_link.link_set_attach_properties(self._c_value, properties._c_value) != 0: self._value_error("Unable to set link attach properties.") cpdef set_desired_capabilities(self, AMQPValue desired_capabilities): if c_link.link_set_desired_capabilities(self._c_value, desired_capabilities._c_value) != 0: self._value_error("Unable to set link desired capabilities.") #### Callback cdef void on_link_detach_received(void* context, c_amqp_definitions.ERROR_HANDLE error): cdef c_amqp_definitions.ERROR_HANDLE cloned context_obj = context if error != NULL: cloned = c_amqp_definitions.error_clone(error) wrapped_error = error_factory(cloned) else: wrapped_error = None if hasattr(context_obj, '_detach_received'): context_obj._detach_received(wrapped_error) azure-uamqp-python-1.6.8/src/message.pyx000066400000000000000000001326331455573770000203160ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports from enum import Enum import logging # C imports from libc cimport stdint cimport c_message cimport c_amqp_definitions cimport c_amqpvalue _logger = logging.getLogger(__name__) class MessageBodyType(Enum): NoneType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_NONE DataType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA SequenceType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_SEQUENCE ValueType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_VALUE cdef message_factory(c_message.MESSAGE_HANDLE value): new_message = cMessage() new_message.wrap(value) return new_message cpdef create_message(): new_message = cMessage() new_message.create() return new_message cdef class cMessage(StructBase): cdef c_message.MESSAGE_HANDLE _c_value def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cMessage") self.destroy() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): try: if self._c_value is not NULL: _logger.debug("Destroying cMessage") c_message.message_destroy(self._c_value) except KeyboardInterrupt: pass finally: self._c_value = NULL cdef wrap(self, c_message.MESSAGE_HANDLE value): self.destroy() self._c_value = value self._create() cdef create(self): self.destroy() self._c_value = c_message.message_create() self._create() cpdef clone(self): cdef c_message.MESSAGE_HANDLE value value = c_message.message_clone(self._c_value) if value == NULL: self._value_error() return message_factory(value) @property def header(self): cdef c_amqp_definitions.HEADER_HANDLE value if c_message.message_get_header(self._c_value, &value) == 0: if value == NULL: return None new_obj = cHeader() new_obj.wrap(value) return new_obj else: self._value_error() @header.setter def header(self, cHeader value): if value is None: if c_message.message_set_header( self._c_value, NULL) != 0: self._value_error() elif c_message.message_set_header( self._c_value, value._c_value) != 0: self._value_error() @property def delivery_annotations(self): cdef c_amqp_definitions.delivery_annotations value if c_message.message_get_delivery_annotations(self._c_value, &value) == 0: if value == NULL: return None new_obj = cDeliveryAnnotations() new_obj.wrap(value) return new_obj else: self._value_error() @delivery_annotations.setter def delivery_annotations(self, cDeliveryAnnotations value): if value is None: if c_message.message_set_delivery_annotations( self._c_value, NULL) != 0: self._value_error() elif c_message.message_set_delivery_annotations( self._c_value, value._c_value) != 0: self._value_error() @property def message_annotations(self): cdef c_amqp_definitions.message_annotations value if c_message.message_get_message_annotations(self._c_value, &value) == 0: if value == NULL: return None new_obj = cMessageAnnotations() new_obj.wrap(value) return new_obj else: self._value_error() @message_annotations.setter def message_annotations(self, cMessageAnnotations value): if value is None: if c_message.message_set_message_annotations( self._c_value, NULL) != 0: self._value_error() elif c_message.message_set_message_annotations( self._c_value, value._c_value) != 0: self._value_error() @property def properties(self): cdef c_amqp_definitions.PROPERTIES_HANDLE value if c_message.message_get_properties(self._c_value, &value) == 0: if value == NULL: return None new_obj = cProperties() new_obj.wrap(value) return new_obj else: self._value_error() @properties.setter def properties(self, cProperties value): if value is None: if c_message.message_set_properties( self._c_value, NULL) != 0: self._value_error() elif c_message.message_set_properties( self._c_value, value._c_value) != 0: self._value_error() @property def application_properties(self): cdef c_amqpvalue.AMQP_VALUE value if c_message.message_get_application_properties(self._c_value, &value) == 0: if value == NULL: return None new_obj = cApplicationProperties() new_obj.wrap(value) return new_obj else: self._value_error() @application_properties.setter def application_properties(self, AMQPValue value): if value is None: if c_message.message_set_application_properties( self._c_value, NULL) != 0: self._value_error() elif c_message.message_set_application_properties( self._c_value, value._c_value) != 0: self._value_error() @property def footer(self): cdef c_amqp_definitions.annotations value if c_message.message_get_footer(self._c_value, &value) == 0: if value == NULL: return None new_obj = cFooter() new_obj.wrap(value) return new_obj else: self._value_error() @footer.setter def footer(self, cFooter value): if value is None: if c_message.message_set_footer( self._c_value, NULL) != 0: self._value_error() elif c_message.message_set_footer( self._c_value, value._c_value) != 0: self._value_error() @property def body_type(self): cdef c_message.MESSAGE_BODY_TYPE_TAG value if c_message.message_get_body_type(self._c_value, &value) == 0: return MessageBodyType(value) else: self._value_error() @property def message_format(self): cdef stdint.uint32_t value if c_message.message_get_message_format(self._c_value, &value) == 0: return value else: self._value_error() @message_format.setter def message_format(self, stdint.uint32_t value): if c_message.message_set_message_format(self._c_value, value) != 0: self._value_error() @property def delivery_tag(self): cdef c_amqpvalue.AMQP_VALUE value if c_message.message_get_delivery_tag(self._c_value, &value) == 0: if value == NULL: return None return value_factory(value) else: self._value_error() cpdef add_body_data(self, bytes value): cdef c_message.BINARY_DATA _binary length = len(value) bytes = value[:length] _binary.length = length _binary.bytes = bytes if c_message.message_add_body_amqp_data(self._c_value, _binary) != 0: self._value_error() cpdef get_body_data(self, size_t index): cdef c_message.BINARY_DATA _value if c_message.message_get_body_amqp_data_in_place(self._c_value, index, &_value) == 0: return _value.bytes[:_value.length] else: self._value_error() cpdef count_body_data(self): cdef size_t body_count if c_message.message_get_body_amqp_data_count(self._c_value, &body_count) == 0: return body_count else: self._value_error() cpdef set_body_value(self, AMQPValue value): if c_message.message_set_body_amqp_value(self._c_value, value._c_value) != 0: self._value_error() cpdef get_body_value(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_message.message_get_body_amqp_value_in_place(self._c_value, &_value) != 0: self._value_error() cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: self._value_error() return value_factory(cloned) cpdef add_body_sequence(self, AMQPValue sequence): if c_message.message_add_body_amqp_sequence(self._c_value, sequence._c_value) != 0: self._value_error() cpdef get_body_sequence(self, size_t index): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_message.message_get_body_amqp_sequence_in_place(self._c_value, index, &_value) != 0: self._value_error() cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: self._value_error() return value_factory(cloned) cpdef count_body_sequence(self): cdef size_t body_count if c_message.message_get_body_amqp_sequence_count(self._c_value, &body_count) == 0: return body_count else: self._value_error() cdef class Messaging(object): @staticmethod def create_source(const char* address): cdef c_amqpvalue.AMQP_VALUE _value _value = c_message.messaging_create_source(address) if _value == NULL: raise MemoryError("Failed to allocate memory for messaging source.") return value_factory(_value) @staticmethod def create_target(const char* address): cdef c_amqpvalue.AMQP_VALUE _value _value = c_message.messaging_create_target(address) if _value == NULL: raise MemoryError("Failed to allocate memory for messaging target.") return value_factory(_value) @staticmethod def delivery_received(stdint.uint32_t section_number, stdint.uint64_t section_offset): cdef c_amqpvalue.AMQP_VALUE _value _value = c_message.messaging_delivery_received(section_number, section_offset) if _value == NULL: raise MemoryError("Failed to allocate memory for received delivery.") return value_factory(_value) @staticmethod def delivery_accepted(): cdef c_amqpvalue.AMQP_VALUE _value _value = c_message.messaging_delivery_accepted() if _value == NULL: raise MemoryError("Failed to allocate memory for accepted delivery.") return value_factory(_value) @staticmethod def delivery_rejected(const char* error_condition, const char* error_description, cFields error_info=None): cdef c_amqpvalue.AMQP_VALUE _value if error_info is not None: delivery_fields = error_info._c_value else: delivery_fields = NULL _value = c_message.messaging_delivery_rejected(error_condition, error_description, delivery_fields) if _value == NULL: raise MemoryError("Failed to allocate memory for rejected delivery.") return value_factory(_value) @staticmethod def delivery_released(): cdef c_amqpvalue.AMQP_VALUE _value _value = c_message.messaging_delivery_released() if _value == NULL: raise MemoryError("Failed to allocate memory for released delivery.") return value_factory(_value) @staticmethod def delivery_modified(bint delivery_failed, bint undeliverable_here, cFields message_annotations): _logger.debug("delivery modified: %r %r", delivery_failed, undeliverable_here) cdef c_amqpvalue.AMQP_VALUE _value _value = c_message.messaging_delivery_modified(delivery_failed, undeliverable_here, message_annotations._c_value) if _value == NULL: raise MemoryError("Failed to allocate memory for modified delivery.") return value_factory(_value) cdef void destroy_amqp_objects_in_get_encoded_message_size(c_amqp_definitions.HEADER_HANDLE header, c_amqpvalue.AMQP_VALUE header_amqp_value, c_amqpvalue.AMQP_VALUE msg_annotations, c_amqpvalue.AMQP_VALUE footer, c_amqpvalue.AMQP_VALUE delivery_annotations, c_amqp_definitions.PROPERTIES_HANDLE properties, c_amqpvalue.AMQP_VALUE properties_amqp_value, c_amqpvalue.AMQP_VALUE application_properties, c_amqpvalue.AMQP_VALUE application_properties_value, c_amqpvalue.AMQP_VALUE body_amqp_value): if header != NULL: c_amqp_definitions.header_destroy(header) if header_amqp_value != NULL: c_amqpvalue.amqpvalue_destroy(header_amqp_value) if msg_annotations != NULL: c_amqpvalue.amqpvalue_destroy(msg_annotations) if footer != NULL: c_amqpvalue.amqpvalue_destroy(footer) if delivery_annotations != NULL: c_amqpvalue.amqpvalue_destroy(delivery_annotations) if properties != NULL: c_amqp_definitions.properties_destroy(properties) if properties_amqp_value != NULL: c_amqpvalue.amqpvalue_destroy(properties_amqp_value) if application_properties != NULL: c_amqpvalue.amqpvalue_destroy(application_properties) if application_properties_value != NULL: c_amqpvalue.amqpvalue_destroy(application_properties_value) if body_amqp_value != NULL: c_amqpvalue.amqpvalue_destroy(body_amqp_value) cpdef size_t get_encoded_message_size(cMessage message, encoded_data): cdef c_message.MESSAGE_HANDLE c_msg c_msg = message._c_value cdef c_message.MESSAGE_BODY_TYPE_TAG message_body_type cdef c_amqp_definitions.message_format message_format cdef c_amqp_definitions.HEADER_HANDLE header = NULL cdef c_amqpvalue.AMQP_VALUE header_amqp_value = NULL cdef c_amqp_definitions.PROPERTIES_HANDLE properties = NULL cdef c_amqpvalue.AMQP_VALUE properties_amqp_value = NULL cdef c_amqpvalue.AMQP_VALUE application_properties = NULL cdef c_amqpvalue.AMQP_VALUE application_properties_value = NULL cdef c_amqpvalue.AMQP_VALUE body_amqp_value = NULL cdef c_amqpvalue.AMQP_VALUE msg_annotations = NULL cdef c_amqpvalue.AMQP_VALUE footer = NULL cdef c_amqpvalue.AMQP_VALUE delivery_annotations = NULL cdef c_amqpvalue.AMQP_VALUE message_body_amqp_value cdef c_amqpvalue.AMQP_VALUE message_body_amqp_sequence cdef c_message.BINARY_DATA binary_data cdef c_amqpvalue.AMQP_VALUE body_amqp_data cdef c_amqpvalue.AMQP_VALUE body_amqp_sequence cdef c_amqpvalue.amqp_binary binary_value cdef size_t encoded_size cdef size_t total_encoded_size = 0 cdef size_t body_data_count = 0 cdef size_t body_sequence_count = 0 # message format if (c_message.message_get_body_type(c_msg, &message_body_type) != 0) or (c_message.message_get_message_format(c_msg, &message_format) != 0): raise ValueError("Failure getting message body type and/or message format") # message header if c_message.message_get_header(c_msg, &header) == 0 and header != NULL: header_amqp_value = c_amqp_definitions.amqpvalue_create_header(header) if header_amqp_value == NULL: _logger.debug("Cannot create header AMQP value") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot get cMessage header.") else: if c_amqpvalue.amqpvalue_get_encoded_size(header_amqp_value, &encoded_size) != 0: _logger.debug("Cannot obtain header encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain header encoded size") else: total_encoded_size += encoded_size # message annotations if c_message.message_get_message_annotations(c_msg, &msg_annotations) == 0 and msg_annotations != NULL: if c_amqpvalue.amqpvalue_get_encoded_size(msg_annotations, &encoded_size) != 0: _logger.debug("Cannot obtain message annotations encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain message annotations encoded size") else: total_encoded_size += encoded_size # properties if c_message.message_get_properties(c_msg, &properties) == 0 and properties != NULL: properties_amqp_value = c_amqp_definitions.amqpvalue_create_properties(properties) if properties_amqp_value == NULL: _logger.debug("Cannot create properties AMQP value") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot get cMessage properties.") else: if c_amqpvalue.amqpvalue_get_encoded_size(properties_amqp_value, &encoded_size) != 0: _logger.debug("Cannot obtain message properties encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain message properties encoded size") else: total_encoded_size += encoded_size # application properties if c_message.message_get_application_properties(c_msg, &application_properties) == 0 and application_properties != NULL: application_properties_value = c_amqp_definitions.amqpvalue_create_application_properties(application_properties) if application_properties_value == NULL: _logger.debug("Cannot create application properties AMQP value") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot get cMessage application properties.") else: if c_amqpvalue.amqpvalue_get_encoded_size(application_properties_value, &encoded_size) != 0: _logger.debug("Cannot obtain application properties encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain application properties encoded size") else: total_encoded_size += encoded_size # footer if c_message.message_get_footer(c_msg, &footer) == 0 and footer != NULL: if c_amqpvalue.amqpvalue_get_encoded_size(footer, &encoded_size) != 0: _logger.debug("Cannot obtain footer encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain footer encoded size") else: total_encoded_size += encoded_size # delivery annotations if c_message.message_get_delivery_annotations(c_msg, &delivery_annotations) == 0 and delivery_annotations != NULL: if c_amqpvalue.amqpvalue_get_encoded_size(delivery_annotations, &encoded_size) != 0: _logger.debug("Cannot obtain delivery annotations encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain delivery annotations encoded size") else: total_encoded_size += encoded_size # value body if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_VALUE: if c_message.message_get_body_amqp_value_in_place(c_msg, &message_body_amqp_value) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot obtain AMQP value from body") body_amqp_value = c_amqp_definitions.amqpvalue_create_amqp_value(message_body_amqp_value) if body_amqp_value == NULL: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot create body AMQP value") else: if c_amqpvalue.amqpvalue_get_encoded_size(body_amqp_value, &encoded_size) != 0: _logger.debug("Cannot get body AMQP value encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP value encoded size") else: total_encoded_size += encoded_size # data body if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA: if c_message.message_get_body_amqp_data_count(c_msg, &body_data_count) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP data count") if body_data_count == 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Body data count is zero") for i in range(body_data_count): if c_message.message_get_body_amqp_data_in_place(c_msg, i, &binary_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP data {}".format(i)) binary_value.bytes = binary_data.bytes binary_value.length = binary_data.length body_amqp_data = c_amqp_definitions.amqpvalue_create_data(binary_value) if body_amqp_data == NULL: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot create body AMQP data") else: if c_amqpvalue.amqpvalue_get_encoded_size(body_amqp_data, &encoded_size) != 0: _logger.debug("Cannot get body AMQP data encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) c_amqpvalue.amqpvalue_destroy(body_amqp_data) raise ValueError("Cannot get body AMQP data encoded size") else: total_encoded_size += encoded_size c_amqpvalue.amqpvalue_destroy(body_amqp_data) # sequence body if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_SEQUENCE: if c_message.message_get_body_amqp_sequence_count(c_msg, &body_sequence_count) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP sequence count") if body_sequence_count == 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Body sequence count is zero") for i in range(body_sequence_count): if c_message.message_get_body_amqp_sequence_in_place(c_msg, i, &message_body_amqp_sequence) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP sequence {}".format(i)) body_amqp_sequence = c_amqp_definitions.amqpvalue_create_amqp_sequence(message_body_amqp_sequence); if body_amqp_sequence == NULL: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot create body AMQP sequence") else: if c_amqpvalue.amqpvalue_get_encoded_size(body_amqp_sequence, &encoded_size) != 0: _logger.debug("Cannot get body AMQP sequence encoded size") destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) c_amqpvalue.amqpvalue_destroy(body_amqp_sequence) raise ValueError("Cannot get body AMQP sequence encoded size") else: total_encoded_size += encoded_size c_amqpvalue.amqpvalue_destroy(body_amqp_sequence) # encode if header != NULL: if c_amqpvalue.amqpvalue_encode( header_amqp_value, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode header value") if msg_annotations != NULL: if c_amqpvalue.amqpvalue_encode( msg_annotations, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode message annotations value") if properties != NULL: if c_amqpvalue.amqpvalue_encode( properties_amqp_value, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode message properties value") if application_properties != NULL: if c_amqpvalue.amqpvalue_encode( application_properties_value, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode application properties value") if footer != NULL: if c_amqpvalue.amqpvalue_encode( footer, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode footer value") if delivery_annotations != NULL: if c_amqpvalue.amqpvalue_encode( delivery_annotations, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode delivery annotations value") if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_VALUE: if c_amqpvalue.amqpvalue_encode( body_amqp_value, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot encode body AMQP value") if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA: for i in range(body_data_count): if c_message.message_get_body_amqp_data_in_place(c_msg, i, &binary_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP data {}".format(i)) binary_value.bytes = binary_data.bytes binary_value.length = binary_data.length body_amqp_data = c_amqp_definitions.amqpvalue_create_data(binary_value) if body_amqp_data == NULL: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot create body AMQP data") else: if c_amqpvalue.amqpvalue_encode( body_amqp_data, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) c_amqpvalue.amqpvalue_destroy(body_amqp_data) raise ValueError("Cannot encode body AMQP value") c_amqpvalue.amqpvalue_destroy(body_amqp_data) if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_SEQUENCE: for i in range(body_sequence_count): if c_message.message_get_body_amqp_sequence_in_place(c_msg, i, &message_body_amqp_sequence) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise ValueError("Cannot get body AMQP sequence {}".format(i)) body_amqp_sequence = c_amqp_definitions.amqpvalue_create_amqp_sequence(message_body_amqp_sequence); if body_amqp_sequence == NULL: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) raise MemoryError("Cannot create body AMQP sequence") else: if c_amqpvalue.amqpvalue_encode( body_amqp_sequence, encode_bytes_callback, encoded_data) != 0: destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) c_amqpvalue.amqpvalue_destroy(body_amqp_sequence) raise ValueError("Cannot get body AMQP sequence encoded size") c_amqpvalue.amqpvalue_destroy(body_amqp_sequence) destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations, properties, properties_amqp_value, application_properties, application_properties_value, body_amqp_value) return total_encoded_size cdef class cMessageDecoder(object): cdef c_message.MESSAGE_HANDLE decoded_message cdef const char* decode_error def __cinit__(self): self.decoded_message = c_message.message_create() if self.decoded_message == NULL: raise MemoryError("Failed to create message decoder.") self.decode_error = NULL def __dealloc__(self): _logger.debug("Deallocating cMessageDecoder") cpdef cMessage decode_message(stdint.uint32_t payload_size, const unsigned char* payload_bytes): cdef c_amqpvalue.AMQPVALUE_DECODER_HANDLE amqpvalue_decoder cdef c_message.MESSAGE_HANDLE result message_decoder = cMessageDecoder() amqpvalue_decoder = c_amqpvalue.amqpvalue_decoder_create(decode_message_data, message_decoder); if amqpvalue_decoder == NULL: raise MemoryError("Cannot create AMQP value decoder") else: if c_amqpvalue.amqpvalue_decode_bytes(amqpvalue_decoder, payload_bytes, payload_size) != 0: raise ValueError("Cannot decode bytes") else: if message_decoder.decode_error != NULL: raise ValueError(message_decoder.decode_error.decode('UTF-8')) else: result = message_decoder.decoded_message c_amqpvalue.amqpvalue_decoder_destroy(amqpvalue_decoder) return message_factory(result) cdef void decode_message_data(void* context, c_amqpvalue.AMQP_VALUE decoded_value): message_decoder = context cdef c_message.MESSAGE_HANDLE decoded_message cdef c_amqpvalue.AMQP_VALUE descriptor cdef c_amqp_definitions.PROPERTIES_HANDLE properties cdef c_amqp_definitions.annotations delivery_annotations cdef c_amqp_definitions.annotations message_annotations cdef c_amqp_definitions.HEADER_HANDLE header cdef c_amqp_definitions.annotations footer cdef c_message.MESSAGE_BODY_TYPE_TAG body_type cdef c_amqpvalue.AMQP_VALUE body_amqp_value cdef c_amqpvalue.AMQP_VALUE body_data_value cdef c_amqp_definitions.data data_value cdef c_message.BINARY_DATA binary_data decoded_message = message_decoder.decoded_message descriptor = c_amqpvalue.amqpvalue_get_inplace_descriptor(decoded_value) if c_amqp_definitions.is_application_properties_type_by_descriptor(descriptor): if c_message.message_set_application_properties(decoded_message, decoded_value) != 0: message_decoder.decode_error = b"Error setting application properties on received message" elif c_amqp_definitions.is_properties_type_by_descriptor(descriptor): if c_amqp_definitions.amqpvalue_get_properties(decoded_value, &properties) != 0: message_decoder.decode_error = b"Error getting message properties" else: if c_message.message_set_properties(decoded_message, properties) != 0: message_decoder.decode_error = b"Error setting message properties on received message" c_amqp_definitions.properties_destroy(properties) elif c_amqp_definitions.is_delivery_annotations_type_by_descriptor(descriptor): delivery_annotations = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value) if delivery_annotations == NULL: message_decoder.decode_error = b"Error getting delivery annotations" else: if c_message.message_set_delivery_annotations(decoded_message, delivery_annotations) != 0: message_decoder.decode_error = b"Error setting delivery annotations on received message" elif c_amqp_definitions.is_message_annotations_type_by_descriptor(descriptor): message_annotations = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value) if message_annotations == NULL: message_decoder.decode_error = b"Error getting message annotations" else: if c_message.message_set_message_annotations(decoded_message, message_annotations) != 0: message_decoder.decode_error = b"Error setting message annotations on received message" elif c_amqp_definitions.is_header_type_by_descriptor(descriptor): if c_amqp_definitions.amqpvalue_get_header(decoded_value, &header) != 0: message_decoder.decode_error = b"Error getting message header" else: if c_message.message_set_header(decoded_message, header) != 0: message_decoder.decode_error = b"Error setting message header on received message" c_amqp_definitions.header_destroy(header) elif c_amqp_definitions.is_footer_type_by_descriptor(descriptor): footer = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value); if footer == NULL: message_decoder.decode_error = b"Error getting message footer" else: if c_message.message_set_footer(decoded_message, footer) != 0: message_decoder.decode_error = b"Error setting message footer on received message" elif c_amqp_definitions.is_amqp_value_type_by_descriptor(descriptor): if c_message.message_get_body_type(decoded_message, &body_type) != 0: message_decoder.decode_error = b"Error getting message body type" else: if body_type != c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_NONE: message_decoder.decode_error = b"Body already set on received message" else: body_amqp_value = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value) if body_amqp_value == NULL: message_decoder.decode_error = b"Error getting body AMQP value" else: if c_message.message_set_body_amqp_value(decoded_message, body_amqp_value) != 0: message_decoder.decode_error = b"Error setting body AMQP value on received message" elif c_amqp_definitions.is_data_type_by_descriptor(descriptor): if c_message.message_get_body_type(decoded_message, &body_type) != 0: message_decoder.decode_error = b"Error getting message body type" else: if (body_type != c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_NONE) and (body_type != c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA): message_decoder.decode_error = b"Message body type already set to something different than AMQP DATA" else: body_data_value = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value) if body_data_value == NULL: message_decoder.decode_error = b"Error getting body DATA value" else: if c_amqpvalue.amqpvalue_get_binary(body_data_value, &data_value) != 0: message_decoder.decode_error = b"Error getting body DATA AMQP value" else: binary_data.bytes = data_value.bytes binary_data.length = data_value.length if c_message.message_add_body_amqp_data(decoded_message, binary_data) != 0: message_decoder.decode_error = b"Error adding body DATA to received message" azure-uamqp-python-1.6.8/src/message_receiver.pyx000066400000000000000000000162001455573770000221710ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_message_receiver cimport c_message cimport c_link cimport c_amqpvalue _logger = logging.getLogger(__name__) cpdef create_message_receiver(cLink link, callback_context): receiver = cMessageReceiver() receiver.create(link, on_message_receiver_state_changed, callback_context) return receiver cdef class cMessageReceiver(StructBase): cdef c_message_receiver.MESSAGE_RECEIVER_HANDLE _c_value cdef const char* _link_name cdef cLink _link def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cMessageReceiver") self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cdef create(self, cLink link, c_message_receiver.ON_MESSAGE_RECEIVER_STATE_CHANGED on_message_sender_state_changed, void* context): self.destroy() self._link = link self._c_value = c_message_receiver.messagereceiver_create(link._c_value, on_message_sender_state_changed, context) self._validate() if c_message_receiver.messagereceiver_get_link_name(self._c_value, &self._link_name)!= 0: self._value_error("Unable to retrieve message receiver link name.") cpdef open(self, callback_context): if c_message_receiver.messagereceiver_open(self._c_value, on_message_received, callback_context) != 0: self._value_error() cpdef close(self): if c_message_receiver.messagereceiver_close(self._c_value) != 0: self._value_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cMessageReceiver") c_message_receiver.messagereceiver_destroy(self._c_value) self._c_value = NULL self._link = None cpdef last_received_message_number(self): cdef c_amqp_definitions.delivery_number message_number if c_message_receiver.messagereceiver_get_received_message_id(self._c_value, &message_number) != 0: self._value_error("Unable to retrieve last received message number.") return message_number cpdef settle_accepted_message(self, c_amqp_definitions.delivery_number message_number): cdef c_amqpvalue.AMQP_VALUE delivery_state delivery_state = c_message.messaging_delivery_accepted() if c_message_receiver.messagereceiver_send_message_disposition(self._c_value, self._link_name, message_number, delivery_state) != 0: raise RuntimeError("Unable to send message dispostition 'accepted' for message number {}".format(message_number)) c_amqpvalue.amqpvalue_destroy(delivery_state) cpdef settle_released_message(self, c_amqp_definitions.delivery_number message_number): cdef c_amqpvalue.AMQP_VALUE delivery_state delivery_state = c_message.messaging_delivery_released() if c_message_receiver.messagereceiver_send_message_disposition(self._c_value, self._link_name, message_number, delivery_state) != 0: raise RuntimeError("Unable to send message dispostition 'released' for message number {}".format(message_number)) c_amqpvalue.amqpvalue_destroy(delivery_state) cpdef settle_rejected_message(self, c_amqp_definitions.delivery_number message_number, const char* error_condition, const char* error_description, AMQPValue error_info=None): cdef c_amqpvalue.AMQP_VALUE delivery_state cdef c_amqp_definitions.fields delivery_fields if error_info is not None: delivery_fields = error_info._c_value else: delivery_fields = NULL delivery_state = c_message.messaging_delivery_rejected(error_condition, error_description, delivery_fields) if c_message_receiver.messagereceiver_send_message_disposition(self._c_value, self._link_name, message_number, delivery_state) != 0: raise RuntimeError("Unable to send message dispostition 'rejected' for message number {}".format(message_number)) c_amqpvalue.amqpvalue_destroy(delivery_state) cpdef settle_modified_message(self, c_amqp_definitions.delivery_number message_number, bint delivery_failed, bint undeliverable_here, AMQPValue annotations): cdef c_amqpvalue.AMQP_VALUE delivery_state cdef c_amqp_definitions.fields delivery_fields if annotations is not None: delivery_fields = annotations._c_value else: delivery_fields = NULL delivery_state = c_message.messaging_delivery_modified(delivery_failed, undeliverable_here, delivery_fields) if c_message_receiver.messagereceiver_send_message_disposition(self._c_value, self._link_name, message_number, delivery_state) != 0: raise RuntimeError("Unable to send message dispostition 'delivery-modified' for message number {}".format(message_number)) c_amqpvalue.amqpvalue_destroy(delivery_state) cdef wrap(self, cMessageReceiver value): self.destroy() self._link = value._link self._c_value = value._c_value self._validate() cpdef set_trace(self, bint value): c_message_receiver.messagereceiver_set_trace(self._c_value, value) #### Callbacks (context is a MessageReceiver instance) cdef void on_message_receiver_state_changed(void* context, c_message_receiver.MESSAGE_RECEIVER_STATE_TAG new_state, c_message_receiver.MESSAGE_RECEIVER_STATE_TAG previous_state): if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call on_state_changed during garbage collection, please be sure to close or use a context manager") return context_obj = context try: context_obj._state_changed(previous_state, new_state) except AttributeError: _logger.info("Unknown MessageReceiver state changed: %r to %r", previous_state, new_state) cdef c_amqpvalue.AMQP_VALUE on_message_received(void* context, c_message.MESSAGE_HANDLE message): cdef c_message.MESSAGE_HANDLE cloned cloned = c_message.message_clone(message) wrapped_message = message_factory(cloned) if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call _message_received during garbage collection") return NULL context_obj = context if hasattr(context_obj, '_message_received'): context_obj._message_received(wrapped_message) return NULL azure-uamqp-python-1.6.8/src/message_sender.pyx000066400000000000000000000111071455573770000216460ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging import copy # C imports from libc cimport stdint from cpython.ref cimport PyObject cimport c_message_sender cimport c_link cimport c_async_operation cimport c_amqpvalue _logger = logging.getLogger(__name__) cpdef create_message_sender(cLink link, callback_context): sender = cMessageSender() sender.create(link, on_message_sender_state_changed, callback_context) return sender cdef create_message_sender_with_callback(cLink link,c_message_sender.ON_MESSAGE_SENDER_STATE_CHANGED callback, void* callback_context): sender = cMessageSender() sender.create(link, callback, callback_context) return sender cdef class cMessageSender(StructBase): cdef c_message_sender.MESSAGE_SENDER_HANDLE _c_value cdef cLink _link def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cMessageSender") self.destroy() def __enter__(self): self.open() return self def __exit__(self, *args): self.destroy() cpdef open(self): if c_message_sender.messagesender_open(self._c_value) != 0: self._value_error() cpdef close(self): if c_message_sender.messagesender_close(self._c_value) != 0: self._value_error() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cMessageSender") c_message_sender.messagesender_destroy(self._c_value) self._c_value = NULL self._link = None cdef wrap(self, cMessageSender value): self.destroy() self._link = value._link self._c_value = value._c_value self._create() cdef create(self, cLink link, c_message_sender.ON_MESSAGE_SENDER_STATE_CHANGED on_message_sender_state_changed, void* context): self.destroy() self._link = link self._c_value = c_message_sender.messagesender_create(link._c_value, on_message_sender_state_changed, context) self._create() cpdef send(self, cMessage message, c_amqp_definitions.tickcounter_ms_t timeout, callback_context): operation = c_message_sender.messagesender_send_async(self._c_value, message._c_value, on_message_send_complete, callback_context, timeout) if operation is NULL: _logger.info("Send operation result is NULL") return False return True cpdef set_trace(self, bint value): c_message_sender.messagesender_set_trace(self._c_value, value) #### Callbacks (context is a MessageSender instance) cdef void on_message_send_complete(void* context, c_message_sender.MESSAGE_SEND_RESULT_TAG send_result, c_amqpvalue.AMQP_VALUE delivery_state): cdef c_amqpvalue.AMQP_VALUE send_data if delivery_state == NULL: wrapped = None else: send_data = c_amqpvalue.amqpvalue_clone(delivery_state) wrapped = copy.deepcopy(value_factory(send_data).value) if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call _on_message_sent during garbage collection") return context_obj = context if hasattr(context_obj, "_on_message_sent"): context_obj._on_message_sent(context_obj, send_result, delivery_state=wrapped) cdef void on_message_sender_state_changed(void* context, c_message_sender.MESSAGE_SENDER_STATE_TAG new_state, c_message_sender.MESSAGE_SENDER_STATE_TAG previous_state): if context != NULL: context_pyobj = context if context_pyobj.ob_refcnt == 0: # context is being garbage collected, skip the callback _logger.warning("Can't call on_state_changed during garbage collection, please be sure to close or use a context manager") return context_obj = context try: context_obj._state_changed(previous_state, new_state) except AttributeError: _logger.info("Unknown MessageSender state changed: %r to %r", previous_state, new_state) azure-uamqp-python-1.6.8/src/platform.pyx000066400000000000000000000026401455573770000205100ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_strings cimport c_platform cimport c_xio cimport c_tlsio _logger = logging.getLogger(__name__) class PlatformInfoOption(Enum): DefaultOption = c_platform.PLATFORM_INFO_OPTION_TAG.PLATFORM_INFO_OPTION_DEFAULT RetrieveSQMOption = c_platform.PLATFORM_INFO_OPTION_TAG.PLATFORM_INFO_OPTION_RETRIEVE_SQM cpdef platform_init(): if c_platform.platform_init() != 0: raise ValueError("Failed to initialize platform.") cpdef platform_deinit(): _logger.debug("Deinitializing platform") c_platform.platform_deinit() cpdef get_info(): cdef c_strings.STRING_HANDLE str_info str_info = c_platform.platform_get_platform_info(PlatformInfoOption.DefaultOption) info = AMQPString() info.wrap(str_info) return info cpdef get_default_tlsio(): cdef const c_xio.IO_INTERFACE_DESCRIPTION* io_desc io_desc = c_platform.platform_get_default_tlsio() if io_desc == NULL: raise ValueError("Failed to create tlsio description.") interface = IOInterfaceDescription() interface.wrap(io_desc) return interface azure-uamqp-python-1.6.8/src/properties.pyx000066400000000000000000000240621455573770000210620ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports from libc cimport stdint cimport c_amqpvalue cimport c_amqp_definitions cimport c_utils _logger = logging.getLogger(__name__) cpdef create_properties(): new_props = cProperties() return new_props cpdef load_properties(AMQPValue value): new_props = cProperties() new_props.load_from_value(value) return new_props cdef class cProperties(StructBase): cdef c_amqp_definitions.PROPERTIES_HANDLE _c_value def __cinit__(self): self._c_value = c_amqp_definitions.properties_create() self._validate() def __dealloc__(self): _logger.debug("Deallocating cProperties") self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): try: if self._c_value is not NULL: _logger.debug("Destroying cProperties") c_amqp_definitions.properties_destroy(self._c_value) except KeyboardInterrupt: pass finally: self._c_value = NULL cdef wrap(self, c_amqp_definitions.PROPERTIES_HANDLE value): self.destroy() self._c_value = value self._validate() cdef load_from_value(self, AMQPValue value): self.destroy() if c_amqp_definitions.amqpvalue_get_properties(value._c_value, &self._c_value) != 0: self._value_error() self._validate() cdef get_properties(self): cdef c_amqpvalue.AMQP_VALUE _value _value = c_amqp_definitions.amqpvalue_create_properties(self._c_value) if _value is NULL: return None return value_factory(_value) cpdef clone(self): cdef c_amqp_definitions.PROPERTIES_HANDLE value value = c_amqp_definitions.properties_clone(self._c_value) if value == NULL: self._value_error() new_obj = cProperties() new_obj.wrap(value) return new_obj @property def message_id(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_amqp_definitions.properties_get_message_id(self._c_value, &_value) == 0: if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: self._value_error() return value_factory(cloned) else: return None @message_id.setter def message_id(self, AMQPValue value): if c_amqp_definitions.properties_set_message_id( self._c_value, value._c_value) != 0: self._value_error("Could not set 'message_id'.") @property def user_id(self): cdef c_amqpvalue.amqp_binary _binary if c_amqp_definitions.properties_get_user_id(self._c_value, &_binary) == 0: bytes_value = _binary.bytes return bytes_value[:_binary.length] else: return None @user_id.setter def user_id(self, AMQPValue value): cdef c_amqpvalue.amqp_binary _binary if c_amqpvalue.amqpvalue_get_binary(value._c_value, &_binary) == 0: if c_amqp_definitions.properties_set_user_id(self._c_value, _binary) != 0: self._value_error("Could not set 'user_id'.") else: self._value_error("Could not set 'user_id'.") @property def to(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_amqp_definitions.properties_get_to(self._c_value, &_value) == 0: if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: self._value_error() return value_factory(cloned) else: return None @to.setter def to(self, AMQPValue value): if c_amqp_definitions.properties_set_to( self._c_value, value._c_value) != 0: self._value_error("Could not set 'to'.") @property def subject(self): cdef char* _value if c_amqp_definitions.properties_get_subject(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @subject.setter def subject(self, char* value): if c_amqp_definitions.properties_set_subject( self._c_value, value) != 0: self._value_error("Could not set 'subject'.") @property def reply_to(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_amqp_definitions.properties_get_reply_to(self._c_value, &_value) == 0: if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: self._value_error() return value_factory(cloned) else: return None @reply_to.setter def reply_to(self, AMQPValue value): if c_amqp_definitions.properties_set_reply_to( self._c_value, value._c_value) != 0: self._value_error("Could not set 'reply_to'.") @property def correlation_id(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_amqp_definitions.properties_get_correlation_id(self._c_value, &_value) == 0: if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: self._value_error() return value_factory(cloned) else: return None @correlation_id.setter def correlation_id(self, AMQPValue value): if c_amqp_definitions.properties_set_correlation_id( self._c_value, value._c_value) != 0: self._value_error("Could not set 'correlation_id'.") @property def content_type(self): cdef char* _value if c_amqp_definitions.properties_get_content_type(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @content_type.setter def content_type(self, char* value): if c_amqp_definitions.properties_set_content_type( self._c_value, value) != 0: self._value_error("Could not set 'content_type'.") @property def content_encoding(self): cdef char* _value if c_amqp_definitions.properties_get_content_encoding(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @content_encoding.setter def content_encoding(self, char* value): if c_amqp_definitions.properties_set_content_encoding( self._c_value, value) != 0: self._value_error("Could not set 'content_encoding'.") @property def absolute_expiry_time(self): cdef c_amqpvalue.timestamp _value if c_amqp_definitions.properties_get_absolute_expiry_time(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @absolute_expiry_time.setter def absolute_expiry_time(self, c_amqpvalue.timestamp value): if c_amqp_definitions.properties_set_absolute_expiry_time( self._c_value, value) != 0: self._value_error("Could not set 'absolute_expiry_time'.") @property def creation_time(self): cdef c_amqpvalue.timestamp _value if c_amqp_definitions.properties_get_creation_time(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @creation_time.setter def creation_time(self, c_amqpvalue.timestamp value): if c_amqp_definitions.properties_set_creation_time( self._c_value, value) != 0: self._value_error("Could not set 'create_time'.") @property def group_id(self): cdef const char* _value if c_amqp_definitions.properties_get_group_id(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @group_id.setter def group_id(self, const char* value): if c_amqp_definitions.properties_set_group_id( self._c_value, value) != 0: self._value_error("Could not set 'group_id'.") @property def group_sequence(self): cdef c_amqp_definitions.sequence_no _value if c_amqp_definitions.properties_get_group_sequence(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @group_sequence.setter def group_sequence(self, c_amqp_definitions.sequence_no value): if c_amqp_definitions.properties_set_group_sequence( self._c_value, value) != 0: self._value_error("Could not set 'group_Sequence'.") @property def reply_to_group_id(self): cdef char* _value if c_amqp_definitions.properties_get_reply_to_group_id(self._c_value, &_value) == 0: if _value == NULL: return None return _value else: return None @reply_to_group_id.setter def reply_to_group_id(self, char* value): if c_amqp_definitions.properties_set_reply_to_group_id( self._c_value, value) != 0: self._value_error("Could not set 'reply_to_group_id'.") azure-uamqp-python-1.6.8/src/sasl.pyx000066400000000000000000000121301455573770000176210ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports cimport c_xio cimport c_sasl_mechanism _logger = logging.getLogger(__name__) cpdef _get_sasl_mechanism_interface(): cdef const c_sasl_mechanism.SASL_MECHANISM_INTERFACE_DESCRIPTION* interface interface = c_sasl_mechanism.saslmssbcbs_get_interface() if interface == NULL: raise ValueError("Failed to create SASL CBS Interface description") desc = SASLMechanismInterfaceDescription() desc.wrap(interface) return desc cpdef saslanonymous_get_interface(): cdef c_sasl_mechanism.SASL_MECHANISM_INTERFACE_DESCRIPTION* io_desc io_desc = c_sasl_mechanism.saslanonymous_get_interface() if io_desc == NULL: raise ValueError("Failed to create SASL Anonymous Interface description") interface = SASLMechanismInterfaceDescription() interface.wrap(io_desc) return interface cpdef saslplain_get_interface(): cdef c_sasl_mechanism.SASL_MECHANISM_INTERFACE_DESCRIPTION* io_desc io_desc = c_sasl_mechanism.saslplain_get_interface() if io_desc == NULL: raise ValueError("Failed to create SASL plain Interface description") interface = SASLMechanismInterfaceDescription() interface.wrap(io_desc) return interface cpdef get_sasl_mechanism(SASLMechanismInterfaceDescription interface=None): if interface is None: interface = _get_sasl_mechanism_interface() sasl_mechanism = SASLMechanism() sasl_mechanism.create(interface) return sasl_mechanism cpdef get_plain_sasl_mechanism(SASLMechanismInterfaceDescription interface, SASLPlainConfig parameters): _logger.debug("Creating SASL Mechanism") sasl_mechanism = SASLMechanism() sasl_mechanism.create_with_parameters(interface, ¶meters._c_value) return sasl_mechanism cdef class SASLMechanism(StructBase): cdef c_sasl_mechanism.SASL_MECHANISM_HANDLE _c_value def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating SASLMechanism") self.destroy() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying SASLMechanism") c_sasl_mechanism.saslmechanism_destroy(self._c_value) self._c_value = NULL cdef wrap(self, c_sasl_mechanism.SASL_MECHANISM_HANDLE value): self.destroy() self._c_value = value self._create() cdef create(self, SASLMechanismInterfaceDescription sasl_mechanism_interface_description): self.destroy() self._c_value = c_sasl_mechanism.saslmechanism_create(sasl_mechanism_interface_description._c_value, NULL) self._create() cdef create_with_parameters(self, SASLMechanismInterfaceDescription sasl_mechanism_interface_description, void *parameters): self.destroy() self._c_value = c_sasl_mechanism.saslmechanism_create(sasl_mechanism_interface_description._c_value, parameters) self._create() cdef class SASLMechanismInterfaceDescription(object): cdef c_sasl_mechanism.SASL_MECHANISM_INTERFACE_DESCRIPTION* _c_value def __cinit__(self): pass cdef wrap(self, c_sasl_mechanism.SASL_MECHANISM_INTERFACE_DESCRIPTION* value): self._c_value = value cdef class SASLClientIOConfig(object): cdef c_sasl_mechanism.SASLCLIENTIO_CONFIG _c_value cdef XIO _underlying_io def __cinit__(self, XIO underlying_io, SASLMechanism sasl_mechanism): if underlying_io._c_value is NULL: raise ValueError("UnderLying IO must not be NULL") if sasl_mechanism._c_value is NULL: raise ValueError("SASL Mechanism must not be NULL") self._underlying_io = underlying_io self._c_value = c_sasl_mechanism.SASLCLIENTIO_CONFIG( underlying_io._c_value, sasl_mechanism._c_value ) cdef class SASLPlainConfig(object): cdef c_sasl_mechanism.SASL_PLAIN_CONFIG _c_value def __cinit__(self): self._c_value = c_sasl_mechanism.SASL_PLAIN_CONFIG(NULL, NULL, NULL) self._c_value.authcid = NULL self._c_value.passwd = NULL self._c_value.authzid = NULL @property def authcid(self): return self._c_value.authcid @authcid.setter def authcid(self, const char* value): self._c_value.authcid = value @property def passwd(self): return self._c_value.passwd @passwd.setter def passwd(self, const char* value): self._c_value.passwd = value @property def authzid(self): return self._c_value.authzid @authzid.setter def authzid(self, const char* value): self._c_value.authzid = value azure-uamqp-python-1.6.8/src/session.pyx000066400000000000000000000126201455573770000203460ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging # C imports from libc cimport stdint cimport c_amqpvalue cimport c_amqp_definitions cimport c_session cimport c_connection _logger = logging.getLogger(__name__) cpdef create_session(Connection connection, on_link_attached_context): session = cSession() session.create(connection, on_link_attached, on_link_attached_context) return session cdef class cSession(StructBase): _links = [] cdef c_session.SESSION_HANDLE _c_value cdef Connection _connection def __cinit__(self): pass def __dealloc__(self): _logger.debug("Deallocating cSession") self.destroy() def __enter__(self): return self def __exit__(self, *args): self.destroy() @property def incoming_window(self): cdef stdint.uint32_t value if c_session.session_get_incoming_window(self._c_value, &value) != 0: self._value_error() return value @incoming_window.setter def incoming_window(self, stdint.uint32_t value): if c_session.session_set_incoming_window(self._c_value, value) != 0: self._value_error() @property def outgoing_window(self): cdef stdint.uint32_t value if c_session.session_get_outgoing_window(self._c_value, &value) != 0: self._value_error() return value @outgoing_window.setter def outgoing_window(self, stdint.uint32_t value): if c_session.session_set_outgoing_window(self._c_value, value) != 0: self._value_error() @property def handle_max(self): cdef c_amqp_definitions.handle value if c_session.session_get_handle_max(self._c_value, &value) != 0: self._value_error() return value @handle_max.setter def handle_max(self, c_amqp_definitions.handle value): if c_session.session_set_handle_max(self._c_value, value) != 0: self._value_error() cdef _create(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cSession") c_session.session_destroy(self._c_value) self._c_value = NULL self._connection = None cdef wrap(self, cSession value): self.destroy() self._connection = value._connection self._c_value = value._c_value self._create() cdef create(self, Connection connection, c_session.ON_LINK_ATTACHED on_link_attached, void* callback_context): self.destroy() self._connection = connection self._c_value = c_session.session_create(connection._c_value, on_link_attached, callback_context) self._create() cpdef begin(self): if c_session.session_begin(self._c_value) != 0: self._value_error() cpdef end(self, const char* condition_value, const char* description): if c_session.session_end(self._c_value, condition_value, description) != 0: self._value_error() #### Callback cdef bint on_link_attached( void* context, c_session.LINK_ENDPOINT_HANDLE new_link_endpoint, const char* name, c_amqp_definitions.role role, c_amqpvalue.AMQP_VALUE source, c_amqpvalue.AMQP_VALUE target, c_amqp_definitions.fields properties): cdef c_amqp_definitions.SOURCE_HANDLE wrapped_source cdef c_amqp_definitions.TARGET_HANDLE wrapped_target cdef c_amqpvalue.AMQP_VALUE wrapped_props cdef c_amqpvalue.AMQP_VALUE cloned_source cdef c_amqpvalue.AMQP_VALUE cloned_target cdef stdint.uint32_t _value attach_properties = None context_obj = context if context_obj == NULL: return True if properties != NULL: wrapped_props = c_amqpvalue.amqpvalue_clone(properties) attach_properties = value_factory(wrapped_props) if source == NULL or target == NULL: _logger.info("Link ATTACH frame missing source and/or target. DETACH pending.") context_obj._attach_received(None, None, attach_properties, "ATTACH frame Source and/or Target is NULL") else: try: cloned_source = c_amqpvalue.amqpvalue_clone(source) cloned_target = c_amqpvalue.amqpvalue_clone(target) if c_amqp_definitions.amqpvalue_get_source(cloned_source, &wrapped_source) != 0: context_obj._attach_received(None, None, attach_properties, "Unable to decode ATTACH frame source") elif c_amqp_definitions.amqpvalue_get_target(cloned_target, &wrapped_target) != 0: context_obj._attach_received(None, None, attach_properties, "Unable to decode ATTACH frame target") else: context_obj._attach_received(source_factory(wrapped_source), target_factory(wrapped_target), attach_properties, None) except Exception as e: _logger.info("Failed to process link ATTACH frame: %r", e) finally: c_amqpvalue.amqpvalue_destroy(cloned_source) c_amqpvalue.amqpvalue_destroy(cloned_target) return True azure-uamqp-python-1.6.8/src/source.pyx000066400000000000000000000146371455573770000201750ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging import copy # C imports cimport c_amqp_definitions cimport c_amqpvalue _logger = logging.getLogger(__name__) cpdef create_source(): source = cSource() return source cdef source_factory(c_amqp_definitions.SOURCE_HANDLE c_source): source = cSource() source.wrap(c_source) return source cdef class cSource(StructBase): cdef c_amqp_definitions.SOURCE_HANDLE _c_value def __cinit__(self): self._c_value = c_amqp_definitions.source_create() self._validate() def __dealloc__(self): _logger.debug("Deallocating cSource") self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cSource") c_amqp_definitions.source_destroy(self._c_value) self._c_value = NULL cdef wrap(self, c_amqp_definitions.SOURCE_HANDLE value): self.destroy() self._c_value = value self._validate() @property def value(self): cdef c_amqpvalue.AMQP_VALUE _value _value = c_amqp_definitions.amqpvalue_create_source(self._c_value) if _value == NULL: self._null_error("Failed to create source.") return value_factory(_value) @property def address(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_amqp_definitions.source_get_address(self._c_value, &_value) != 0: self._value_error("Failed to get source address") if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: return None return value_factory(cloned).value @address.setter def address(self, AMQPValue value): if c_amqp_definitions.source_set_address(self._c_value, value._c_value) != 0: self._value_error("Failed to set source address") @property def durable(self): cdef c_amqp_definitions.terminus_durability _value if c_amqp_definitions.source_get_durable(self._c_value, &_value) != 0: self._value_error("Failed to get source durable") if _value == NULL: return None return _value @durable.setter def durable(self, c_amqp_definitions.terminus_durability value): if c_amqp_definitions.source_set_durable(self._c_value, value) != 0: self._value_error("Failed to set source durable") @property def expiry_policy(self): cdef c_amqp_definitions.terminus_expiry_policy _value if c_amqp_definitions.source_get_expiry_policy(self._c_value, &_value) != 0: self._value_error("Failed to get source expiry_policy") if _value == NULL: return None return _value @expiry_policy.setter def expiry_policy(self, c_amqp_definitions.terminus_expiry_policy value): if c_amqp_definitions.source_set_expiry_policy(self._c_value, value) != 0: self._value_error("Failed to set source expiry_policy") @property def timeout(self): cdef c_amqp_definitions.seconds _value if c_amqp_definitions.source_get_timeout(self._c_value, &_value) != 0: self._value_error("Failed to get source timeout") if _value == NULL: return None return _value @timeout.setter def timeout(self, c_amqp_definitions.seconds value): if c_amqp_definitions.source_set_timeout(self._c_value, value) != 0: self._value_error("Failed to set source timeout") @property def dynamic(self): cdef bint _value if c_amqp_definitions.source_get_dynamic(self._c_value, &_value) != 0: self._value_error("Failed to get source dynamic") if _value == NULL: return None return _value @dynamic.setter def dynamic(self, bint value): if c_amqp_definitions.source_set_dynamic(self._c_value, value) != 0: self._value_error("Failed to set source dynamic") @property def dynamic_node_properties(self): cdef c_amqp_definitions.node_properties _value if c_amqp_definitions.source_get_dynamic_node_properties(self._c_value, &_value) != 0: self._value_error("Failed to get source dynamic_node_properties") if _value == NULL: return None return annotations_factory(_value) @dynamic_node_properties.setter def dynamic_node_properties(self, cFields value): if c_amqp_definitions.source_set_dynamic_node_properties(self._c_value, value._c_value) != 0: self._value_error("Failed to set source dynamic_node_properties") @property def distribution_mode(self): cdef const char* _value if c_amqp_definitions.source_get_distribution_mode(self._c_value, &_value) != 0: self._value_error("Failed to get source distribution_mode") if _value == NULL: return None return _value @distribution_mode.setter def distribution_mode(self, const char* value): if c_amqp_definitions.source_set_distribution_mode(self._c_value, value) != 0: self._value_error("Failed to set source distribution_mode") @property def filter_set(self): cdef c_amqp_definitions.filter_set _value cdef c_amqp_definitions.filter_set clone if c_amqp_definitions.source_get_filter(self._c_value, &_value) != 0: self._value_error("Failed to get source filter_set") if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: return None return value_factory(cloned) @filter_set.setter def filter_set(self, AMQPValue value): if c_amqp_definitions.source_set_filter(self._c_value, value._c_value) != 0: self._value_error("Failed to set source filter_set") azure-uamqp-python-1.6.8/src/target.pyx000066400000000000000000000122131455573770000201470ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # Python imports import logging import copy # C imports cimport c_amqp_definitions cimport c_amqpvalue _logger = logging.getLogger(__name__) cpdef create_target(): target = cTarget() return target cdef target_factory(c_amqp_definitions.TARGET_HANDLE c_target): target = cTarget() target.wrap(c_target) return target cdef class cTarget(StructBase): cdef c_amqp_definitions.TARGET_HANDLE _c_value def __cinit__(self): self._c_value = c_amqp_definitions.target_create() self._validate() def __dealloc__(self): _logger.debug("Deallocating cTarget") self.destroy() cdef _validate(self): if self._c_value is NULL: self._memory_error() cpdef destroy(self): if self._c_value is not NULL: _logger.debug("Destroying cTarget") c_amqp_definitions.target_destroy(self._c_value) self._c_value = NULL cdef wrap(self, c_amqp_definitions.TARGET_HANDLE value): self.destroy() self._c_value = value self._validate() @property def value(self): cdef c_amqpvalue.AMQP_VALUE _value _value = c_amqp_definitions.amqpvalue_create_target(self._c_value) if _value == NULL: self._null_error("Failed to create target.") return value_factory(_value) @property def address(self): cdef c_amqpvalue.AMQP_VALUE _value cdef c_amqpvalue.AMQP_VALUE cloned if c_amqp_definitions.target_get_address(self._c_value, &_value) != 0: self._value_error("Failed to get target address") if _value == NULL: return None cloned = c_amqpvalue.amqpvalue_clone(_value) if cloned == NULL: return None return value_factory(cloned).value @address.setter def address(self, AMQPValue value): if c_amqp_definitions.target_set_address(self._c_value, value._c_value) != 0: self._value_error("Failed to set target address") @property def durable(self): cdef c_amqp_definitions.terminus_durability _value if c_amqp_definitions.target_get_durable(self._c_value, &_value) != 0: self._value_error("Failed to get target durable") if _value == NULL: return None return _value @durable.setter def durable(self, c_amqp_definitions.terminus_durability value): if c_amqp_definitions.target_set_durable(self._c_value, value) != 0: self._value_error("Failed to set target durable") @property def expiry_policy(self): cdef c_amqp_definitions.terminus_expiry_policy _value if c_amqp_definitions.target_get_expiry_policy(self._c_value, &_value) != 0: self._value_error("Failed to get target expiry_policy") if _value == NULL: return None return _value @expiry_policy.setter def expiry_policy(self, c_amqp_definitions.terminus_expiry_policy value): if c_amqp_definitions.target_set_expiry_policy(self._c_value, value) != 0: self._value_error("Failed to set target expiry_policy") @property def timeout(self): cdef c_amqp_definitions.seconds _value if c_amqp_definitions.target_get_timeout(self._c_value, &_value) != 0: self._value_error("Failed to get target timeout") if _value == NULL: return None return _value @timeout.setter def timeout(self, c_amqp_definitions.seconds value): if c_amqp_definitions.target_set_timeout(self._c_value, value) != 0: self._value_error("Failed to set target timeout") @property def dynamic(self): cdef bint _value if c_amqp_definitions.target_get_dynamic(self._c_value, &_value) != 0: self._value_error("Failed to get target dynamic") if _value == NULL: return None return _value @dynamic.setter def dynamic(self, bint value): if c_amqp_definitions.target_set_dynamic(self._c_value, value) != 0: self._value_error("Failed to set target dynamic") @property def dynamic_node_properties(self): cdef c_amqp_definitions.node_properties _value if c_amqp_definitions.target_get_dynamic_node_properties(self._c_value, &_value) != 0: self._value_error("Failed to get target dynamic_node_properties") if _value == NULL: return None return annotations_factory(_value) @dynamic_node_properties.setter def dynamic_node_properties(self, cFields value): if c_amqp_definitions.target_set_dynamic_node_properties(self._c_value, value._c_value) != 0: self._value_error("Failed to set target dynamic_node_properties") azure-uamqp-python-1.6.8/src/tlsio.pyx000066400000000000000000000047161455573770000200240ustar00rootroot00000000000000#------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- # C imports cimport c_tlsio cimport c_xio DEFAULT_PORT = 5671 cdef class TLSIOConfig(object): cdef c_tlsio.TLSIO_CONFIG _c_value def __cinit__(self): self._c_value = c_tlsio.TLSIO_CONFIG(NULL, DEFAULT_PORT, NULL, NULL) @property def hostname(self): return self._c_value.hostname @hostname.setter def hostname(self, const char* value): self._c_value.hostname = value @property def port(self): return self._c_value.port @port.setter def port(self, int port): self._c_value.port = port cpdef set_proxy_config(self, HTTPProxyConfig underlying_io_parameters): cdef const c_xio.IO_INTERFACE_DESCRIPTION* proxy_io proxy_io = c_tlsio.http_proxy_io_get_interface_description() self._c_value.underlying_io_interface = proxy_io self._c_value.underlying_io_parameters = &underlying_io_parameters._c_value cdef class HTTPProxyConfig(object): cdef c_tlsio.HTTP_PROXY_IO_CONFIG _c_value def __cinit__(self): self._c_value = c_tlsio.HTTP_PROXY_IO_CONFIG(NULL, 0, NULL, 0, NULL, NULL) @property def hostname(self): return self._c_value.hostname @hostname.setter def hostname(self, const char* value): self._c_value.hostname = value @property def port(self): return self._c_value.port @port.setter def port(self, int port): self._c_value.port = port @property def proxy_hostname(self): return self._c_value.proxy_hostname @proxy_hostname.setter def proxy_hostname(self, const char* value): self._c_value.proxy_hostname = value @property def proxy_port(self): return self._c_value.proxy_port @proxy_port.setter def proxy_port(self, int port): self._c_value.proxy_port = port @property def username(self): return self._c_value.username @username.setter def username(self, const char* value): self._c_value.username = value @property def password(self): return self._c_value.password @password.setter def password(self, const char* value): self._c_value.password = value azure-uamqp-python-1.6.8/src/vendor/000077500000000000000000000000001455573770000174155ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/000077500000000000000000000000001455573770000221045ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/.gitattributes000066400000000000000000000014711455573770000250020ustar00rootroot00000000000000# Default behavior: if Git thinks a file is text (as opposed to binary), it # will normalize line endings to LF in the repository, but convert to your # platform's native line endings on checkout (e.g., CRLF for Windows). * text=auto # Explicitly declare text files you want to always be normalized and converted # to native line endings on checkout. E.g., #*.c text # Declare files that will always have CRLF line endings on checkout. E.g., #*.sln text eol=crlf # Declare files that will always have LF line endings on checkout. E.g., *.sh text eol=lf *.json text eol=lf # Denote all files that should not have line endings normalized, should not be # merged, and should not show in a textual diff. *.docm binary *.docx binary *.ico binary *.lib binary *.png binary *.pptx binary *.snk binary *.vsdx binary *.xps binary azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/.gitignore000066400000000000000000000010251455573770000240720ustar00rootroot00000000000000################################################################################ # This .gitignore file was automatically created by Microsoft(R) Visual Studio. ################################################################################ **/bin/* **/obj/* *.lastbuildstate *.log *.opensdf *.sdf *.suo *.~vsdx *.lib *.pdb *.idb *.obj *.tlog *.cache *.exe *.ilk *.TMP *.zip *.ipch *.pch *.user *.codeanalysis *.codeanalysisast *.lastcodeanalysissucceeded *.dll *.config *.coverage *.exp *.i /cmake* /build /.vscode/* /**/.vs/*azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/.gitmodules000066400000000000000000000011221455573770000242550ustar00rootroot00000000000000[submodule "deps/azure-c-shared-utility"] path = deps/azure-c-shared-utility url = https://github.com/Azure/azure-c-shared-utility [submodule "deps/azure-ctest"] path = deps/azure-ctest url = https://github.com/Azure/azure-ctest [submodule "deps/umock-c"] path = deps/umock-c url = https://github.com/Azure/umock-c [submodule "deps/azure-c-testrunnerswitcher"] path = deps/azure-c-testrunnerswitcher url = https://github.com/Azure/azure-c-testrunnerswitcher [submodule "deps/azure-macro-utils-c"] path = deps/azure-macro-utils-c url = https://github.com/Azure/azure-macro-utils-c.git azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/CMakeLists.txt000066400000000000000000000275411455573770000246550ustar00rootroot00000000000000#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. cmake_minimum_required(VERSION 3.5) project(uamqp) FILE(READ ${CMAKE_CURRENT_LIST_DIR}/version.txt UAMQP_VERSION) option(run_e2e_tests "set run_e2e_tests to ON to run e2e tests (default is OFF) [if possible, they are always built]" OFF) option(run_unittests "set run_unittests to ON to run unittests (default is OFF)" OFF) option(skip_samples "set skip_samples to ON to skip building samples (default is OFF)[if possible, they are always built]" OFF) option(use_installed_dependencies "set use_installed_dependencies to ON to use installed packages instead of building dependencies from submodules" OFF) option(memory_trace "set memory_trace to ON if memory usage is to be used, set to OFF to not use it" OFF) option(use_custom_heap "use externally defined heap functions instead of the malloc family" OFF) option(use_latest_windows_sdk "use latest windows sdk if available (default is OFF)" OFF) option(latest_windows_sdk_shared_include_path "the path to Windows SDK shared include") if(${use_latest_windows_sdk}) include_directories(${latest_windows_sdk_shared_include_path}) endif() if(${use_custom_heap}) add_definitions(-DGB_USE_CUSTOM_HEAP) endif() if(${no_logging}) add_definitions(-DNO_LOGGING) endif() #do not add or build any tests of the dependencies set(original_run_e2e_tests ${run_e2e_tests}) set(original_run_int_tests ${run_int_tests}) set(original_run_unittests ${run_unittests}) set(run_e2e_tests OFF) set(run_int_tests OFF) set(run_unittests OFF) if(NOT ${use_installed_dependencies}) if ((NOT TARGET azure_macro_utils_c) AND (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/azure-macro-utils-c/CMakeLists.txt)) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/azure-macro-utils-c) endif() if ((NOT TARGET umock_c) AND (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/umock-c/CMakeLists.txt)) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/umock-c) endif() if(${original_run_e2e_tests} OR ${original_run_unittests}) if ((NOT TARGET testrunnerswitcher) AND (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-testrunnerswitcher/CMakeLists.txt)) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-testrunnerswitcher) endif() if ((NOT TARGET ctest) AND (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/azure-ctest/CMakeLists.txt)) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/azure-ctest) endif() endif() if ((NOT TARGET aziotsharedutil) AND (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-shared-utility/CMakeLists.txt)) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-shared-utility) endif() else() if (NOT azure_macro_utils_cFOUND) find_package(azure_macro_utils_c REQUIRED CONFIG) endif () if (NOT umock_cFOUND) find_package(umock_c REQUIRED CONFIG) endif () if (NOT azure_c_shared_utilityFOUND) find_package(azure_c_shared_utility REQUIRED CONFIG) endif () include(${azure_c_shared_utility_DIR}/azure_c_shared_utilityConfig.cmake) include(${azure_c_shared_utility_DIR}/azure_c_shared_utilityFunctions.cmake) include(${azure_c_shared_utility_DIR}/azure_iot_build_rules.cmake) endif() include_directories(${MACRO_UTILS_INC_FOLDER} ${UMOCK_C_INC_FOLDER}) # Include the common build rules for C shared utility if(NOT ${use_installed_dependencies}) include(${SHARED_UTIL_FOLDER}/configs/azure_iot_build_rules.cmake) set_platform_files(${SHARED_UTIL_FOLDER}) endif() set(run_e2e_tests ${original_run_e2e_tests}) set(run_int_tests ${original_run_int_tests}) set(run_unittests ${original_run_unittests}) if(${memory_trace}) add_definitions(-DGB_MEASURE_MEMORY_FOR_THIS -DGB_DEBUG_ALLOC) endif() option(use_socketio "set use_socketio to ON if socketio is to be included in the library, set to OFF if a different implementation will be provided" ON) if(WIN32) option(use_schannel "set use_schannel to ON if schannel is to be used, set to OFF to not use schannel" ON) option(use_openssl "set use_openssl to ON if openssl is to be used, set to OFF to not use openssl" OFF) option(use_wolfssl "set use_wolfssl to ON if wolfssl is to be used, set to OFF to not use wolfssl" OFF) else() option(use_schannel "set use_schannel to ON if schannel is to be used, set to OFF to not use schannel" OFF) option(use_openssl "set use_openssl to ON if openssl is to be used, set to OFF to not use openssl" ON) option(use_wolfssl "set use_wolfssl to ON if wolfssl is to be used, set to OFF to not use wolfssl" OFF) endif() # The native apple tlsio does not support socket_io if(MACOSX AND NOT ${use_openssl}) set(use_socketio OFF) endif() add_definitions(-DREFCOUNT_ATOMIC_DONTCARE) add_definitions(-D__STDC_NO_ATOMICS__=1) include_directories(${CMAKE_CURRENT_LIST_DIR}/inc) if(WIN32) include_directories($ENV{OpenSSLDir}/include) endif() set(uamqp_h_files ./inc/azure_uamqp_c/amqp_definitions_role.h ./inc/azure_uamqp_c/amqp_definitions_sender_settle_mode.h ./inc/azure_uamqp_c/amqp_definitions_receiver_settle_mode.h ./inc/azure_uamqp_c/amqp_definitions_handle.h ./inc/azure_uamqp_c/amqp_definitions_seconds.h ./inc/azure_uamqp_c/amqp_definitions_milliseconds.h ./inc/azure_uamqp_c/amqp_definitions_delivery_tag.h ./inc/azure_uamqp_c/amqp_definitions_sequence_no.h ./inc/azure_uamqp_c/amqp_definitions_delivery_number.h ./inc/azure_uamqp_c/amqp_definitions_transfer_number.h ./inc/azure_uamqp_c/amqp_definitions_message_format.h ./inc/azure_uamqp_c/amqp_definitions_ietf_language_tag.h ./inc/azure_uamqp_c/amqp_definitions_fields.h ./inc/azure_uamqp_c/amqp_definitions_error.h ./inc/azure_uamqp_c/amqp_definitions_amqp_error.h ./inc/azure_uamqp_c/amqp_definitions_connection_error.h ./inc/azure_uamqp_c/amqp_definitions_session_error.h ./inc/azure_uamqp_c/amqp_definitions_link_error.h ./inc/azure_uamqp_c/amqp_definitions_open.h ./inc/azure_uamqp_c/amqp_definitions_begin.h ./inc/azure_uamqp_c/amqp_definitions_attach.h ./inc/azure_uamqp_c/amqp_definitions_flow.h ./inc/azure_uamqp_c/amqp_definitions_transfer.h ./inc/azure_uamqp_c/amqp_definitions_disposition.h ./inc/azure_uamqp_c/amqp_definitions_detach.h ./inc/azure_uamqp_c/amqp_definitions_end.h ./inc/azure_uamqp_c/amqp_definitions_close.h ./inc/azure_uamqp_c/amqp_definitions_sasl_code.h ./inc/azure_uamqp_c/amqp_definitions_sasl_mechanisms.h ./inc/azure_uamqp_c/amqp_definitions_sasl_init.h ./inc/azure_uamqp_c/amqp_definitions_sasl_challenge.h ./inc/azure_uamqp_c/amqp_definitions_sasl_response.h ./inc/azure_uamqp_c/amqp_definitions_sasl_outcome.h ./inc/azure_uamqp_c/amqp_definitions_terminus_durability.h ./inc/azure_uamqp_c/amqp_definitions_terminus_expiry_policy.h ./inc/azure_uamqp_c/amqp_definitions_node_properties.h ./inc/azure_uamqp_c/amqp_definitions_filter_set.h ./inc/azure_uamqp_c/amqp_definitions_source.h ./inc/azure_uamqp_c/amqp_definitions_target.h ./inc/azure_uamqp_c/amqp_definitions_annotations.h ./inc/azure_uamqp_c/amqp_definitions_message_id_ulong.h ./inc/azure_uamqp_c/amqp_definitions_message_id_uuid.h ./inc/azure_uamqp_c/amqp_definitions_message_id_binary.h ./inc/azure_uamqp_c/amqp_definitions_message_id_string.h ./inc/azure_uamqp_c/amqp_definitions_address_string.h ./inc/azure_uamqp_c/amqp_definitions_header.h ./inc/azure_uamqp_c/amqp_definitions_delivery_annotations.h ./inc/azure_uamqp_c/amqp_definitions_message_annotations.h ./inc/azure_uamqp_c/amqp_definitions_application_properties.h ./inc/azure_uamqp_c/amqp_definitions_data.h ./inc/azure_uamqp_c/amqp_definitions_amqp_sequence.h ./inc/azure_uamqp_c/amqp_definitions_amqp_value.h ./inc/azure_uamqp_c/amqp_definitions_footer.h ./inc/azure_uamqp_c/amqp_definitions_properties.h ./inc/azure_uamqp_c/amqp_definitions_received.h ./inc/azure_uamqp_c/amqp_definitions_accepted.h ./inc/azure_uamqp_c/amqp_definitions_rejected.h ./inc/azure_uamqp_c/amqp_definitions_released.h ./inc/azure_uamqp_c/amqp_definitions_modified.h ./inc/azure_uamqp_c/amqp_definitions.h ./inc/azure_uamqp_c/amqp_frame_codec.h ./inc/azure_uamqp_c/amqp_management.h ./inc/azure_uamqp_c/amqp_types.h ./inc/azure_uamqp_c/amqpvalue.h ./inc/azure_uamqp_c/amqpvalue_to_string.h ./inc/azure_uamqp_c/async_operation.h ./inc/azure_uamqp_c/cbs.h ./inc/azure_uamqp_c/connection.h ./inc/azure_uamqp_c/frame_codec.h ./inc/azure_uamqp_c/header_detect_io.h ./inc/azure_uamqp_c/link.h ./inc/azure_uamqp_c/message.h ./inc/azure_uamqp_c/message_receiver.h ./inc/azure_uamqp_c/message_sender.h ./inc/azure_uamqp_c/messaging.h ./inc/azure_uamqp_c/sasl_anonymous.h ./inc/azure_uamqp_c/sasl_frame_codec.h ./inc/azure_uamqp_c/sasl_mechanism.h ./inc/azure_uamqp_c/sasl_server_mechanism.h ./inc/azure_uamqp_c/sasl_mssbcbs.h ./inc/azure_uamqp_c/sasl_plain.h ./inc/azure_uamqp_c/saslclientio.h ./inc/azure_uamqp_c/sasl_server_io.h ./inc/azure_uamqp_c/server_protocol_io.h ./inc/azure_uamqp_c/session.h ./inc/azure_uamqp_c/socket_listener.h ./inc/azure_uamqp_c/uamqp.h ) set(uamqp_c_files ./src/amqp_definitions.c ./src/amqp_frame_codec.c ./src/amqp_management.c ./src/amqpvalue.c ./src/amqpvalue_to_string.c ./src/async_operation.c ./src/cbs.c ./src/connection.c ./src/frame_codec.c ./src/header_detect_io.c ./src/link.c ./src/message.c ./src/message_receiver.c ./src/message_sender.c ./src/messaging.c ./src/sasl_anonymous.c ./src/sasl_frame_codec.c ./src/sasl_mechanism.c ./src/sasl_server_mechanism.c ./src/sasl_mssbcbs.c ./src/sasl_plain.c ./src/saslclientio.c ./src/session.c ) if(WIN32) set(socketlistener_c_files ./src/socket_listener_win32.c ) elseif(UNIX) set(socketlistener_c_files ./src/socket_listener_berkeley.c ) else() set(socketlistener_c_files ) endif() add_library(uamqp ${uamqp_c_files} ${uamqp_h_files} ${socketlistener_c_files} ) setTargetBuildProperties(uamqp) target_link_libraries(uamqp aziotsharedutil) if (NOT ${skip_samples}) add_subdirectory(samples) endif() if (${run_unittests}) include("dependencies-test.cmake") add_subdirectory(tests) endif() # The following "set" statetement exports across the project a global variable set(UAMQP_INC_FOLDER ${CMAKE_CURRENT_LIST_DIR}/inc CACHE INTERNAL "This is the include folder for UAMQP" FORCE) set(UAMQP_SRC_FOLDER ${CMAKE_CURRENT_LIST_DIR}/src CACHE INTERNAL "This is the lib folder for UAMQP" FORCE) # Set CMAKE_INSTALL_LIBDIR if not defined include(GNUInstallDirs) # Install uamqp set(package_location "cmake") if(NOT DEFINED CMAKE_INSTALL_LIBDIR) set(CMAKE_INSTALL_LIBDIR "lib") endif() install(TARGETS uamqp EXPORT uamqpTargets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/../bin INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/azureiot ) install(FILES ${uamqp_h_files} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/azureiot/azure_uamqp_c) include(CMakePackageConfigHelpers) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake" VERSION ${UAMQP_VERSION} COMPATIBILITY SameMajorVersion ) configure_file("configs/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake" COPYONLY ) install(EXPORT uamqpTargets FILE "${PROJECT_NAME}Targets.cmake" DESTINATION ${package_location} ) install( FILES "configs/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake" DESTINATION ${package_location} ) compileTargetAsC99(uamqp) azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/LICENSE000066400000000000000000000021541455573770000231130ustar00rootroot00000000000000Microsoft Azure IoT SDKs Copyright (c) Microsoft Corporation All rights reserved. MIT License Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/SECURITY.MD000066400000000000000000000054111455573770000235760ustar00rootroot00000000000000 ## Security Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/). If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft's [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)) of a security vulnerability, please report it to us as described below. ## Reporting Security Issues **Please do not report security vulnerabilities through public GitHub issues.** Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report). If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc). You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc). Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue: * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.) * Full paths of source file(s) related to the manifestation of the issue * The location of the affected source code (tag/branch/commit or direct URL) * Any special configuration required to reproduce the issue * Step-by-step instructions to reproduce the issue * Proof-of-concept or exploit code (if possible) * Impact of the issue, including how an attacker might exploit the issue This information will help us triage your report more quickly. If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs. ## Preferred Languages We prefer all communications to be in English. ## Policy Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd). azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build/000077500000000000000000000000001455573770000232035ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build/.vsts-ci.yml000066400000000000000000000421221455573770000253750ustar00rootroot00000000000000name: $(BuildID)_$(BuildDefinitionName)_$(SourceBranchName)_$(Date:yyyyMMdd)$(Rev:.r) variables: runCodesignValidationInjection: false resources: - repo: self clean: true jobs: - job: checksubmodule pool: vmImage: 'ubuntu-20.04' steps: - script: | sudo apt-get update && apt-get install -y \ curl \ git \ python-software-properties \ build-essential \ pkg-config sudo curl -sL https://deb.nodesource.com/setup_6.x | bash - sudo apt-get install -y nodejs displayName: 'setup' - script: | npm install check_submodules ./../../node_modules/.bin/check_submodules . master displayName: 'build' - job: windowsx86 pool: name: 'sdk-c--win-vs2017' steps: - script: | if exist jenkins\windows_c.cmd ( call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\VsDevCmd.bat" call jenkins\windows_c.cmd) displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: cd .. && rd /Q /S $(Agent.BuildDirectory)\s displayName: 'cleanup' condition: always() - job: raspberrypi variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/raspberrypi-c-buster:brown" pool: name: 'sdk-c--ubuntu-18' displayName: raspberrypi steps: - script: | chmod +x jenkins/raspberrypi_c_buster.sh ./jenkins/raspberrypi_c_buster.sh displayName: 'build' - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' - job: linuxoptions variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/vsts-linux-c-ubuntu" pool: name: 'sdk-c--ubuntu-18' displayName: 'linux-options' steps: - script: | if [ -f "jenkins/linux_c_option_test.sh" ] then sudo ./jenkins/linux_c_option_test.sh fi displayName: 'build' condition: always() - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: windowsdynamic pool: name: 'sdk-c--win-vs2017' steps: - script: | if exist jenkins\windows_c_build_as_dynamic.cmd ( call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\VsDevCmd.bat" call jenkins\windows_c_build_as_dynamic.cmd) displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: cd .. && rd /Q /S $(Agent.BuildDirectory)\s displayName: 'cleanup' condition: always() - job: OSX pool: name: OSX steps: - script: | if [ -f "jenkins/osx_gcc_openssl.sh" ] then ./jenkins/osx_gcc_openssl.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: clang variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/ubuntu-clang" pool: name: 'sdk-c--ubuntu-18' displayName: 'clang' steps: - script: | if [ -f "jenkins/ubuntu_clang.sh" ] then export OPENSSL_ia32cap=0x00000000 sudo chmod -R 755 . sudo -E ./jenkins/ubuntu_clang.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: ubuntu1604 variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/linux-c-ubuntu" pool: name: 'sdk-c--ubuntu-18' displayName: 'ubuntu1604' steps: - script: | if [ -f "jenkins/ubuntu1604_c.sh" ] then export OPENSSL_ia32cap=0x00000000 sudo chmod -R 755 . sudo -E ./jenkins/ubuntu1604_c.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: linux_install_deps variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/c-debian" pool: name: 'sdk-c--ubuntu-18' displayName: 'linux_install_deps' steps: - script: | if [ -f "jenkins/linux_install_deps.sh" ] then sudo chmod 755 jenkins/linux_install_deps.sh sudo -E ./jenkins/linux_install_deps.sh sudo jenkins/linux_install_deps.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: debian variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/c-debian" pool: name: 'sdk-c--ubuntu-18' displayName: 'debian' steps: - script: | if [ -f "jenkins/debian_c.sh" ] then sudo chmod 755 jenkins/debian_c.sh sudo -E ./debian_c.sh sudo jenkins/debian_c.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: wolfssl variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/vsts-c-wolfssl" pool: name: 'sdk-c--ubuntu-18' displayName: 'wolfssl' steps: - script: | if [ -f "jenkins/linux_wolfssl.sh" ] then LD_LIBRARY_PATH=/usr/local/lib LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/my_library/ sudo jenkins/linux_wolfssl.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: windowsx64 pool: name: 'sdk-c--win-vs2017' displayName: 'windowsx64' steps: - script: | if exist jenkins\windows_c.cmd ( call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\VsDevCmd.bat" call jenkins\windows_c.cmd --platform x64) displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: cd .. && rd /Q /S $(Agent.BuildDirectory)\s displayName: 'cleanup' condition: always() - job: xcodenative pool: name: OSX steps: - script: | if [ -f "jenkins/osx_xcode_native.sh" ] then DYLD_LIBRARY_PATH=/usr/local/Cellar/curl/7.61.0/lib ./jenkins/osx_xcode_native.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) UAMQP_E2E_DEVICE_KEY: $(UAMQP-E2E-DEVICE-KEY) - script: rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/000077500000000000000000000000001455573770000240335ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/mbed/000077500000000000000000000000001455573770000247425ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/mbed/CMakeLists.txt000066400000000000000000000006241455573770000275040ustar00rootroot00000000000000#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. cmake_minimum_required(VERSION 2.8.11) set(shared_util_base_path ../../deps/azure-c-shared-utility) set(mbed_project_base "azure_uamqp_c" CACHE STRING "The item being built") include (${shared_util_base_path}/tools/mbed_build_scripts/mbedbldtemplate.txt) azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/mbed/azure_uamqp_c_filelist.txt000066400000000000000000000203511455573770000322320ustar00rootroot00000000000000set(mbed_exported_project_files ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_accepted.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_address_string.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_amqp_error.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_amqp_sequence.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_amqp_value.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_annotations.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_application_properties.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_attach.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_begin.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_close.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_connection_error.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_data.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_delivery_annotations.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_delivery_number.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_delivery_tag.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_detach.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_disposition.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_end.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_error.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_fields.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_filter_set.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_flow.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_footer.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_handle.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_header.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_ietf_language_tag.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_link_error.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_message_annotations.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_message_format.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_message_id_binary.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_message_id_string.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_message_id_ulong.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_message_id_uuid.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_milliseconds.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_modified.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_node_properties.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_open.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_properties.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_received.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_receiver_settle_mode.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_rejected.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_released.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_role.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sasl_challenge.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sasl_code.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sasl_init.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sasl_mechanisms.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sasl_outcome.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sasl_response.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_seconds.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sender_settle_mode.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_sequence_no.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_session_error.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_source.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_target.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_terminus_durability.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_terminus_expiry_policy.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_transfer.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_definitions_transfer_number.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_frame_codec.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_management.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqp_types.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqpalloc.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqpvalue.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/amqpvalue_to_string.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/async_operation.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/cbs.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/connection.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/frame_codec.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/header_detect_io.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/link.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/logger.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/message.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/message_receiver.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/message_sender.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/messaging.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_anonymous.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_frame_codec.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_mechanism.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_mssbcbs.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_plain.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_server_mechanism.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/sasl_server_io.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/saslclientio.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/server_protocol_io.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/session.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/socket_listener.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_uamqp_c/uamqp.h ) set(mbed_project_files ${CMAKE_CURRENT_SOURCE_DIR}/../../src/amqp_definitions.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/amqp_frame_codec.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/amqp_management.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/amqpalloc.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/amqpvalue.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/amqpvalue_to_string.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/async_operation.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/cbs.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/connection.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/frame_codec.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/header_detect_io.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/link.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/message.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/message_receiver.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/message_sender.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/messaging.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sasl_anonymous.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sasl_frame_codec.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sasl_mechanism.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sasl_mssbcbs.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sasl_plain.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/saslclientio.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/session.c ) azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/mbed/build.cmd000066400000000000000000000030301455573770000265220ustar00rootroot00000000000000 @setlocal EnableExtensions EnableDelayedExpansion @echo off set current-path=%~dp0 rem // remove trailing slash set current-path=%current-path:~0,-1% set repo-build-root=%current-path%\..\.. rem // resolve to fully qualified path for %%i in ("%repo-build-root%") do set repo-build-root=%%~fi rem ----------------------------------------------------------------------------- rem -- build (clean) compilembed tool rem ----------------------------------------------------------------------------- call "%repo-build-root%\deps\azure-c-shared-utility\tools\compilembed\build.cmd" --clean if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- build uAMQP and samples rem ----------------------------------------------------------------------------- call %repo-build-root%\deps\azure-c-shared-utility\tools\mbed_build_scripts\release_mbed_project.cmd %repo-build-root%\build_all if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! call :compile message_sender_sample %repo-build-root%\samples\message_sender_sample\mbed if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! goto :eof :compile setlocal EnableExtensions set "project_name=%~1" set "project_path=%~2" set "download_bin_path=%~3" set "cmake_project_bin_path=%project_name%_cmake_build" mkdir %cmake_project_bin_path% cd %cmake_project_bin_path% cmake -Dmbed_repo_name:string=%project_name% -Dmbed_output_bin_path:string=%download_bin_path% %project_path% set CMAKE_ERROR_CODE=!ERRORLEVEL! cd .. exit /b %CMAKE_ERROR_CODE% goto:eof azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/000077500000000000000000000000001455573770000257575ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/000077500000000000000000000000001455573770000271165ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/000077500000000000000000000000001455573770000303405ustar00rootroot00000000000000azure-uamqp-c-dev.dirs000066400000000000000000000000511455573770000344030ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debianusr/lib usr/include usr/include/azureiot azure-uamqp-c-dev.install000066400000000000000000000000271455573770000351130ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debianusr/include/azureiot/* azure-uamqp-c-lib.dirs000066400000000000000000000000101455573770000343660ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debianusr/lib azure-uamqp-c-lib.install000066400000000000000000000000171455573770000351020ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debianusr/lib/lib*.a azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/changelog-trusty000066400000000000000000000003301455573770000335560ustar00rootroot00000000000000azure-uamqp-c (0.2.0-1trusty) trusty; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Tue, 27 Sep 2016 11:00:00 +0000 azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/changelog-vivid000066400000000000000000000003271455573770000333330ustar00rootroot00000000000000azure-uamqp-c (0.1.0-65vivid) vivid; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Tue, 27 Sep 2016 11:00:00 +0000 azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/changelog-wily000066400000000000000000000003221455573770000331710ustar00rootroot00000000000000azure-uamqp-c (undefined) wily; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Tue, 27 Sep 2016 11:00:00 +0000 azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/changelog-xenial000066400000000000000000000003321455573770000334660ustar00rootroot00000000000000azure-uamqp-c (0.2.0.0-1xenial) xenial; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Tue, 29 Sep 2016 11:00:00 +0000 azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/compat000066400000000000000000000000021455573770000315360ustar00rootroot000000000000009 azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/control000066400000000000000000000031341455573770000317440ustar00rootroot00000000000000Source: azure-uamqp-c Priority: optional Maintainer: AzureIoT User Build-Depends: debhelper (>= 9), cmake (>= 2.8), libssl-dev, libcurl4-openssl-dev, curl, azure-c-shared-util-dev Standards-Version: 3.9.6 Section: libs Homepage: https://github.com/Azure/azure-uamqp-c.git #Vcs-Git: git://anonscm.debian.org/collab-maint/azure-uamqp-c.git #Vcs-Browser: https://anonscm.debian.org/gitweb/?p=collab-maint/azure-uamqp-c.git;a=summary Package: azure-uamqp-c-dev Section: libdevel Architecture: any Depends: azure-uamqp-c-lib (= ${binary:Version}), ${misc:Depends}, azure-c-shared-util-dev Description: uAMQP is a general purpose C library for AMQP. The goal is to be as compliant with the standard as possible while optimizing for low RAM footprint and also being portable. It is currently a client side implementation only. Although much of the standardis symmetrical, there are parts that are asymmetrical, like the SASL handshake. Currently uAMQP does not provide the server side for these asymmetrical protions of the ISO. Package: azure-uamqp-c-lib Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, curl, azure-c-shared-util-dev Description: uAMQP is a general purpose C library for AMQP. The goal is to be as compliant with the standard as possible while optimizing for low RAM footprint and also being portable. It is currently a client side implementation only. Although much of the standardis symmetrical, there are parts that are asymmetrical, like the SASL handshake. Currently uAMQP does not provide the server side for these asymmetrical protions of the ISO. azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/copyright000066400000000000000000000025141455573770000322750ustar00rootroot00000000000000Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: azure-uamqp-c Source: Files: * Copyright: 2016 AzureIoT User License: MIT Files: debian/* Copyright: 2016 Azure User License: MIT License: MIT Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: . The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. . THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/docs000066400000000000000000000000121455573770000312040ustar00rootroot00000000000000readme.md azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/rules000077500000000000000000000021051455573770000314160ustar00rootroot00000000000000#!/usr/bin/make -f # See debhelper(7) (uncomment to enable) # output every command that modifies files on the build system. export DH_VERBOSE = 1 # see EXAMPLES in dpkg-buildflags(1) and read /usr/share/dpkg/* DPKG_EXPORT_BUILDFLAGS = 1 include /usr/share/dpkg/default.mk # see FEATURE AREAS in dpkg-buildflags(1) #export DEB_BUILD_MAINT_OPTIONS = hardening=+all # see ENVIRONMENT in dpkg-buildflags(1) # package maintainers to append CFLAGS #export DEB_CFLAGS_MAINT_APPEND = -Wall -pedantic # package maintainers to append LDFLAGS #export DEB_LDFLAGS_MAINT_APPEND = -Wl,--as-needed # main packaging script based on dh7 syntax %: dh $@ --buildsystem=cmake --DSYSINSTALL_BINDINGS=ON override_dh_auto_configure: dh_auto_configure -- override_dh_auto_install: rm -f -r $$(pwd)/debian/tmp mkdir $$(pwd)/debian/tmp mkdir $$(pwd)/debian/tmp/usr mkdir $$(pwd)/debian/tmp/usr/lib mkdir $$(pwd)/debian/tmp/usr/include mkdir $$(pwd)/debian/tmp/usr/include/azureiot cp $$(pwd)/obj-*/*.a $$(pwd)/debian/tmp/usr/lib/ cp $$(pwd)/inc/azure_uamqp_c/* $$(pwd)/debian/tmp/usr/include/azureiot azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/source/000077500000000000000000000000001455573770000316405ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/linux/debian/source/format000066400000000000000000000000151455573770000330470ustar00rootroot000000000000003.0 (native) azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/windows/000077500000000000000000000000001455573770000274515ustar00rootroot00000000000000Microsoft.Azure.uamqp.nuspec000066400000000000000000000050071455573770000347670ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/windows Microsoft.Azure.uamqp 1.2.4 Microsoft Azure uAMQP Microsoft Corp Azure-IoT https://github.com/Azure/azure-uamqp-c/blob/master/LICENSE https://github.com/Azure/azure-uamqp-c true Microsoft Azure uAMQP library http://go.microsoft.com/fwlink/?LinkID=288890 This nuget package can be used for developing amqp applications and libraries Updated reference to shared utility nuget Copyright 2016 Microsoft Azure C Native x86 x64 arm native uamqp package Microsoft.Azure.uamqp.targets000066400000000000000000000175751455573770000351600ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/windows static cdecl $(MSBuildThisFileDirectory)../../build/native/include/;%(AdditionalIncludeDirectories) $(MSBuildThisFileDirectory)../../build/native/include/;%(AdditionalIncludeDirectories) $(MSBuildThisFileDirectory)../../build/native/Win32/Debug/uamqp.lib;%(AdditionalDependencies) $(MSBuildThisFileDirectory)../../build/native/Win32/Release/uamqp.lib;%(AdditionalDependencies) $(MSBuildThisFileDirectory)../../build/native/x64/Debug/uamqp.lib;%(AdditionalDependencies) $(MSBuildThisFileDirectory)../../build/native/x64/Release/uamqp.lib;%(AdditionalDependencies) $(MSBuildThisFileDirectory)../../build/native/arm/Debug/uamqp.lib;%(AdditionalDependencies) $(MSBuildThisFileDirectory)../../build/native/arm/Release/uamqp.lib;%(AdditionalDependencies) Result = ((Text ?? "").Split(';').Contains(Library) ) ? Value : String.Empty; Microsoft.Azure.uamqp_thirdpartynotice.txt000066400000000000000000000010771455573770000377700ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/windowsThird Party Notices for Azure Amqp library project This project incorporates material from the project(s) listed below (collectively, "Third Party Code"). Microsoft Corporation is not the original author of the Third Party Code. The original copyright notice and license, under which Microsoft Corporation received such Third Party Code, are set out below. This Third Party Code is licensed to you under their original license terms set forth below. Microsoft Corporation reserves all other rights not expressly granted, whether by implication, estoppel or otherwise. azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/packaging/windows/rebuild_nugets.cmd000066400000000000000000000100041455573770000331440ustar00rootroot00000000000000@REM Copyright (c) Microsoft. All rights reserved. @REM Licensed under the MIT license. See LICENSE file in the project root for full license information. @setlocal EnableExtensions EnableDelayedExpansion @echo off rem ----------------------------------------------------------------------------- rem -- setup path information rem ----------------------------------------------------------------------------- set current-path=%~dp0 rem // remove trailing slash set current-path=%current-path:~0,-1% echo Current Path: %current-path% set build-root=%current-path%\..\..\.. rem // resolve to fully qualified path for %%i in ("%build-root%") do set build-root=%%~fi set client-root=%current-path%\..\..\.. for %%i in ("%client-root%") do set client-root=%%~fi rem ----------------------------------------------------------------------------- rem -- check prerequisites and clean directories rem ----------------------------------------------------------------------------- where /q nuget.exe if not !errorlevel! == 0 ( @Echo Azure Amqp needs to download nuget.exe from https://www.nuget.org/nuget.exe @Echo https://www.nuget.org choice /C yn /M "Do you want to download and run nuget.exe?" if not !errorlevel!==1 goto :eof rem if nuget.exe is not found, then ask user Powershell.exe wget -outf nuget.exe https://nuget.org/nuget.exe if not exist .\nuget.exe ( echo nuget does not exist exit /b 1 ) ) set build-path=%build-root%\cmake if exist %build-path%\azure_amqp_output ( rmdir /s/q %build-path%\azure_amqp_output rem no error checking ) rem ----------------------------------------------------------------------------- rem -- build project rem ----------------------------------------------------------------------------- call %build-root%\build_all\windows\build.cmd --make_nuget yes rem ----------------------------------------------------------------------------- rem -- Copy Win32 binaries rem ----------------------------------------------------------------------------- rem -- Copy all Win32 files from cmake build directory to the repo directory echo copying %build-path%\uamqp_win32\win32\debug rem -- Copy all Win32 files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\uamqp_win32\Debug\*.* %build-path%\azure_amqp_output\win32\debug\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Copy all Win32 Release files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\uamqp_win32\Release\*.* %build-path%\azure_amqp_output\win32\Release\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- build with CMAKE x64 rem ----------------------------------------------------------------------------- rem -- Copy all x64 files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\uamqp_x64\Debug\*.* %build-path%\azure_amqp_output\x64\debug\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Copy all x64 Release files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\uamqp_x64\Release\*.* %build-path%\azure_amqp_output\x64\Release\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- build with CMAKE ARM rem ----------------------------------------------------------------------------- rem -- Copy all ARM files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\uamqp_arm\Debug\*.* %build-path%\azure_amqp_output\arm\debug\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Copy all x64 Release files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\uamqp_arm\Release\*.* %build-path%\azure_amqp_output\arm\Release\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! if exist *.nupkg ( del *.nupkg ) rem -- Package Nuget nuget pack %build-root%\build_all\packaging\windows\Microsoft.Azure.uamqp.nuspec -OutputDirectory %build-root%\build_all\packaging\windows rmdir /s/q %build-path%\azure_amqp_output popd goto :eof echo doneazure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/windows/000077500000000000000000000000001455573770000255255ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/build_all/windows/build.cmd000066400000000000000000000167011455573770000273160ustar00rootroot00000000000000@REM Copyright (c) Microsoft. All rights reserved. @REM Licensed under the MIT license. See LICENSE file in the project root for full license information. @setlocal EnableExtensions EnableDelayedExpansion @echo off set current-path=%~dp0 rem // remove trailing slash set current-path=%current-path:~0,-1% echo Current Path: %current-path% set build-root=%current-path%\..\.. rem // resolve to fully qualified path for %%i in ("%build-root%") do set build-root=%%~fi set repo_root=%build-root%\..\.. rem // resolve to fully qualified path for %%i in ("%repo_root%") do set repo_root=%%~fi echo Build Root: %build-root% echo Repo Root: %repo_root% rem ----------------------------------------------------------------------------- rem -- check prerequisites rem ----------------------------------------------------------------------------- rem ----------------------------------------------------------------------------- rem -- parse script arguments rem ----------------------------------------------------------------------------- rem // default build options set build-clean=0 set build-config=Debug set build-platform=Win32 set CMAKE_DIR=uamqp_win32 set MAKE_NUGET_PKG=no :args-loop if "%1" equ "" goto args-done if "%1" equ "-c" goto arg-build-clean if "%1" equ "--clean" goto arg-build-clean if "%1" equ "--config" goto arg-build-config if "%1" equ "--platform" goto arg-build-platform if "%1" equ "--make_nuget" goto arg-build-nuget call :usage && exit /b 1 :arg-build-clean set build-clean=1 goto args-continue :arg-build-config shift if "%1" equ "" call :usage && exit /b 1 set build-config=%1 goto args-continue :arg-build-platform shift if "%1" equ "" call :usage && exit /b 1 set build-platform=%1 if %build-platform% == x64 ( set CMAKE_DIR=uamqp_x64 ) else if %build-platform% == arm ( set CMAKE_DIR=uamqp_arm ) goto args-continue :arg-build-nuget shift if "%1" equ "" call :usage && exit /b 1 set MAKE_NUGET_PKG=%1 goto args-continue :args-continue shift goto args-loop :args-done rem ----------------------------------------------------------------------------- rem -- clean solutions rem ----------------------------------------------------------------------------- if %build-clean%==1 ( rem -- call nuget restore "%build-root%\iothub_client\samples\iothub_client_sample_amqp\windows\iothub_client_sample_amqp.sln" rem -- call :clean-a-solution "%build-root%\iothub_client\samples\iothub_client_sample_amqp\windows\iothub_client_sample_amqp.sln" rem -- if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) rem ----------------------------------------------------------------------------- rem -- build with CMAKE and run tests rem ----------------------------------------------------------------------------- echo CMAKE Output Path: %build-root%\cmake\%CMAKE_DIR% if EXIST %build-root%\cmake\%CMAKE_DIR% ( rmdir /s/q %build-root%\cmake\%CMAKE_DIR% rem no error checking ) echo %build-root%\cmake\%CMAKE_DIR% mkdir %build-root%\cmake\%CMAKE_DIR% rem no error checking pushd %build-root%\cmake\%CMAKE_DIR% echo ***checking msbuild*** where /q msbuild IF ERRORLEVEL 1 ( echo ***setting VC paths*** IF EXIST "%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsMSBuildCmd.bat" call "%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsMSBuildCmd.bat" ) where msbuild if %MAKE_NUGET_PKG% == yes ( echo ***Running CMAKE for Win32*** cmake %build-root% if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! popd echo ***Running CMAKE for Win64*** if EXIST %build-root%\cmake\uamqp_x64 ( rmdir /s/q %build-root%\cmake\uamqp_x64 ) mkdir %build-root%\cmake\uamqp_x64 pushd %build-root%\cmake\uamqp_x64 cmake %build-root% -G "Visual Studio 15 2017" -A x64 if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! popd echo ***Running CMAKE for ARM*** if EXIST %build-root%\cmake\uamqp_arm ( rmdir /s/q %build-root%\cmake\uamqp_arm ) mkdir %build-root%\cmake\uamqp_arm pushd %build-root%\cmake\uamqp_arm cmake %build-root% -G "Visual Studio 15 2017" -A ARM if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else if %build-platform% == Win32 ( echo ***Running CMAKE for Win32*** cmake %build-root% -Drun_unittests:BOOL=ON -Drun_e2e_tests:BOOL=ON -G "Visual Studio 15 2017" -A Win32 if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else if %build-platform% == arm ( echo ***Running CMAKE for ARM*** cmake %build-root% -Drun_unittests:BOOL=ON -Drun_e2e_tests:BOOL=ON -G "Visual Studio 15 2017" -A ARM if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else ( echo ***Running CMAKE for Win64*** cmake %build-root% -Drun_unittests:BOOL=ON -Drun_e2e_tests:BOOL=ON -G "Visual Studio 15 2017" -A x64 if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) if %MAKE_NUGET_PKG% == yes ( echo ***Building all configurations*** msbuild /m %build-root%\cmake\uamqp_win32\uamqp.sln /p:Configuration=Release msbuild /m %build-root%\cmake\uamqp_win32\uamqp.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! msbuild /m %build-root%\cmake\uamqp_x64\uamqp.sln /p:Configuration=Release msbuild /m %build-root%\cmake\uamqp_x64\uamqp.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! msbuild /m %build-root%\cmake\uamqp_arm\uamqp.sln /p:Configuration=Release msbuild /m %build-root%\cmake\uamqp_arm\uamqp.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else ( call :_run-msbuild "Build" uamqp.sln %2 %3 if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! if %build-platform% neq arm ( echo Build Platform: %build-platform% if "%build-config%" == "Debug" ( ctest -C "debug" -V if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) ) ) popd goto :eof rem ----------------------------------------------------------------------------- rem -- subroutines rem ----------------------------------------------------------------------------- :clean-a-solution call :_run-msbuild "Clean" %1 %2 %3 goto :eof :build-a-solution call :_run-msbuild "Build" %1 %2 %3 goto :eof :run-unit-tests call :_run-tests %1 "UnitTests" goto :eof :usage echo build.cmd [options] echo options: echo -c, --clean delete artifacts from previous build before building echo --config ^ [Debug] build configuration (e.g. Debug, Release) echo --platform ^ [Win32] build platform (e.g. Win32, x64, arm, ...) goto :eof rem ----------------------------------------------------------------------------- rem -- helper subroutines rem ----------------------------------------------------------------------------- :_run-msbuild rem // optionally override configuration|platform setlocal EnableExtensions set build-target= if "%~1" neq "Build" set "build-target=/t:%~1" if "%~3" neq "" set build-config=%~3 if "%~4" neq "" set build-platform=%~4 msbuild /m %build-target% "/p:Configuration=%build-config%;Platform=%build-platform%" %2 if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! goto :eof :_run-tests rem // discover tests set test-dlls-list= set test-dlls-path=%build-root%\%~1\build\windows\%build-platform%\%build-config% for /f %%i in ('dir /b %test-dlls-path%\*%~2*.dll') do set test-dlls-list="%test-dlls-path%\%%i" !test-dlls-list! if "%test-dlls-list%" equ "" ( echo No unit tests found in %test-dlls-path% exit /b 1 ) rem // run tests echo Test DLLs: %test-dlls-list% echo. vstest.console.exe %test-dlls-list% if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! goto :eof echo doneazure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/configs/000077500000000000000000000000001455573770000235345ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/configs/uamqpConfig.cmake000066400000000000000000000005151455573770000270100ustar00rootroot00000000000000#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. include("${CMAKE_CURRENT_LIST_DIR}/uamqpTargets.cmake") get_target_property(UAMQP_INCLUDES uamqp INTERFACE_INCLUDE_DIRECTORIES) set(UAMQP_INCLUDES ${UAMQP_INCLUDES} CACHE INTERNAL "")azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/contribute.md000066400000000000000000000032411455573770000246040ustar00rootroot00000000000000## What to contribute There are many ways that you can contribute to the uAMQP project: * Submit a bug * Submit a code fix for a bug * Submit code to add a new platform/language support to the project, or modify existing code * Submit additions or modifications to the documentation * Submit a feature request ## Contributing Code To contribute code you need to issue a Pull Request against the master branch. All code submissions will be reviewed and tested, and those that meet a high bar for both quality and design/roadmap appropriateness will be merged into the source. You must sign a [Contribution License Agreement](https://cla.microsoft.com/) ([CLA](https://cla.microsoft.com/)) before submitting a Pull Request. To complete the CLA, you will need to submit the request via the form and then electronically sign the CLA when you receive the email containing the link to the document. ## Big contributions If your contribution is significantly big it is better to first check with the project developers in order to make sure the change aligns with the long term plans. This can be done simply by submitting a question via the GitHub Issues section. ## Things to keep in mind when contributing Some guidance for when you make a contribution: * Add/update the Visio design diagram when required by your change * Add/update module requirements as required by your change * Add/update unit tests and code as required by your change * Make sure you run all the unit tests on the affected platform(s). If the change is in common code, generally running on one platform would be acceptable * Run end-to-end tests or simple sample code to make sure the lib works in an end-to-end scenario. azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/dependencies-test.cmake000066400000000000000000000012331455573770000265100ustar00rootroot00000000000000#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. if(${use_installed_dependencies}) #These need to be set for the functions included by azure-c-shared-utility set(SHARED_UTIL_SRC_FOLDER "${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-shared-utility/src") set(SHARED_UTIL_FOLDER "${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-shared-utility") set(SHARED_UTIL_ADAPTER_FOLDER "${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-shared-utility/adapters") set_platform_files("${CMAKE_CURRENT_LIST_DIR}/deps/azure-c-shared-utility") find_package(umock_c REQUIRED CONFIG) endif()azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/000077500000000000000000000000001455573770000230375ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/000077500000000000000000000000001455573770000273525ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/.gitattributes000066400000000000000000000014711455573770000322500ustar00rootroot00000000000000# Default behavior: if Git thinks a file is text (as opposed to binary), it # will normalize line endings to LF in the repository, but convert to your # platform's native line endings on checkout (e.g., CRLF for Windows). * text=auto # Explicitly declare text files you want to always be normalized and converted # to native line endings on checkout. E.g., #*.c text # Declare files that will always have CRLF line endings on checkout. E.g., #*.sln text eol=crlf # Declare files that will always have LF line endings on checkout. E.g., *.sh text eol=lf *.json text eol=lf # Denote all files that should not have line endings normalized, should not be # merged, and should not show in a textual diff. *.docm binary *.docx binary *.ico binary *.lib binary *.png binary *.pptx binary *.snk binary *.vsdx binary *.xps binary azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/.gitignore000066400000000000000000000033521455573770000313450ustar00rootroot00000000000000################################################################################ # This .gitignore file was automatically created by Microsoft(R) Visual Studio. ################################################################################ # Compiled object files *.o *.opp # Compiled static libraries *.a # Doxygen output html/ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. ## ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ # Visual Studio 2015 cache/options directory .vs/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # VS Code Directory .vscode/ # Azure IoT specific build artifacts /build /build_all/windows/nuget.exe /cmake* /.vs *.jar *.aps /res **/obj/* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # TFS 2012 Local Workspace $tf/ # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/packages/* # except build/, which is used as an MSBuild target. !**/packages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/packages/repositories.config # NuGet v3's project.json files produces more ignorable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/.gitmodules000066400000000000000000000007011455573770000315250ustar00rootroot00000000000000[submodule "testtools/ctest"] path = testtools/ctest url = https://github.com/Azure/azure-ctest.git [submodule "testtools/testrunner"] path = testtools/testrunner url = https://github.com/Azure/azure-c-testrunnerswitcher.git [submodule "deps/azure-macro-utils-c"] path = deps/azure-macro-utils-c url = https://github.com/Azure/azure-macro-utils-c.git [submodule "deps/umock-c"] path = deps/umock-c url = https://github.com/Azure/umock-c.git azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/CMakeLists.txt000066400000000000000000000640521455573770000321210ustar00rootroot00000000000000#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. cmake_minimum_required (VERSION 3.5) if (TARGET aziotsharedutil) RETURN() endif() project(azure_c_shared_utility) FILE(READ ${CMAKE_CURRENT_LIST_DIR}/version.txt C_SHARED_VERSION) # Include the common build rules for the C SDK include(configs/azure_iot_build_rules.cmake) #the following variables are project-wide and can be used with cmake-gui option(run_unittests "set run_unittests to ON to run unittests (default is OFF)" OFF) option(skip_samples "set skip_samples to ON to skip building samples (default is OFF)[if possible, they are always built]" OFF) option(use_http "set use_http to ON if http is to be used, set to OFF to not use http" ON) option(use_condition "set use_condition to ON if the condition module and its adapters should be enabled" ON) option(use_wsio "set use_wsio to ON to build WebSockets support (default is ON)" ON) option(nuget_e2e_tests "set nuget_e2e_tests to ON to generate e2e tests to run with nuget packages (default is OFF)" OFF) option(use_installed_dependencies "set use_installed_dependencies to ON to use installed packages instead of building dependencies from submodules" OFF) option(use_default_uuid "set use_default_uuid to ON to use the out of the box UUID that comes with the SDK rather than platform specific implementations" OFF) option(run_e2e_tests "set run_e2e_tests to ON to run e2e tests (default is OFF). Chsare dutility does not have any e2e tests, but the option needs to exist to evaluate in IF statements" OFF) option(run_int_tests "set run_int_tests to ON to integration tests (default is OFF)." OFF) option(use_builtin_httpapi "set use_builtin_httpapi to ON to use the built-in httpapi_compact that comes with C shared utility (default is OFF)" OFF) option(use_cppunittest "set use_cppunittest to ON to build CppUnitTest tests on Windows (default is OFF)" OFF) option(suppress_header_searches "do not try to find headers - used when compiler check will fail" OFF) option(use_custom_heap "use externally defined heap functions instead of the malloc family" OFF) if(${use_custom_heap}) add_definitions(-DGB_USE_CUSTOM_HEAP) endif() if(WIN32) option(use_schannel "set use_schannel to ON if schannel is to be used, set to OFF to not use schannel" ON) option(use_openssl "set use_openssl to ON if openssl is to be used, set to OFF to not use openssl" OFF) option(use_mbedtls "set use_mbedtls to ON if mbedtls is to be used, set to OFF to not use mbedtls" OFF) option(use_wolfssl "set use_wolfssl to ON if wolfssl is to be used, set to OFF to not use wolfssl" OFF) option(use_bearssl "set use_bearssl to ON if BearSSL is to be used, set to OFF to not use BearSSL" OFF) option(logerror_captures_stack_traces "LogError will make a reasonable attempt to capture the stack trace at the time of calling LogError. Only available on Windows" OFF) option(use_socketio "set use_socketio to ON if socketio is to be included in the library, set to OFF if a different implementation will be provided" ON) set(use_etw OFF CACHE STRING "set use_etw to OFF = No ETW logging, TRACELOGGING = Use ETW from tracelogging.h, TRACELOGGING_WITH_CONSOLE = Use ETW from tracelogging.h and call console logger. Default is OFF") set_property(CACHE use_etw PROPERTY STRINGS TRACELOGGING_WITH_CONSOLE TRACELOGGING OFF) else() option(use_schannel "set use_schannel to ON if schannel is to be used, set to OFF to not use schannel" OFF) if(MACOSX) option(use_openssl "set use_openssl to ON if openssl is to be used, set to OFF to not use openssl" OFF) option(use_socketio "set use_socketio to ON if socketio is to be included in the library, set to OFF if a different implementation will be provided" OFF) else() option(use_openssl "set use_openssl to ON if openssl is to be used, set to OFF to not use openssl" ON) option(use_socketio "set use_socketio to ON if socketio is to be included in the library, set to OFF if a different implementation will be provided" ON) endif() option(use_mbedtls "set use_mbedtls to ON if mbedtls is to be used, set to OFF to not use mbedtls" OFF) option(use_wolfssl "set use_wolfssl to ON if wolfssl is to be used, set to OFF to not use wolfssl" OFF) option(use_bearssl "set use_bearssl to ON if BearSSL is to be used, set to OFF to not use BearSSL" OFF) option(use_c_ares "set use_c_ares to ON if c-ares is to be used, set to OFF to not use c-ares" OFF) endif() option(no_logging "disable logging (default is OFF)" OFF) # The options setting for use_socketio is not reliable. If openssl is used, make sure it's on, # and if apple tls is used then use_socketio must be off. if (MACOSX) if (${use_openssl}) set(use_socketio ON) else() # MACOSX only has native tls and open ssl, so this must be the native apple tls set(use_applessl ON) set(use_socketio OFF) endif() endif() if(WIN32) if(${use_etw} STREQUAL "TRACELOGGING_WITH_CONSOLE") add_definitions(-DUSE_TRACELOGGING) add_definitions(-DCALL_CONSOLE_LOGGER) endif() #(${use_etw} STREQUAL "TRACELOGGING_WITH_CONSOLE") if(${use_etw} STREQUAL "TRACELOGGING") add_definitions(-DUSE_TRACELOGGING) endif() #(${use_etw} STREQUAL "TRACELOGGING") endif() if(${logerror_captures_stack_traces}) #set a preprocessor option (LOGERROR_CAPTURES_STACK_TRACES) and add the files that provide the functionality add_definitions(-DLOGERROR_CAPTURES_STACK_TRACES) set(LOGGING_STACKTRACE_C_FILE ./src/logging_stacktrace.c) set(LOGGING_STACKTRACE_H_FILE ./inc/azure_c_shared_utility/logging_stacktrace.h) else() set(LOGGING_STACKTRACE_C_FILE) set(LOGGING_STACKTRACE_H_FILE) endif() option(build_as_dynamic "build the C Shared libaries as shared" OFF) if(${memory_trace}) add_definitions(-DGB_MEASURE_MEMORY_FOR_THIS -DGB_DEBUG_ALLOC) add_definitions(-DGB_MEASURE_NETWORK_FOR_THIS -DGB_DEBUG_NETWORK) endif() if(${use_openssl}) if("${OPENSSL_ROOT_DIR}" STREQUAL "" AND NOT ("$ENV{OpenSSLDir}" STREQUAL "")) set(OPENSSL_ROOT_DIR $ENV{OpenSSLDir} CACHE PATH "") endif() # If OpenSSL::SSL OR OpenSSL::Crypto are not set then you need to run # the find package for openssl if (NOT TARGET OpenSSL::SSL OR NOT TARGET OpenSSL::Crypto OR NOT ${OPENSSL_INCLUDE_DIR}) find_package(OpenSSL REQUIRED) endif() include_directories(${OPENSSL_INCLUDE_DIR}) endif() if(${use_applessl}) # MACOSX only has native tls and open ssl, so use the native apple tls find_library(cf_foundation Foundation) find_library(cf_network CFNetwork) endif() if(${no_logging}) add_definitions(-DNO_LOGGING) endif() # Start of variables used during install set (LIB_INSTALL_DIR lib CACHE PATH "Library object file directory") #Setup the platform files include("${CMAKE_CURRENT_LIST_DIR}/configs/azure_c_shared_utilityFunctions.cmake") set_platform_files(${CMAKE_CURRENT_LIST_DIR}) if(MSVC) if(${use_openssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_OPENSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_OPENSSL") endif() if(${use_mbedtls}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_MBEDTLS") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_MBEDTLS") endif() if(${use_bearssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_BEARSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_BEARSSL") endif() if(${use_wolfssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_WOLFSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_WOLFSSL") # Disables error if a bit-field is used on non-integer variable set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /wd4214") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4 /wd4214") endif() elseif(LINUX) #LINUX OR APPLE set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wformat=2 -Wformat-security") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wformat=2 -Wformat-security") if(${use_openssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_OPENSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_OPENSSL") endif() if(${use_mbedtls}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_MBEDTLS") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_MBEDTLS") endif() if(${use_bearssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_BEARSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_BEARSSL") endif() if(${use_wolfssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_WOLFSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_WOLFSSL") endif() # Turn off warning that can not be fixed right now set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable -Wno-missing-braces -Wno-missing-field-initializers -Wno-format-nonliteral") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-variable -Wno-missing-braces -Wno-missing-field-initializers -Wno-format-nonliteral") elseif(APPLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wformat-security") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat-security") if(${use_openssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_OPENSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_OPENSSL") endif() if(${use_mbedtls}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_MBEDTLS") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_MBEDTLS") endif() if(${use_wolfssl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_WOLFSSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_WOLFSSL") endif() endif() include_directories(${UMOCK_C_INC_FOLDER}) #these are the C source files set(source_c_files ./src/azure_base32.c ./src/azure_base64.c ./src/buffer.c ./src/constbuffer_array.c ./src/constbuffer_array_batcher.c ./src/connection_string_parser.c ./src/constbuffer.c ${LOGGING_C_FILE} ./src/crt_abstractions.c ./src/constmap.c ./src/doublylinkedlist.c ./src/gballoc.c ./src/gbnetwork.c ./src/gb_stdio.c ./src/gb_time.c ./src/gb_rand.c ./src/hmac.c ./src/hmacsha256.c ./src/xio.c ./src/singlylinkedlist.c ./src/map.c ./src/sastoken.c ./src/sha1.c ./src/sha224.c ./src/sha384-512.c ./src/strings.c ./src/string_token.c ./src/string_tokenizer.c ./src/uuid.c ./src/urlencode.c ./src/usha.c ./src/vector.c ${XLOGGING_C_FILE} ./src/optionhandler.c ./src/memory_data.c ./adapters/agenttime.c ${CONDITION_C_FILE} ${LOCK_C_FILE} ${TIMER_C_FILE} ${STRING_UTILS_C_FILE} ${PLATFORM_C_FILE} ${SOCKETIO_C_FILE} ${TICKCOUTER_C_FILE} ${THREAD_C_FILE} ${UNIQUEID_C_FILE} ${ENVIRONMENT_VARIABLE_C_FILE} ${LOGGING_STACKTRACE_C_FILE} ${DNS_C_FILE} ) if(UNIX) #LINUX OR APPLE set(source_c_files ${source_c_files} ./adapters/linux_time.c ) endif() if(${use_http}) set(source_c_files ${source_c_files} ./src/httpapiex.c ./src/httpapiexsas.c ./src/httpheaders.c ${HTTP_C_FILE} ) endif() if(${use_schannel}) set(source_c_files ${source_c_files} ./adapters/tlsio_schannel.c ./adapters/x509_schannel.c ) endif() # If SocketIO isn't used, then we need to substitute stubs for HTTP Proxy # since it depends on SocketIO if(${use_socketio}) set(source_c_files ${source_c_files} ./src/http_proxy_io.c ) else() set(source_c_files ${source_c_files} ./src/http_proxy_stub.c ) endif() if(${use_wolfssl}) set(source_c_files ${source_c_files} ./adapters/tlsio_wolfssl.c ) endif() if(${use_mbedtls}) set(source_c_files ${source_c_files} ./adapters/tlsio_mbedtls.c ) endif() if(${use_bearssl}) set(source_c_files ${source_c_files} ./adapters/tlsio_bearssl.c ) endif() if(${use_openssl}) set(source_c_files ${source_c_files} ./adapters/tlsio_openssl.c ./adapters/x509_openssl.c ) endif() if(${use_applessl}) set(source_c_files ${source_c_files} ./pal/ios-osx/tlsio_appleios.c ./pal/tlsio_options.c ) include_directories(./pal/ios-osx/) endif() if (WIN32 AND ("${CMAKE_SYSTEM_VERSION}" VERSION_EQUAL "10.0.17763.0" OR "${CMAKE_SYSTEM_VERSION}" VERSION_GREATER "10.0.17763.0")) # Windows added support for UNIX domain sockets to the OS and SDK # in the Oct 2018 update (10.0.17763.0, aka RS5) add_definitions(-DAF_UNIX_ON_WINDOWS) endif() #these are the C headers set(source_h_files ./inc/azure_c_shared_utility/agenttime.h ./inc/azure_c_shared_utility/azure_base32.h ./inc/azure_c_shared_utility/azure_base64.h ./inc/azure_c_shared_utility/buffer_.h ./inc/azure_c_shared_utility/constbuffer_array.h ./inc/azure_c_shared_utility/constbuffer_array_batcher.h ./inc/azure_c_shared_utility/connection_string_parser.h ./inc/azure_c_shared_utility/crt_abstractions.h ./inc/azure_c_shared_utility/constmap.h ./inc/azure_c_shared_utility/condition.h ./inc/azure_c_shared_utility/const_defines.h ${LOGGING_H_FILE} ./inc/azure_c_shared_utility/doublylinkedlist.h ./inc/azure_c_shared_utility/envvariable.h ./inc/azure_c_shared_utility/gballoc.h ./inc/azure_c_shared_utility/gbnetwork.h ./inc/azure_c_shared_utility/gb_stdio.h ./inc/azure_c_shared_utility/gb_time.h ./inc/azure_c_shared_utility/gb_rand.h ./inc/azure_c_shared_utility/hmac.h ./inc/azure_c_shared_utility/hmacsha256.h ./inc/azure_c_shared_utility/http_proxy_io.h ./inc/azure_c_shared_utility/singlylinkedlist.h ./inc/azure_c_shared_utility/lock.h ./inc/azure_c_shared_utility/map.h ./inc/azure_c_shared_utility/optimize_size.h ./inc/azure_c_shared_utility/platform.h ./inc/azure_c_shared_utility/refcount.h ./inc/azure_c_shared_utility/sastoken.h ./inc/azure_c_shared_utility/sha-private.h ./inc/azure_c_shared_utility/shared_util_options.h ./inc/azure_c_shared_utility/sha.h ./inc/azure_c_shared_utility/socketio.h ./inc/azure_c_shared_utility/stdint_ce6.h ./inc/azure_c_shared_utility/strings.h ./inc/azure_c_shared_utility/strings_types.h ./inc/azure_c_shared_utility/string_token.h ./inc/azure_c_shared_utility/string_tokenizer.h ./inc/azure_c_shared_utility/string_tokenizer_types.h ./inc/azure_c_shared_utility/string_utils.h ./inc/azure_c_shared_utility/tlsio_options.h ./inc/azure_c_shared_utility/tickcounter.h ./inc/azure_c_shared_utility/threadapi.h ./inc/azure_c_shared_utility/xio.h ./inc/azure_c_shared_utility/uniqueid.h ./inc/azure_c_shared_utility/uuid.h ./inc/azure_c_shared_utility/urlencode.h ./inc/azure_c_shared_utility/vector.h ./inc/azure_c_shared_utility/vector_types.h ./inc/azure_c_shared_utility/vector_types_internal.h ./inc/azure_c_shared_utility/xlogging.h ./inc/azure_c_shared_utility/constbuffer.h ./inc/azure_c_shared_utility/tlsio.h ./inc/azure_c_shared_utility/optionhandler.h ./inc/azure_c_shared_utility/memory_data.h ./inc/azure_c_shared_utility/safe_math.h ${LOGGING_STACKTRACE_H_FILE} ) if(UNIX) #LINUX OR APPLE set(source_h_files ${source_h_files} ./adapters/linux_time.h ) endif() if(${use_wsio}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/wsio.h ./inc/azure_c_shared_utility/uws_client.h ./inc/azure_c_shared_utility/uws_frame_encoder.h ./inc/azure_c_shared_utility/utf8_checker.h ./inc/azure_c_shared_utility/ws_url.h ) set(source_c_files ${source_c_files} ./src/wsio.c ./src/uws_client.c ./src/uws_frame_encoder.c ./src/utf8_checker.c ./src/ws_url.c ) endif() if(${use_http}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/httpapi.h ./inc/azure_c_shared_utility/httpapiex.h ./inc/azure_c_shared_utility/httpapiexsas.h ./inc/azure_c_shared_utility/httpheaders.h ) endif() if(${use_schannel}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/tlsio_schannel.h ./inc/azure_c_shared_utility/x509_schannel.h ) endif() if(${use_wolfssl}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/tlsio_wolfssl.h ) if(WIN32) include_directories($ENV{WolfSSLDir}) endif() endif() if(${use_mbedtls}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/tlsio_mbedtls.h ) endif() if(${use_openssl}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/tlsio_openssl.h ./inc/azure_c_shared_utility/x509_openssl.h ) endif() if(${use_applessl}) set(source_h_files ${source_h_files} ./pal/ios-osx/tlsio_appleios.h ) include_directories(./pal/ios-osx/) endif() if(${use_bearssl}) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/tlsio_bearssl.h ) endif() FILE(GLOB aziotsharedutil_md_files "devdoc/*.md") SOURCE_GROUP(devdoc FILES ${aziotsharedutil_md_files}) # Add ignore deprecated functions so we may use 1.1.1 APIs # in OpenSSL 3 if(LINUX) set_property( SOURCE ${CMAKE_CURRENT_LIST_DIR}/adapters/tlsio_openssl.c ${CMAKE_CURRENT_LIST_DIR}/adapters/x509_openssl.c PROPERTY COMPILE_OPTIONS -Wno-deprecated-declarations ) endif() #this is the product (a library) add_library(aziotsharedutil ${source_c_files} ${source_h_files} ${aziotsharedutil_md_files}) setTargetBuildProperties(aziotsharedutil) target_include_directories(aziotsharedutil PUBLIC $) if(MSVC) set(source_h_files ${source_h_files} ./pal/windows/refcount_os.h ) target_include_directories(aziotsharedutil PUBLIC $$) else() set(source_h_files ${source_h_files} ./pal/linux/refcount_os.h ) target_include_directories(aziotsharedutil PUBLIC $$) endif() if(${build_as_dynamic}) # need to create a def file from existing def files due to cmake # not letting us build more than one file file(READ ./src/aziotsharedutil.def DEF_FILE_CONTENT) file(WRITE "${CMAKE_BINARY_DIR}/shared_util.def" ${DEF_FILE_CONTENT}) file(READ ./src/aziotsharedutil_http.def DEF_FILE_CONTENT) file(APPEND "${CMAKE_BINARY_DIR}/shared_util.def" ${DEF_FILE_CONTENT}) file(READ ./src/aziotsharedutil_wsio.def DEF_FILE_CONTENT) file(APPEND "${CMAKE_BINARY_DIR}/shared_util.def" ${DEF_FILE_CONTENT}) set(def_files "${CMAKE_BINARY_DIR}/shared_util.def") #make sure we can link as dll/so add_library(aziotsharedutil_dll SHARED ${source_c_files} ${source_h_files} ${def_files} ) set_target_properties(aziotsharedutil_dll PROPERTIES OUTPUT_NAME "aziotsharedutil_dll") endif() set(aziotsharedutil_target_libs) if(${logerror_captures_stack_traces}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} Dbghelp.lib) endif() if(${use_http}) if(WIN32) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} crypt32 winhttp) else() if (NOT use_builtin_httpapi) # try CMake find_package first find_package(CURL) # As mentioned at https://cmake.org/Wiki/CMake_Cross_Compiling the # pkg-config tool can not be used by cmake while cross compiling. if (NOT CMAKE_CROSSCOMPILING) # if find_package didn't work, try pkg-config if(NOT CURL_FOUND) find_package(PkgConfig) if(PKG_CONFIG_FOUND) pkg_check_modules(CURL libcurl) endif() endif() endif() set(CURL_FIND_REQUIRED 1) find_package_handle_standard_args(CURL DEFAULT_MSG CURL_LIBRARIES) include_directories(${CURL_INCLUDE_DIRS}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} ${CURL_LIBRARIES}) endif(NOT use_builtin_httpapi) endif() endif(${use_http}) if(${use_schannel}) if(WIN32) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} crypt32 ws2_32 secur32 advapi32 ncrypt) endif() endif() if(${use_mbedtls}) if (WIN32) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} ws2_32 $ENV{mbedtlsLibDir}/mbedtls.lib $ENV{mbedtlsLibDir}/mbedx509.lib $ENV{mbedtlsLibDir}/mbedcrypto.lib ) include_directories("$ENV{mbedtlsDir}/include") else() set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} mbedtls mbedx509 mbedcrypto) endif() endif() if(${use_bearssl}) if (WIN32) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} $ENV{bearsslDir}/build/bearssls.lib ) include_directories("$ENV{bearsslDir}/inc") else() include_directories($ENV{bearsslDir}/inc) link_directories($ENV{bearsslDir}/build) find_library(bearssl bearssl $ENV{bearsslDir}/build/) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} ${bearssl}) endif() endif() if(${use_openssl}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} ${OPENSSL_LIBRARIES}) if (WIN32) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} crypt32 ws2_32 secur32) endif() endif() if(${use_wolfssl}) if (WIN32) if (CMAKE_BUILD_TYPE EQUAL "DEBUG") set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} $ENV{WolfSSLDir}/Debug/wolfssl.lib) else() set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} $ENV{WolfSSLDir}/Release/wolfssl.lib) endif() else() set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} wolfssl) endif() endif() if(${use_applessl}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} ${cf_foundation} ${cf_network}) endif() if(WIN32) if (NOT ${use_default_uuid}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} rpcrt4.lib) endif() endif() if(LINUX) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} pthread m rt) if (NOT ${use_default_uuid}) if(APPLE) find_package(PkgConfig REQUIRED) pkg_search_module(UUID REQUIRED uuid) link_directories(${UUID_LIBRARY_DIRS}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} -L${UUID_LIBRARY_DIRS} ${UUID_LIBRARIES}) else() set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} uuid) endif() endif() if(${use_c_ares}) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} cares) endif() endif() target_link_libraries(aziotsharedutil ${aziotsharedutil_target_libs}) if(${build_as_dynamic}) target_link_libraries(aziotsharedutil_dll ${aziotsharedutil_target_libs}) endif() set(original_run_e2e_tests ${run_e2e_tests}) set(original_run_unittests ${run_unittests}) set(original_run_int_tests ${run_int_tests}) set(run_e2e_tests OFF) set(run_unittests OFF) set(run_int_tests OFF) include(dependencies.cmake) if (${original_run_unittests} OR ${original_run_e2e_tests}) include("${CMAKE_CURRENT_LIST_DIR}/dependencies-test.cmake") add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/testtools) setTargetBuildProperties(ctest) setTargetBuildProperties(testrunnerswitcher) setTargetBuildProperties(umock_c) endif() set(run_e2e_tests ${original_run_e2e_tests}) set(run_unittests ${original_run_unittests}) set(run_int_tests ${original_run_int_tests}) include_directories(${MACRO_UTILS_INC_FOLDER}) include_directories(${UMOCK_C_INC_FOLDER}) if (${run_unittests} OR ${run_int_tests}) add_subdirectory(tests) endif() function(FindDllFromLib var libFile) get_filename_component(_libName ${libFile} NAME_WE) get_filename_component(_libDir ${libFile} DIRECTORY) while(NOT ("${_libDir}" STREQUAL "")) file(GLOB_RECURSE _dllList "${_libDir}/${_libName}.dll") list(LENGTH _dllList _listLen) if(${_listLen} GREATER 0) list(GET _dllList 0 _dll) set(${var} "${_dll}" PARENT_SCOPE) break() endif() get_filename_component(_libDir ${_libDir} DIRECTORY) endwhile() endfunction() if (NOT ${skip_samples}) if(${use_openssl} AND WIN32) FindDllFromLib(SSL_DLL "${OPENSSL_SSL_LIBRARY}") FindDllFromLib(CRYPTO_DLL "${OPENSSL_CRYPTO_LIBRARY}") endif() add_subdirectory(samples) endif() # Set CMAKE_INSTALL_* if not defined include(GNUInstallDirs) # Install Azure C Shared Utility if(NOT DEFINED CMAKE_INSTALL_LIBDIR) set(CMAKE_INSTALL_LIBDIR "lib") endif() set(package_location "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") if(${build_as_dynamic}) set(targets aziotsharedutil aziotsharedutil_dll) else(${build_as_dynamic}) set(targets aziotsharedutil) endif(${build_as_dynamic}) install (TARGETS ${targets} EXPORT aziotsharedutilTargets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/azureiot ) install (FILES ${source_h_files} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/azure_c_shared_utility) install (FILES ${micromock_h_files_full_path} ${INSTALL_H_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/azureiot) include(CMakePackageConfigHelpers) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake" VERSION ${C_SHARED_VERSION} COMPATIBILITY SameMajorVersion ) configure_file("configs/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake" COPYONLY ) install(EXPORT aziotsharedutilTargets FILE "${PROJECT_NAME}Targets.cmake" DESTINATION ${package_location} ) install( FILES "configs/${PROJECT_NAME}Config.cmake" "configs/${PROJECT_NAME}Functions.cmake" "configs/azure_iot_build_rules.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake" DESTINATION ${package_location} ) compileTargetAsC99(aziotsharedutil) azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/LICENSE000066400000000000000000000021541455573770000303610ustar00rootroot00000000000000Microsoft Azure IoT SDKs Copyright (c) Microsoft Corporation All rights reserved. MIT License Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/README.md000066400000000000000000000057631455573770000306440ustar00rootroot00000000000000This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. # Azure C Shared Utility azure-c-shared-utility is a C library providing common functionality for basic tasks (like string, list manipulation, IO, etc.). ## Dependencies azure-c-shared-utility provides 3 tlsio implementations: - tlsio_schannel - runs only on Windows - tlsio_openssl - depends on OpenSSL being installed - tlsio_wolfssl - depends on WolfSSL being installed azure-c-shared-utility depends on curl for HTTPAPI for Linux. azure-c-shared-utility uses cmake for configuring build files. ## Setup 1. Clone **azure-c-shared-utility** using the recursive option: ``` git clone --recursive https://github.com/Azure/azure-c-shared-utility.git ``` 2. Create a folder called *cmake* under *azure-c-shared-utility* 3. Switch to the *cmake* folder and run ``` cmake .. ``` 4. Build ``` cmake --build . ``` ### Installation and Use Optionally, you may choose to install azure-c-shared-utility on your machine: 1. Switch to the *cmake* folder and run ``` cmake -Duse_installed_dependencies=ON ../ ``` ``` cmake --build . --target install ``` or install using the follow commands for each platform: On Linux: ``` sudo make install ``` On Windows: ``` msbuild /m INSTALL.vcxproj ``` 2. Use it in your project (if installed) ``` find_package(azure_c_shared_utility REQUIRED CONFIG) target_link_library(yourlib aziotsharedutil) ``` _If running tests, this requires that umock-c, azure-ctest, and azure-c-testrunnerswitcher are installed (through CMake) on your machine._ ### Building the tests In order to build the tests use: ``` cmake .. -Drun_unittests:bool=ON ``` ## Configuration options In order to turn on/off the tlsio implementations use the following CMAKE options: * `-Duse_schannel:bool={ON/OFF}` - turns on/off the SChannel support * `-Duse_openssl:bool={ON/OFF}` - turns on/off the OpenSSL support. If this option is used, an environment variable named OpenSSLDir should be set to point to the OpenSSL folder. * `-Duse_wolfssl:bool={ON/OFF}` - turns on/off the WolfSSL support. If this option is used, an environment variable named WolfSSLDir should be set to point to the WolfSSL folder. * `-Duse_http:bool={ON/OFF}` - turns on/off the HTTP API support. * `-Duse_installed_dependencies:bool={ON/OFF}` - turns on/off building azure-c-shared-utility using installed dependencies. This package may only be installed if this flag is ON. * `-Drun_unittests:bool={ON/OFF}` - enables building of unit tests. Default is OFF. ## Porting to new devices Instructions for porting the Azure IoT C SDK to new devices are located [here](https://github.com/Azure/azure-c-shared-utility/blob/master/devdoc/porting_guide.md). azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/SECURITY.MD000066400000000000000000000054111455573770000310440ustar00rootroot00000000000000 ## Security Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/). If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft's [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)) of a security vulnerability, please report it to us as described below. ## Reporting Security Issues **Please do not report security vulnerabilities through public GitHub issues.** Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report). If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc). You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc). Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue: * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.) * Full paths of source file(s) related to the manifestation of the issue * The location of the affected source code (tag/branch/commit or direct URL) * Any special configuration required to reproduce the issue * Step-by-step instructions to reproduce the issue * Proof-of-concept or exploit code (if possible) * Impact of the issue, including how an attacker might exploit the issue This information will help us triage your report more quickly. If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs. ## Preferred Languages We prefer all communications to be in English. ## Policy Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd). azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/000077500000000000000000000000001455573770000311555ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/README.md000066400000000000000000000015701455573770000324370ustar00rootroot00000000000000This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. # azure-c-shared-utility/src This directory contains source files for Azure C Shared Utility. ### Where did that file go? Files related to adapting the Azure IoT C SDK to specific devices are being moved to new locations within the [azure-c-shared-utility/pal](https://github.com/Azure/azure-c-shared-utility/tree/master/pal) directory and its subfolders. ### Porting to new devices Instructions for porting the Azure IoT C SDK to new devices are located [here](https://github.com/Azure/azure-c-shared-utility/blob/master/devdoc/porting_guide.md). azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/agenttime.c000066400000000000000000000011741455573770000333010ustar00rootroot00000000000000// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/agenttime.h" time_t get_time(time_t* p) { return time(p); } struct tm* get_gmtime(time_t* currentTime) { return gmtime(currentTime); } time_t get_mktime(struct tm* cal_time) { return mktime(cal_time); } char* get_ctime(time_t* timeToGet) { return ctime(timeToGet); } double get_difftime(time_t stopTime, time_t startTime) { return difftime(stopTime, startTime); } agenttime_mbed.c000066400000000000000000000011541455573770000342070ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/agenttime.h" // mbed version of gmtime() returns NULL. // system RTC should be set to UTC as its localtime time_t get_time(time_t* currentTime) { return time(currentTime); } double get_difftime(time_t stopTime, time_t startTime) { return difftime(stopTime, startTime); } struct tm* get_gmtime(time_t* currentTime) { return localtime(currentTime); } char* get_ctime(time_t* timeToGet) { return ctime(timeToGet); } condition_pthreads.c000066400000000000000000000112031455573770000351170ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/lock.h" #include "azure_c_shared_utility/condition.h" #include "azure_c_shared_utility/xlogging.h" #include #include #include "azure_c_shared_utility/gballoc.h" #include "time.h" #include "linux_time.h" MU_DEFINE_ENUM_STRINGS(COND_RESULT, COND_RESULT_VALUES); pthread_cond_t* create_cond(void) { pthread_cond_t * cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t)); if (cond != NULL) { #ifdef __MACH__ pthread_cond_init(cond, NULL); #else pthread_condattr_t cattr; pthread_condattr_init(&cattr); pthread_condattr_setclock(&cattr, time_basis); pthread_cond_init(cond, &cattr); pthread_condattr_destroy(&cattr); #endif } return cond; } COND_HANDLE Condition_Init(void) { set_time_basis(); // Codes_SRS_CONDITION_18_002: [ Condition_Init shall create and return a CONDITION_HANDLE ] // Codes_SRS_CONDITION_18_008: [ Condition_Init shall return NULL if it fails to allocate the CONDITION_HANDLE ] return create_cond(); } COND_RESULT Condition_Post(COND_HANDLE handle) { COND_RESULT result; // Codes_SRS_CONDITION_18_001: [ Condition_Post shall return COND_INVALID_ARG if handle is NULL ] if (handle == NULL) { result = COND_INVALID_ARG; } else { // Codes_SRS_CONDITION_18_003: [ Condition_Post shall return COND_OK if it succcessfully posts the condition ] if (pthread_cond_signal((pthread_cond_t*)handle) == 0) { result = COND_OK; } else { result = COND_ERROR; } } return result; } COND_RESULT Condition_Wait(COND_HANDLE handle, LOCK_HANDLE lock, int timeout_milliseconds) { COND_RESULT result; // Codes_SRS_CONDITION_18_004: [ Condition_Wait shall return COND_INVALID_ARG if handle is NULL ] // Codes_SRS_CONDITION_18_005: [ Condition_Wait shall return COND_INVALID_ARG if lock is NULL and timeout_milliseconds is 0 ] // Codes_SRS_CONDITION_18_006: [ Condition_Wait shall return COND_INVALID_ARG if lock is NULL and timeout_milliseconds is not 0 ] if (handle == NULL || lock == NULL) { result = COND_INVALID_ARG; } else { if (timeout_milliseconds > 0) { // Codes_SRS_CONDITION_18_013: [ Condition_Wait shall accept relative timeouts ] struct timespec tm; if (get_time_ns(&tm) != 0) { LogError("Failed to get the current time"); return COND_ERROR; } tm.tv_nsec += (timeout_milliseconds % MILLISECONDS_IN_1_SECOND) * NANOSECONDS_IN_1_MILLISECOND; tm.tv_sec += timeout_milliseconds / MILLISECONDS_IN_1_SECOND; // handle overflow in tv_nsec tm.tv_sec+= tm.tv_nsec / NANOSECONDS_IN_1_SECOND; tm.tv_nsec %= NANOSECONDS_IN_1_SECOND; int wait_result = pthread_cond_timedwait((pthread_cond_t *)handle, (pthread_mutex_t *)lock, &tm); if (wait_result == ETIMEDOUT) { // Codes_SRS_CONDITION_18_011: [ Condition_Wait shall return COND_TIMEOUT if the condition is NOT triggered and timeout_milliseconds is not 0 ] return COND_TIMEOUT; } else if (wait_result == 0) { // Codes_SRS_CONDITION_18_012: [ Condition_Wait shall return COND_OK if the condition is triggered and timeout_milliseconds is not 0 ] result = COND_OK; } else { LogError("Failed to pthread_cond_timedwait"); return COND_ERROR; } } else { if (pthread_cond_wait((pthread_cond_t*)handle, (pthread_mutex_t *)lock) != 0) { LogError("Failed to pthread_cond_wait"); return COND_ERROR; } else { // Codes_SRS_CONDITION_18_010: [ Condition_Wait shall return COND_OK if the condition is triggered and timeout_milliseconds is 0 ] result = COND_OK; } } } return result; } void Condition_Deinit(COND_HANDLE handle) { // Codes_SRS_CONDITION_18_007: [ Condition_Deinit will not fail if handle is NULL ] if (handle != NULL) { // Codes_SRS_CONDITION_18_009: [ Condition_Deinit will deallocate handle if it is not NULL pthread_cond_t* cond = (pthread_cond_t*)handle; pthread_cond_destroy(cond); free(cond); } } condition_rtx_mbed.cpp000066400000000000000000000016241455573770000354570ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/lock.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/condition.h" #include "rtos.h" COND_HANDLE Condition_Init(void) { return NULL; } COND_RESULT Condition_Post(COND_HANDLE handle) { COND_RESULT result; if (handle == NULL) { result = COND_INVALID_ARG; } else { result = COND_ERROR; } return result; } COND_RESULT Condition_Wait(COND_HANDLE handle, LOCK_HANDLE lock, int timeout_milliseconds) { COND_RESULT result; if (handle == NULL) { result = COND_INVALID_ARG; } else { result = COND_ERROR; } return result; } void Condition_Deinit(COND_HANDLE handle) { if (handle != NULL) { } } condition_win32.c000066400000000000000000000124121455573770000342520ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/condition.h" #include "windows.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/gballoc.h" MU_DEFINE_ENUM_STRINGS(COND_RESULT, COND_RESULT_VALUES); typedef struct CONDITION_TAG { volatile LONG waiting_thread_count; HANDLE event_handle; } CONDITION; COND_HANDLE Condition_Init(void) { // Codes_SRS_CONDITION_18_002: [ Condition_Init shall create and return a CONDITION_HANDLE ] CONDITION* cond = (CONDITION*)malloc(sizeof(CONDITION)); // Codes_SRS_CONDITION_18_008: [ Condition_Init shall return NULL if it fails to allocate the CONDITION_HANDLE ] if (cond != NULL) { (void)memset(cond, 0, sizeof(CONDITION)); cond->event_handle = CreateEvent(NULL, FALSE, FALSE, NULL); if (cond->event_handle == NULL) { LogError("CreateEvent failed with error %d", GetLastError()); free(cond); cond = NULL; } else { /* Needed to emulate pthread_signal as we only signal the event when there are waiting threads */ cond->waiting_thread_count = 0; } } else { LogError("Failed to allocate condition handle"); } return (COND_HANDLE)cond; } COND_RESULT Condition_Post(COND_HANDLE handle) { COND_RESULT result; if (handle == NULL) { LogError("Null argument handle passed to Condition_Post"); // Codes_SRS_CONDITION_18_001: [ Condition_Post shall return COND_INVALID_ARG if handle is NULL ] result = COND_INVALID_ARG; } else { CONDITION* cond = (CONDITION*)handle; /* Emulate pthreads signalling, by only unblocking *one* waiting thread if there is one waiting */ if (cond->waiting_thread_count == 0 || SetEvent(cond->event_handle)) { // Codes_SRS_CONDITION_18_003: [ Condition_Post shall return COND_OK if it succcessfully posts the condition ] result = COND_OK; } else { LogError("Failed SetEvent call with error %d", GetLastError()); result = COND_ERROR; } } return result; } COND_RESULT Condition_Wait(COND_HANDLE handle, LOCK_HANDLE lock, int timeout_milliseconds) { COND_RESULT result; // Codes_SRS_CONDITION_18_004: [ Condition_Wait shall return COND_INVALID_ARG if handle is NULL ] // Codes_SRS_CONDITION_18_005: [ Condition_Wait shall return COND_INVALID_ARG if lock is NULL and timeout_milliseconds is 0 ] // Codes_SRS_CONDITION_18_006: [ Condition_Wait shall return COND_INVALID_ARG if lock is NULL and timeout_milliseconds is not 0 ] if (handle == NULL || lock == NULL) { result = COND_INVALID_ARG; } else { CONDITION* cond = (CONDITION*)handle; /* Increment the waiting thread count, unlock the lock and wait */ cond->waiting_thread_count++; if (Unlock(lock) == LOCK_OK) { DWORD wait_result; // Codes_SRS_CONDITION_18_013: [ Condition_Wait shall accept relative timeouts ] wait_result = WaitForSingleObject(cond->event_handle, timeout_milliseconds == 0 ? INFINITE : timeout_milliseconds); /* If we unlocked ok, it means the lock handle is valid, lock must succeed since it wraps EnterCriticalSection */ (void)Lock(lock); if (wait_result != WAIT_OBJECT_0 && wait_result != WAIT_TIMEOUT) { LogError("Failed wait, wait returned with %x", wait_result); /* cond might be freed at this point, just return error and do not touch condition */ result = COND_ERROR; } else { /* To handle the chance of a race condition reset the event again when there are no more waiting threads */ if (--cond->waiting_thread_count == 0) { (void)ResetEvent(cond->event_handle); } if (wait_result == WAIT_TIMEOUT) { // Codes_SRS_CONDITION_18_011: [ Condition_Wait shall return COND_TIMEOUT if the condition is NOT triggered and timeout_milliseconds is not 0 ] result = COND_TIMEOUT; } else { // Codes_SRS_CONDITION_18_012: [ Condition_Wait shall return COND_OK if the condition is triggered and timeout_milliseconds is not 0 ] result = COND_OK; } } } else { cond->waiting_thread_count--; LogError("Invalid lock passed which failed to unlock"); result = COND_ERROR; } } return result; } void Condition_Deinit(COND_HANDLE handle) { // Codes_SRS_CONDITION_18_007: [ Condition_Deinit will not fail if handle is NULL ] // Codes_SRS_CONDITION_18_009: [ Condition_Deinit will deallocate handle if it is not NULL if (handle != NULL) { CONDITION* cond = (CONDITION*)handle; (void)CloseHandle(cond->event_handle); cond->event_handle = INVALID_HANDLE_VALUE; free(cond); } } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/envvariable.c000066400000000000000000000005051455573770000336170ustar00rootroot00000000000000// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/envvariable.h" const char* environment_get_variable(const char *variable_name) { return getenv(variable_name); } httpapi_compact.c000066400000000000000000002017141455573770000344260ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/httpheaders.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/xio.h" #include "azure_c_shared_utility/platform.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/threadapi.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/http_proxy_io.h" #ifdef _MSC_VER #define snprintf _snprintf #endif /*Codes_SRS_HTTPAPI_COMPACT_21_001: [ The httpapi_compact shall implement the methods defined by the httpapi.h. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_002: [ The httpapi_compact shall support the http requests. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_003: [ The httpapi_compact shall return error codes defined by HTTPAPI_RESULT. ]*/ #include "azure_c_shared_utility/httpapi.h" #define MAX_HOSTNAME 64 #define TEMP_BUFFER_SIZE 1024 /*Codes_SRS_HTTPAPI_COMPACT_21_077: [ The HTTPAPI_ExecuteRequest shall wait, at least, 10 seconds for the SSL open process. ]*/ #define MAX_OPEN_RETRY 100 /*Codes_SRS_HTTPAPI_COMPACT_21_084: [ The HTTPAPI_CloseConnection shall wait, at least, 10 seconds for the SSL close process. ]*/ #define MAX_CLOSE_RETRY 100 /*Codes_SRS_HTTPAPI_COMPACT_21_079: [ The HTTPAPI_ExecuteRequest shall wait, at least, 20 seconds to send a buffer using the SSL connection. ]*/ #define MAX_SEND_RETRY 200 /*Codes_SRS_HTTPAPI_COMPACT_21_081: [ The HTTPAPI_ExecuteRequest shall try to read the message with the response up to 20 seconds. ]*/ #define MAX_RECEIVE_RETRY 200 /*Codes_SRS_HTTPAPI_COMPACT_21_083: [ The HTTPAPI_ExecuteRequest shall wait, at least, 100 milliseconds between retries. ]*/ #define RETRY_INTERVAL_IN_MS 100 MU_DEFINE_ENUM_STRINGS(HTTPAPI_RESULT, HTTPAPI_RESULT_VALUES) typedef struct HTTP_HANDLE_DATA_TAG { char* hostName; char* certificate; char* x509ClientCertificate; char* x509ClientPrivateKey; XIO_HANDLE xio_handle; size_t received_bytes_count; unsigned char* received_bytes; unsigned int is_io_error : 1; unsigned int is_connected : 1; unsigned int send_completed : 1; bool tls_renegotiation; } HTTP_HANDLE_DATA; /*the following function does the same as sscanf(pos2, "%d", &sec)*/ /*this function only exists because some of platforms do not have sscanf. */ static int ParseStringToDecimal(const char *src, int* dst) { int result; char* next; long num = strtol(src, &next, 0); if (src == next || num < INT_MIN || num > INT_MAX) { result = EOF; } else { result = 1; } if (num < INT_MIN) num = INT_MIN; if (num > INT_MAX) num = INT_MAX; *dst = (int)num; return result; } /*the following function does the same as sscanf(pos2, "%x", &sec)*/ /*this function only exists because some of platforms do not have sscanf. This is not a full implementation; it only works with well-defined x numbers. */ #define HEXA_DIGIT_VAL(c) (((c>='0') && (c<='9')) ? (c-'0') : ((c>='a') && (c<='f')) ? (c-'a'+10) : ((c>='A') && (c<='F')) ? (c-'A'+10) : -1) static int ParseStringToHexadecimal(const char *src, size_t* dst) { int result; int digitVal; if (src == NULL) { result = EOF; } else if (HEXA_DIGIT_VAL(*src) == -1) { result = EOF; } else { (*dst) = 0; while ((digitVal = HEXA_DIGIT_VAL(*src)) != -1) { (*dst) *= 0x10; (*dst) += (size_t)digitVal; src++; } result = 1; } return result; } /*the following function does the same as sscanf(buf, "HTTP/%*d.%*d %d %*[^\r\n]", &ret) */ /*this function only exists because some of platforms do not have sscanf. This is not a full implementation; it only works with well-defined HTTP response. */ static int ParseHttpResponse(const char* src, int* dst) { int result; static const char HTTPPrefix[] = "HTTP/"; bool fail; const char* runPrefix; if ((src == NULL) || (dst == NULL)) { result = EOF; } else { fail = false; runPrefix = HTTPPrefix; while((*runPrefix) != '\0') { if ((*runPrefix) != (*src)) { fail = true; break; } src++; runPrefix++; } if (!fail) { while ((*src) != '.') { if ((*src) == '\0') { fail = true; break; } src++; } } if (!fail) { while ((*src) != ' ') { if ((*src) == '\0') { fail = true; break; } src++; } } if (fail) { result = EOF; } else { result = ParseStringToDecimal(src, dst); } } return result; } HTTPAPI_RESULT HTTPAPI_Init(void) { /*Codes_SRS_HTTPAPI_COMPACT_21_004: [ The HTTPAPI_Init shall allocate all memory to control the http protocol. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_007: [ If there is not enough memory to control the http protocol, the HTTPAPI_Init shall return HTTPAPI_ALLOC_FAILED. ]*/ /** * No memory is necessary. */ /*Codes_SRS_HTTPAPI_COMPACT_21_006: [ If HTTPAPI_Init succeed allocating all the needed memory, it shall return HTTPAPI_OK. ]*/ return HTTPAPI_OK; } void HTTPAPI_Deinit(void) { /*Codes_SRS_HTTPAPI_COMPACT_21_009: [ The HTTPAPI_Init shall release all memory allocated by the httpapi_compact. ]*/ /** * No memory was necessary. */ } /*Codes_SRS_HTTPAPI_COMPACT_21_011: [ The HTTPAPI_CreateConnection shall create an http connection to the host specified by the hostName parameter. ]*/ HTTP_HANDLE HTTPAPI_CreateConnection(const char* hostName) { HTTP_HANDLE_DATA* http_instance; TLSIO_CONFIG tlsio_config; if (hostName == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_014: [ If the hostName is NULL, the HTTPAPI_CreateConnection shall return NULL as the handle. ]*/ LogError("Invalid host name. Null hostName parameter."); http_instance = NULL; } else if (*hostName == '\0') { /*Codes_SRS_HTTPAPI_COMPACT_21_015: [ If the hostName is empty, the HTTPAPI_CreateConnection shall return NULL as the handle. ]*/ LogError("Invalid host name. Empty string."); http_instance = NULL; } else { http_instance = (HTTP_HANDLE_DATA*)malloc(sizeof(HTTP_HANDLE_DATA)); /*Codes_SRS_HTTPAPI_COMPACT_21_013: [ If there is not enough memory to control the http connection, the HTTPAPI_CreateConnection shall return NULL as the handle. ]*/ if (http_instance == NULL) { LogError("There is no memory to control the http connection"); } else if (mallocAndStrcpy_s(&http_instance->hostName, hostName) != 0) { LogError("Failed copying hostname"); free(http_instance); http_instance = NULL; } else { tlsio_config.hostname = http_instance->hostName; tlsio_config.port = 443; tlsio_config.underlying_io_interface = NULL; tlsio_config.underlying_io_parameters = NULL; tlsio_config.invoke_on_send_complete_callback_for_fragments = true; http_instance->xio_handle = xio_create(platform_get_default_tlsio(), (void*)&tlsio_config); /*Codes_SRS_HTTPAPI_COMPACT_21_016: [ If the HTTPAPI_CreateConnection failed to create the connection, it shall return NULL as the handle. ]*/ if (http_instance->xio_handle == NULL) { LogError("Create connection failed"); free(http_instance->hostName); free(http_instance); http_instance = NULL; } else { http_instance->is_connected = 0; http_instance->is_io_error = 0; http_instance->received_bytes_count = 0; http_instance->received_bytes = NULL; http_instance->certificate = NULL; http_instance->x509ClientCertificate = NULL; http_instance->x509ClientPrivateKey = NULL; http_instance->tls_renegotiation = false; } } } /*Codes_SRS_HTTPAPI_COMPACT_21_012: [ The HTTPAPI_CreateConnection shall return a non-NULL handle on success. ]*/ return (HTTP_HANDLE)http_instance; } static void on_io_close_complete(void* context) { HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)context; if (http_instance != NULL) { http_instance->is_connected = 0; } } void HTTPAPI_CloseConnection(HTTP_HANDLE handle) { HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)handle; /*Codes_SRS_HTTPAPI_COMPACT_21_020: [ If the connection handle is NULL, the HTTPAPI_CloseConnection shall not do anything. ]*/ if (http_instance != NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_019: [ If there is no previous connection, the HTTPAPI_CloseConnection shall not do anything. ]*/ if (http_instance->xio_handle != NULL) { http_instance->is_io_error = 0; /*Codes_SRS_HTTPAPI_COMPACT_21_017: [ The HTTPAPI_CloseConnection shall close the connection previously created in HTTPAPI_ExecuteRequest. ]*/ if (xio_close(http_instance->xio_handle, on_io_close_complete, http_instance) != 0) { LogError("The SSL got error closing the connection"); /*Codes_SRS_HTTPAPI_COMPACT_21_087: [ If the xio return anything different than 0, the HTTPAPI_CloseConnection shall destroy the connection anyway. ]*/ http_instance->is_connected = 0; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_084: [ The HTTPAPI_CloseConnection shall wait, at least, 10 seconds for the SSL close process. ]*/ int countRetry = MAX_CLOSE_RETRY; while (http_instance->is_connected == 1) { xio_dowork(http_instance->xio_handle); if ((countRetry--) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_085: [ If the HTTPAPI_CloseConnection retries 10 seconds to close the connection without success, it shall destroy the connection anyway. ]*/ LogError("Close timeout. The SSL didn't close the connection"); http_instance->is_connected = 0; } else if (http_instance->is_io_error == 1) { LogError("The SSL got error closing the connection"); http_instance->is_connected = 0; } else if (http_instance->is_connected == 1) { LogInfo("Waiting for TLS close connection"); /*Codes_SRS_HTTPAPI_COMPACT_21_086: [ The HTTPAPI_CloseConnection shall wait, at least, 100 milliseconds between retries. ]*/ ThreadAPI_Sleep(RETRY_INTERVAL_IN_MS); } } } /*Codes_SRS_HTTPAPI_COMPACT_21_076: [ After close the connection, The HTTPAPI_CloseConnection shall destroy the connection previously created in HTTPAPI_CreateConnection. ]*/ xio_destroy(http_instance->xio_handle); } #ifndef DO_NOT_COPY_TRUSTED_CERTS_STRING /*Codes_SRS_HTTPAPI_COMPACT_21_018: [ If there is a certificate associated to this connection, the HTTPAPI_CloseConnection shall free all allocated memory for the certificate. ]*/ if (http_instance->certificate) { free(http_instance->certificate); } #endif /*Codes_SRS_HTTPAPI_COMPACT_06_001: [ If there is a x509 client certificate associated to this connection, the HTTAPI_CloseConnection shall free all allocated memory for the certificate. ]*/ if (http_instance->x509ClientCertificate) { free(http_instance->x509ClientCertificate); } /*Codes_SRS_HTTPAPI_COMPACT_06_002: [ If there is a x509 client private key associated to this connection, then HTTP_CloseConnection shall free all the allocated memory for the private key. ]*/ if (http_instance->x509ClientPrivateKey) { free(http_instance->x509ClientPrivateKey); } if (http_instance->hostName) { free(http_instance->hostName); } free(http_instance); } } static void on_io_open_complete(void* context, IO_OPEN_RESULT open_result) { HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)context; if (http_instance != NULL) { if (open_result == IO_OPEN_OK) { http_instance->is_connected = 1; http_instance->is_io_error = 0; } else { http_instance->is_io_error = 1; } } } static void on_send_complete(void* context, IO_SEND_RESULT send_result) { HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)context; if (http_instance != NULL) { if (send_result == IO_SEND_OK) { http_instance->send_completed = 1; http_instance->is_io_error = 0; } else { http_instance->is_io_error = 1; } } } #define TOLOWER(c) (((c>='A') && (c<='Z'))?c-'A'+'a':c) static int InternStrnicmp(const char* s1, const char* s2, size_t n) { int result; if (s1 == NULL) result = -1; else if (s2 == NULL) result = 1; else { result = 0; while(n-- && result == 0) { if (*s1 == 0) result = -1; else if (*s2 == 0) result = 1; else { result = TOLOWER(*s1) - TOLOWER(*s2); ++s1; ++s2; } } } return result; } static void on_bytes_received(void* context, const unsigned char* buffer, size_t size) { unsigned char* new_received_bytes; HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)context; if (http_instance != NULL) { if (buffer == NULL) { http_instance->is_io_error = 1; LogError("NULL pointer error"); } else { /* Here we got some bytes so we'll buffer them so the receive functions can consumer it */ new_received_bytes = (unsigned char*)realloc(http_instance->received_bytes, http_instance->received_bytes_count + size); if (new_received_bytes == NULL) { http_instance->is_io_error = 1; LogError("Error allocating memory for received data"); } else { http_instance->received_bytes = new_received_bytes; if (memcpy(http_instance->received_bytes + http_instance->received_bytes_count, buffer, size) == NULL) { http_instance->is_io_error = 1; LogError("Error copping received data to the HTTP bufffer"); } else { http_instance->received_bytes_count += size; } } } } } static void on_io_error(void* context) { HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)context; if (http_instance != NULL) { http_instance->is_io_error = 1; LogError("Error signalled by underlying IO"); } } static int conn_receive(HTTP_HANDLE_DATA* http_instance, char* buffer, int count) { int result; if ((http_instance == NULL) || (buffer == NULL) || (count < 0)) { LogError("conn_receive: %s", ((http_instance == NULL) ? "Invalid HTTP instance" : "Invalid HTTP buffer")); result = -1; } else { result = 0; while (result < count) { xio_dowork(http_instance->xio_handle); /* if any error was detected while receiving then simply break and report it */ if (http_instance->is_io_error != 0) { LogError("xio reported error on dowork"); result = -1; break; } if (http_instance->received_bytes_count >= (size_t)count) { /* Consuming bytes from the receive buffer */ (void)memcpy(buffer, http_instance->received_bytes, count); (void)memmove(http_instance->received_bytes, http_instance->received_bytes + count, http_instance->received_bytes_count - count); http_instance->received_bytes_count -= count; /* we're not reallocating at each consumption so that we don't trash due to byte by byte consumption */ if (http_instance->received_bytes_count == 0) { free(http_instance->received_bytes); http_instance->received_bytes = NULL; } result = count; break; } /*Codes_SRS_HTTPAPI_COMPACT_21_083: [ The HTTPAPI_ExecuteRequest shall wait, at least, 100 milliseconds between retries. ]*/ ThreadAPI_Sleep(RETRY_INTERVAL_IN_MS); } } return result; } static void conn_receive_discard_buffer(HTTP_HANDLE_DATA* http_instance) { if (http_instance != NULL) { if (http_instance->received_bytes != NULL) { free(http_instance->received_bytes); http_instance->received_bytes = NULL; } http_instance->received_bytes_count = 0; } } static int readLine(HTTP_HANDLE_DATA* http_instance, char* buf, const size_t maxBufSize) { int resultLineSize; if ((http_instance == NULL) || (buf == NULL) || (maxBufSize == 0)) { LogError("%s", ((http_instance == NULL) ? "Invalid HTTP instance" : "Invalid HTTP buffer")); resultLineSize = -1; } else { char* destByte = buf; /*Codes_SRS_HTTPAPI_COMPACT_21_081: [ The HTTPAPI_ExecuteRequest shall try to read the message with the response up to 20 seconds. ]*/ int countRetry = MAX_RECEIVE_RETRY; bool endOfSearch = false; resultLineSize = -1; while (!endOfSearch) { xio_dowork(http_instance->xio_handle); /* if any error was detected while receiving then simply break and report it */ if (http_instance->is_io_error != 0) { LogError("xio reported error on dowork"); endOfSearch = true; } else { unsigned char* receivedByte = http_instance->received_bytes; while (receivedByte < (http_instance->received_bytes + http_instance->received_bytes_count)) { if ((*receivedByte) != '\r') { (*destByte) = (*receivedByte); destByte++; receivedByte++; if (destByte >= (buf + maxBufSize - 1)) { LogError("Received message is bigger than the http buffer"); receivedByte = http_instance->received_bytes + http_instance->received_bytes_count; endOfSearch = true; break; } } else { receivedByte++; if ((receivedByte < (http_instance->received_bytes + http_instance->received_bytes_count)) && ((*receivedByte) == '\n')) { receivedByte++; } (*destByte) = '\0'; resultLineSize = (int)(destByte - buf); endOfSearch = true; break; } } http_instance->received_bytes_count -= (receivedByte - http_instance->received_bytes); if (http_instance->received_bytes_count != 0) { (void)memmove(http_instance->received_bytes, receivedByte, http_instance->received_bytes_count); } else { conn_receive_discard_buffer(http_instance); } } if (!endOfSearch) { if ((countRetry--) > 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_083: [ The HTTPAPI_ExecuteRequest shall wait, at least, 100 milliseconds between retries. ]*/ ThreadAPI_Sleep(RETRY_INTERVAL_IN_MS); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ LogError("Receive timeout. The HTTP request is incomplete"); endOfSearch = true; } } } } return resultLineSize; } static int readChunk(HTTP_HANDLE_DATA* http_instance, char* buf, size_t size) { int cur, offset; // read content with specified length, even if it is received // only in chunks due to fragmentation in the networking layer. // returns -1 in case of error. offset = 0; while (size > (size_t)0) { cur = conn_receive(http_instance, buf + offset, (int)size); // end of stream reached if (cur == 0) { break; } // on error if (cur < 0) { return cur; } // read cur bytes (might be less than requested) size -= (size_t)cur; offset += cur; } return offset; } static int skipN(HTTP_HANDLE_DATA* http_instance, size_t n) { // read and abandon response content with specified length // returns -1 in case of error. int result; if (http_instance == NULL) { LogError("Invalid HTTP instance"); result = -1; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_081: [ The HTTPAPI_ExecuteRequest shall try to read the message with the response up to 20 seconds. ]*/ int countRetry = MAX_RECEIVE_RETRY; result = (int)n; while (n > 0) { xio_dowork(http_instance->xio_handle); /* if any error was detected while receiving then simply break and report it */ if (http_instance->is_io_error != 0) { LogError("xio reported error on dowork"); result = -1; n = 0; } else { if (http_instance->received_bytes_count <= n) { n -= http_instance->received_bytes_count; http_instance->received_bytes_count = 0; } else { http_instance->received_bytes_count -= n; (void)memmove(http_instance->received_bytes, http_instance->received_bytes + n, http_instance->received_bytes_count); n = 0; } if (n > 0) { if ((countRetry--) > 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_083: [ The HTTPAPI_ExecuteRequest shall wait, at least, 100 milliseconds between retries. ]*/ ThreadAPI_Sleep(RETRY_INTERVAL_IN_MS); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ LogError("Receive timeout. The HTTP request is incomplete"); n = 0; result = -1; } } } } } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_021: [ The HTTPAPI_ExecuteRequest shall execute the http communtication with the provided host, sending a request and reciving the response. ]*/ static HTTPAPI_RESULT OpenXIOConnection(HTTP_HANDLE_DATA* http_instance) { HTTPAPI_RESULT result; if (http_instance->is_connected != 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; } else { http_instance->is_io_error = 0; /*Codes_SRS_HTTPAPI_COMPACT_21_022: [ If a Certificate was provided, the HTTPAPI_ExecuteRequest shall set this option on the transport layer. ]*/ if ((http_instance->certificate != NULL) && (xio_setoption(http_instance->xio_handle, OPTION_TRUSTED_CERT, http_instance->certificate) != 0)) { /*Codes_SRS_HTTPAPI_COMPACT_21_023: [ If the transport failed setting the Certificate, the HTTPAPI_ExecuteRequest shall not send any request and return HTTPAPI_SET_OPTION_FAILED. ]*/ result = HTTPAPI_SET_OPTION_FAILED; LogInfo("Could not load certificate"); } /*Codes_SRS_HTTPAPI_COMPACT_06_003: [ If the x509 client certificate is provided, the HTTPAPI_ExecuteRequest shall set this option on the transport layer. ]*/ else if ((http_instance->x509ClientCertificate != NULL) && (xio_setoption(http_instance->xio_handle, SU_OPTION_X509_CERT, http_instance->x509ClientCertificate) != 0)) { /*Codes_SRS_HTTPAPI_COMPACT_06_005: [ If the transport failed setting the client certificate, the HTTPAPI_ExecuteRequest shall not send any request and return HTTPAPI_SET_OPTION_FAILED. ]*/ result = HTTPAPI_SET_OPTION_FAILED; LogInfo("Could not load the client certificate"); } else if ((http_instance->x509ClientPrivateKey != NULL) && (xio_setoption(http_instance->xio_handle, SU_OPTION_X509_PRIVATE_KEY, http_instance->x509ClientPrivateKey) != 0)) { /*Codes_SRS_HTTPAPI_COMPACT_06_006: [ If the transport failed setting the client certificate private key, the HTTPAPI_ExecuteRequest shall not send any request and return HTTPAPI_SET_OPTION_FAILED. ] */ result = HTTPAPI_SET_OPTION_FAILED; LogInfo("Could not load the client certificate private key"); } else if ((http_instance->tls_renegotiation == true) && (xio_setoption(http_instance->xio_handle, OPTION_SET_TLS_RENEGOTIATION, &http_instance->tls_renegotiation) != 0)) { result = HTTPAPI_SET_OPTION_FAILED; LogInfo("Could not load renegotiation flag"); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_024: [ The HTTPAPI_ExecuteRequest shall open the transport connection with the host to send the request. ]*/ if (xio_open(http_instance->xio_handle, on_io_open_complete, http_instance, on_bytes_received, http_instance, on_io_error, http_instance) != 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_025: [ If the open process failed, the HTTPAPI_ExecuteRequest shall not send any request and return HTTPAPI_OPEN_REQUEST_FAILED. ]*/ result = HTTPAPI_OPEN_REQUEST_FAILED; } else { int countRetry; /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; /*Codes_SRS_HTTPAPI_COMPACT_21_077: [ The HTTPAPI_ExecuteRequest shall wait, at least, 10 seconds for the SSL open process. ]*/ countRetry = MAX_OPEN_RETRY; while ((http_instance->is_connected == 0) && (http_instance->is_io_error == 0)) { xio_dowork(http_instance->xio_handle); LogInfo("Waiting for TLS connection"); if ((countRetry--) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_078: [ If the HTTPAPI_ExecuteRequest cannot open the connection in 10 seconds, it shall fail and return HTTPAPI_OPEN_REQUEST_FAILED. ]*/ LogError("Open timeout. The HTTP request is incomplete"); result = HTTPAPI_OPEN_REQUEST_FAILED; break; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_083: [ The HTTPAPI_ExecuteRequest shall wait, at least, 100 milliseconds between retries. ]*/ ThreadAPI_Sleep(RETRY_INTERVAL_IN_MS); } } } } } if ((http_instance->is_io_error != 0) && (result == HTTPAPI_OK)) { /*Codes_SRS_HTTPAPI_COMPACT_21_025: [ If the open process failed, the HTTPAPI_ExecuteRequest shall not send any request and return HTTPAPI_OPEN_REQUEST_FAILED. ]*/ result = HTTPAPI_OPEN_REQUEST_FAILED; } return result; } static HTTPAPI_RESULT conn_send_all(HTTP_HANDLE_DATA* http_instance, const unsigned char* buf, size_t bufLen) { HTTPAPI_RESULT result; http_instance->send_completed = 0; http_instance->is_io_error = 0; if (xio_send(http_instance->xio_handle, buf, bufLen, on_send_complete, http_instance) != 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_028: [ If the HTTPAPI_ExecuteRequest cannot send the request header, it shall return HTTPAPI_HTTP_HEADERS_FAILED. ]*/ result = HTTPAPI_SEND_REQUEST_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_079: [ The HTTPAPI_ExecuteRequest shall wait, at least, 20 seconds to send a buffer using the SSL connection. ]*/ int countRetry = MAX_SEND_RETRY; /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; while ((http_instance->send_completed == 0) && (result == HTTPAPI_OK)) { xio_dowork(http_instance->xio_handle); if (http_instance->is_io_error != 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_028: [ If the HTTPAPI_ExecuteRequest cannot send the request header, it shall return HTTPAPI_HTTP_HEADERS_FAILED. ]*/ result = HTTPAPI_SEND_REQUEST_FAILED; } else if ((countRetry--) <= 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_080: [ If the HTTPAPI_ExecuteRequest retries to send the message for 20 seconds without success, it shall fail and return HTTPAPI_SEND_REQUEST_FAILED. ]*/ LogError("Send timeout. The HTTP request is incomplete"); /*Codes_SRS_HTTPAPI_COMPACT_21_028: [ If the HTTPAPI_ExecuteRequest cannot send the request header, it shall return HTTPAPI_HTTP_HEADERS_FAILED. ]*/ result = HTTPAPI_SEND_REQUEST_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_083: [ The HTTPAPI_ExecuteRequest shall wait, at least, 100 milliseconds between retries. ]*/ ThreadAPI_Sleep(RETRY_INTERVAL_IN_MS); } } } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_035: [ The HTTPAPI_ExecuteRequest shall execute resquest for types GET, POST, PUT, DELETE, PATCH, HEAD. ]*/ const char httpapiRequestString[6][7] = { "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD" }; const char* get_request_type(HTTPAPI_REQUEST_TYPE requestType) { return (const char*)httpapiRequestString[requestType - HTTPAPI_REQUEST_GET]; } /*Codes_SRS_HTTPAPI_COMPACT_21_026: [ If the open process succeed, the HTTPAPI_ExecuteRequest shall send the request message to the host. ]*/ static HTTPAPI_RESULT SendHeadsToXIO(HTTP_HANDLE_DATA* http_instance, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath, HTTP_HEADERS_HANDLE httpHeadersHandle, size_t headersCount) { HTTPAPI_RESULT result; char buf[TEMP_BUFFER_SIZE]; int ret; //Send request /*Codes_SRS_HTTPAPI_COMPACT_21_038: [ The HTTPAPI_ExecuteRequest shall execute the resquest for the path in relativePath parameter. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_036: [ The request type shall be provided in the parameter requestType. ]*/ if (((ret = snprintf(buf, sizeof(buf), "%s %s HTTP/1.1\r\n", get_request_type(requestType), relativePath)) < 0) || ((size_t)ret >= sizeof(buf))) { /*Codes_SRS_HTTPAPI_COMPACT_21_027: [ If the HTTPAPI_ExecuteRequest cannot create a buffer to send the request, it shall not send any request and return HTTPAPI_STRING_PROCESSING_ERROR. ]*/ result = HTTPAPI_STRING_PROCESSING_ERROR; } /*Codes_SRS_HTTPAPI_COMPACT_21_028: [ If the HTTPAPI_ExecuteRequest cannot send the request header, it shall return HTTPAPI_HTTP_HEADERS_FAILED. ]*/ else if ((result = conn_send_all(http_instance, (const unsigned char*)buf, strlen(buf))) == HTTPAPI_OK) { size_t i; //Send default headers /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ for (i = 0; ((i < headersCount) && (result == HTTPAPI_OK)); i++) { char* header; if (HTTPHeaders_GetHeader(httpHeadersHandle, i, &header) != HTTP_HEADERS_OK) { /*Codes_SRS_HTTPAPI_COMPACT_21_027: [ If the HTTPAPI_ExecuteRequest cannot create a buffer to send the request, it shall not send any request and return HTTPAPI_STRING_PROCESSING_ERROR. ]*/ result = HTTPAPI_STRING_PROCESSING_ERROR; } else { if ((result = conn_send_all(http_instance, (const unsigned char*)header, strlen(header))) == HTTPAPI_OK) { result = conn_send_all(http_instance, (const unsigned char*)"\r\n", (size_t)2); } free(header); } } //Close headers if (result == HTTPAPI_OK) { result = conn_send_all(http_instance, (const unsigned char*)"\r\n", (size_t)2); } } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_042: [ The request can contain the a content message, provided in content parameter. ]*/ static HTTPAPI_RESULT SendContentToXIO(HTTP_HANDLE_DATA* http_instance, const unsigned char* content, size_t contentLength) { HTTPAPI_RESULT result; //Send data (if available) /*Codes_SRS_HTTPAPI_COMPACT_21_045: [ If the contentLength is lower than one, the HTTPAPI_ExecuteRequest shall send the request without content. ]*/ if (content && contentLength > 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_044: [ If the content is not NULL, the number of bytes in the content shall be provided in contentLength parameter. ]*/ result = conn_send_all(http_instance, content, contentLength); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_043: [ If the content is NULL, the HTTPAPI_ExecuteRequest shall send the request without content. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_030: [ At the end of the transmission, the HTTPAPI_ExecuteRequest shall receive the response from the host. ]*/ static HTTPAPI_RESULT ReceiveHeaderFromXIO(HTTP_HANDLE_DATA* http_instance, unsigned int* statusCode) { HTTPAPI_RESULT result; char buf[TEMP_BUFFER_SIZE]; int ret; http_instance->is_io_error = 0; //Receive response if (readLine(http_instance, buf, TEMP_BUFFER_SIZE) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_032: [ If the HTTPAPI_ExecuteRequest cannot read the message with the request result, it shall return HTTPAPI_READ_DATA_FAILED. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } //Parse HTTP response else if (ParseHttpResponse(buf, &ret) != 1) { //Cannot match string, error /*Codes_SRS_HTTPAPI_COMPACT_21_055: [ If the HTTPAPI_ExecuteRequest cannot parser the received message, it shall return HTTPAPI_RECEIVE_RESPONSE_FAILED. ]*/ LogInfo("Not a correct HTTP answer"); result = HTTPAPI_RECEIVE_RESPONSE_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_046: [ The HTTPAPI_ExecuteRequest shall return the http status reported by the host in the received response. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_048: [ If the statusCode is NULL, the HTTPAPI_ExecuteRequest shall report not report any status. ]*/ if (statusCode) { /*Codes_SRS_HTTPAPI_COMPACT_21_047: [ The HTTPAPI_ExecuteRequest shall report the status in the statusCode parameter. ]*/ *statusCode = ret; } /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; } return result; } static HTTPAPI_RESULT ReceiveContentInfoFromXIO(HTTP_HANDLE_DATA* http_instance, HTTP_HEADERS_HANDLE responseHeadersHandle, size_t* bodyLength, bool* chunked) { HTTPAPI_RESULT result; char buf[TEMP_BUFFER_SIZE]; const char* substr; char* whereIsColon; int lengthInMsg; const char ContentLength[] = "content-length:"; const size_t ContentLengthSize = sizeof(ContentLength) - 1; const char TransferEncoding[] = "transfer-encoding:"; const size_t TransferEncodingSize = sizeof(TransferEncoding) - 1; const char Chunked[] = "chunked"; const size_t ChunkedSize = sizeof(Chunked) - 1; http_instance->is_io_error = 0; //Read HTTP response headers if (readLine(http_instance, buf, sizeof(buf)) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_032: [ If the HTTPAPI_ExecuteRequest cannot read the message with the request result, it shall return HTTPAPI_READ_DATA_FAILED. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; while (*buf && (result == HTTPAPI_OK)) { if (InternStrnicmp(buf, ContentLength, ContentLengthSize) == 0) { substr = buf + ContentLengthSize; if (ParseStringToDecimal(substr, &lengthInMsg) != 1) { /*Codes_SRS_HTTPAPI_COMPACT_21_032: [ If the HTTPAPI_ExecuteRequest cannot read the message with the request result, it shall return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } else { (*bodyLength) = (size_t)lengthInMsg; } } else if (InternStrnicmp(buf, TransferEncoding, TransferEncodingSize) == 0) { substr = buf + TransferEncodingSize; while (isspace(*substr)) substr++; if (InternStrnicmp(substr, Chunked, ChunkedSize) == 0) { (*chunked) = true; } } if (result == HTTPAPI_OK) { whereIsColon = strchr((char*)buf, ':'); /*Codes_SRS_HTTPAPI_COMPACT_21_049: [ If responseHeadersHandle is provide, the HTTPAPI_ExecuteRequest shall prepare a Response Header usign the HTTPHeaders_AddHeaderNameValuePair. ]*/ if (whereIsColon && (responseHeadersHandle != NULL)) { *whereIsColon = '\0'; HTTPHeaders_AddHeaderNameValuePair(responseHeadersHandle, buf, whereIsColon + 1); } if (readLine(http_instance, buf, sizeof(buf)) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_032: [ If the HTTPAPI_ExecuteRequest cannot read the message with the request result, it shall return HTTPAPI_READ_DATA_FAILED. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } } } } return result; } static HTTPAPI_RESULT ReadHTTPResponseBodyFromXIO(HTTP_HANDLE_DATA* http_instance, size_t bodyLength, bool chunked, BUFFER_HANDLE responseContent) { HTTPAPI_RESULT result; char buf[TEMP_BUFFER_SIZE]; const unsigned char* receivedContent; http_instance->is_io_error = 0; //Read HTTP response body if (!chunked) { if (bodyLength) { if (responseContent != NULL) { if (BUFFER_pre_build(responseContent, bodyLength) != 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_052: [ If any memory allocation get fail, the HTTPAPI_ExecuteRequest shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else if (BUFFER_content(responseContent, &receivedContent) != 0) { (void)BUFFER_unbuild(responseContent); /*Codes_SRS_HTTPAPI_COMPACT_21_052: [ If any memory allocation get fail, the HTTPAPI_ExecuteRequest shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else if (readChunk(http_instance, (char*)receivedContent, bodyLength) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_032: [ If the HTTPAPI_ExecuteRequest cannot read the message with the request result, it shall return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; } } else { /*Codes_SRS_HTTPAPI_COMPACT_21_051: [ If the responseContent is NULL, the HTTPAPI_ExecuteRequest shall ignore any content in the response. ]*/ if (skipN(http_instance, bodyLength) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } else { result = HTTPAPI_OK; } } } else { /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; } } else { size_t size = 0; /*Codes_SRS_HTTPAPI_COMPACT_21_033: [ If the whole process succeed, the HTTPAPI_ExecuteRequest shall retur HTTPAPI_OK. ]*/ result = HTTPAPI_OK; while (result == HTTPAPI_OK) { size_t chunkSize; if (readLine(http_instance, buf, sizeof(buf)) < 0) // read [length in hex]/r/n { /*Codes_SRS_HTTPAPI_COMPACT_21_032: [ If the HTTPAPI_ExecuteRequest cannot read the message with the request result, it shall return HTTPAPI_READ_DATA_FAILED. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } else if (ParseStringToHexadecimal(buf, &chunkSize) != 1) // chunkSize is length of next line (/r/n is not counted) { //Cannot match string, error /*Codes_SRS_HTTPAPI_COMPACT_21_055: [ If the HTTPAPI_ExecuteRequest cannot parser the received message, it shall return HTTPAPI_RECEIVE_RESPONSE_FAILED. ]*/ result = HTTPAPI_RECEIVE_RESPONSE_FAILED; } else if (chunkSize == 0) { // 0 length means next line is just '\r\n' and end of chunks if (readChunk(http_instance, (char*)buf, (size_t)2) < 0 || buf[0] != '\r' || buf[1] != '\n') // skip /r/n { (void)BUFFER_unbuild(responseContent); result = HTTPAPI_READ_DATA_FAILED; } break; } else { if (responseContent != NULL) { if (BUFFER_enlarge(responseContent, chunkSize) != 0) { (void)BUFFER_unbuild(responseContent); /*Codes_SRS_HTTPAPI_COMPACT_21_052: [ If any memory allocation get fail, the HTTPAPI_ExecuteRequest shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else if (BUFFER_content(responseContent, &receivedContent) != 0) { (void)BUFFER_unbuild(responseContent); /*Codes_SRS_HTTPAPI_COMPACT_21_052: [ If any memory allocation get fail, the HTTPAPI_ExecuteRequest shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else if (readChunk(http_instance, (char*)receivedContent + size, chunkSize) < 0) { result = HTTPAPI_READ_DATA_FAILED; } } else { /*Codes_SRS_HTTPAPI_COMPACT_21_051: [ If the responseContent is NULL, the HTTPAPI_ExecuteRequest shall ignore any content in the response. ]*/ if (skipN(http_instance, chunkSize) < 0) { /*Codes_SRS_HTTPAPI_COMPACT_21_082: [ If the HTTPAPI_ExecuteRequest retries 20 seconds to receive the message without success, it shall fail and return HTTPAPI_READ_DATA_FAILED. ]*/ result = HTTPAPI_READ_DATA_FAILED; } } if (result == HTTPAPI_OK) { if (readChunk(http_instance, (char*)buf, (size_t)2) < 0 || buf[0] != '\r' || buf[1] != '\n') // skip /r/n { result = HTTPAPI_READ_DATA_FAILED; } size += chunkSize; } } } } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_037: [ If the request type is unknown, the HTTPAPI_ExecuteRequest shall return HTTPAPI_INVALID_ARG. ]*/ static bool validRequestType(HTTPAPI_REQUEST_TYPE requestType) { bool result; if ((requestType == HTTPAPI_REQUEST_GET) || (requestType == HTTPAPI_REQUEST_POST) || (requestType == HTTPAPI_REQUEST_PUT) || (requestType == HTTPAPI_REQUEST_DELETE) || (requestType == HTTPAPI_REQUEST_PATCH) || (requestType == HTTPAPI_REQUEST_HEAD)) { result = true; } else { result = false; } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_021: [ The HTTPAPI_ExecuteRequest shall execute the http communtication with the provided host, sending a request and reciving the response. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_050: [ If there is a content in the response, the HTTPAPI_ExecuteRequest shall copy it in the responseContent buffer. ]*/ //Note: This function assumes that "Host:" and "Content-Length:" headers are setup // by the caller of HTTPAPI_ExecuteRequest() (which is true for httptransport.c). HTTPAPI_RESULT HTTPAPI_ExecuteRequest(HTTP_HANDLE handle, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath, HTTP_HEADERS_HANDLE httpHeadersHandle, const unsigned char* content, size_t contentLength, unsigned int* statusCode, HTTP_HEADERS_HANDLE responseHeadersHandle, BUFFER_HANDLE responseContent) { HTTPAPI_RESULT result = HTTPAPI_ERROR; size_t headersCount; size_t bodyLength = 0; bool chunked = false; HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)handle; /*Codes_SRS_HTTPAPI_COMPACT_21_034: [ If there is no previous connection, the HTTPAPI_ExecuteRequest shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_037: [ If the request type is unknown, the HTTPAPI_ExecuteRequest shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_039: [ If the relativePath is NULL or invalid, the HTTPAPI_ExecuteRequest shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_041: [ If the httpHeadersHandle is NULL or invalid, the HTTPAPI_ExecuteRequest shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_053: [ The HTTPAPI_ExecuteRequest shall produce a set of http header to send to the host. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_040: [ The request shall contain the http header provided in httpHeadersHandle parameter. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_054: [ If Http header maker cannot provide the number of headers, the HTTPAPI_ExecuteRequest shall return HTTPAPI_INVALID_ARG. ]*/ if (http_instance == NULL || relativePath == NULL || httpHeadersHandle == NULL || !validRequestType(requestType) || HTTPHeaders_GetHeaderCount(httpHeadersHandle, &headersCount) != HTTP_HEADERS_OK) { result = HTTPAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /*Codes_SRS_HTTPAPI_COMPACT_21_024: [ The HTTPAPI_ExecuteRequest shall open the transport connection with the host to send the request. ]*/ else if ((result = OpenXIOConnection(http_instance)) != HTTPAPI_OK) { LogError("Open HTTP connection failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /*Codes_SRS_HTTPAPI_COMPACT_21_026: [ If the open process succeed, the HTTPAPI_ExecuteRequest shall send the request message to the host. ]*/ else if ((result = SendHeadsToXIO(http_instance, requestType, relativePath, httpHeadersHandle, headersCount)) != HTTPAPI_OK) { LogError("Send heads to HTTP failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /*Codes_SRS_HTTPAPI_COMPACT_21_042: [ The request can contain the a content message, provided in content parameter. ]*/ else if ((result = SendContentToXIO(http_instance, content, contentLength)) != HTTPAPI_OK) { LogError("Send content to HTTP failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /*Codes_SRS_HTTPAPI_COMPACT_21_030: [ At the end of the transmission, the HTTPAPI_ExecuteRequest shall receive the response from the host. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_073: [ The message received by the HTTPAPI_ExecuteRequest shall starts with a valid header. ]*/ else if ((result = ReceiveHeaderFromXIO(http_instance, statusCode)) != HTTPAPI_OK) { LogError("Receive header from HTTP failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /*Codes_SRS_HTTPAPI_COMPACT_21_074: [ After the header, the message received by the HTTPAPI_ExecuteRequest can contain addition information about the content. ]*/ else if ((result = ReceiveContentInfoFromXIO(http_instance, responseHeadersHandle, &bodyLength, &chunked)) != HTTPAPI_OK) { LogError("Receive content information from HTTP failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /*Codes_SRS_HTTPAPI_COMPACT_42_084: [ The message received by the HTTPAPI_ExecuteRequest should not contain http body. ]*/ else if (requestType != HTTPAPI_REQUEST_HEAD) { /*Codes_SRS_HTTPAPI_COMPACT_21_075: [ The message received by the HTTPAPI_ExecuteRequest can contain a body with the message content. ]*/ if ((result = ReadHTTPResponseBodyFromXIO(http_instance, bodyLength, chunked, responseContent)) != HTTPAPI_OK) { LogError("Read HTTP response body from HTTP failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } conn_receive_discard_buffer(http_instance); return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_056: [ The HTTPAPI_SetOption shall change the HTTP options. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_057: [ The HTTPAPI_SetOption shall receive a handle that identiry the HTTP connection. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_058: [ The HTTPAPI_SetOption shall receive the option as a pair optionName/value. ]*/ HTTPAPI_RESULT HTTPAPI_SetOption(HTTP_HANDLE handle, const char* optionName, const void* value) { HTTPAPI_RESULT result; HTTP_HANDLE_DATA* http_instance = (HTTP_HANDLE_DATA*)handle; if ( (http_instance == NULL) || (optionName == NULL) || (value == NULL) ) { /*Codes_SRS_HTTPAPI_COMPACT_21_059: [ If the handle is NULL, the HTTPAPI_SetOption shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_060: [ If the optionName is NULL, the HTTPAPI_SetOption shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_061: [ If the value is NULL, the HTTPAPI_SetOption shall return HTTPAPI_INVALID_ARG. ]*/ result = HTTPAPI_INVALID_ARG; } else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { #ifdef DO_NOT_COPY_TRUSTED_CERTS_STRING result = HTTPAPI_OK; http_instance->certificate = (char*)value; #else int len; if (http_instance->certificate) { free(http_instance->certificate); } len = (int)strlen((char*)value); http_instance->certificate = (char*)malloc((len + 1) * sizeof(char)); if (http_instance->certificate == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_062: [ If any memory allocation get fail, the HTTPAPI_SetOption shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; LogInfo("unable to allocate memory for the certificate in HTTPAPI_SetOption"); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_064: [ If the HTTPAPI_SetOption get success setting the option, it shall return HTTPAPI_OK. ]*/ (void)strcpy(http_instance->certificate, (const char*)value); result = HTTPAPI_OK; } #endif // DO_NOT_COPY_TRUSTED_CERTS_STRING } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { int len; if (http_instance->x509ClientCertificate) { free(http_instance->x509ClientCertificate); } len = (int)strlen((char*)value); http_instance->x509ClientCertificate = (char*)malloc((len + 1) * sizeof(char)); if (http_instance->x509ClientCertificate == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_062: [ If any memory allocation get fail, the HTTPAPI_SetOption shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; LogInfo("unable to allocate memory for the client certificate in HTTPAPI_SetOption"); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_064: [ If the HTTPAPI_SetOption get success setting the option, it shall return HTTPAPI_OK. ]*/ (void)strcpy(http_instance->x509ClientCertificate, (const char*)value); result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { int len; if (http_instance->x509ClientPrivateKey) { free(http_instance->x509ClientPrivateKey); } len = (int)strlen((char*)value); http_instance->x509ClientPrivateKey = (char*)malloc((len + 1) * sizeof(char)); if (http_instance->x509ClientPrivateKey == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_062: [ If any memory allocation get fail, the HTTPAPI_SetOption shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; LogInfo("unable to allocate memory for the client private key in HTTPAPI_SetOption"); } else { /*Codes_SRS_HTTPAPI_COMPACT_21_064: [ If the HTTPAPI_SetOption get success setting the option, it shall return HTTPAPI_OK. ]*/ (void)strcpy(http_instance->x509ClientPrivateKey, (const char*)value); result = HTTPAPI_OK; } } else if (strcmp(OPTION_HTTP_PROXY, optionName) == 0) { TLSIO_CONFIG tlsio_config; HTTP_PROXY_IO_CONFIG proxy_config; HTTP_PROXY_OPTIONS* proxy_options = (HTTP_PROXY_OPTIONS*)value; if (proxy_options->host_address == NULL) { LogError("NULL host_address in proxy options"); result = HTTPAPI_ERROR; } else if (((proxy_options->username == NULL) || (proxy_options->password == NULL)) && (proxy_options->username != proxy_options->password)) { LogError("Only one of username and password for proxy settings was NULL"); result = HTTPAPI_ERROR; } else { /* Workaround: xio interface is already created when HTTPAPI_CreateConnection is call without proxy support * need to destroy the interface and create a new one with proxy information */ OPTIONHANDLER_HANDLE xio_options; if ((xio_options = xio_retrieveoptions(http_instance->xio_handle)) == NULL) { LogError("failed saving underlying I/O transport options"); result = HTTPAPI_ERROR; } else { xio_destroy(http_instance->xio_handle); proxy_config.hostname = http_instance->hostName; proxy_config.proxy_hostname = proxy_options->host_address; proxy_config.password = proxy_options->password; proxy_config.username = proxy_options->username; proxy_config.proxy_port = proxy_options->port; proxy_config.port = 443; tlsio_config.hostname = http_instance->hostName; tlsio_config.port = 443; tlsio_config.underlying_io_interface = http_proxy_io_get_interface_description(); tlsio_config.underlying_io_parameters = &proxy_config; tlsio_config.invoke_on_send_complete_callback_for_fragments = true; http_instance->xio_handle = xio_create(platform_get_default_tlsio(), (void*)&tlsio_config); if (http_instance->xio_handle == NULL) { LogError("Failed to create xio handle with proxy configuration"); result = HTTPAPI_ERROR; } else { if (OptionHandler_FeedOptions(xio_options, http_instance->xio_handle) != OPTIONHANDLER_OK) { LogError("Failed feeding existing options to new xio instance."); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } OptionHandler_Destroy(xio_options); } } } else if (strcmp(OPTION_SET_TLS_RENEGOTIATION, optionName) == 0) { bool tls_renegotiation = *(bool*)value; http_instance->tls_renegotiation = tls_renegotiation; result = HTTPAPI_OK; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_063: [ If the HTTP do not support the optionName, the HTTPAPI_SetOption shall return HTTPAPI_INVALID_ARG. ]*/ result = HTTPAPI_INVALID_ARG; LogInfo("unknown option %s", optionName); } return result; } /*Codes_SRS_HTTPAPI_COMPACT_21_065: [ The HTTPAPI_CloneOption shall provide the means to clone the HTTP option. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_066: [ The HTTPAPI_CloneOption shall return a clone of the value identified by the optionName. ]*/ HTTPAPI_RESULT HTTPAPI_CloneOption(const char* optionName, const void* value, const void** savedValue) { HTTPAPI_RESULT result; size_t certLen; char* tempCert; if ( (optionName == NULL) || (value == NULL) || (savedValue == NULL) ) { /*Codes_SRS_HTTPAPI_COMPACT_21_067: [ If the optionName is NULL, the HTTPAPI_CloneOption shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_068: [ If the value is NULL, the HTTPAPI_CloneOption shall return HTTPAPI_INVALID_ARG. ]*/ /*Codes_SRS_HTTPAPI_COMPACT_21_069: [ If the savedValue is NULL, the HTTPAPI_CloneOption shall return HTTPAPI_INVALID_ARG. ]*/ result = HTTPAPI_INVALID_ARG; } else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { #ifdef DO_NOT_COPY_TRUSTED_CERTS_STRING *savedValue = (const void*)value; result = HTTPAPI_OK; #else certLen = strlen((const char*)value); tempCert = (char*)malloc((certLen + 1) * sizeof(char)); if (tempCert == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_070: [ If any memory allocation get fail, the HTTPAPI_CloneOption shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_072: [ If the HTTPAPI_CloneOption get success setting the option, it shall return HTTPAPI_OK. ]*/ (void)strcpy(tempCert, (const char*)value); *savedValue = tempCert; result = HTTPAPI_OK; } #endif // DO_NOT_COPY_TRUSTED_CERTS_STRING } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { certLen = strlen((const char*)value); tempCert = (char*)malloc((certLen + 1) * sizeof(char)); if (tempCert == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_070: [ If any memory allocation get fail, the HTTPAPI_CloneOption shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_072: [ If the HTTPAPI_CloneOption get success setting the option, it shall return HTTPAPI_OK. ]*/ (void)strcpy(tempCert, (const char*)value); *savedValue = tempCert; result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { certLen = strlen((const char*)value); tempCert = (char*)malloc((certLen + 1) * sizeof(char)); if (tempCert == NULL) { /*Codes_SRS_HTTPAPI_COMPACT_21_070: [ If any memory allocation get fail, the HTTPAPI_CloneOption shall return HTTPAPI_ALLOC_FAILED. ]*/ result = HTTPAPI_ALLOC_FAILED; } else { /*Codes_SRS_HTTPAPI_COMPACT_21_072: [ If the HTTPAPI_CloneOption get success setting the option, it shall return HTTPAPI_OK. ]*/ (void)strcpy(tempCert, (const char*)value); *savedValue = tempCert; result = HTTPAPI_OK; } } else if (strcmp(OPTION_HTTP_PROXY, optionName) == 0) { HTTP_PROXY_OPTIONS* proxy_data = (HTTP_PROXY_OPTIONS*)value; HTTP_PROXY_OPTIONS* new_proxy_info = malloc(sizeof(HTTP_PROXY_OPTIONS)); if (new_proxy_info == NULL) { LogError("unable to allocate proxy option information"); result = HTTPAPI_ERROR; } else { new_proxy_info->host_address = proxy_data->host_address; new_proxy_info->port = proxy_data->port; new_proxy_info->password = proxy_data->password; new_proxy_info->username = proxy_data->username; *savedValue = new_proxy_info; result = HTTPAPI_OK; } } else if (strcmp(OPTION_SET_TLS_RENEGOTIATION, optionName) == 0) { bool* temp = (bool*)malloc(sizeof(bool)); /*shall be freed by HTTPAPIEX_Destroy*/ if (temp == NULL) { result = HTTPAPI_ERROR; LogError("malloc failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { *temp = *(bool*)value; *savedValue = temp; result = HTTPAPI_OK; } } else { /*Codes_SRS_HTTPAPI_COMPACT_21_071: [ If the HTTP do not support the optionName, the HTTPAPI_CloneOption shall return HTTPAPI_INVALID_ARG. ]*/ result = HTTPAPI_INVALID_ARG; LogInfo("unknown option %s", optionName); } return result; } httpapi_curl.c000066400000000000000000001315471455573770000337530ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/strings.h" #include "azure_c_shared_utility/httpapi.h" #include "azure_c_shared_utility/httpheaders.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "curl/curl.h" #include "azure_c_shared_utility/xlogging.h" #ifdef USE_OPENSSL #include "azure_c_shared_utility/x509_openssl.h" #elif USE_WOLFSSL #define WOLFSSL_OPTIONS_IGNORE_SYS #include "wolfssl/options.h" #include "wolfssl/ssl.h" #include "wolfssl/error-ssl.h" #elif USE_MBEDTLS #include "mbedtls/x509_crt.h" #include "mbedtls/ssl.h" #endif #include "azure_c_shared_utility/shared_util_options.h" #define TEMP_BUFFER_SIZE 1024 MU_DEFINE_ENUM_STRINGS(HTTPAPI_RESULT, HTTPAPI_RESULT_VALUES); typedef struct HTTP_HANDLE_DATA_TAG { CURL* curl; char* hostURL; long timeout; long lowSpeedLimit; long lowSpeedTime; long forbidReuse; long freshConnect; long verbose; const char* x509privatekey; const char* x509certificate; const char* certificates; /*a list of CA certificates*/ #if USE_MBEDTLS mbedtls_x509_crt cert; mbedtls_pk_context key; mbedtls_x509_crt trusted_certificates; #endif } HTTP_HANDLE_DATA; typedef struct HTTP_RESPONSE_CONTENT_BUFFER_TAG { unsigned char* buffer; size_t bufferSize; unsigned char error; } HTTP_RESPONSE_CONTENT_BUFFER; static size_t nUsersOfHTTPAPI = 0; /*used for reference counting (a weak one)*/ HTTPAPI_RESULT HTTPAPI_Init(void) { HTTPAPI_RESULT result; if (nUsersOfHTTPAPI == 0) { if (curl_global_init(CURL_GLOBAL_NOTHING) != 0) { result = HTTPAPI_INIT_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { nUsersOfHTTPAPI++; result = HTTPAPI_OK; } } else { nUsersOfHTTPAPI++; result = HTTPAPI_OK; } return result; } void HTTPAPI_Deinit(void) { if (nUsersOfHTTPAPI > 0) { nUsersOfHTTPAPI--; if (nUsersOfHTTPAPI == 0) { curl_global_cleanup(); } } } HTTP_HANDLE HTTPAPI_CreateConnection(const char* hostName) { HTTP_HANDLE_DATA* httpHandleData; if (hostName == NULL) { LogError("invalid arg const char* hostName = %p", hostName); httpHandleData = NULL; } else { httpHandleData = (HTTP_HANDLE_DATA*)malloc(sizeof(HTTP_HANDLE_DATA)); if (httpHandleData != NULL) { size_t hostURL_size = strlen("https://") + strlen(hostName) + 1; httpHandleData->hostURL = malloc(hostURL_size); if (httpHandleData->hostURL == NULL) { LogError("unable to malloc"); free(httpHandleData); httpHandleData = NULL; } else { if ((strcpy_s(httpHandleData->hostURL, hostURL_size, "https://") == 0) && (strcat_s(httpHandleData->hostURL, hostURL_size, hostName) == 0)) { httpHandleData->curl = curl_easy_init(); if (httpHandleData->curl == NULL) { free(httpHandleData->hostURL); free(httpHandleData); httpHandleData = NULL; } else { httpHandleData->timeout = 242 * 1000; /*242 seconds seems like a nice enough time. Reasone for 242: 1. http://curl.haxx.se/libcurl/c/CURLOPT_TIMEOUT.html says Normally, name lookups can take a considerable time and limiting operations to less than a few minutes risk aborting perfectly normal operations. 2. 256KB of data... at 9600 bps transfers in about 218 seconds. Add to that a buffer of 10%... round it up to 242 :)*/ httpHandleData->lowSpeedTime = 0; httpHandleData->lowSpeedLimit = 0; httpHandleData->forbidReuse = 0; httpHandleData->freshConnect = 0; httpHandleData->verbose = 0; httpHandleData->x509certificate = NULL; httpHandleData->x509privatekey = NULL; httpHandleData->certificates = NULL; #if USE_MBEDTLS mbedtls_x509_crt_init(&httpHandleData->cert); mbedtls_pk_init(&httpHandleData->key); mbedtls_x509_crt_init(&httpHandleData->trusted_certificates); #endif } } else { free(httpHandleData->hostURL); free(httpHandleData); httpHandleData = NULL; } } } } return (HTTP_HANDLE)httpHandleData; } void HTTPAPI_CloseConnection(HTTP_HANDLE handle) { HTTP_HANDLE_DATA* httpHandleData = (HTTP_HANDLE_DATA*)handle; if (httpHandleData != NULL) { free(httpHandleData->hostURL); curl_easy_cleanup(httpHandleData->curl); #if USE_MBEDTLS mbedtls_x509_crt_free(&httpHandleData->cert); mbedtls_pk_free(&httpHandleData->key); mbedtls_x509_crt_free(&httpHandleData->trusted_certificates); #endif free(httpHandleData); } } static size_t HeadersWriteFunction(void *ptr, size_t size, size_t nmemb, void *userdata) { HTTP_HEADERS_HANDLE responseHeadersHandle = (HTTP_HEADERS_HANDLE)userdata; char* headerLine = (char*)ptr; if (headerLine != NULL) { char* token = strtok(headerLine, "\r\n"); while ((token != NULL) && (token[0] != '\0')) { char* whereIsColon = strchr(token, ':'); if(whereIsColon!=NULL) { *whereIsColon='\0'; HTTPHeaders_AddHeaderNameValuePair(responseHeadersHandle, token, whereIsColon+1); *whereIsColon=':'; } else { /*not a header, maybe a status-line*/ } token = strtok(NULL, "\r\n"); } } return size * nmemb; } static size_t ContentWriteFunction(void *ptr, size_t size, size_t nmemb, void *userdata) { HTTP_RESPONSE_CONTENT_BUFFER* responseContentBuffer = (HTTP_RESPONSE_CONTENT_BUFFER*)userdata; if ((userdata != NULL) && (ptr != NULL) && (size * nmemb > 0)) { void* newBuffer = realloc(responseContentBuffer->buffer, responseContentBuffer->bufferSize + (size * nmemb)); if (newBuffer != NULL) { responseContentBuffer->buffer = newBuffer; memcpy(responseContentBuffer->buffer + responseContentBuffer->bufferSize, ptr, size * nmemb); responseContentBuffer->bufferSize += size * nmemb; } else { LogError("Could not allocate buffer of size %lu", (unsigned long)(responseContentBuffer->bufferSize + (size * nmemb))); responseContentBuffer->error = 1; if (responseContentBuffer->buffer != NULL) { free(responseContentBuffer->buffer); } } } return size * nmemb; } static CURLcode ssl_ctx_callback(CURL *curl, void *ssl_ctx, void *userptr) { CURLcode result; if ( (curl == NULL) || (ssl_ctx == NULL) || (userptr == NULL) ) { LogError("unexpected parameter CURL *curl=%p, void *ssl_ctx=%p, void *userptr=%p", curl, ssl_ctx, userptr); result = CURLE_SSL_CERTPROBLEM; } else { HTTP_HANDLE_DATA *httpHandleData = (HTTP_HANDLE_DATA *)userptr; #ifdef USE_OPENSSL /*trying to set the x509 per device certificate*/ if ( (httpHandleData->x509certificate != NULL) && (httpHandleData->x509privatekey != NULL) && (x509_openssl_add_credentials(ssl_ctx, httpHandleData->x509certificate, httpHandleData->x509privatekey, KEY_TYPE_DEFAULT, NULL) != 0) ) { LogError("unable to x509_openssl_add_credentials"); result = CURLE_SSL_CERTPROBLEM; } /*trying to set CA certificates*/ else if ( (httpHandleData->certificates != NULL) && (x509_openssl_add_certificates(ssl_ctx, httpHandleData->certificates) != 0) ) { LogError("failure in x509_openssl_add_certificates"); result = CURLE_SSL_CERTPROBLEM; } #elif USE_WOLFSSL if ( (httpHandleData->x509certificate != NULL) && (httpHandleData->x509privatekey != NULL) && ( ((wolfSSL_CTX_use_certificate_chain_buffer(ssl_ctx, (unsigned char*)httpHandleData->x509certificate, strlen(httpHandleData->x509certificate)) != SSL_SUCCESS)) || ((wolfSSL_CTX_use_PrivateKey_buffer(ssl_ctx, (unsigned char*)httpHandleData->x509privatekey, strlen(httpHandleData->x509privatekey), SSL_FILETYPE_PEM) != SSL_SUCCESS)) ) ) { LogError("unable to add x509 certs to wolfssl"); result = CURLE_SSL_CERTPROBLEM; } else if ( (httpHandleData->certificates != NULL) && (wolfSSL_CTX_load_verify_buffer(ssl_ctx, (const unsigned char*)httpHandleData->certificates, strlen(httpHandleData->certificates), SSL_FILETYPE_PEM) != SSL_SUCCESS) ) { LogError("failure in adding trusted certificate to client"); result = CURLE_SSL_CERTPROBLEM; } #elif USE_MBEDTLS // set device cert and key if ( (httpHandleData->x509certificate != NULL) && (httpHandleData->x509privatekey != NULL) && !( (mbedtls_x509_crt_parse(&httpHandleData->cert, (const unsigned char *)httpHandleData->x509certificate, (int)(strlen(httpHandleData->x509certificate) + 1)) == 0) && (mbedtls_pk_parse_key(&httpHandleData->key, (const unsigned char *)httpHandleData->x509privatekey, (int)(strlen(httpHandleData->x509privatekey) + 1), NULL, 0) == 0) && (mbedtls_ssl_conf_own_cert(ssl_ctx, &httpHandleData->cert, &httpHandleData->key) == 0) ) ) { LogError("unable to set x509 credentials"); result = CURLE_SSL_CERTPROBLEM; } // set CA else if (httpHandleData->certificates != NULL) { if (mbedtls_x509_crt_parse(&httpHandleData->trusted_certificates, (const unsigned char *)httpHandleData->certificates, (int)(strlen(httpHandleData->certificates) + 1)) != 0) { LogError("unable to set trusted certificate"); result = CURLE_SSL_CERTPROBLEM; } else { mbedtls_ssl_conf_ca_chain(ssl_ctx, &httpHandleData->trusted_certificates, NULL); result = CURLE_OK; } } #else if (httpHandleData->x509certificate != NULL || httpHandleData->x509privatekey != NULL) { LogError("Failure no platform is enabled to handle certificates"); result = CURLE_SSL_CERTPROBLEM; } #endif else { result = CURLE_OK; } } return result; } HTTPAPI_RESULT HTTPAPI_ExecuteRequest(HTTP_HANDLE handle, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath, HTTP_HEADERS_HANDLE httpHeadersHandle, const unsigned char* content, size_t contentLength, unsigned int* statusCode, HTTP_HEADERS_HANDLE responseHeadersHandle, BUFFER_HANDLE responseContent) { HTTPAPI_RESULT result; HTTP_HANDLE_DATA* httpHandleData = (HTTP_HANDLE_DATA*)handle; size_t headersCount; HTTP_RESPONSE_CONTENT_BUFFER responseContentBuffer; if ((httpHandleData == NULL) || (relativePath == NULL) || (httpHeadersHandle == NULL) || ((content == NULL) && (contentLength > 0)) ) { result = HTTPAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (HTTPHeaders_GetHeaderCount(httpHeadersHandle, &headersCount) != HTTP_HEADERS_OK) { result = HTTPAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { char* tempHostURL; size_t tempHostURL_size = strlen(httpHandleData->hostURL) + strlen(relativePath) + 1; tempHostURL = malloc(tempHostURL_size); if (tempHostURL == NULL) { result = HTTPAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_VERBOSE, httpHandleData->verbose) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_VERBOSE (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if ((strcpy_s(tempHostURL, tempHostURL_size, httpHandleData->hostURL) != 0) || (strcat_s(tempHostURL, tempHostURL_size, relativePath) != 0)) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } /* set the URL */ else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_URL, tempHostURL) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_URL (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_TIMEOUT_MS, httpHandleData->timeout) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_TIMEOUT_MS (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_LOW_SPEED_LIMIT, httpHandleData->lowSpeedLimit) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_LOW_SPEED_LIMIT (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_LOW_SPEED_TIME, httpHandleData->lowSpeedTime) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_LOW_SPEED_TIME (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_FRESH_CONNECT, httpHandleData->freshConnect) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_FRESH_CONNECT (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_FORBID_REUSE, httpHandleData->forbidReuse) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_FORBID_REUSE (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("failed to set CURLOPT_HTTP_VERSION (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { result = HTTPAPI_OK; switch (requestType) { default: result = HTTPAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; case HTTPAPI_REQUEST_GET: if (curl_easy_setopt(httpHandleData->curl, CURLOPT_HTTPGET, 1L) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_CUSTOMREQUEST, NULL) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } break; case HTTPAPI_REQUEST_HEAD: if (curl_easy_setopt(httpHandleData->curl, CURLOPT_HTTPGET, 1L) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_NOBODY, 1L) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (curl_easy_setopt(httpHandleData->curl, CURLOPT_CUSTOMREQUEST, NULL) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } break; case HTTPAPI_REQUEST_POST: if (curl_easy_setopt(httpHandleData->curl, CURLOPT_POST, 1L) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_CUSTOMREQUEST, NULL) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } break; case HTTPAPI_REQUEST_PUT: if (curl_easy_setopt(httpHandleData->curl, CURLOPT_POST, 1L)) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_CUSTOMREQUEST, "PUT") != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } break; case HTTPAPI_REQUEST_DELETE: if (curl_easy_setopt(httpHandleData->curl, CURLOPT_POST, 1L) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_CUSTOMREQUEST, "DELETE") != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } break; case HTTPAPI_REQUEST_PATCH: if (curl_easy_setopt(httpHandleData->curl, CURLOPT_POST, 1L) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_CUSTOMREQUEST, "PATCH") != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } break; } if (result == HTTPAPI_OK) { /* add headers */ struct curl_slist* headers = NULL; size_t i; for (i = 0; i < headersCount; i++) { char *tempBuffer; if (HTTPHeaders_GetHeader(httpHeadersHandle, i, &tempBuffer) != HTTP_HEADERS_OK) { /* error */ result = HTTPAPI_HTTP_HEADERS_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } else { struct curl_slist* newHeaders = curl_slist_append(headers, tempBuffer); if (newHeaders == NULL) { result = HTTPAPI_ALLOC_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); free(tempBuffer); break; } else { free(tempBuffer); headers = newHeaders; } } } if (result == HTTPAPI_OK) { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_HTTPHEADER, headers) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { /* add content */ if ((content != NULL) && (contentLength > 0)) { if ((curl_easy_setopt(httpHandleData->curl, CURLOPT_POSTFIELDS, (void*)content) != CURLE_OK) || (curl_easy_setopt(httpHandleData->curl, CURLOPT_POSTFIELDSIZE, contentLength) != CURLE_OK)) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } else { if (requestType != HTTPAPI_REQUEST_GET) { if ((curl_easy_setopt(httpHandleData->curl, CURLOPT_POSTFIELDS, (void*)NULL) != CURLE_OK) || (curl_easy_setopt(httpHandleData->curl, CURLOPT_POSTFIELDSIZE, 0) != CURLE_OK)) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } else { /*GET request cannot POST, so "do nothing*/ } } if (result == HTTPAPI_OK) { if ((curl_easy_setopt(httpHandleData->curl, CURLOPT_WRITEHEADER, NULL) != CURLE_OK) || (curl_easy_setopt(httpHandleData->curl, CURLOPT_HEADERFUNCTION, NULL) != CURLE_OK) || (curl_easy_setopt(httpHandleData->curl, CURLOPT_WRITEFUNCTION, ContentWriteFunction) != CURLE_OK)) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (responseHeadersHandle != NULL) { /* setup the code to get the response headers */ if ((curl_easy_setopt(httpHandleData->curl, CURLOPT_WRITEHEADER, responseHeadersHandle) != CURLE_OK) || (curl_easy_setopt(httpHandleData->curl, CURLOPT_HEADERFUNCTION, HeadersWriteFunction) != CURLE_OK)) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } } if (result == HTTPAPI_OK) { responseContentBuffer.buffer = NULL; responseContentBuffer.bufferSize = 0; responseContentBuffer.error = 0; if (curl_easy_setopt(httpHandleData->curl, CURLOPT_WRITEDATA, &responseContentBuffer) != CURLE_OK) { result = HTTPAPI_SET_OPTION_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } if (result == HTTPAPI_OK) { /* Execute request */ CURLcode curlRes = curl_easy_perform(httpHandleData->curl); if (curlRes != CURLE_OK) { LogError("curl_easy_perform() failed: %s\n", curl_easy_strerror(curlRes)); result = HTTPAPI_OPEN_REQUEST_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { long httpCode; /* get the status code */ if (curl_easy_getinfo(httpHandleData->curl, CURLINFO_RESPONSE_CODE, &httpCode) != CURLE_OK) { result = HTTPAPI_QUERY_HEADERS_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (responseContentBuffer.error) { result = HTTPAPI_READ_DATA_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { if (statusCode != NULL) { *statusCode = (unsigned int)httpCode; } /* fill response content length */ if (responseContent != NULL) { if ((responseContentBuffer.bufferSize > 0) && (BUFFER_build(responseContent, responseContentBuffer.buffer, responseContentBuffer.bufferSize) != 0)) { result = HTTPAPI_INSUFFICIENT_RESPONSE_BUFFER; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { /*all nice*/ } } if (httpCode >= 300) { LogError("Failure in HTTP communication: server reply code is %ld", httpCode); LogInfo("HTTP Response:%*.*s", (int)responseContentBuffer.bufferSize, (int)responseContentBuffer.bufferSize, responseContentBuffer.buffer); } else { result = HTTPAPI_OK; } } } } if (responseContentBuffer.buffer != NULL) { free(responseContentBuffer.buffer); } } } } } } curl_slist_free_all(headers); } } free(tempHostURL); } } return result; } HTTPAPI_RESULT HTTPAPI_SetOption(HTTP_HANDLE handle, const char* optionName, const void* value) { HTTPAPI_RESULT result; if ( (handle == NULL) || (optionName == NULL) || (value == NULL) ) { result = HTTPAPI_INVALID_ARG; LogError("invalid parameter (NULL) passed to HTTPAPI_SetOption"); } else { HTTP_HANDLE_DATA* httpHandleData = (HTTP_HANDLE_DATA*)handle; if (strcmp(OPTION_HTTP_TIMEOUT, optionName) == 0) { long timeout = (long)(*(unsigned int*)value); httpHandleData->timeout = timeout; result = HTTPAPI_OK; } else if (strcmp(OPTION_CURL_LOW_SPEED_LIMIT, optionName) == 0) { httpHandleData->lowSpeedLimit = *(const long*)value; result = HTTPAPI_OK; } else if (strcmp(OPTION_CURL_LOW_SPEED_TIME, optionName) == 0) { httpHandleData->lowSpeedTime = *(const long*)value; result = HTTPAPI_OK; } else if (strcmp(OPTION_CURL_FRESH_CONNECT, optionName) == 0) { httpHandleData->freshConnect = *(const long*)value; result = HTTPAPI_OK; } else if (strcmp(OPTION_CURL_FORBID_REUSE, optionName) == 0) { httpHandleData->forbidReuse = *(const long*)value; result = HTTPAPI_OK; } else if (strcmp(OPTION_CURL_VERBOSE, optionName) == 0) { httpHandleData->verbose = *(const long*)value; result = HTTPAPI_OK; } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { httpHandleData->x509privatekey = value; if (httpHandleData->x509certificate != NULL) { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_SSL_CTX_FUNCTION, ssl_ctx_callback) != CURLE_OK) { LogError("unable to curl_easy_setopt"); result = HTTPAPI_ERROR; } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_SSL_CTX_DATA, httpHandleData) != CURLE_OK) { LogError("unable to curl_easy_setopt"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } } else { /*if privatekey comes 1st and certificate is not set yet, then return OK and wait for the certificate to be set*/ result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { httpHandleData->x509certificate = value; if (httpHandleData->x509privatekey != NULL) { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_SSL_CTX_FUNCTION, ssl_ctx_callback) != CURLE_OK) { LogError("unable to curl_easy_setopt"); result = HTTPAPI_ERROR; } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_SSL_CTX_DATA, httpHandleData) != CURLE_OK) { LogError("unable to curl_easy_setopt"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } } else { /*if certificate comes 1st and private key is not set yet, then return OK and wait for the private key to be set*/ result = HTTPAPI_OK; } } else if (strcmp(OPTION_HTTP_PROXY, optionName) == 0) { char proxy[MAX_HOSTNAME_LEN]; char* proxy_auth; HTTP_PROXY_OPTIONS* proxy_data = (HTTP_PROXY_OPTIONS*)value; if (sprintf_s(proxy, MAX_HOSTNAME_LEN, "%s:%d", proxy_data->host_address, proxy_data->port) <= 0) { LogError("failure constructing proxy address"); result = HTTPAPI_ERROR; } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_PROXY, proxy) != CURLE_OK) { LogError("failure setting curl proxy address"); result = HTTPAPI_ERROR; } else { if (proxy_data->username != NULL && proxy_data->password != NULL) { size_t authLen = strlen(proxy_data->username)+strlen(proxy_data->password)+1; proxy_auth = malloc(authLen+1); if (proxy_auth == NULL) { LogError("failure allocating proxy authentication"); result = HTTPAPI_ERROR; } else { // From curl website 'Pass a char * as parameter, which should be [user name]:[password]' if (sprintf_s(proxy_auth, MAX_HOSTNAME_LEN, "%s:%s", proxy_data->username, proxy_data->password) <= 0) { LogError("failure constructing proxy authentication"); result = HTTPAPI_ERROR; } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_PROXYUSERPWD, proxy_auth) != CURLE_OK) { LogError("failure setting curl proxy authentication"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } free(proxy_auth); } } else { result = HTTPAPI_OK; } } } } else if (strcmp("TrustedCerts", optionName) == 0) { /*TrustedCerts needs to trigger the CURLOPT_SSL_CTX_FUNCTION in curl so we can pass the CAs*/ if (curl_easy_setopt(httpHandleData->curl, CURLOPT_SSL_CTX_FUNCTION, ssl_ctx_callback) != CURLE_OK) { LogError("failure in curl_easy_setopt - CURLOPT_SSL_CTX_FUNCTION"); result = HTTPAPI_ERROR; } else { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_SSL_CTX_DATA, httpHandleData) != CURLE_OK) { LogError("failure in curl_easy_setopt - CURLOPT_SSL_CTX_DATA"); result = HTTPAPI_ERROR; } else { httpHandleData->certificates = (const char*)value; result = HTTPAPI_OK; } } } else if (strcmp(OPTION_CURL_INTERFACE, optionName) == 0) { const char *interfaceName = (const char*)value; if (interfaceName != NULL && interfaceName[0] != '\0') { if (curl_easy_setopt(httpHandleData->curl, CURLOPT_INTERFACE, interfaceName) != CURLE_OK) { LogError("unable to curl_easy_setopt for CURLOPT_INTERFACE"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } else { LogError("unable to curl_easy_setopt for CURLOPT_INTERFACE option as option-value is invalid/empty"); result = HTTPAPI_ERROR; } } else { result = HTTPAPI_INVALID_ARG; LogError("unknown option %s", optionName); } } return result; } HTTPAPI_RESULT HTTPAPI_CloneOption(const char* optionName, const void* value, const void** savedValue) { HTTPAPI_RESULT result; if ( (optionName == NULL) || (value == NULL) || (savedValue == NULL) ) { result = HTTPAPI_INVALID_ARG; LogError("invalid argument(NULL) passed to HTTPAPI_CloneOption"); } else { if (strcmp(OPTION_HTTP_TIMEOUT, optionName) == 0) { /*by convention value is pointing to an unsigned int */ unsigned int* temp = malloc(sizeof(unsigned int)); /*shall be freed by HTTPAPIEX*/ if (temp == NULL) { result = HTTPAPI_ERROR; LogError("malloc failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { *temp = *(const unsigned int*)value; *savedValue = temp; result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { /*this is getting the x509 certificate. In this case, value is a pointer to a const char* that contains the certificate as a null terminated string*/ if (mallocAndStrcpy_s((char**)savedValue, value) != 0) { LogError("unable to clone the x509 certificate content"); result = HTTPAPI_ERROR; } else { /*return OK when the certificate has been clones successfully*/ result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { /*this is getting the x509 private key. In this case, value is a pointer to a const char* that contains the private key as a null terminated string*/ if (mallocAndStrcpy_s((char**)savedValue, value) != 0) { LogError("unable to clone the x509 private key content"); result = HTTPAPI_ERROR; } else { /*return OK when the private key has been clones successfully*/ result = HTTPAPI_OK; } } else if (strcmp("TrustedCerts", optionName) == 0) { if (mallocAndStrcpy_s((char**)savedValue, value) != 0) { LogError("unable to clone TrustedCerts"); result = HTTPAPI_ERROR; } else { /*return OK when the certificates have been clones successfully*/ result = HTTPAPI_OK; } } else if (strcmp(OPTION_HTTP_PROXY, optionName) == 0) { HTTP_PROXY_OPTIONS* proxy_data = (HTTP_PROXY_OPTIONS*)value; HTTP_PROXY_OPTIONS* new_proxy_info = malloc(sizeof(HTTP_PROXY_OPTIONS)); if (new_proxy_info == NULL) { LogError("unable to allocate proxy option information"); result = HTTPAPI_ERROR; } else { new_proxy_info->host_address = proxy_data->host_address; new_proxy_info->port = proxy_data->port; new_proxy_info->password = proxy_data->password; new_proxy_info->username = proxy_data->username; *savedValue = new_proxy_info; result = HTTPAPI_OK; } } /*all "long" options are cloned in the same way*/ else if ( (strcmp(OPTION_CURL_LOW_SPEED_LIMIT, optionName) == 0) || (strcmp(OPTION_CURL_LOW_SPEED_TIME, optionName) == 0) || (strcmp(OPTION_CURL_FRESH_CONNECT, optionName) == 0) || (strcmp(OPTION_CURL_FORBID_REUSE, optionName) == 0) || (strcmp(OPTION_CURL_VERBOSE, optionName) == 0) ) { /*by convention value is pointing to an long */ long* temp = malloc(sizeof(long)); /*shall be freed by HTTPAPIEX*/ if (temp == NULL) { result = HTTPAPI_ERROR; LogError("malloc failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { *temp = *(const long*)value; *savedValue = temp; result = HTTPAPI_OK; } } else if (strcmp(OPTION_CURL_INTERFACE, optionName) == 0) { if (mallocAndStrcpy_s((char**)savedValue, value) != 0) { LogError("unable to clone the interface name"); result = HTTPAPI_ERROR; } else { /*return OK when the interface name has been cloned successfully*/ result = HTTPAPI_OK; } } else { result = HTTPAPI_INVALID_ARG; LogError("unknown option %s", optionName); } } return result; } httpapi_tirtos.c000066400000000000000000000202041455573770000343150ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Texas Instruments. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include "azure_c_shared_utility/httpapi.h" #include "azure_c_shared_utility/strings.h" #include "azure_c_shared_utility/xlogging.h" #define CONTENT_BUF_LEN 128 static const char* getHttpMethod(HTTPAPI_REQUEST_TYPE requestType) { switch (requestType) { case HTTPAPI_REQUEST_GET: return (HTTPStd_GET); case HTTPAPI_REQUEST_POST: return (HTTPStd_POST); case HTTPAPI_REQUEST_PUT: return (HTTPStd_PUT); case HTTPAPI_REQUEST_DELETE: return (HTTPStd_DELETE); case HTTPAPI_REQUEST_PATCH: return (HTTPStd_PATCH); default: return (NULL); } } static int splitHeader(char *headerName, char **headerValue) { *headerValue = strchr(headerName, ':'); if (*headerValue == NULL) { return (-1); } **headerValue = '\0'; (*headerValue)++; while (**headerValue == ' ') { (*headerValue)++; } return (0); } HTTPAPI_RESULT HTTPAPI_Init(void) { return (HTTPAPI_OK); } void HTTPAPI_Deinit(void) { } HTTP_HANDLE HTTPAPI_CreateConnection(const char* hostName) { int ret; struct sockaddr addr; HTTPCli_Handle cli; ret = HTTPCli_initSockAddr(&addr, hostName, 0); if (ret < 0) { LogError("HTTPCli_initSockAddr failed, ret=%d", ret); return (NULL); } ((struct sockaddr_in *) (&addr))->sin_port = htons(HTTPStd_SECURE_PORT); cli = HTTPCli_create(); if (cli == NULL) { LogError("HTTPCli_create failed"); return (NULL); } ret = HTTPCli_connect(cli, &addr, HTTPCli_TYPE_TLS, NULL); if (ret < 0) { LogError("HTTPCli_connect failed, ret=%d", ret); HTTPCli_delete(&cli); return (NULL); } return ((HTTP_HANDLE) cli); } void HTTPAPI_CloseConnection(HTTP_HANDLE handle) { HTTPCli_Handle cli = (HTTPCli_Handle) handle; if (cli) { HTTPCli_disconnect(cli); HTTPCli_delete(&cli); } } HTTPAPI_RESULT HTTPAPI_ExecuteRequest(HTTP_HANDLE handle, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath, HTTP_HEADERS_HANDLE httpHeadersHandle, const unsigned char* content, size_t contentLength, unsigned int* statusCode, HTTP_HEADERS_HANDLE responseHeadersHandle, BUFFER_HANDLE responseContent) { HTTPCli_Handle cli = (HTTPCli_Handle) handle; int ret; int offset; size_t cnt; char contentBuf[CONTENT_BUF_LEN] = {0}; char *hname; char *hvalue; const char *method; bool moreFlag; method = getHttpMethod(requestType); if ((cli == NULL) || (method == NULL) || (relativePath == NULL) || (statusCode == NULL) || (responseHeadersHandle == NULL)) { LogError("Invalid arguments: handle=%p, requestType=%d, relativePath=%p, statusCode=%p, responseHeadersHandle=%p", handle, (int)requestType, relativePath, statusCode, responseHeadersHandle); return (HTTPAPI_INVALID_ARG); } else if (HTTPHeaders_GetHeaderCount(httpHeadersHandle, &cnt) != HTTP_HEADERS_OK) { LogError("Cannot get header count"); return (HTTPAPI_QUERY_HEADERS_FAILED); } /* Send the request line */ ret = HTTPCli_sendRequest(cli, method, relativePath, true); if (ret < 0) { LogError("HTTPCli_sendRequest failed, ret=%d", ret); return (HTTPAPI_SEND_REQUEST_FAILED); } /* Send the request headers */ while (cnt--) { ret = HTTPHeaders_GetHeader(httpHeadersHandle, cnt, &hname); if (ret != HTTP_HEADERS_OK) { LogError("Cannot get request header %d", cnt); return (HTTPAPI_QUERY_HEADERS_FAILED); } ret = splitHeader(hname, &hvalue); if (ret == 0) { ret = HTTPCli_sendField(cli, hname, hvalue, false); } free(hname); hname = NULL; if (ret < 0) { LogError("HTTP send field failed, ret=%d", ret); return (HTTPAPI_SEND_REQUEST_FAILED); } } /* Send the last header and request body */ ret = HTTPCli_sendField(cli, NULL, NULL, true); if (ret < 0) { LogError("HTTP send empty field failed, ret=%d", ret); return (HTTPAPI_SEND_REQUEST_FAILED); } if (content && contentLength != 0) { ret = HTTPCli_sendRequestBody(cli, (const char *)content, contentLength); if (ret < 0) { LogError("HTTP send request body failed, ret=%d", ret); return (HTTPAPI_SEND_REQUEST_FAILED); } } /* Get the response status code */ ret = HTTPCli_getResponseStatus(cli); if (ret < 0) { LogError("HTTP receive response failed, ret=%d", ret); return (HTTPAPI_RECEIVE_RESPONSE_FAILED); } *statusCode = (unsigned int)ret; /* Get the response headers */ hname = NULL; cnt = 0; offset = 0; do { ret = HTTPCli_readResponseHeader(cli, contentBuf, CONTENT_BUF_LEN, &moreFlag); if (ret < 0) { LogError("HTTP read response header failed, ret=%d", ret); ret = HTTPAPI_RECEIVE_RESPONSE_FAILED; goto headersDone; } else if (ret == 0) { /* All headers read */ goto headersDone; } if (cnt < offset + ret) { hname = (char *)realloc(hname, offset + ret); if (hname == NULL) { LogError("Failed reallocating memory"); ret = HTTPAPI_ALLOC_FAILED; goto headersDone; } cnt = offset + ret; } memcpy(hname + offset, contentBuf, ret); offset += ret; if (moreFlag) { continue; } ret = splitHeader(hname, &hvalue); if (ret < 0) { LogError("HTTP split header failed, ret=%d", ret); ret = HTTPAPI_HTTP_HEADERS_FAILED; goto headersDone; } ret = HTTPHeaders_AddHeaderNameValuePair(responseHeadersHandle, hname, hvalue); if (ret != HTTP_HEADERS_OK) { LogError("Adding the response header failed"); ret = HTTPAPI_HTTP_HEADERS_FAILED; goto headersDone; } offset = 0; } while (1); headersDone: free(hname); hname = NULL; if (ret != 0) { return ((HTTPAPI_RESULT)ret); } /* Get response body */ if (responseContent != NULL) { offset = 0; cnt = 0; do { ret = HTTPCli_readResponseBody(cli, contentBuf, CONTENT_BUF_LEN, &moreFlag); if (ret < 0) { LogError("HTTP read response body failed, ret=%d", ret); ret = HTTPAPI_RECEIVE_RESPONSE_FAILED; goto contentDone; } if (ret != 0) { cnt = ret; ret = BUFFER_enlarge(responseContent, cnt); if (ret != 0) { LogError("Failed enlarging response buffer"); ret = HTTPAPI_ALLOC_FAILED; goto contentDone; } ret = BUFFER_content(responseContent, (const unsigned char **)&hname); if (ret != 0) { LogError("Failed getting the response buffer content"); ret = HTTPAPI_ALLOC_FAILED; goto contentDone; } memcpy(hname + offset, contentBuf, cnt); offset += cnt; } } while (moreFlag); contentDone: if (ret < 0) { BUFFER_unbuild(responseContent); return ((HTTPAPI_RESULT)ret); } } return (HTTPAPI_OK); } HTTPAPI_RESULT HTTPAPI_SetOption(HTTP_HANDLE handle, const char* optionName, const void* value) { return (HTTPAPI_INVALID_ARG); } HTTPAPI_RESULT HTTPAPI_CloneOption(const char* optionName, const void* value, const void** savedValue) { return (HTTPAPI_INVALID_ARG); } httpapi_winhttp.c000066400000000000000000001310411455573770000344700ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "windows.h" #include "winhttp.h" #include "wincrypt.h" #include "azure_c_shared_utility/httpapi.h" #include "azure_c_shared_utility/httpheaders.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/strings.h" #include "azure_c_shared_utility/x509_schannel.h" #include "azure_c_shared_utility/shared_util_options.h" MU_DEFINE_ENUM_STRINGS(HTTPAPI_RESULT, HTTPAPI_RESULT_VALUES) typedef enum HTTPAPI_STATE_TAG { HTTPAPI_NOT_INITIALIZED, HTTPAPI_INITIALIZED } HTTPAPI_STATE; typedef struct HTTP_HANDLE_DATA_TAG { /*working set*/ HINTERNET ConnectionHandle; X509_SCHANNEL_HANDLE x509SchannelHandle; /*options*/ unsigned int timeout; const char* x509certificate; const char* x509privatekey; const char* proxy_host; const char* proxy_username; const char* proxy_password; // Certificate to check server certificate chains to, overriding built-in Windows certificate store certificates. char* trustedCertificate; // Set when a callback fails. bool handleClosedOnCallbackError; } HTTP_HANDLE_DATA; static HTTPAPI_STATE g_HTTPAPIState = HTTPAPI_NOT_INITIALIZED; /*There's a global SessionHandle for all the connections*/ static HINTERNET g_SessionHandle; static size_t nUsersOfHTTPAPI = 0; /*used for reference counting (a weak one)*/ static char* ConcatHttpHeaders(HTTP_HEADERS_HANDLE httpHeadersHandle, size_t toAlloc, size_t headersCount) { char *result = (char*)malloc(toAlloc * sizeof(char) + 1); size_t i; if (result == NULL) { LogError("unable to malloc"); } else { result[0] = '\0'; for (i = 0; i < headersCount; i++) { char* temp; if (HTTPHeaders_GetHeader(httpHeadersHandle, i, &temp) != HTTP_HEADERS_OK) { LogError("unable to HTTPHeaders_GetHeader"); break; } else { (void)strcat(result, temp); (void)strcat(result, "\r\n"); free(temp); } } if (i < headersCount) { free(result); result = NULL; } else { /*all is good*/ } } return result; } /*returns NULL if it failed to construct the headers*/ static HTTPAPI_RESULT ConstructHeadersString(HTTP_HEADERS_HANDLE httpHeadersHandle, wchar_t** httpHeaders) { HTTPAPI_RESULT result; size_t headersCount; if (HTTPHeaders_GetHeaderCount(httpHeadersHandle, &headersCount) != HTTP_HEADERS_OK) { result = HTTPAPI_ERROR; LogError("HTTPHeaders_GetHeaderCount failed (result = %" PRI_MU_ENUM ").", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { size_t i; /*the total size of all the headers is given by sumof(lengthof(everyheader)+2)*/ size_t toAlloc = 0; for (i = 0; i < headersCount; i++) { char *temp; if (HTTPHeaders_GetHeader(httpHeadersHandle, i, &temp) == HTTP_HEADERS_OK) { toAlloc += strlen(temp); toAlloc += 2; free(temp); } else { LogError("HTTPHeaders_GetHeader failed"); break; } } if (i < headersCount) { result = HTTPAPI_ERROR; } else { char *httpHeadersA; size_t requiredCharactersForHeaders; if ((httpHeadersA = ConcatHttpHeaders(httpHeadersHandle, toAlloc, headersCount)) == NULL) { result = HTTPAPI_ERROR; LogError("Cannot concatenate headers"); } else if ((requiredCharactersForHeaders = MultiByteToWideChar(CP_ACP, 0, httpHeadersA, -1, NULL, 0)) == 0) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("MultiByteToWideChar failed, GetLastError=0x%08x (result = %" PRI_MU_ENUM ")", GetLastError(), MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if ((*httpHeaders = (wchar_t*)malloc((requiredCharactersForHeaders + 1) * sizeof(wchar_t))) == NULL) { result = HTTPAPI_ALLOC_FAILED; LogError("Cannot allocate memory (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (MultiByteToWideChar(CP_ACP, 0, httpHeadersA, -1, *httpHeaders, (int)requiredCharactersForHeaders) == 0) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("MultiByteToWideChar failed, GetLastError=0x%08x (result = %" PRI_MU_ENUM ")", GetLastError(), MU_ENUM_VALUE(HTTPAPI_RESULT, result)); free(*httpHeaders); *httpHeaders = NULL; } else { result = HTTPAPI_OK; } free(httpHeadersA); } } return result; } void CALLBACK httpapi_WinhttpStatusCallback( IN HINTERNET hInternet, IN DWORD_PTR dwContext, IN DWORD dwInternetStatus, IN LPVOID lpvStatusInformation, IN DWORD dwStatusInformationLength ) { HTTP_HANDLE_DATA* handleData = (HTTP_HANDLE_DATA*)dwContext; (void)dwStatusInformationLength; (void)lpvStatusInformation; if (dwContext == 0) { LogError("WinhttpStatusCallback called without context set"); } else if (dwInternetStatus != WINHTTP_CALLBACK_STATUS_SENDING_REQUEST) { // Silently ignore if there's any statuses we get that we can't handle ; } else if (handleData->trustedCertificate != NULL) { PCERT_CONTEXT pCertContext = NULL; DWORD bufferLength = sizeof(pCertContext); bool certificateTrusted; if (! WinHttpQueryOption(hInternet, WINHTTP_OPTION_SERVER_CERT_CONTEXT, (void*)&pCertContext, &bufferLength)) { LogErrorWinHTTPWithGetLastErrorAsString("WinHttpQueryOption(WINHTTP_OPTION_SERVER_CERT_CONTEXT) failed"); certificateTrusted = false; } else if (x509_verify_certificate_in_chain(handleData->trustedCertificate, pCertContext) != 0) { LogError("Certificate does not chain up correctly"); certificateTrusted = false; } else { certificateTrusted = true; } if (certificateTrusted == false) { LogError("Server certificate is not trusted. Aborting HTTP request"); // To signal to caller that the request is to be terminated, the callback closes the handle. WinHttpCloseHandle(hInternet); // To avoid a double free of this handle (in HTTPAPI_ExecuteRequset cleanup) record we've processed close already. handleData->handleClosedOnCallbackError = true; } if (pCertContext != NULL) { CertFreeCertificateContext(pCertContext); } } } HTTPAPI_RESULT HTTPAPI_Init(void) { HTTPAPI_RESULT result; if (nUsersOfHTTPAPI == 0) { if ((g_SessionHandle = WinHttpOpen( NULL, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0)) == NULL) { LogErrorWinHTTPWithGetLastErrorAsString("WinHttpOpen failed."); result = HTTPAPI_INIT_FAILED; } else { DWORD supportedProtocols = WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 | // TLS 1.0 is support for back-compat reasons (https://docs.microsoft.com/en-us/azure/iot-fundamentals/iot-security-deployment) WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 | WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2; if (!WinHttpSetOption( g_SessionHandle, WINHTTP_OPTION_SECURE_PROTOCOLS, &supportedProtocols, sizeof(supportedProtocols) )) { LogErrorWinHTTPWithGetLastErrorAsString("unable to WinHttpSetOption (WINHTTP_OPTION_SECURE_PROTOCOLS)"); (void)WinHttpCloseHandle(g_SessionHandle); g_SessionHandle = NULL; result = HTTPAPI_INIT_FAILED; } else if (WinHttpSetStatusCallback(g_SessionHandle, httpapi_WinhttpStatusCallback, WINHTTP_CALLBACK_FLAG_SEND_REQUEST, 0) == WINHTTP_INVALID_STATUS_CALLBACK) { LogErrorWinHTTPWithGetLastErrorAsString("WinHttpSetStatusCallback failed."); (void)WinHttpCloseHandle(g_SessionHandle); g_SessionHandle = NULL; result = HTTPAPI_INIT_FAILED; } else { nUsersOfHTTPAPI++; g_HTTPAPIState = HTTPAPI_INITIALIZED; result = HTTPAPI_OK; } } } else { nUsersOfHTTPAPI++; result = HTTPAPI_OK; } return result; } void HTTPAPI_Deinit(void) { if (nUsersOfHTTPAPI > 0) { nUsersOfHTTPAPI--; if (nUsersOfHTTPAPI == 0) { if (g_SessionHandle != NULL) { (void)WinHttpCloseHandle(g_SessionHandle); g_SessionHandle = NULL; g_HTTPAPIState = HTTPAPI_NOT_INITIALIZED; } } } } HTTP_HANDLE HTTPAPI_CreateConnection(const char* hostName) { HTTP_HANDLE_DATA* result; if (g_HTTPAPIState != HTTPAPI_INITIALIZED) { LogError("g_HTTPAPIState not HTTPAPI_INITIALIZED"); result = NULL; } else { result = (HTTP_HANDLE_DATA*)malloc(sizeof(HTTP_HANDLE_DATA)); if (result == NULL) { LogError("malloc returned NULL."); } else { memset(result, 0, sizeof(*result)); wchar_t* hostNameTemp; size_t hostNameTemp_size = MultiByteToWideChar(CP_ACP, 0, hostName, -1, NULL, 0); if (hostNameTemp_size == 0) { LogError("MultiByteToWideChar failed"); free(result); result = NULL; } else { hostNameTemp = (wchar_t*)malloc(sizeof(wchar_t) * hostNameTemp_size); if (hostNameTemp == NULL) { LogError("malloc failed"); free(result); result = NULL; } else { if (MultiByteToWideChar(CP_ACP, 0, hostName, -1, hostNameTemp, (int)hostNameTemp_size) == 0) { LogError("MultiByteToWideChar failed"); free(result); result = NULL; } else { result->ConnectionHandle = WinHttpConnect( g_SessionHandle, hostNameTemp, INTERNET_DEFAULT_HTTPS_PORT, 0); if (result->ConnectionHandle == NULL) { LogErrorWinHTTPWithGetLastErrorAsString("WinHttpConnect returned NULL."); free(result); result = NULL; } else { result->timeout = 60000; } } free(hostNameTemp); } } } } return (HTTP_HANDLE)result; } void HTTPAPI_CloseConnection(HTTP_HANDLE handle) { if (g_HTTPAPIState != HTTPAPI_INITIALIZED) { LogError("g_HTTPAPIState not HTTPAPI_INITIALIZED"); } else { HTTP_HANDLE_DATA* handleData = (HTTP_HANDLE_DATA*)handle; if (handleData != NULL) { if (handleData->ConnectionHandle != NULL) { (void)WinHttpCloseHandle(handleData->ConnectionHandle); /*no x509 free because the options are owned by httpapiex.*/ handleData->ConnectionHandle = NULL; } if (handleData->proxy_host != NULL) { free((void*)handleData->proxy_host); } if (handleData->proxy_username != NULL) { free((void*)handleData->proxy_username); } if (handleData->proxy_password != NULL) { free((void*)handleData->proxy_password); } x509_schannel_destroy(handleData->x509SchannelHandle); free(handleData); } } } static const wchar_t* GetHttpRequestString(HTTPAPI_REQUEST_TYPE requestType) { wchar_t* requestTypeString = NULL; switch (requestType) { default: break; case HTTPAPI_REQUEST_GET: requestTypeString = L"GET"; break; case HTTPAPI_REQUEST_HEAD: requestTypeString = L"HEAD"; break; case HTTPAPI_REQUEST_POST: requestTypeString = L"POST"; break; case HTTPAPI_REQUEST_PUT: requestTypeString = L"PUT"; break; case HTTPAPI_REQUEST_DELETE: requestTypeString = L"DELETE"; break; case HTTPAPI_REQUEST_PATCH: requestTypeString = L"PATCH"; break; } return requestTypeString; } static HTTPAPI_RESULT InitiateWinhttpRequest(HTTP_HANDLE_DATA* handleData, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath, HINTERNET *requestHandle) { HTTPAPI_RESULT result; const wchar_t* requestTypeString; size_t requiredCharactersForRelativePath; wchar_t* relativePathTemp = NULL; if ((requestTypeString = GetHttpRequestString(requestType)) == NULL) { result = HTTPAPI_INVALID_ARG; LogError("requestTypeString was NULL (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if ((requiredCharactersForRelativePath = MultiByteToWideChar(CP_ACP, 0, relativePath, -1, NULL, 0)) == 0) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("MultiByteToWideChar failed, GetLastError=0x%08x", GetLastError()); } else if ((relativePathTemp = (wchar_t*)malloc((requiredCharactersForRelativePath + 1) * sizeof(wchar_t))) == NULL) { result = HTTPAPI_ALLOC_FAILED; LogError("malloc failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (MultiByteToWideChar(CP_ACP, 0, relativePath, -1, relativePathTemp, (int)requiredCharactersForRelativePath) == 0) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("MultiByteToWideChar was 0. (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if ((*requestHandle = WinHttpOpenRequest( handleData->ConnectionHandle, requestTypeString, relativePathTemp, NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE)) == NULL) { result = HTTPAPI_OPEN_REQUEST_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpOpenRequest failed (result = %" PRI_MU_ENUM ").", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if ((handleData->x509SchannelHandle != NULL) && !WinHttpSetOption( *requestHandle, WINHTTP_OPTION_CLIENT_CERT_CONTEXT, (void*)x509_schannel_get_certificate_context(handleData->x509SchannelHandle), sizeof(CERT_CONTEXT) )) { result = HTTPAPI_SET_X509_FAILURE; LogErrorWinHTTPWithGetLastErrorAsString("unable to WinHttpSetOption (WINHTTP_OPTION_CLIENT_CERT_CONTEXT)"); (void)WinHttpCloseHandle(*requestHandle); *requestHandle = NULL; } else { result = HTTPAPI_OK; } free(relativePathTemp); return result; } static HTTPAPI_RESULT SendHttpRequest(HTTP_HANDLE_DATA* handleData, HINTERNET requestHandle, const unsigned char* content, size_t contentLength, const wchar_t* httpHeaders) { HTTPAPI_RESULT result; if (WinHttpSetTimeouts(requestHandle, 0, /*_In_ int dwResolveTimeout - The initial value is zero, meaning no time-out (infinite). */ 60000, /*_In_ int dwConnectTimeout, - The initial value is 60,000 (60 seconds).*/ handleData->timeout, /*_In_ int dwSendTimeout, - The initial value is 30,000 (30 seconds).*/ handleData->timeout /* int dwReceiveTimeout The initial value is 30,000 (30 seconds).*/ ) == FALSE) { result = HTTPAPI_SET_TIMEOUTS_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpOpenRequest failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { DWORD dwSecurityFlags; if (handleData->trustedCertificate != NULL) { // If caller has specified trusted certificates, then we'll instruct Winhttp to ignore certain classes // of invalid certificate errors (since the trusted cert won't chain into the Windows cert store). // We will validate certificate manually during Winhttp callbacks. dwSecurityFlags = SECURITY_FLAG_IGNORE_UNKNOWN_CA; } else { dwSecurityFlags = 0; } if (!WinHttpSetOption( requestHandle, WINHTTP_OPTION_SECURITY_FLAGS, &dwSecurityFlags, sizeof(dwSecurityFlags))) { result = HTTPAPI_SET_OPTION_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpSetOption failed (result = %" PRI_MU_ENUM ").", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (!WinHttpSendRequest( requestHandle, httpHeaders, (DWORD)-1L, /*An unsigned long integer value that contains the length, in characters, of the additional headers. If this parameter is -1L ... */ (void*)content, (DWORD)contentLength, (DWORD)contentLength, (DWORD_PTR)handleData)) { result = HTTPAPI_SEND_REQUEST_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpSendRequest: (result = %" PRI_MU_ENUM ").", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { result = HTTPAPI_OK; } } return result; } static HTTPAPI_RESULT SetProxyIfNecessary(HTTP_HANDLE_DATA* handleData, HINTERNET requestHandle) { HTTPAPI_RESULT result; // Set proxy host if needed if (handleData->proxy_host != NULL) { WINHTTP_PROXY_INFO winhttp_proxy; wchar_t wproxy[MAX_HOSTNAME_LEN]; winhttp_proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY; if (mbstowcs_s(NULL, wproxy, MAX_HOSTNAME_LEN, handleData->proxy_host, MAX_HOSTNAME_LEN-1) != 0) { LogError("Error during proxy host conversion"); result = HTTPAPI_ERROR; } else { winhttp_proxy.lpszProxy = wproxy; winhttp_proxy.lpszProxyBypass = NULL; if (WinHttpSetOption(requestHandle, WINHTTP_OPTION_PROXY, &winhttp_proxy, (DWORD)sizeof(WINHTTP_PROXY_INFO)) != TRUE) { LogError("failure setting proxy address (%i)", GetLastError()); result = HTTPAPI_ERROR; } else { //Set username and password if needed if (handleData->proxy_username != NULL && handleData->proxy_password != NULL) { wchar_t wusername[MAX_USERNAME_LEN]; if (mbstowcs_s(NULL, wusername, MAX_USERNAME_LEN, handleData->proxy_username, MAX_USERNAME_LEN-1) != 0) { LogError("Error during proxy username conversion"); result = HTTPAPI_ERROR; } else { wchar_t wpassword[MAX_PASSWORD_LEN]; if (mbstowcs_s(NULL, wpassword, MAX_PASSWORD_LEN, handleData->proxy_password, MAX_PASSWORD_LEN-1) != 0) { LogError("Error during proxy password conversion"); result = HTTPAPI_ERROR; } else { if (WinHttpSetCredentials(requestHandle, WINHTTP_AUTH_TARGET_PROXY, WINHTTP_AUTH_SCHEME_BASIC, wusername, wpassword, NULL) != TRUE) { LogErrorWinHTTPWithGetLastErrorAsString("Failure setting proxy credentials"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } } } else { result = HTTPAPI_OK; } } } } else { result = HTTPAPI_OK; } return result; } static HTTPAPI_RESULT ReceiveResponseAndStatusCode(HINTERNET requestHandle, unsigned int* statusCode) { HTTPAPI_RESULT result; if (!WinHttpReceiveResponse( requestHandle, 0)) { result = HTTPAPI_RECEIVE_RESPONSE_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpReceiveResponse: (result = %" PRI_MU_ENUM ").", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (statusCode != NULL) { DWORD dwStatusCode = 0; DWORD dwBufferLength = sizeof(DWORD); if (!WinHttpQueryHeaders( requestHandle, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, WINHTTP_HEADER_NAME_BY_INDEX, &dwStatusCode, &dwBufferLength, WINHTTP_NO_HEADER_INDEX)) { result = HTTPAPI_QUERY_HEADERS_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpQueryHeaders failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { *statusCode = dwStatusCode; result = HTTPAPI_OK; } } else { result = HTTPAPI_OK; } return result; } static HTTPAPI_RESULT ReceiveResponseContent(HINTERNET requestHandle, BUFFER_HANDLE responseContent) { HTTPAPI_RESULT result; DWORD responseBytesAvailable; while (true) { /*from MSDN: If no data is available and the end of the file has not been reached, one of two things happens. If the session is synchronous, the request waits until data becomes available.*/ if (!WinHttpQueryDataAvailable(requestHandle, &responseBytesAvailable)) { result = HTTPAPI_QUERY_DATA_AVAILABLE_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpQueryDataAvailable failed (result = %" PRI_MU_ENUM ").", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } else if (responseBytesAvailable == 0) { /*end of the stream, go out*/ result = HTTPAPI_OK; break; } else if (BUFFER_enlarge(responseContent, responseBytesAvailable) != 0) { result = HTTPAPI_ALLOC_FAILED; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } else { /*Add the read bytes to the response buffer*/ size_t bufferSize; const unsigned char* bufferContent; if (BUFFER_content(responseContent, &bufferContent) != 0) { result = HTTPAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } else if (BUFFER_size(responseContent, &bufferSize) != 0) { result = HTTPAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } else { DWORD bytesReceived; if (!WinHttpReadData(requestHandle, (LPVOID)(bufferContent + bufferSize - responseBytesAvailable), responseBytesAvailable, &bytesReceived)) { result = HTTPAPI_READ_DATA_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpReadData failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } /*if for some reason bytesReceived is zero If you are using WinHttpReadData synchronously, and the return value is TRUE and the number of bytes read is zero, the transfer has been completed and there are no more bytes to read on the handle.*/ else if (bytesReceived == 0) { /*end of everything, but this looks like an error still, or a non-conformance between WinHttpQueryDataAvailable and WinHttpReadData*/ result = HTTPAPI_READ_DATA_FAILED; LogError("bytesReceived was unexpectedly zero (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); break; } else { /*all is fine, keep going*/ } } } } return result; } static HTTPAPI_RESULT ReceiveResponseHeaders(HINTERNET requestHandle, HTTP_HEADERS_HANDLE responseHeadersHandle) { HTTPAPI_RESULT result; wchar_t* responseHeadersTemp = NULL; DWORD responseHeadersTempLength = 0; // Don't explicictly check return code here - since this should fail (to determine length) // and checking return code means an explicit GetLastError() comparison. Instead // rely on subsequent WinHttpQueryHeaders() to fail. WinHttpQueryHeaders( requestHandle, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_HEADER_NAME_BY_INDEX, WINHTTP_NO_OUTPUT_BUFFER, &responseHeadersTempLength, WINHTTP_NO_HEADER_INDEX); if ((responseHeadersTemp = (wchar_t*)malloc(responseHeadersTempLength + 2)) == NULL) { result = HTTPAPI_ALLOC_FAILED; LogError("malloc failed: (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else if (! WinHttpQueryHeaders( requestHandle, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_HEADER_NAME_BY_INDEX, responseHeadersTemp, &responseHeadersTempLength, WINHTTP_NO_HEADER_INDEX)) { result = HTTPAPI_QUERY_HEADERS_FAILED; LogErrorWinHTTPWithGetLastErrorAsString("WinHttpQueryHeaders failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { wchar_t *next_token = NULL; wchar_t* token = wcstok_s(responseHeadersTemp, L"\r\n", &next_token); char* tokenTemp = NULL; result = HTTPAPI_OK; while ((token != NULL) && (token[0] != L'\0')) { size_t tokenTemp_size; tokenTemp_size = WideCharToMultiByte(CP_ACP, 0, token, -1, NULL, 0, NULL, NULL); if (tokenTemp_size == 0) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("WideCharToMultiByte failed"); break; } else if ((tokenTemp = (char*)malloc(sizeof(char) * tokenTemp_size)) == NULL) { result = HTTPAPI_ALLOC_FAILED; LogError("malloc failed"); break; } else if (WideCharToMultiByte(CP_ACP, 0, token, -1, tokenTemp, (int)tokenTemp_size, NULL, NULL) == 0) { result = HTTPAPI_STRING_PROCESSING_ERROR; LogError("WideCharToMultiByte failed"); break; } else { /*breaking the token in 2 parts: everything before the first ":" and everything after the first ":"*/ /*if there is no such character, then skip it*/ /*if there is a : then replace is by a '\0' and so it breaks the original string in name and value*/ char* whereIsColon = strchr(tokenTemp, ':'); if (whereIsColon != NULL) { *whereIsColon = '\0'; if (HTTPHeaders_AddHeaderNameValuePair(responseHeadersHandle, tokenTemp, whereIsColon + 1) != HTTP_HEADERS_OK) { LogError("HTTPHeaders_AddHeaderNameValuePair failed"); result = HTTPAPI_HTTP_HEADERS_FAILED; break; } } } free(tokenTemp); tokenTemp = NULL; token = wcstok_s(NULL, L"\r\n", &next_token); } free(tokenTemp); tokenTemp = NULL; } free(responseHeadersTemp); return result; } HTTPAPI_RESULT HTTPAPI_ExecuteRequest(HTTP_HANDLE handle, HTTPAPI_REQUEST_TYPE requestType, const char* relativePath, HTTP_HEADERS_HANDLE httpHeadersHandle, const unsigned char* content, size_t contentLength, unsigned int* statusCode, HTTP_HEADERS_HANDLE responseHeadersHandle, BUFFER_HANDLE responseContent) { HTTPAPI_RESULT result; if (g_HTTPAPIState != HTTPAPI_INITIALIZED) { LogError("g_HTTPAPIState not HTTPAPI_INITIALIZED"); result = HTTPAPI_NOT_INIT; } else if ((handle == NULL) || (relativePath == NULL) || (httpHeadersHandle == NULL)) { result = HTTPAPI_INVALID_ARG; LogError("NULL parameter detected (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { HTTP_HANDLE_DATA* handleData = (HTTP_HANDLE_DATA*)handle; wchar_t* httpHeaders = NULL; HINTERNET requestHandle = NULL; if ((result = InitiateWinhttpRequest(handleData, requestType, relativePath, &requestHandle)) != HTTPAPI_OK) { LogError("Cannot create Winhttp request handle"); } else if ((result = SetProxyIfNecessary(handleData, requestHandle)) != HTTPAPI_OK) { LogError("unable to set proxy"); } else if ((result = ConstructHeadersString(httpHeadersHandle, &httpHeaders)) != HTTPAPI_OK) { LogError("Cannot construct http headers"); } else if ((result = SendHttpRequest(handleData, requestHandle, content, contentLength, httpHeaders)) != HTTPAPI_OK) { LogError("Cannot set options / send http request"); } else if ((result = ReceiveResponseAndStatusCode(requestHandle, statusCode)) != HTTPAPI_OK) { LogError("failed receiving response and/or headers"); } else if ((responseContent != NULL) && ((result = ReceiveResponseContent(requestHandle, responseContent)) != HTTPAPI_OK)) { LogError("failed to receive response content"); } else if ((responseHeadersHandle != NULL) && ((result = ReceiveResponseHeaders(requestHandle, responseHeadersHandle)) != HTTPAPI_OK)) { LogError("Unable to retrieve http response headers"); } else { result = HTTPAPI_OK; } if ((requestHandle != NULL) && (handleData->handleClosedOnCallbackError == false)) { (void)WinHttpCloseHandle(requestHandle); } handleData->handleClosedOnCallbackError = false; free(httpHeaders); } return result; } HTTPAPI_RESULT HTTPAPI_SetOption(HTTP_HANDLE handle, const char* optionName, const void* value) { HTTPAPI_RESULT result; if ( (handle == NULL) || (optionName == NULL) || (value == NULL) ) { result = HTTPAPI_INVALID_ARG; LogError("invalid parameter (NULL) passed to HTTPAPI_SetOption"); } else { HTTP_HANDLE_DATA* httpHandleData = (HTTP_HANDLE_DATA*)handle; if (strcmp(OPTION_HTTP_TIMEOUT, optionName) == 0) { long timeout = (long)(*(unsigned int*)value); httpHandleData->timeout = timeout; result = HTTPAPI_OK; } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { httpHandleData->x509certificate = (const char*)value; if (httpHandleData->x509privatekey != NULL) { httpHandleData->x509SchannelHandle = x509_schannel_create(httpHandleData->x509certificate, httpHandleData->x509privatekey); if (httpHandleData->x509SchannelHandle == NULL) { LogError("unable to x509_schannel_create"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } else { /*if certificate comes 1st and private key is not set yet, then return OK and wait for the private key to be set*/ result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { httpHandleData->x509privatekey = (const char*)value; if (httpHandleData->x509certificate != NULL) { httpHandleData->x509SchannelHandle = x509_schannel_create(httpHandleData->x509certificate, httpHandleData->x509privatekey); if (httpHandleData->x509SchannelHandle == NULL) { LogError("unable to x509_schannel_create"); result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } else { /*if privatekey comes 1st and certificate is not set yet, then return OK and wait for the certificate to be set*/ result = HTTPAPI_OK; } } else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { if (value == NULL) { LogError("Invalid paramater: OPTION_TRUSTED_CERT value=NULL"); result = MU_FAILURE; } else { if (httpHandleData->trustedCertificate != NULL) { free(httpHandleData->trustedCertificate); httpHandleData->trustedCertificate = NULL; } if (mallocAndStrcpy_s((char**)&httpHandleData->trustedCertificate, (const char*)value) != 0) { LogError("unable to mallocAndStrcpy_s option trusted certificate"); result = MU_FAILURE; } else { result = HTTPAPI_OK; } } } else if (strcmp(OPTION_HTTP_PROXY, optionName) == 0) { char proxyAddressAndPort[MAX_HOSTNAME_LEN]; HTTP_PROXY_OPTIONS* proxy_data = (HTTP_PROXY_OPTIONS*)value; if (proxy_data->host_address == NULL || proxy_data->port <= 0) { LogError("invalid proxy_data values ( host_address = %p, port = %d)", proxy_data->host_address, proxy_data->port); result = HTTPAPI_ERROR; } else { if (sprintf_s(proxyAddressAndPort, MAX_HOSTNAME_LEN, "%s:%d", proxy_data->host_address, proxy_data->port) <= 0) { LogError("failure constructing proxy address"); result = HTTPAPI_ERROR; } else { if(httpHandleData->proxy_host != NULL) { free((void*)httpHandleData->proxy_host); httpHandleData->proxy_host = NULL; } if(mallocAndStrcpy_s((char**)&(httpHandleData->proxy_host), (const char*)proxyAddressAndPort) != 0) { LogError("failure allocate proxy host"); result = HTTPAPI_ERROR; } else { if (proxy_data->username != NULL && proxy_data->password != NULL) { if(httpHandleData->proxy_username != NULL) { free((void*)httpHandleData->proxy_username); httpHandleData->proxy_username = NULL; } if(mallocAndStrcpy_s((char**)&(httpHandleData->proxy_username), (const char*)proxy_data->username) != 0) { LogError("failure allocate proxy username"); free((void*)httpHandleData->proxy_host); httpHandleData->proxy_host = NULL; result = HTTPAPI_ERROR; } else { if(httpHandleData->proxy_password != NULL) { free((void*)httpHandleData->proxy_password); httpHandleData->proxy_password = NULL; } if(mallocAndStrcpy_s((char**)&(httpHandleData->proxy_password), (const char*)proxy_data->password) != 0) { LogError("failure allocate proxy password"); free((void*)httpHandleData->proxy_host); httpHandleData->proxy_host = NULL; free((void*)httpHandleData->proxy_username); httpHandleData->proxy_username = NULL; result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } } else { result = HTTPAPI_OK; } } } } } else { result = HTTPAPI_INVALID_ARG; LogError("unknown option %s", optionName); } } return result; } HTTPAPI_RESULT HTTPAPI_CloneOption(const char* optionName, const void* value, const void** savedValue) { HTTPAPI_RESULT result; if ( (optionName == NULL) || (value == NULL) || (savedValue == NULL) ) { result = HTTPAPI_INVALID_ARG; LogError("invalid argument(NULL) passed to HTTPAPI_CloneOption"); } else { if (strcmp(OPTION_HTTP_TIMEOUT, optionName) == 0) { /*by convention value is pointing to an unsigned int */ unsigned int* temp = (unsigned int*)malloc(sizeof(unsigned int)); /*shall be freed by HTTPAPIEX*/ if (temp == NULL) { result = HTTPAPI_ERROR; LogError("malloc failed (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(HTTPAPI_RESULT, result)); } else { *temp = *(const unsigned int*)value; *savedValue = temp; result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { /*this is getting the x509 certificate. In this case, value is a pointer to a const char* that contains the certificate as a null terminated string*/ if (mallocAndStrcpy_s((char**)savedValue, (const char*)value) != 0) { LogError("unable to clone the x509 certificate content"); result = HTTPAPI_ERROR; } else { /*return OK when the certificate has been cloned successfully*/ result = HTTPAPI_OK; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { /*this is getting the x509 private key. In this case, value is a pointer to a const char* that contains the private key as a null terminated string*/ if (mallocAndStrcpy_s((char**)savedValue, (const char*)value) != 0) { LogError("unable to clone the x509 private key content"); result = HTTPAPI_ERROR; } else { /*return OK when the private key has been cloned successfully*/ result = HTTPAPI_OK; } } else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { /*this is getting the trusted certificate */ if (mallocAndStrcpy_s((char**)savedValue, (const char*)value) != 0) { LogError("unable to clone the trusted certificate content"); result = HTTPAPI_ERROR; } else { /*return OK when the certificate has been cloned successfully*/ result = HTTPAPI_OK; } } else if (strcmp(OPTION_HTTP_PROXY, optionName) == 0) { *savedValue = malloc(sizeof(HTTP_PROXY_OPTIONS)); if (*savedValue == NULL) { LogError("failure in malloc"); result = HTTPAPI_ERROR; } else { HTTP_PROXY_OPTIONS *savedOption = (HTTP_PROXY_OPTIONS*) *savedValue; HTTP_PROXY_OPTIONS *option = (HTTP_PROXY_OPTIONS*) value; memset((void*)*savedValue, 0, sizeof(HTTP_PROXY_OPTIONS)); if (mallocAndStrcpy_s((char**)&(savedOption->host_address), (const char*)option->host_address) != 0) { LogError("unable to clone the proxy host adress content"); free((void*)*savedValue); *savedValue = NULL; result = HTTPAPI_ERROR; } else { savedOption->port = option->port; if (option->username != NULL && mallocAndStrcpy_s((char**)&(savedOption->username), (const char*)option->username) != 0) { LogError("unable to clone the proxy username content"); free((void*)savedOption->host_address); savedOption->host_address = NULL; free((void*)*savedValue); *savedValue = NULL; result = HTTPAPI_ERROR; } else { if (option->password != NULL && mallocAndStrcpy_s((char**)&(savedOption->password), (const char*)option->password) != 0) { LogError("unable to clone the proxy password content"); free((void*)savedOption->host_address); savedOption->host_address = NULL; free((void*)savedOption->username); savedOption->username = NULL; free((void*)*savedValue); *savedValue = NULL; result = HTTPAPI_ERROR; } else { result = HTTPAPI_OK; } } } } } else { result = HTTPAPI_INVALID_ARG; LogError("unknown option %s", optionName); } } return result; } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/linux_time.c000066400000000000000000000035471455573770000335070ustar00rootroot00000000000000// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/xlogging.h" #include "linux_time.h" #ifdef __MACH__ #include #include #endif #ifndef __MACH__ clockid_t time_basis = -1; #endif void set_time_basis(void) { // The time basis depends on what clock is available. Prefer CLOCK_MONOTONIC, // then CLOCK_REALTIME, otherwise query the default pthread_condattr_t value // and use that. Note the time basis stuff requires _POSIX_TIMERS [TMR] at a // minimum; querying pthread_condattr_t requires _POSIX_CLOCK_SELECTION [CS]. // OSX has neither so we use a platform-specific clock. #ifndef __MACH__ #if defined(CLOCK_MONOTONIC) time_basis = CLOCK_MONOTONIC; #elif defined(CLOCK_REALTIME) time_basis = CLOCK_REALTIME; #else pthread_condattr_t cattr; pthread_condattr_init(&cattr); pthread_condattr_getclock(&cattr, &time_basis); pthread_condattr_destroy(&cattr); #endif #endif } int get_time_ns(struct timespec* ts) { int err; #ifdef __MACH__ clock_serv_t cclock; mach_timespec_t mts; err = host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); if (!err) { err = clock_get_time(cclock, &mts); mach_port_deallocate(mach_task_self(), cclock); if (!err) { ts->tv_sec = mts.tv_sec; ts->tv_nsec = mts.tv_nsec; } } #else err = clock_gettime(time_basis, ts); #endif return err; } int64_t get_time_ms() { struct timespec ts; if (get_time_ns(&ts) != 0) { LogError("Failed to get the current time"); return INVALID_TIME_VALUE; } return (int64_t)((int64_t)ts.tv_sec * MILLISECONDS_IN_1_SECOND + (int64_t)ts.tv_nsec / NANOSECONDS_IN_1_MILLISECOND); } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/linux_time.h000066400000000000000000000011401455573770000334770ustar00rootroot00000000000000// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #ifndef LINUX_TIME_H #define LINUX_TIME_H #include #include #include #ifndef __MACH__ extern clockid_t time_basis; #endif extern void set_time_basis(void); extern int get_time_ns(struct timespec* ts); extern int64_t get_time_ms(void); #define INVALID_TIME_VALUE (int64_t)(-1) #define NANOSECONDS_IN_1_SECOND 1000000000L #define MILLISECONDS_IN_1_SECOND 1000 #define NANOSECONDS_IN_1_MILLISECOND 1000000L #endif lock_pthreads.c000066400000000000000000000060751455573770000340740ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include "azure_c_shared_utility/lock.h" #include "azure_c_shared_utility/xlogging.h" LOCK_HANDLE Lock_Init(void) { /* Codes_SRS_LOCK_10_002: [Lock_Init on success shall return a valid lock handle which should be a non NULL value] */ pthread_mutex_t* result = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t)); if (result == NULL) { LogError("malloc failed."); } else { if (pthread_mutex_init(result, NULL) != 0) { /* Codes_SRS_LOCK_10_003: [Lock_Init on error shall return NULL ] */ LogError("pthread_mutex_init failed."); free(result); result = NULL; } } return (LOCK_HANDLE)result; } LOCK_RESULT Lock(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Lock on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { int return_code = pthread_mutex_lock((pthread_mutex_t*)handle); if (return_code == 0) { /* Codes_SRS_LOCK_10_005: [Lock on success shall return LOCK_OK] */ result = LOCK_OK; } else { /* Codes_SRS_LOCK_10_006: [Lock on error shall return LOCK_ERROR] */ LogError("pthread_mutex_lock failed (%d).", return_code); result = LOCK_ERROR; } } return result; } LOCK_RESULT Unlock(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Unlock on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { int return_code = pthread_mutex_unlock((pthread_mutex_t*)handle); if (return_code == 0) { /* Codes_SRS_LOCK_10_009: [Unlock on success shall return LOCK_OK] */ result = LOCK_OK; } else { /* Codes_SRS_LOCK_10_010: [Unlock on error shall return LOCK_ERROR] */ LogError("pthread_mutex_unlock failed (%d).", return_code); result = LOCK_ERROR; } } return result; } LOCK_RESULT Lock_Deinit(LOCK_HANDLE handle) { LOCK_RESULT result; if (NULL == handle) { /* Codes_SRS_LOCK_10_007: [Lock_Deinit on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { /* Codes_SRS_LOCK_10_012: [Lock_Deinit frees the memory pointed by handle] */ if(pthread_mutex_destroy((pthread_mutex_t*)handle) == 0) { free(handle); handle = NULL; result = LOCK_OK; } else { LogError("pthread_mutex_destroy failed;"); result = LOCK_ERROR; } } return result; } lock_rtx_mbed.cpp000066400000000000000000000051021455573770000344140ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/lock.h" #include "azure_c_shared_utility/xlogging.h" #include "rtos.h" LOCK_HANDLE Lock_Init(void) { /* Codes_SRS_LOCK_10_002: [Lock_Init on success shall return a valid lock handle which should be a non NULL value] */ /* Codes_SRS_LOCK_10_003: [Lock_Init on error shall return NULL] */ Mutex* result = new Mutex(); if (result == NULL) { LogError("Failed to instantiate a new Mutex object."); } return (LOCK_HANDLE)result; } LOCK_RESULT Lock(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Lock on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { Mutex* lock_mtx = (Mutex*)handle; if (lock_mtx->lock() == osOK) { /* Codes_SRS_LOCK_10_005: [Lock on success shall return LOCK_OK] */ result = LOCK_OK; } else { /* Codes_SRS_LOCK_10_006: [Lock on error shall return LOCK_ERROR] */ LogError("Mutex(%p)->lock() failed.", handle); result = LOCK_ERROR; } } return result; } LOCK_RESULT Unlock(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Unlock on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { Mutex* lock_mtx = (Mutex*)handle; if (lock_mtx->unlock() == osOK) { /* Codes_SRS_LOCK_10_009: [Unlock on success shall return LOCK_OK] */ result = LOCK_OK; } else { /* Codes_SRS_LOCK_10_010: [Unlock on error shall return LOCK_ERROR] */ LogError("Mutex(%p)->unlock() failed.", handle); result = LOCK_ERROR; } } return result; } LOCK_RESULT Lock_Deinit(LOCK_HANDLE handle) { LOCK_RESULT result; if (NULL == handle) { /* Codes_SRS_LOCK_10_007: [Lock_Deinit on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { /* Codes_SRS_LOCK_10_012: [Lock_Deinit frees the memory pointed by handle] */ Mutex* lock_mtx = (Mutex*)handle; delete lock_mtx; result = LOCK_OK; } return result; } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/lock_win32.c000066400000000000000000000045551455573770000333040ustar00rootroot00000000000000// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include "azure_c_shared_utility/lock.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_macro_utils/macro_utils.h" LOCK_HANDLE Lock_Init(void) { /* Codes_SRS_LOCK_10_002: [Lock_Init on success shall return a valid lock handle which should be a non NULL value] */ /* Codes_SRS_LOCK_10_003: [Lock_Init on error shall return NULL ] */ SRWLOCK* result = malloc(sizeof(SRWLOCK)); if (result == NULL) { LogError("Allocate SRWLOCK failed."); } else { InitializeSRWLock(result); } return (LOCK_HANDLE)result; } LOCK_RESULT Lock_Deinit(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Lock_Deinit on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { /* Codes_SRS_LOCK_10_012: [Lock_Deinit frees the memory pointed by handle] */ free(handle); result = LOCK_OK; } return result; } LOCK_RESULT Lock(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Lock on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { AcquireSRWLockExclusive((SRWLOCK*)handle); /* Codes_SRS_LOCK_10_005: [Lock on success shall return LOCK_OK] */ result = LOCK_OK; // Cannot fail /* Codes_SRS_LOCK_10_006: [Lock on error shall return LOCK_ERROR] */ } return result; } LOCK_RESULT Unlock(LOCK_HANDLE handle) { LOCK_RESULT result; if (handle == NULL) { /* Codes_SRS_LOCK_10_007: [Unlock on NULL handle passed returns LOCK_ERROR] */ LogError("Invalid argument; handle is NULL."); result = LOCK_ERROR; } else { ReleaseSRWLockExclusive((SRWLOCK*)handle); /* Codes_SRS_LOCK_10_009: [Unlock on success shall return LOCK_OK] */ result = LOCK_OK; // Cannot fail /* Codes_SRS_LOCK_10_010: [Unlock on error shall return LOCK_ERROR] */ } return result; } platform_freertos.c000066400000000000000000000017471455573770000350100ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (C) Firmwave Ltd., All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/platform.h" #include "azure_c_shared_utility/xio.h" #include "azure_c_shared_utility/tlsio_cyclonessl.h" #include "azure_c_shared_utility/threadapi.h" #include "debug.h" int platform_init(void) { //TODO Add proper network events synchronization ThreadAPI_Sleep(10000); return 0; } const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void) { return tlsio_cyclonessl_get_interface_description(); } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // No applicable options, so ignoring parameter (void)options; // Expected format: "(; ; )" return STRING_construct("(native; freertos; undefined)"); } void platform_deinit(void) { TRACE_INFO("Deinitializing platform \r\n"); while(1) {}; } platform_linux.c000066400000000000000000000050151455573770000343060ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/platform.h" #include "azure_c_shared_utility/xio.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/httpapiex.h" #ifdef USE_OPENSSL #include "azure_c_shared_utility/tlsio_openssl.h" #else const IO_INTERFACE_DESCRIPTION* tlsio_openssl_get_interface_description(); #endif #if USE_CYCLONESSL #include "azure_c_shared_utility/tlsio_cyclonessl.h" #endif #if USE_WOLFSSL #include "azure_c_shared_utility/tlsio_wolfssl.h" #endif #if USE_MBEDTLS #include "azure_c_shared_utility/tlsio_mbedtls.h" #endif #if USE_BEARSSL #include "azure_c_shared_utility/tlsio_bearssl.h" #endif #include #include #include int platform_init(void) { int result = 0; #ifndef DONT_USE_UPLOADTOBLOB if (HTTPAPIEX_Init() == HTTPAPIEX_ERROR) { LogError("HTTP for upload to blob failed on initialization."); result = MU_FAILURE; } #endif /* DONT_USE_UPLOADTOBLOB */ #ifdef USE_OPENSSL if (result == 0) { result = tlsio_openssl_init(); } #elif USE_WOLFSSL if (result == 0) { result = tlsio_wolfssl_init(); } #endif return result; } const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void) { #if USE_CYCLONESSL return tlsio_cyclonessl_get_interface_description(); #elif USE_WOLFSSL return tlsio_wolfssl_get_interface_description(); #elif USE_MBEDTLS return tlsio_mbedtls_get_interface_description(); #elif USE_BEARSSL return tlsio_bearssl_get_interface_description(); #else // Default to openssl return tlsio_openssl_get_interface_description(); #endif } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // No applicable options, so ignoring parameter (void)options; // Expected format: "(; ; )" STRING_HANDLE result; struct utsname nnn; if (uname(&nnn) == 0) { result = STRING_construct_sprintf("(native; %s; %s)", nnn.sysname, nnn.machine); } else { LogInfo("WARNING: failed to find machine info."); result = STRING_construct("(native; Linux; undefined)"); } return result; } void platform_deinit(void) { #ifndef DONT_USE_UPLOADTOBLOB HTTPAPIEX_Deinit(); #endif /* DONT_USE_UPLOADTOBLOB */ #ifdef USE_OPENSSL tlsio_openssl_deinit(); #elif USE_WOLFSSL tlsio_wolfssl_deinit(); #endif } platform_mbed.cpp000066400000000000000000000033501455573770000344160ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. // MBED seems to not implement size_t properly within their cstddef.h header, and builds will fail if stddef.h is not included by the projects. #include #include "azure_c_shared_utility/platform.h" #include "EthernetInterface.h" #include "NTPClient.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xio.h" #include "azure_c_shared_utility/tlsio_wolfssl.h" int setupRealTime(void) { int result; if (EthernetInterface::connect()) { result = MU_FAILURE; } else { NTPClient ntp; if (ntp.setTime("0.pool.ntp.org") != 0) { result = MU_FAILURE; } else { result = 0; } EthernetInterface::disconnect(); } return result; } int platform_init(void) { int result; if (EthernetInterface::init()) { result = MU_FAILURE; } else if (setupRealTime() != 0) { result = MU_FAILURE; } else if (EthernetInterface::connect()) { result = MU_FAILURE; } else { result = 0; } return result; } const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void) { return tlsio_wolfssl_get_interface_description(); } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // No applicable options, so ignoring parameter (void)options; // Expected format: "(; ; )" return STRING_construct("(native; mbed; undefined)"); } void platform_deinit(void) { EthernetInterface::disconnect(); } platform_mbed_os5.cpp000066400000000000000000000014671455573770000352130ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/platform.h" #include "azure_c_shared_utility/tickcounter.h" #include "azure_c_shared_utility/tlsio_mbedtls.h" #include "azure_c_shared_utility/xio.h" int platform_init(void) { return 0; } const IO_INTERFACE_DESCRIPTION *platform_get_default_tlsio(void) { return tlsio_mbedtls_get_interface_description(); } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // No applicable options, so ignoring parameter (void)options; // Expected format: "(; ; )" return STRING_construct("(native; mbedOS5; undefined)"); } void platform_deinit(void) { } platform_stub.c000066400000000000000000000012271455573770000341250ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/platform.h" int platform_init(void) { return 0; } const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void) { return NULL; } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // No applicable options, so ignoring parameter (void)options; // Expected format: "(; ; )" return STRING_construct("(native; undefined; undefined)"); } void platform_deinit(void) { return; } platform_tizenrt.c000066400000000000000000000014001455573770000346400ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/platform.h" #include "azure_c_shared_utility/tlsio_mbedtls.h" int platform_init(void) { return 0; } const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void) { return tlsio_mbedtls_get_interface_description(); } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // No applicable options, so ignoring parameter (void)options; // Expected format: "(; ; )" return STRING_construct("(native; tizenrt; undefined)"); } void platform_deinit(void) { return; } platform_win32.c000066400000000000000000000146521455573770000341200ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/platform.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xio.h" #include "azure_c_shared_utility/strings.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/httpapiex.h" #include "winsock2.h" #include "minwindef.h" #include "winnt.h" #ifdef USE_OPENSSL #include "azure_c_shared_utility/tlsio_openssl.h" #endif #if USE_CYCLONESSL #include "azure_c_shared_utility/tlsio_cyclonessl.h" #endif #if USE_WOLFSSL #include "azure_c_shared_utility/tlsio_wolfssl.h" #endif #if USE_MBEDTLS #include "azure_c_shared_utility/tlsio_mbedtls.h" #endif #if USE_BEARSSL #include "azure_c_shared_utility/tlsio_bearssl.h" #endif #include "azure_c_shared_utility/tlsio_schannel.h" int platform_init(void) { int result; WSADATA wsaData; int error_code = WSAStartup(MAKEWORD(2, 2), &wsaData); if (error_code != 0) { LogError("WSAStartup failed: 0x%x", error_code); result = MU_FAILURE; } else { result = 0; #ifndef DONT_USE_UPLOADTOBLOB if (HTTPAPIEX_Init() == HTTPAPIEX_ERROR) { LogError("HTTP for upload to blob failed on initialization."); result = MU_FAILURE; } #endif /* DONT_USE_UPLOADTOBLOB */ #ifdef USE_OPENSSL if (result == 0) { result = tlsio_openssl_init(); } #endif } return result; } const IO_INTERFACE_DESCRIPTION* platform_get_default_tlsio(void) { #ifdef USE_OPENSSL return tlsio_openssl_get_interface_description(); #elif USE_CYCLONESSL return tlsio_cyclonessl_get_interface_description(); #elif USE_WOLFSSL return tlsio_wolfssl_get_interface_description(); #elif USE_BEARSSL return tlsio_bearssl_get_interface_description(); #elif USE_MBEDTLS return tlsio_mbedtls_get_interface_description(); #else return tlsio_schannel_get_interface_description(); #endif } static char* get_win_sqm_info(void) { char* result; LONG openKey; DWORD options = 0; HKEY openResult; HKEY hKey = HKEY_LOCAL_MACHINE; LPCSTR subKey = "Software\\Microsoft\\SQMClient"; LPCSTR lpValue = "MachineId"; DWORD dwFlags = RRF_RT_ANY; LONG getRegValue = ERROR_INVALID_HANDLE; DWORD dataType; DWORD size = GUID_LENGTH; PVOID pvData; // SQM values are guids in the system, we will allocate enough space to hold that if ((result = (char*)malloc(GUID_LENGTH)) == NULL) { LogError("Failure allocating sqm info"); } else if ((openKey = RegOpenKeyExA(hKey, subKey, options, KEY_READ, &openResult)) != ERROR_SUCCESS) { LogError("Failure opening registry key: %d:%s", GetLastError(), subKey); free(result); result = NULL; } else { pvData = result; if ((getRegValue = RegGetValueA(openResult, NULL, lpValue, dwFlags, &dataType, pvData, &size)) != ERROR_SUCCESS) { // Failed to read value, so try opening the 64-bit reg key // in case this is an x86 binary being run on Windows x64 if ((openKey = RegOpenKeyExA(hKey, subKey, options, KEY_READ | KEY_WOW64_64KEY, &openResult)) != ERROR_SUCCESS) { LogError("Failure opening registry sub key: %d:%s", GetLastError(), subKey); free(result); result = NULL; } else if ((getRegValue = RegGetValueA(openResult, NULL, lpValue, dwFlags, &dataType, pvData, &size)) != ERROR_SUCCESS) { LogError("Failure opening registry sub key: %d:%s", GetLastError(), subKey); free(result); result = NULL; } } if (getRegValue != ERROR_SUCCESS) { LogError("Failure retrieving SQM info Error value: %d", GetLastError()); free(result); result = NULL; } RegCloseKey(openResult); } return result; } STRING_HANDLE platform_get_platform_info(PLATFORM_INFO_OPTION options) { // Expected format: "(; ; )" STRING_HANDLE result; SYSTEM_INFO sys_info; OSVERSIONINFO osvi; char *arch; GetSystemInfo(&sys_info); switch (sys_info.wProcessorArchitecture) { case PROCESSOR_ARCHITECTURE_AMD64: arch = "x64"; break; case PROCESSOR_ARCHITECTURE_ARM: arch = "ARM"; break; case PROCESSOR_ARCHITECTURE_IA64: arch = "IA64"; break; case PROCESSOR_ARCHITECTURE_INTEL: arch = "x32"; break; default: arch = "UNKNOWN"; break; } result = NULL; memset(&osvi, 0, sizeof(osvi)); osvi.dwOSVersionInfoSize = sizeof(osvi); #pragma warning(disable:4996) if (GetVersionEx(&osvi)) { DWORD product_type; if (GetProductInfo(osvi.dwMajorVersion, osvi.dwMinorVersion, 0, 0, &product_type)) { result = STRING_construct_sprintf("(native; WindowsProduct:0x%08x %d.%d; %s", product_type, osvi.dwMajorVersion, osvi.dwMinorVersion, arch); } } if (result == NULL) { DWORD dwVersion = GetVersion(); result = STRING_construct_sprintf("(native; WindowsProduct:Windows NT %d.%d; %s", LOBYTE(LOWORD(dwVersion)), HIBYTE(LOWORD(dwVersion)), arch); } #pragma warning(default:4996) if (result == NULL) { LogError("STRING_construct_sprintf failed"); } else if (options & PLATFORM_INFO_OPTION_RETRIEVE_SQM) { // Failure here should continue char* sqm_info = get_win_sqm_info(); if (sqm_info != NULL) { if (STRING_sprintf(result, "; %s)", sqm_info) != 0) { LogError("failure concat file"); } free(sqm_info); } else { if (STRING_concat(result, ")") != 0) { LogError("failure concat file"); } } } else { if (STRING_concat(result, ")") != 0) { LogError("failure concat file"); } } return result; } void platform_deinit(void) { (void)WSACleanup(); #ifndef DONT_USE_UPLOADTOBLOB HTTPAPIEX_Deinit(); #endif /* DONT_USE_UPLOADTOBLOB */ #ifdef USE_OPENSSL tlsio_openssl_deinit(); #endif } socketio_berkeley.c000077500000000000000000001136761455573770000347650ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #ifndef _BSD_SOURCE #define _BSD_SOURCE #define SOCKETIO_BERKELEY_UNDEF_BSD_SOURCE #endif #define _DEFAULT_SOURCE #include #undef _DEFAULT_SOURCE #ifdef SOCKETIO_BERKELEY_UNDEF_BSD_SOURCE #undef _BSD_SOURCE #undef SOCKETIO_BERKELEY_UNDEF_BSD_SOURCE #endif #ifndef MSG_NOSIGNAL #define MSG_NOSIGNAL 0 #endif #include #include #include #include #include #include #include "azure_c_shared_utility/socketio.h" #include #include #include #ifdef TIZENRT #include #else #include #endif #include #include #include #include #include "azure_c_shared_utility/singlylinkedlist.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/gbnetwork.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/optionhandler.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/const_defines.h" #include "azure_c_shared_utility/dns_resolver.h" #include #include #include #include #define SOCKET_SUCCESS 0 #define INVALID_SOCKET -1 #define SOCKET_SEND_FAILURE -1 #define MAC_ADDRESS_STRING_LENGTH 18 #ifndef IFREQ_BUFFER_SIZE #define IFREQ_BUFFER_SIZE 1024 #endif // connect timeout in seconds #define CONNECT_TIMEOUT 10 typedef enum IO_STATE_TAG { IO_STATE_CLOSED, IO_STATE_OPENING, IO_STATE_OPEN, IO_STATE_CLOSING, IO_STATE_ERROR } IO_STATE; typedef struct PENDING_SOCKET_IO_TAG { unsigned char* bytes; size_t size; ON_SEND_COMPLETE on_send_complete; void* callback_context; SINGLYLINKEDLIST_HANDLE pending_io_list; } PENDING_SOCKET_IO; typedef struct SOCKET_IO_INSTANCE_TAG { int socket; SOCKETIO_ADDRESS_TYPE address_type; ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; ON_IO_OPEN_COMPLETE on_io_open_complete; void* on_bytes_received_context; void* on_io_error_context; void* on_io_open_complete_context; char* hostname; int port; char* target_mac_address; IO_STATE io_state; SINGLYLINKEDLIST_HANDLE pending_io_list; unsigned char recv_bytes[XIO_RECEIVE_BUFFER_SIZE]; DNSRESOLVER_HANDLE dns_resolver; } SOCKET_IO_INSTANCE; typedef struct NETWORK_INTERFACE_DESCRIPTION_TAG { char* name; char* mac_address; char* ip_address; struct NETWORK_INTERFACE_DESCRIPTION_TAG* next; } NETWORK_INTERFACE_DESCRIPTION; /*this function will clone an option given by name and value*/ static void* socketio_CloneOption(const char* name, const void* value) { void* result; if (name != NULL) { result = NULL; if (strcmp(name, OPTION_NET_INT_MAC_ADDRESS) == 0) { if (value == NULL) { LogError("Failed cloning option %s (value is NULL)", name); } else { if ((result = malloc(sizeof(char) * (strlen((char*)value) + 1))) == NULL) { LogError("Failed cloning option %s (malloc failed)", name); } else if (strcpy((char*)result, (char*)value) == NULL) { LogError("Failed cloning option %s (strcpy failed)", name); free(result); result = NULL; } } } else { LogError("Cannot clone option %s (not supported)", name); } } else { result = NULL; } return result; } /*this function destroys an option previously created*/ static void socketio_DestroyOption(const char* name, const void* value) { if (name != NULL) { if (strcmp(name, OPTION_NET_INT_MAC_ADDRESS) == 0 && value != NULL) { free((void*)value); } } } static OPTIONHANDLER_HANDLE socketio_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result; if (handle == NULL) { LogError("failed retrieving options (handle is NULL)"); result = NULL; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)handle; result = OptionHandler_Create(socketio_CloneOption, socketio_DestroyOption, socketio_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); } else if (socket_io_instance->target_mac_address != NULL && OptionHandler_AddOption(result, OPTION_NET_INT_MAC_ADDRESS, socket_io_instance->target_mac_address) != OPTIONHANDLER_OK) { LogError("failed retrieving options (failed adding net_interface_mac_address)"); OptionHandler_Destroy(result); result = NULL; } } return result; } static const IO_INTERFACE_DESCRIPTION socket_io_interface_description = { socketio_retrieveoptions, socketio_create, socketio_destroy, socketio_open, socketio_close, socketio_send, socketio_dowork, socketio_setoption }; static void indicate_error(SOCKET_IO_INSTANCE* socket_io_instance) { socket_io_instance->io_state = IO_STATE_ERROR; if (socket_io_instance->on_io_error != NULL) { socket_io_instance->on_io_error(socket_io_instance->on_io_error_context); } } static int add_pending_io(SOCKET_IO_INSTANCE* socket_io_instance, const unsigned char* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)malloc(sizeof(PENDING_SOCKET_IO)); if (pending_socket_io == NULL) { result = MU_FAILURE; } else { pending_socket_io->bytes = (unsigned char*)malloc(size); if (pending_socket_io->bytes == NULL) { LogError("Allocation Failure: Unable to allocate pending list."); free(pending_socket_io); result = MU_FAILURE; } else { pending_socket_io->size = size; pending_socket_io->on_send_complete = on_send_complete; pending_socket_io->callback_context = callback_context; pending_socket_io->pending_io_list = socket_io_instance->pending_io_list; (void)memcpy(pending_socket_io->bytes, buffer, size); if (singlylinkedlist_add(socket_io_instance->pending_io_list, pending_socket_io) == NULL) { LogError("Failure: Unable to add socket to pending list."); free(pending_socket_io->bytes); free(pending_socket_io); result = MU_FAILURE; } else { result = 0; } } } return result; } static STATIC_VAR_UNUSED void signal_callback(int signum) { AZURE_UNREFERENCED_PARAMETER(signum); LogError("Socket received signal %d.", signum); } static int lookup_address(SOCKET_IO_INSTANCE* socket_io_instance) { int result = 0; if (socket_io_instance->address_type == ADDRESS_TYPE_IP) { if (!dns_resolver_is_lookup_complete(socket_io_instance->dns_resolver)) { socket_io_instance->io_state = IO_STATE_OPENING; } else { socket_io_instance->io_state = IO_STATE_OPEN; } } else //ADDRESS_TYPE_DOMAIN_SOCKET { socket_io_instance->io_state = IO_STATE_OPEN; } return result; } static int initiate_socket_connection(SOCKET_IO_INSTANCE* socket_io_instance) { int result; int flags; struct addrinfo* addr = NULL; struct sockaddr* connect_addr = NULL; struct sockaddr_un addrInfoUn; socklen_t connect_addr_len; if(socket_io_instance->address_type == ADDRESS_TYPE_IP) { if(!dns_resolver_is_lookup_complete(socket_io_instance->dns_resolver)) { LogError("DNS did not resolve IP address"); result = MU_FAILURE; } else { addr = dns_resolver_get_addrInfo(socket_io_instance->dns_resolver); if (addr == NULL) { LogError("DNS resolution failed"); result = MU_FAILURE; } else { connect_addr = addr->ai_addr; connect_addr_len = sizeof(*addr->ai_addr); result = 0; } } } else { size_t hostname_len = strlen(socket_io_instance->hostname); if (hostname_len + 1 > sizeof(addrInfoUn.sun_path)) { LogError("Hostname %s is too long for a unix socket (max len = %lu)", socket_io_instance->hostname, (unsigned long)sizeof(addrInfoUn.sun_path)); result = MU_FAILURE; } else { memset(&addrInfoUn, 0, sizeof(addrInfoUn)); addrInfoUn.sun_family = AF_UNIX; // No need to add NULL terminator due to the above memset (void)memcpy(addrInfoUn.sun_path, socket_io_instance->hostname, hostname_len); connect_addr = (struct sockaddr*)&addrInfoUn; connect_addr_len = sizeof(addrInfoUn); result = 0; } } if(result == 0) { if ((-1 == (flags = fcntl(socket_io_instance->socket, F_GETFL, 0))) || (fcntl(socket_io_instance->socket, F_SETFL, flags | O_NONBLOCK) == -1)) { LogError("Failure: fcntl failure."); result = MU_FAILURE; } else { result = connect(socket_io_instance->socket, connect_addr, connect_addr_len); if ((result != 0) && (errno != EINPROGRESS)) { LogError("Failure: connect failure %d.", errno); result = MU_FAILURE; } else { // Async connect will return -1. result = 0; if (socket_io_instance->on_io_open_complete != NULL) { socket_io_instance->on_io_open_complete(socket_io_instance->on_io_open_complete_context, IO_OPEN_OK /*: IO_OPEN_ERROR*/); } } } } return result; } static int lookup_address_and_initiate_socket_connection(SOCKET_IO_INSTANCE* socket_io_instance) { int result; result = lookup_address(socket_io_instance); if(socket_io_instance->io_state == IO_STATE_OPEN) { if (result == 0) { result = initiate_socket_connection(socket_io_instance); } } return result; } static int wait_for_connection(SOCKET_IO_INSTANCE* socket_io_instance) { int result; int err; int retval; int select_errno = 0; fd_set fdset; struct timeval tv; FD_ZERO(&fdset); FD_SET(socket_io_instance->socket, &fdset); tv.tv_sec = CONNECT_TIMEOUT; tv.tv_usec = 0; do { retval = select(socket_io_instance->socket + 1, NULL, &fdset, NULL, &tv); if (retval < 0) { select_errno = errno; } } while (retval < 0 && select_errno == EINTR); if (retval != 1) { LogError("Failure: select failure."); result = MU_FAILURE; } else { int so_error = 0; socklen_t len = sizeof(so_error); err = getsockopt(socket_io_instance->socket, SOL_SOCKET, SO_ERROR, &so_error, &len); if (err != 0) { LogError("Failure: getsockopt failure %d.", errno); result = MU_FAILURE; } else if (so_error != 0) { err = so_error; LogError("Failure: connect failure %d.", so_error); result = MU_FAILURE; } else { result = 0; } } return result; } #ifndef __APPLE__ static void destroy_network_interface_descriptions(NETWORK_INTERFACE_DESCRIPTION* nid) { if (nid != NULL) { if (nid->next != NULL) { destroy_network_interface_descriptions(nid->next); } if (nid->name != NULL) { free(nid->name); } if (nid->mac_address != NULL) { free(nid->mac_address); } if (nid->ip_address != NULL) { free(nid->ip_address); } free(nid); } } static NETWORK_INTERFACE_DESCRIPTION* create_network_interface_description(struct ifreq *ifr, NETWORK_INTERFACE_DESCRIPTION* previous_nid) { NETWORK_INTERFACE_DESCRIPTION* result; if ((result = (NETWORK_INTERFACE_DESCRIPTION*)malloc(sizeof(NETWORK_INTERFACE_DESCRIPTION))) == NULL) { LogError("Failed allocating NETWORK_INTERFACE_DESCRIPTION"); } else if ((result->name = (char*)malloc(sizeof(char) * (strlen(ifr->ifr_name) + 1))) == NULL) { LogError("failed setting interface description name (malloc failed)"); destroy_network_interface_descriptions(result); result = NULL; } else if (strcpy(result->name, ifr->ifr_name) == NULL) { LogError("failed setting interface description name (strcpy failed)"); destroy_network_interface_descriptions(result); result = NULL; } else { char* ip_address; unsigned char* mac = (unsigned char*)ifr->ifr_hwaddr.sa_data; if ((result->mac_address = (char*)malloc(sizeof(char) * MAC_ADDRESS_STRING_LENGTH)) == NULL) { LogError("failed formatting mac address (malloc failed)"); destroy_network_interface_descriptions(result); result = NULL; } else if (sprintf(result->mac_address, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]) <= 0) { LogError("failed formatting mac address (sprintf failed)"); destroy_network_interface_descriptions(result); result = NULL; } else if ((ip_address = inet_ntoa(((struct sockaddr_in*)&ifr->ifr_addr)->sin_addr)) == NULL) { LogError("failed setting the ip address (inet_ntoa failed)"); destroy_network_interface_descriptions(result); result = NULL; } else if ((result->ip_address = (char*)malloc(sizeof(char) * (strlen(ip_address) + 1))) == NULL) { LogError("failed setting the ip address (malloc failed)"); destroy_network_interface_descriptions(result); result = NULL; } else if (strcpy(result->ip_address, ip_address) == NULL) { LogError("failed setting the ip address (strcpy failed)"); destroy_network_interface_descriptions(result); result = NULL; } else { result->next = NULL; if (previous_nid != NULL) { previous_nid->next = result; } } } return result; } static int get_network_interface_descriptions(int socket, NETWORK_INTERFACE_DESCRIPTION** nid) { int result; struct ifreq ifr; struct ifconf ifc; char buf[IFREQ_BUFFER_SIZE]; ifc.ifc_len = sizeof(buf); ifc.ifc_buf = buf; if (ioctl(socket, SIOCGIFCONF, &ifc) == -1) { LogError("ioctl failed querying socket (SIOCGIFCONF, errno=%d)", errno); result = MU_FAILURE; } else { NETWORK_INTERFACE_DESCRIPTION* root_nid = NULL; NETWORK_INTERFACE_DESCRIPTION* new_nid = NULL; struct ifreq* it = ifc.ifc_req; const struct ifreq* const end = it + (ifc.ifc_len / sizeof(struct ifreq)); result = 0; for (; it != end; ++it) { strcpy(ifr.ifr_name, it->ifr_name); if (ioctl(socket, SIOCGIFFLAGS, &ifr) != 0) { LogError("ioctl failed querying socket (SIOCGIFFLAGS, errno=%d)", errno); result = MU_FAILURE; break; } else if (ioctl(socket, SIOCGIFHWADDR, &ifr) != 0) { LogError("ioctl failed querying socket (SIOCGIFHWADDR, errno=%d)", errno); result = MU_FAILURE; break; } else if (ioctl(socket, SIOCGIFADDR, &ifr) != 0) { LogError("ioctl failed querying socket (SIOCGIFADDR, errno=%d)", errno); result = MU_FAILURE; break; } else if ((new_nid = create_network_interface_description(&ifr, new_nid)) == NULL) { LogError("Failed creating network interface description"); result = MU_FAILURE; break; } else if (root_nid == NULL) { root_nid = new_nid; } } if (result == 0) { *nid = root_nid; } else { destroy_network_interface_descriptions(root_nid); } } return result; } static int set_target_network_interface(int socket, char* mac_address) { int result; NETWORK_INTERFACE_DESCRIPTION* nid; if (get_network_interface_descriptions(socket, &nid) != 0) { LogError("Failed getting network interface descriptions"); result = MU_FAILURE; } else { NETWORK_INTERFACE_DESCRIPTION* current_nid = nid; while(current_nid != NULL) { if (strcmp(mac_address, current_nid->mac_address) == 0) { break; } current_nid = current_nid->next; } if (current_nid == NULL) { LogError("Did not find a network interface matching MAC ADDRESS"); result = MU_FAILURE; } else if (setsockopt(socket, SOL_SOCKET, SO_BINDTODEVICE, current_nid->name, strlen(current_nid->name)) != 0) { LogError("setsockopt failed (%d)", errno); result = MU_FAILURE; } else { result = 0; } destroy_network_interface_descriptions(nid); } return result; } #endif //__APPLE__ static void destroy_socket_io_instance(SOCKET_IO_INSTANCE* instance) { if (instance->dns_resolver != NULL) { dns_resolver_destroy(instance->dns_resolver); } free(instance->hostname); free(instance->target_mac_address); if (instance->pending_io_list != NULL) { singlylinkedlist_destroy(instance->pending_io_list); } free(instance); } CONCRETE_IO_HANDLE socketio_create(void* io_create_parameters) { SOCKETIO_CONFIG* socket_io_config = io_create_parameters; SOCKET_IO_INSTANCE* result; if (socket_io_config == NULL) { LogError("Invalid argument: socket_io_config is NULL"); result = NULL; } else { result = malloc(sizeof(SOCKET_IO_INSTANCE)); if (result != NULL) { (void)memset(result, 0, sizeof(SOCKET_IO_INSTANCE)); result->address_type = ADDRESS_TYPE_IP; result->pending_io_list = singlylinkedlist_create(); if (result->pending_io_list == NULL) { LogError("Failure: singlylinkedlist_create unable to create pending list."); destroy_socket_io_instance(result); result = NULL; } else { if (socket_io_config->hostname != NULL) { result->hostname = (char*)malloc(strlen(socket_io_config->hostname) + 1); if (result->hostname != NULL) { (void)strcpy(result->hostname, socket_io_config->hostname); } result->socket = INVALID_SOCKET; } else { result->hostname = NULL; result->socket = *((int*)socket_io_config->accepted_socket); } if ((result->hostname == NULL) && (result->socket == INVALID_SOCKET)) { LogError("Failure: hostname == NULL and socket is invalid."); destroy_socket_io_instance(result); result = NULL; } else { result->port = socket_io_config->port; result->on_io_open_complete = NULL; result->dns_resolver = dns_resolver_create(result->hostname, socket_io_config->port, NULL); result->target_mac_address = NULL; result->on_bytes_received = NULL; result->on_io_error = NULL; result->on_bytes_received_context = NULL; result->on_io_error_context = NULL; result->io_state = IO_STATE_CLOSED; } } } else { LogError("Allocation Failure: SOCKET_IO_INSTANCE"); } } return result; } void socketio_destroy(CONCRETE_IO_HANDLE socket_io) { if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; /* we cannot do much if the close fails, so just ignore the result */ if (socket_io_instance->socket != INVALID_SOCKET) { close(socket_io_instance->socket); } /* clear allpending IOs */ LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io != NULL) { free(pending_socket_io->bytes); free(pending_socket_io); } (void)singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io); first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } destroy_socket_io_instance(socket_io_instance); } } int socketio_open(CONCRETE_IO_HANDLE socket_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io == NULL) { LogError("Invalid argument: SOCKET_IO_INSTANCE is NULL"); result = MU_FAILURE; } else { if (socket_io_instance->io_state != IO_STATE_CLOSED) { LogError("Failure: socket state is not closed."); result = MU_FAILURE; } else if (socket_io_instance->socket != INVALID_SOCKET) { // Opening an accepted socket socket_io_instance->on_bytes_received_context = on_bytes_received_context; socket_io_instance->on_bytes_received = on_bytes_received; socket_io_instance->on_io_error = on_io_error; socket_io_instance->on_io_error_context = on_io_error_context; socket_io_instance->io_state = IO_STATE_OPEN; result = 0; } else { socket_io_instance->socket = socket (socket_io_instance->address_type == ADDRESS_TYPE_IP ? AF_INET : AF_UNIX, SOCK_STREAM, 0); if (socket_io_instance->socket < SOCKET_SUCCESS) { LogError("Failure: socket create failure %d.", socket_io_instance->socket); result = MU_FAILURE; } #ifndef __APPLE__ else if (socket_io_instance->target_mac_address != NULL && set_target_network_interface(socket_io_instance->socket, socket_io_instance->target_mac_address) != 0) { LogError("Failure: failed selecting target network interface (MACADDR=%s).", socket_io_instance->target_mac_address); result = MU_FAILURE; } #endif //__APPLE__ else if ((result = lookup_address_and_initiate_socket_connection(socket_io_instance)) != 0) { LogError("lookup_address_and_connect_socket failed"); } else if ((result = wait_for_connection(socket_io_instance)) != 0) { LogError("wait_for_connection failed"); } if (result == 0) { socket_io_instance->on_bytes_received = on_bytes_received; socket_io_instance->on_bytes_received_context = on_bytes_received_context; socket_io_instance->on_io_error = on_io_error; socket_io_instance->on_io_error_context = on_io_error_context; socket_io_instance->on_io_open_complete = on_io_open_complete; socket_io_instance->on_io_open_complete_context = on_io_open_complete_context; } else { if (socket_io_instance->socket >= SOCKET_SUCCESS) { close(socket_io_instance->socket); } socket_io_instance->socket = INVALID_SOCKET; } } } if (socket_io_instance->io_state != IO_STATE_OPENING) { if (on_io_open_complete != NULL) { on_io_open_complete(on_io_open_complete_context, result == 0 ? IO_OPEN_OK : IO_OPEN_ERROR); } } return result; } int socketio_close(CONCRETE_IO_HANDLE socket_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result = 0; if (socket_io == NULL) { result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if ((socket_io_instance->io_state != IO_STATE_CLOSED) && (socket_io_instance->io_state != IO_STATE_CLOSING)) { // Only close if the socket isn't already in the closed or closing state (void)shutdown(socket_io_instance->socket, SHUT_RDWR); close(socket_io_instance->socket); socket_io_instance->socket = INVALID_SOCKET; socket_io_instance->io_state = IO_STATE_CLOSED; } if (on_io_close_complete != NULL) { on_io_close_complete(callback_context); } result = 0; } return result; } int socketio_send(CONCRETE_IO_HANDLE socket_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if ((socket_io == NULL) || (buffer == NULL) || (size == 0)) { /* Invalid arguments */ LogError("Invalid argument: send given invalid parameter"); result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state != IO_STATE_OPEN) { LogError("Failure: socket state is not opened."); result = MU_FAILURE; } else { LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); if (first_pending_io != NULL) { if (add_pending_io(socket_io_instance, buffer, size, on_send_complete, callback_context) != 0) { LogError("Failure: add_pending_io failed."); result = MU_FAILURE; } else { result = 0; } } else { signal(SIGPIPE, SIG_IGN); ssize_t send_result = send(socket_io_instance->socket, buffer, size, MSG_NOSIGNAL); if ((size_t)send_result != size) { if (send_result == SOCKET_SEND_FAILURE && errno != EAGAIN) { LogError("Failure: sending socket failed. errno=%d (%s).", errno, strerror(errno)); result = MU_FAILURE; } else { /*send says "come back later" with EAGAIN - likely the socket buffer cannot accept more data*/ /* queue data */ size_t bytes_sent = (send_result < 0 ? 0 : send_result); if (add_pending_io(socket_io_instance, (const unsigned char*)buffer + bytes_sent, size - bytes_sent, on_send_complete, callback_context) != 0) { LogError("Failure: add_pending_io failed."); result = MU_FAILURE; } else { result = 0; } } } else { if (on_send_complete != NULL) { on_send_complete(callback_context, IO_SEND_OK); } result = 0; } } } } return result; } void socketio_dowork(CONCRETE_IO_HANDLE socket_io) { if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; signal(SIGPIPE, SIG_IGN); if (socket_io_instance->io_state == IO_STATE_OPEN) { LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io == NULL) { indicate_error(socket_io_instance); LogError("Failure: retrieving socket from list"); break; } ssize_t send_result = send(socket_io_instance->socket, pending_socket_io->bytes, pending_socket_io->size, MSG_NOSIGNAL); if ((send_result < 0) || ((size_t)send_result != pending_socket_io->size)) { if (send_result == INVALID_SOCKET) { if (errno == EAGAIN) /*send says "come back later" with EAGAIN - likely the socket buffer cannot accept more data*/ { /*do nothing until next dowork */ break; } else { free(pending_socket_io->bytes); free(pending_socket_io); (void)singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io); LogError("Failure: sending Socket information. errno=%d (%s).", errno, strerror(errno)); indicate_error(socket_io_instance); } } else { /* simply wait until next dowork */ (void)memmove(pending_socket_io->bytes, pending_socket_io->bytes + send_result, pending_socket_io->size - send_result); pending_socket_io->size -= send_result; break; } } else { if (pending_socket_io->on_send_complete != NULL) { pending_socket_io->on_send_complete(pending_socket_io->callback_context, IO_SEND_OK); } free(pending_socket_io->bytes); free(pending_socket_io); if (singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io) != 0) { indicate_error(socket_io_instance); LogError("Failure: unable to remove socket from list"); } } first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } if (socket_io_instance->io_state == IO_STATE_OPEN) { ssize_t received = 0; do { received = recv(socket_io_instance->socket, socket_io_instance->recv_bytes, XIO_RECEIVE_BUFFER_SIZE, MSG_NOSIGNAL); if (received > 0) { if (socket_io_instance->on_bytes_received != NULL) { /* Explicitly ignoring here the result of the callback */ (void)socket_io_instance->on_bytes_received(socket_io_instance->on_bytes_received_context, socket_io_instance->recv_bytes, received); } } else if (received == 0) { // Do not log error here due to this is probably the socket being closed on the other end indicate_error(socket_io_instance); } else if (received < 0 && errno != EAGAIN) { LogError("Socketio_Failure: Receiving data from endpoint: errno=%d.", errno); indicate_error(socket_io_instance); } } while (received > 0 && socket_io_instance->io_state == IO_STATE_OPEN); } } else { if (socket_io_instance->io_state == IO_STATE_OPENING) { if(lookup_address(socket_io_instance) != 0) { LogError("Socketio_Failure: lookup address failed"); indicate_error(socket_io_instance); } else { if(socket_io_instance->io_state == IO_STATE_OPEN) { initiate_socket_connection(socket_io_instance); } } } } } } // Edison is missing this from netinet/tcp.h, but this code still works if we manually define it. #ifndef SOL_TCP #define SOL_TCP 6 #endif #ifndef __APPLE__ static void strtoup(char* str) { if (str != NULL) { while (*str != '\0') { if (isalpha((int)*str) && islower((int)*str)) { *str = (char)toupper((int)*str); } str++; } } } #endif // __APPLE__ static int socketio_setaddresstype_option(SOCKET_IO_INSTANCE* socket_io_instance, const char* addressType) { int result; if (socket_io_instance->io_state != IO_STATE_CLOSED) { LogError("Socket's type can only be changed when in state 'IO_STATE_CLOSED'. Current state=%d", socket_io_instance->io_state); result = MU_FAILURE; } else if (strcmp(addressType, OPTION_ADDRESS_TYPE_DOMAIN_SOCKET) == 0) { socket_io_instance->address_type = ADDRESS_TYPE_DOMAIN_SOCKET; result = 0; } else if (strcmp(addressType, OPTION_ADDRESS_TYPE_IP_SOCKET) == 0) { socket_io_instance->address_type = ADDRESS_TYPE_IP; result = 0; } else { LogError("Address type %s is not supported", addressType); result = MU_FAILURE; } return result; } int socketio_setoption(CONCRETE_IO_HANDLE socket_io, const char* optionName, const void* value) { int result; if (socket_io == NULL || optionName == NULL || value == NULL) { result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (strcmp(optionName, "tcp_keepalive") == 0) { result = setsockopt(socket_io_instance->socket, SOL_SOCKET, SO_KEEPALIVE, value, sizeof(int)); if (result == -1) result = errno; } else if (strcmp(optionName, "tcp_keepalive_time") == 0) { #ifdef __APPLE__ result = setsockopt(socket_io_instance->socket, IPPROTO_TCP, TCP_KEEPALIVE, value, sizeof(int)); #else result = setsockopt(socket_io_instance->socket, SOL_TCP, TCP_KEEPIDLE, value, sizeof(int)); #endif if (result == -1) result = errno; } else if (strcmp(optionName, "tcp_keepalive_interval") == 0) { result = setsockopt(socket_io_instance->socket, SOL_TCP, TCP_KEEPINTVL, value, sizeof(int)); if (result == -1) result = errno; } else if (strcmp(optionName, OPTION_NET_INT_MAC_ADDRESS) == 0) { #ifdef __APPLE__ LogError("option not supported."); result = MU_FAILURE; #else if (strlen(value) == 0) { LogError("option value must be a valid mac address"); result = MU_FAILURE; } else if ((socket_io_instance->target_mac_address = (char*)malloc(sizeof(char) * (strlen(value) + 1))) == NULL) { LogError("failed setting net_interface_mac_address option (malloc failed)"); result = MU_FAILURE; } else if (strcpy(socket_io_instance->target_mac_address, value) == NULL) { LogError("failed setting net_interface_mac_address option (strcpy failed)"); free(socket_io_instance->target_mac_address); socket_io_instance->target_mac_address = NULL; result = MU_FAILURE; } else { strtoup(socket_io_instance->target_mac_address); result = 0; } #endif } else if (strcmp(optionName, OPTION_ADDRESS_TYPE) == 0) { result = socketio_setaddresstype_option(socket_io_instance, (const char*)value); } else { result = MU_FAILURE; } } return result; } const IO_INTERFACE_DESCRIPTION* socketio_get_interface_description(void) { return &socket_io_interface_description; } socketio_mbed.c000066400000000000000000000357351455573770000340660ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/singlylinkedlist.h" #include "azure_c_shared_utility/tcpsocketconnection_c.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #define UNABLE_TO_COMPLETE -2 #define MBED_XIO_RECEIVE_BUFFER_SIZE 128 typedef enum IO_STATE_TAG { IO_STATE_CLOSED, IO_STATE_OPENING, IO_STATE_OPEN, IO_STATE_CLOSING, IO_STATE_ERROR } IO_STATE; typedef struct PENDING_SOCKET_IO_TAG { unsigned char* bytes; size_t size; ON_SEND_COMPLETE on_send_complete; void* callback_context; SINGLYLINKEDLIST_HANDLE pending_io_list; } PENDING_SOCKET_IO; typedef struct SOCKET_IO_INSTANCE_TAG { TCPSOCKETCONNECTION_HANDLE tcp_socket_connection; ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; void* on_bytes_received_context; void* on_io_error_context; char* hostname; int port; IO_STATE io_state; SINGLYLINKEDLIST_HANDLE pending_io_list; } SOCKET_IO_INSTANCE; /*this function will clone an option given by name and value*/ static void* socketio_CloneOption(const char* name, const void* value) { (void)name; (void)value; return NULL; } /*this function destroys an option previously created*/ static void socketio_DestroyOption(const char* name, const void* value) { (void)name; (void)value; } static OPTIONHANDLER_HANDLE socketio_retrieveoptions(CONCRETE_IO_HANDLE socket_io) { OPTIONHANDLER_HANDLE result; (void)socket_io; result = OptionHandler_Create(socketio_CloneOption, socketio_DestroyOption, socketio_setoption); if (result == NULL) { /*return as is*/ } else { /*insert here work to add the options to "result" handle*/ } return result; } static const IO_INTERFACE_DESCRIPTION socket_io_interface_description = { socketio_retrieveoptions, socketio_create, socketio_destroy, socketio_open, socketio_close, socketio_send, socketio_dowork, socketio_setoption }; static void indicate_error(SOCKET_IO_INSTANCE* socket_io_instance) { if (socket_io_instance->on_io_error != NULL) { socket_io_instance->on_io_error(socket_io_instance->on_io_error_context); } } static int add_pending_io(SOCKET_IO_INSTANCE* socket_io_instance, const unsigned char* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)malloc(sizeof(PENDING_SOCKET_IO)); if (pending_socket_io == NULL) { result = MU_FAILURE; } else { pending_socket_io->bytes = (unsigned char*)malloc(size); if (pending_socket_io->bytes == NULL) { free(pending_socket_io); result = MU_FAILURE; } else { pending_socket_io->size = size; pending_socket_io->on_send_complete = on_send_complete; pending_socket_io->callback_context = callback_context; pending_socket_io->pending_io_list = socket_io_instance->pending_io_list; (void)memcpy(pending_socket_io->bytes, buffer, size); if (singlylinkedlist_add(socket_io_instance->pending_io_list, pending_socket_io) == NULL) { free(pending_socket_io->bytes); free(pending_socket_io); result = MU_FAILURE; } else { result = 0; } } } return result; } CONCRETE_IO_HANDLE socketio_create(void* io_create_parameters) { SOCKETIO_CONFIG* socket_io_config = io_create_parameters; SOCKET_IO_INSTANCE* result; if (socket_io_config == NULL) { result = NULL; } else { result = malloc(sizeof(SOCKET_IO_INSTANCE)); if (result != NULL) { result->pending_io_list = singlylinkedlist_create(); if (result->pending_io_list == NULL) { free(result); result = NULL; } else { result->hostname = (char*)malloc(strlen(socket_io_config->hostname) + 1); if (result->hostname == NULL) { singlylinkedlist_destroy(result->pending_io_list); free(result); result = NULL; } else { strcpy(result->hostname, socket_io_config->hostname); result->port = socket_io_config->port; result->on_bytes_received = NULL; result->on_io_error = NULL; result->on_bytes_received_context = NULL; result->on_io_error_context = NULL; result->io_state = IO_STATE_CLOSED; result->tcp_socket_connection = NULL; } } } } return result; } void socketio_destroy(CONCRETE_IO_HANDLE socket_io) { if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->tcp_socket_connection != NULL) { tcpsocketconnection_destroy(socket_io_instance->tcp_socket_connection); } /* clear all pending IOs */ LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io != NULL) { free(pending_socket_io->bytes); free(pending_socket_io); } (void)singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io); first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } singlylinkedlist_destroy(socket_io_instance->pending_io_list); free(socket_io_instance->hostname); free(socket_io); } } int socketio_open(CONCRETE_IO_HANDLE socket_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io == NULL) { result = MU_FAILURE; } else { if (socket_io_instance->tcp_socket_connection != NULL) { tcpsocketconnection_close(socket_io_instance->tcp_socket_connection); tcpsocketconnection_destroy(socket_io_instance->tcp_socket_connection); } socket_io_instance->tcp_socket_connection = tcpsocketconnection_create(); if (socket_io_instance->tcp_socket_connection == NULL) { result = MU_FAILURE; } else { if (tcpsocketconnection_connect(socket_io_instance->tcp_socket_connection, socket_io_instance->hostname, socket_io_instance->port) != 0) { tcpsocketconnection_destroy(socket_io_instance->tcp_socket_connection); socket_io_instance->tcp_socket_connection = NULL; result = MU_FAILURE; } else { tcpsocketconnection_set_blocking(socket_io_instance->tcp_socket_connection, false, 0); socket_io_instance->on_bytes_received = on_bytes_received; socket_io_instance->on_bytes_received_context = on_bytes_received_context; socket_io_instance->on_io_error = on_io_error; socket_io_instance->on_io_error_context = on_io_error_context; socket_io_instance->io_state = IO_STATE_OPEN; result = 0; } } } if (on_io_open_complete != NULL) { on_io_open_complete(on_io_open_complete_context, result == 0 ? IO_OPEN_OK : IO_OPEN_ERROR); } return result; } int socketio_close(CONCRETE_IO_HANDLE socket_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result = 0; if (socket_io == NULL) { result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if ((socket_io_instance->io_state == IO_STATE_CLOSED) || (socket_io_instance->io_state == IO_STATE_CLOSING)) { result = MU_FAILURE; } else { tcpsocketconnection_close(socket_io_instance->tcp_socket_connection); socket_io_instance->io_state = IO_STATE_CLOSED; if (on_io_close_complete != NULL) { on_io_close_complete(callback_context); } result = 0; } } return result; } int socketio_send(CONCRETE_IO_HANDLE socket_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if ((socket_io == NULL) || (buffer == NULL) || (size == 0)) { /* Invalid arguments */ result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state != IO_STATE_OPEN) { result = MU_FAILURE; } else { LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); if (first_pending_io != NULL) { if (add_pending_io(socket_io_instance, buffer, size, on_send_complete, callback_context) != 0) { result = MU_FAILURE; } else { result = 0; } } else { int send_result = tcpsocketconnection_send(socket_io_instance->tcp_socket_connection, buffer, size); if ((size_t)send_result != size) { if (send_result < 0) { send_result = 0; } /* queue data */ if (add_pending_io(socket_io_instance, (unsigned char*)buffer + send_result, size - send_result, on_send_complete, callback_context) != 0) { result = MU_FAILURE; } else { result = 0; } } else { if (on_send_complete != NULL) { on_send_complete(callback_context, IO_SEND_OK); } result = 0; } } } } return result; } void socketio_dowork(CONCRETE_IO_HANDLE socket_io) { if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state == IO_STATE_OPEN) { int received = 1; LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io == NULL) { socket_io_instance->io_state = IO_STATE_ERROR; indicate_error(socket_io_instance); break; } int send_result = tcpsocketconnection_send(socket_io_instance->tcp_socket_connection, (const char*)pending_socket_io->bytes, pending_socket_io->size); if ((size_t)send_result != pending_socket_io->size) { if (send_result < 0) { if (send_result < UNABLE_TO_COMPLETE) { // Bad error. Indicate as much. socket_io_instance->io_state = IO_STATE_ERROR; indicate_error(socket_io_instance); } break; } else { /* send something, wait for the rest */ (void)memmove(pending_socket_io->bytes, pending_socket_io->bytes + send_result, pending_socket_io->size - send_result); } } else { if (pending_socket_io->on_send_complete != NULL) { pending_socket_io->on_send_complete(pending_socket_io->callback_context, IO_SEND_OK); } free(pending_socket_io->bytes); free(pending_socket_io); if (singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io) != 0) { socket_io_instance->io_state = IO_STATE_ERROR; indicate_error(socket_io_instance); } } first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } while (received > 0) { unsigned char* recv_bytes = malloc(MBED_XIO_RECEIVE_BUFFER_SIZE); if (recv_bytes == NULL) { LogError("Socketio_Failure: NULL allocating input buffer."); indicate_error(socket_io_instance); } else { received = tcpsocketconnection_receive(socket_io_instance->tcp_socket_connection, (char*)recv_bytes, MBED_XIO_RECEIVE_BUFFER_SIZE); if (received > 0) { if (socket_io_instance->on_bytes_received != NULL) { /* explictly ignoring here the result of the callback */ (void)socket_io_instance->on_bytes_received(socket_io_instance->on_bytes_received_context, recv_bytes, received); } } free(recv_bytes); } } } } } int socketio_setoption(CONCRETE_IO_HANDLE socket_io, const char* optionName, const void* value) { /* Not implementing any options */ (void)socket_io; (void)optionName; (void)value; return MU_FAILURE; } const IO_INTERFACE_DESCRIPTION* socketio_get_interface_description(void) { return &socket_io_interface_description; } socketio_mbed_os5.c000066400000000000000000000361301455573770000346420ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/singlylinkedlist.h" #include "azure_c_shared_utility/tcpsocketconnection_c.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "netsocket/nsapi_types.h" #define MBED_XIO_RECEIVE_BUFFER_SIZE 128 typedef enum IO_STATE_TAG { IO_STATE_CLOSED, IO_STATE_OPENING, IO_STATE_OPEN, IO_STATE_CLOSING, IO_STATE_ERROR } IO_STATE; typedef struct PENDING_SOCKET_IO_TAG { unsigned char* bytes; size_t size; ON_SEND_COMPLETE on_send_complete; void* callback_context; SINGLYLINKEDLIST_HANDLE pending_io_list; } PENDING_SOCKET_IO; typedef struct SOCKET_IO_INSTANCE_TAG { TCPSOCKETCONNECTION_HANDLE tcp_socket_connection; ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; void* on_bytes_received_context; void* on_io_error_context; char* hostname; int port; IO_STATE io_state; SINGLYLINKEDLIST_HANDLE pending_io_list; } SOCKET_IO_INSTANCE; /*this function will clone an option given by name and value*/ static void* socketio_CloneOption(const char* name, const void* value) { (void)name; (void)value; return NULL; } /*this function destroys an option previously created*/ static void socketio_DestroyOption(const char* name, const void* value) { (void)name; (void)value; } static OPTIONHANDLER_HANDLE socketio_retrieveoptions(CONCRETE_IO_HANDLE socket_io) { OPTIONHANDLER_HANDLE result; (void)socket_io; result = OptionHandler_Create(socketio_CloneOption, socketio_DestroyOption, socketio_setoption); if (result == NULL) { /*return as is*/ } else { /*insert here work to add the options to "result" handle*/ } return result; } static const IO_INTERFACE_DESCRIPTION socket_io_interface_description = { socketio_retrieveoptions, socketio_create, socketio_destroy, socketio_open, socketio_close, socketio_send, socketio_dowork, socketio_setoption }; static void indicate_error(SOCKET_IO_INSTANCE* socket_io_instance) { if ((socket_io_instance->io_state == IO_STATE_CLOSED) || (socket_io_instance->io_state == IO_STATE_ERROR)) { return; } socket_io_instance->io_state = IO_STATE_ERROR; if (socket_io_instance->on_io_error != NULL) { socket_io_instance->on_io_error(socket_io_instance->on_io_error_context); } } static int add_pending_io(SOCKET_IO_INSTANCE* socket_io_instance, const unsigned char* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)malloc(sizeof(PENDING_SOCKET_IO)); if (pending_socket_io == NULL) { result = MU_FAILURE; } else { pending_socket_io->bytes = (unsigned char*)malloc(size); if (pending_socket_io->bytes == NULL) { free(pending_socket_io); result = MU_FAILURE; } else { pending_socket_io->size = size; pending_socket_io->on_send_complete = on_send_complete; pending_socket_io->callback_context = callback_context; pending_socket_io->pending_io_list = socket_io_instance->pending_io_list; (void)memcpy(pending_socket_io->bytes, buffer, size); if (singlylinkedlist_add(socket_io_instance->pending_io_list, pending_socket_io) == NULL) { free(pending_socket_io->bytes); free(pending_socket_io); result = MU_FAILURE; } else { result = 0; } } } return result; } static int retrieve_data(SOCKET_IO_INSTANCE* socket_io_instance) { int received = 1; int total_received = 0; unsigned char* recv_bytes = malloc(MBED_XIO_RECEIVE_BUFFER_SIZE); if (recv_bytes == NULL) { LogError("Socketio_Failure: NULL allocating input buffer."); indicate_error(socket_io_instance); return -1; } while (received > 0) { /* Codes_SRS_SOCKETIO_MBED_OS5_99_005: [ retrieve_data shall succeed if tcp receive bytes succeed ]*/ received = tcpsocketconnection_receive(socket_io_instance->tcp_socket_connection, (char*)recv_bytes, MBED_XIO_RECEIVE_BUFFER_SIZE); if (received > 0) { total_received += received; if (socket_io_instance->on_bytes_received != NULL) { /* explictly ignoring here the result of the callback */ socket_io_instance->on_bytes_received(socket_io_instance->on_bytes_received_context, recv_bytes, received); } } else if (received < 0) { if(received != NSAPI_ERROR_WOULD_BLOCK) // NSAPI_ERROR_WOULD_BLOCK is not a real error but pending. { indicate_error(socket_io_instance); LogError("Socketio_Failure: underlying IO error %d.", received); free(recv_bytes); return -1; } } } free(recv_bytes); return total_received; } static int send_queued_data(SOCKET_IO_INSTANCE* socket_io_instance) { int errors = 0; int sent = 0; LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io == NULL) { indicate_error(socket_io_instance); return -1; } int send_result = tcpsocketconnection_send(socket_io_instance->tcp_socket_connection, (const char*)pending_socket_io->bytes, pending_socket_io->size); if (send_result != (int)pending_socket_io->size) { if (send_result == 0) { // The underlying network layer may encounter hardware / environment issues, // but the driver doesn't handle it properly. So here the send API always return 0, // this causes the program running into dead loop if not check it here. if (errors++ >= 10) { // Treat it as a network error after try 10 times. LogError("Socketio_Failure: encountered unknow connection issue, the connection will be restarted."); indicate_error(socket_io_instance); return -1; } wait_ms(10); } else if (send_result < 0) { indicate_error(socket_io_instance); return -1; } else { /* send something, wait for the rest */ memmove(pending_socket_io->bytes, pending_socket_io->bytes + send_result, pending_socket_io->size - send_result); sent += send_result; } } else { sent += send_result; if (pending_socket_io->on_send_complete != NULL) { pending_socket_io->on_send_complete(pending_socket_io->callback_context, IO_SEND_OK); } free(pending_socket_io->bytes); free(pending_socket_io); if (singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io) != 0) { indicate_error(socket_io_instance); return -1; } errors = 0; } first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } return sent; } static void close_tcp_connection(SOCKET_IO_INSTANCE* socket_io_instance) { if (socket_io_instance->io_state != IO_STATE_CLOSED) { if (socket_io_instance->tcp_socket_connection != NULL) { tcpsocketconnection_close(socket_io_instance->tcp_socket_connection); tcpsocketconnection_destroy(socket_io_instance->tcp_socket_connection); socket_io_instance->tcp_socket_connection = NULL; } socket_io_instance->io_state = IO_STATE_CLOSED; } } CONCRETE_IO_HANDLE socketio_create(void* io_create_parameters) { SOCKETIO_CONFIG* socket_io_config = io_create_parameters; SOCKET_IO_INSTANCE* result; if (socket_io_config == NULL) { result = NULL; } else { result = (SOCKET_IO_INSTANCE*)malloc(sizeof(SOCKET_IO_INSTANCE)); if (result != NULL) { result->pending_io_list = singlylinkedlist_create(); if (result->pending_io_list == NULL) { free(result); result = NULL; } else { result->hostname = strdup(socket_io_config->hostname); if (result->hostname == NULL) { singlylinkedlist_destroy(result->pending_io_list); free(result); result = NULL; } else { result->port = socket_io_config->port; result->on_bytes_received = NULL; result->on_io_error = NULL; result->on_bytes_received_context = NULL; result->on_io_error_context = NULL; result->io_state = IO_STATE_CLOSED; result->tcp_socket_connection = NULL; } } } } return result; } void socketio_destroy(CONCRETE_IO_HANDLE socket_io) { if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; // Close the tcp connection close_tcp_connection(socket_io_instance); // Clear all pending IOs LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io != NULL) { free(pending_socket_io->bytes); free(pending_socket_io); } (void)singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io); first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } singlylinkedlist_destroy(socket_io_instance->pending_io_list); if(socket_io_instance->hostname != NULL) { free(socket_io_instance->hostname); socket_io_instance->hostname = NULL; } free(socket_io); } } int socketio_open(CONCRETE_IO_HANDLE socket_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance == NULL || socket_io_instance->io_state != IO_STATE_CLOSED) { result = MU_FAILURE; } else { socket_io_instance->tcp_socket_connection = tcpsocketconnection_create(); if (socket_io_instance->tcp_socket_connection == NULL) { result = MU_FAILURE; } else { if (tcpsocketconnection_connect(socket_io_instance->tcp_socket_connection, socket_io_instance->hostname, socket_io_instance->port) != 0) { tcpsocketconnection_destroy(socket_io_instance->tcp_socket_connection); socket_io_instance->tcp_socket_connection = NULL; result = MU_FAILURE; } else { tcpsocketconnection_set_blocking(socket_io_instance->tcp_socket_connection, false, 0); socket_io_instance->on_bytes_received = on_bytes_received; socket_io_instance->on_bytes_received_context = on_bytes_received_context; socket_io_instance->on_io_error = on_io_error; socket_io_instance->on_io_error_context = on_io_error_context; socket_io_instance->io_state = IO_STATE_OPEN; result = 0; } } } if (on_io_open_complete != NULL) { on_io_open_complete(on_io_open_complete_context, result == 0 ? IO_OPEN_OK : IO_OPEN_ERROR); } return result; } int socketio_close(CONCRETE_IO_HANDLE socket_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result = 0; if (socket_io == NULL) { result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state == IO_STATE_CLOSED || socket_io_instance->io_state == IO_STATE_ERROR) { result = MU_FAILURE; } else { close_tcp_connection(socket_io_instance); if (on_io_close_complete != NULL) { on_io_close_complete(callback_context); } result = 0; } } return result; } int socketio_send(CONCRETE_IO_HANDLE socket_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if ((socket_io == NULL) || (buffer == NULL) || (size == 0)) { /* Invalid arguments */ result = MU_FAILURE; } else { result = 0; SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state != IO_STATE_OPEN) { result = MU_FAILURE; } else { // Queue the data, and the socketio_dowork sends the package later if (add_pending_io(socket_io_instance, buffer, size, on_send_complete, callback_context) != 0) { result = MU_FAILURE; } } } return result; } void socketio_dowork(CONCRETE_IO_HANDLE socket_io) { if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state == IO_STATE_OPEN) { // Retrieve all data from IoT Hub if (retrieve_data(socket_io_instance) < 0) { return; } // Send all packages in the queue send_queued_data(socket_io_instance); } } } int socketio_setoption(CONCRETE_IO_HANDLE socket_io, const char* optionName, const void* value) { /* Not implementing any options, do nothing */ return OPTIONHANDLER_OK; } const IO_INTERFACE_DESCRIPTION* socketio_get_interface_description(void) { return &socket_io_interface_description; } socketio_win32.c000066400000000000000000000666651455573770000341270ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include #include #ifdef AF_UNIX_ON_WINDOWS #include #endif #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/singlylinkedlist.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/gbnetwork.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/dns_resolver.h" typedef enum IO_STATE_TAG { IO_STATE_CLOSED, IO_STATE_OPENING, IO_STATE_OPEN, IO_STATE_CLOSING } IO_STATE; typedef struct PENDING_SOCKET_IO_TAG { unsigned char* bytes; size_t size; ON_SEND_COMPLETE on_send_complete; void* callback_context; SINGLYLINKEDLIST_HANDLE pending_io_list; } PENDING_SOCKET_IO; typedef struct SOCKET_IO_INSTANCE_TAG { SOCKET socket; SOCKETIO_ADDRESS_TYPE address_type; ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; ON_IO_OPEN_COMPLETE on_io_open_complete; void* on_bytes_received_context; void* on_io_error_context; void* on_io_open_complete_context; char* hostname; int port; IO_STATE io_state; SINGLYLINKEDLIST_HANDLE pending_io_list; struct tcp_keepalive keep_alive; unsigned char recv_bytes[XIO_RECEIVE_BUFFER_SIZE]; DNSRESOLVER_HANDLE dns_resolver; struct addrinfo* addrInfo; } SOCKET_IO_INSTANCE; /*this function will clone an option given by name and value*/ static void* socketio_CloneOption(const char* name, const void* value) { (void)name; (void)value; return NULL; } /*this function destroys an option previously created*/ static void socketio_DestroyOption(const char* name, const void* value) { (void)name; (void)value; } static OPTIONHANDLER_HANDLE socketio_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result; (void)handle; result = OptionHandler_Create(socketio_CloneOption, socketio_DestroyOption, socketio_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); /*return as is*/ } else { /*insert here work to add the options to "result" handle*/ } return result; } static const IO_INTERFACE_DESCRIPTION socket_io_interface_description = { socketio_retrieveoptions, socketio_create, socketio_destroy, socketio_open, socketio_close, socketio_send, socketio_dowork, socketio_setoption }; static void indicate_error(SOCKET_IO_INSTANCE* socket_io_instance) { if (socket_io_instance->on_io_error != NULL) { socket_io_instance->on_io_error(socket_io_instance->on_io_error_context); } } static int add_pending_io(SOCKET_IO_INSTANCE* socket_io_instance, const unsigned char* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)calloc(1, sizeof(PENDING_SOCKET_IO)); if (pending_socket_io == NULL) { result = MU_FAILURE; } else { pending_socket_io->bytes = (unsigned char*)malloc(size); if (pending_socket_io->bytes == NULL) { LogError("Allocation Failure: Unable to allocate pending list."); free(pending_socket_io); result = MU_FAILURE; } else { pending_socket_io->size = size; pending_socket_io->on_send_complete = on_send_complete; pending_socket_io->callback_context = callback_context; pending_socket_io->pending_io_list = socket_io_instance->pending_io_list; (void)memcpy(pending_socket_io->bytes, buffer, size); if (singlylinkedlist_add(socket_io_instance->pending_io_list, pending_socket_io) == NULL) { LogError("Failure: Unable to add socket to pending list."); free(pending_socket_io->bytes); free(pending_socket_io); result = MU_FAILURE; } else { result = 0; } } } return result; } static int lookup_address(SOCKET_IO_INSTANCE* socket_io_instance) { int result = 0; if (socket_io_instance->address_type == ADDRESS_TYPE_IP) { if (!dns_resolver_is_lookup_complete(socket_io_instance->dns_resolver)) { socket_io_instance->io_state = IO_STATE_OPENING; } else if (dns_resolver_get_ipv4(socket_io_instance->dns_resolver) == 0) { LogError("DNS resolution failure %d.", WSAGetLastError()); result = MU_FAILURE; } else { //The hostname IP has been returned. //So, the socket is ready to open because currently socket_io_instance->socket is INVALID_SOCKET. socket_io_instance->io_state = IO_STATE_OPEN; } } else //ADDRESS_TYPE_DOMAIN_SOCKET { socket_io_instance->io_state = IO_STATE_OPEN; } return result; } static int connect_socket(SOCKET socket, struct sockaddr* addr, size_t len) { int result; u_long iMode = 1; if (connect(socket, addr, (int)len) != 0) { LogError("Failure: connect failure %d.", WSAGetLastError()); result = MU_FAILURE; } else if (ioctlsocket(socket, FIONBIO, &iMode) != 0) { LogError("Failure: ioctlsocket failure %d.", WSAGetLastError()); result = MU_FAILURE; } else { result = 0; } return result; } static int initiate_socket_connection(SOCKET_IO_INSTANCE* socket_io_instance) { int result; #ifdef AF_UNIX_ON_WINDOWS if (socket_io_instance->address_type == ADDRESS_TYPE_IP) { #endif struct addrinfo* addr = dns_resolver_get_addrInfo(socket_io_instance->dns_resolver); if (addr == NULL) { LogError("DNS resolution failed"); result = MU_FAILURE; } else { (void)memcpy((socket_io_instance->addrInfo), addr, sizeof(*(socket_io_instance->addrInfo))); result = connect_socket(socket_io_instance->socket, (socket_io_instance->addrInfo)->ai_addr, sizeof(*((socket_io_instance->addrInfo)->ai_addr))); if (result != 0) { LogError("connect_socket failed"); } else { if (socket_io_instance->on_io_open_complete != NULL) { socket_io_instance->on_io_open_complete(socket_io_instance->on_io_open_complete_context, IO_OPEN_OK /*: IO_OPEN_ERROR*/); } } } #ifdef AF_UNIX_ON_WINDOWS } else // ADDRESS_TYPE_DOMAIN_SOCKET { SOCKADDR_UN addr_un; const char* path = socket_io_instance->hostname; size_t path_len = strlen(path); // If the value of hostname was parsed out of a 'unix://' URL, it might have a // leading forward slash ('/'). That's because the domain socket path is found // in the path portion of the URL, not the hostname portion. The hostname is // empty and the forward slash delimits the start of the path. For Unix domain // socket paths on Windows, discard the leading forward slash. if (path[0] == '/') { ++path; --path_len; } if (path_len + 1 > sizeof(addr_un.sun_path)) { LogError("Path '%s' is too long for a unix socket (max len = %lu)", path, (unsigned long)sizeof(addr_un.sun_path)); result = MU_FAILURE; } else { (void)memset(&addr_un, 0, sizeof(addr_un)); addr_un.sun_family = AF_UNIX; // No need to add NULL terminator due to the above memset (void)memcpy(addr_un.sun_path, path, path_len); result = connect_socket(socket_io_instance->socket, (struct sockaddr*)&addr_un, sizeof(addr_un)); if (result != 0) { LogError("connect_socket failed"); result = MU_FAILURE; } else { socket_io_instance->io_state = IO_STATE_OPEN; if (socket_io_instance->on_io_open_complete != NULL) { socket_io_instance->on_io_open_complete(socket_io_instance->on_io_open_complete_context, IO_OPEN_OK); } } } } #endif return result; } static void destroy_socket_io_instance(SOCKET_IO_INSTANCE* instance) { if (instance->dns_resolver != NULL) { dns_resolver_destroy(instance->dns_resolver); } free(instance->hostname); free(instance->addrInfo); if (instance->pending_io_list != NULL) { singlylinkedlist_destroy(instance->pending_io_list); } free(instance); } CONCRETE_IO_HANDLE socketio_create(void* io_create_parameters) { SOCKETIO_CONFIG* socket_io_config = (SOCKETIO_CONFIG*)io_create_parameters; SOCKET_IO_INSTANCE* result; struct tcp_keepalive tcp_keepalive = { 0, 0, 0 }; if (socket_io_config == NULL) { LogError("Invalid argument: socket_io_config is NULL"); result = NULL; } else { result = (SOCKET_IO_INSTANCE*)malloc(sizeof(SOCKET_IO_INSTANCE)); if (result != NULL) { (void)memset(result, 0, sizeof(SOCKET_IO_INSTANCE)); result->address_type = ADDRESS_TYPE_IP; result->pending_io_list = singlylinkedlist_create(); if (result->pending_io_list == NULL) { LogError("Failure: singlylinkedlist_create unable to create pending list."); destroy_socket_io_instance(result); result = NULL; } else { if (socket_io_config->hostname != NULL) { result->hostname = (char*)malloc(strlen(socket_io_config->hostname) + 1); if (result->hostname != NULL) { (void)strcpy(result->hostname, socket_io_config->hostname); } result->socket = INVALID_SOCKET; } else { result->hostname = NULL; result->socket = *((SOCKET*)socket_io_config->accepted_socket); } if ((result->hostname == NULL) && (result->socket == INVALID_SOCKET)) { LogError("Failure: hostname == NULL and socket is invalid."); destroy_socket_io_instance(result); result = NULL; } else if ((result->addrInfo = calloc(1, sizeof(struct addrinfo))) == NULL) { LogError("Failure: addrInfo == NULL."); destroy_socket_io_instance(result); result = NULL; } else { result->port = socket_io_config->port; result->on_io_open_complete = NULL; result->dns_resolver = dns_resolver_create(result->hostname, socket_io_config->port, NULL); result->on_bytes_received = NULL; result->on_io_error = NULL; result->on_bytes_received_context = NULL; result->on_io_error_context = NULL; result->io_state = IO_STATE_CLOSED; result->keep_alive = tcp_keepalive; } } } else { LogError("Allocation Failure: SOCKET_IO_INSTANCE"); } } return (XIO_HANDLE)result; } void socketio_destroy(CONCRETE_IO_HANDLE socket_io) { LIST_ITEM_HANDLE first_pending_io; if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; /* we cannot do much if the close fails, so just ignore the result */ (void)closesocket(socket_io_instance->socket); /* clear allpending IOs */ while ((first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list)) != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io != NULL) { free(pending_socket_io->bytes); free(pending_socket_io); } singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io); } destroy_socket_io_instance(socket_io); } } int socketio_open(CONCRETE_IO_HANDLE socket_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance == NULL) { LogError("Invalid argument: SOCKET_IO_INSTANCE is NULL"); result = MU_FAILURE; } else { if (socket_io_instance->io_state != IO_STATE_CLOSED) { LogError("Failure: socket state is not closed."); result = MU_FAILURE; } else if (socket_io_instance->socket != INVALID_SOCKET) { // Opening an accepted socket socket_io_instance->on_bytes_received_context = on_bytes_received_context; socket_io_instance->on_bytes_received = on_bytes_received; socket_io_instance->on_io_error = on_io_error; socket_io_instance->on_io_error_context = on_io_error_context; socket_io_instance->on_io_open_complete = on_io_open_complete; socket_io_instance->on_io_open_complete_context = on_io_open_complete_context; socket_io_instance->io_state = IO_STATE_OPEN; result = 0; } else { #ifdef AF_UNIX_ON_WINDOWS int addr_family = socket_io_instance->address_type == ADDRESS_TYPE_IP ? AF_INET : AF_UNIX; #else int addr_family = AF_INET; #endif socket_io_instance->socket = socket(addr_family, SOCK_STREAM, 0); if (socket_io_instance->socket == INVALID_SOCKET) { LogError("Failure: socket create failure %d.", WSAGetLastError()); result = MU_FAILURE; } else if (lookup_address(socket_io_instance) != 0) { LogError("lookup_address failed"); (void)closesocket(socket_io_instance->socket); socket_io_instance->socket = INVALID_SOCKET; result = MU_FAILURE; } else if (socket_io_instance->io_state == IO_STATE_OPEN && initiate_socket_connection(socket_io_instance) != 0) { LogError("initiate_socket_connection failed"); (void)closesocket(socket_io_instance->socket); socket_io_instance->socket = INVALID_SOCKET; result = MU_FAILURE; } else { socket_io_instance->on_bytes_received_context = on_bytes_received_context; socket_io_instance->on_bytes_received = on_bytes_received; socket_io_instance->on_io_error = on_io_error; socket_io_instance->on_io_error_context = on_io_error_context; socket_io_instance->on_io_open_complete = on_io_open_complete; socket_io_instance->on_io_open_complete_context = on_io_open_complete_context; result = 0; } } } if (socket_io_instance != NULL && socket_io_instance->io_state != IO_STATE_OPENING) { if (on_io_open_complete != NULL) { on_io_open_complete(on_io_open_complete_context, result == 0 ? IO_OPEN_OK : IO_OPEN_ERROR); } } return result; } int socketio_close(CONCRETE_IO_HANDLE socket_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result; if (socket_io == NULL) { LogError("Invalid argument: socket_io is NULL"); result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if ((socket_io_instance->io_state != IO_STATE_CLOSING) && (socket_io_instance->io_state != IO_STATE_CLOSED)) { (void)closesocket(socket_io_instance->socket); socket_io_instance->socket = INVALID_SOCKET; socket_io_instance->io_state = IO_STATE_CLOSED; } if (on_io_close_complete != NULL) { on_io_close_complete(callback_context); } result = 0; } return result; } int socketio_send(CONCRETE_IO_HANDLE socket_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if ((socket_io == NULL) || (buffer == NULL) || (size == 0)) { /* Invalid arguments */ LogError("Invalid argument: send given invalid parameter"); result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state != IO_STATE_OPEN) { LogError("Failure: socket state is not opened."); result = MU_FAILURE; } else { LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); if (first_pending_io != NULL) { if (add_pending_io(socket_io_instance, (const unsigned char*)buffer, size, on_send_complete, callback_context) != 0) { LogError("Failure: add_pending_io failed."); result = MU_FAILURE; } else { result = 0; } } else { int send_result = send(socket_io_instance->socket, (const char*)buffer, (int)size, 0); if ((size_t)send_result != size) { int last_error = WSAGetLastError(); if (send_result == SOCKET_ERROR && last_error != WSAEWOULDBLOCK) { LogError("Failure: sending socket failed %d.", last_error); result = MU_FAILURE; } else { size_t bytes_sent = (send_result == SOCKET_ERROR ? 0 : send_result); /* queue data */ if (add_pending_io(socket_io_instance, ((const unsigned char*)buffer) + bytes_sent, size - bytes_sent, on_send_complete, callback_context) != 0) { LogError("Failure: add_pending_io failed."); result = MU_FAILURE; } else { result = 0; } } } else { if (on_send_complete != NULL) { on_send_complete(callback_context, IO_SEND_OK); } result = 0; } } } } return result; } void socketio_dowork(CONCRETE_IO_HANDLE socket_io) { int send_result; if (socket_io != NULL) { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (socket_io_instance->io_state == IO_STATE_OPEN) { LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SOCKET_IO* pending_socket_io = (PENDING_SOCKET_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_socket_io == NULL) { LogError("Failure: retrieving socket from list"); indicate_error(socket_io_instance); break; } /* TODO: we need to do more than a cast here to be 100% clean The following bug was filed: [WarnL4] socketio_win32 does not account for already sent bytes and there is a truncation of size from size_t to int */ send_result = send(socket_io_instance->socket, (const char*)pending_socket_io->bytes, (int)pending_socket_io->size, 0); if ((size_t)send_result != pending_socket_io->size) { int last_error = WSAGetLastError(); if (last_error != WSAEWOULDBLOCK) { free(pending_socket_io->bytes); free(pending_socket_io); (void)singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io); } else { /* try again */ } } else { if (pending_socket_io->on_send_complete != NULL) { pending_socket_io->on_send_complete(pending_socket_io->callback_context, IO_SEND_OK); } free(pending_socket_io->bytes); free(pending_socket_io); if (singlylinkedlist_remove(socket_io_instance->pending_io_list, first_pending_io) != 0) { LogError("Failure: removing socket from list"); indicate_error(socket_io_instance); } } first_pending_io = singlylinkedlist_get_head_item(socket_io_instance->pending_io_list); } if (socket_io_instance->io_state == IO_STATE_OPEN) { int received = 0; do { received = recv(socket_io_instance->socket, (char*)socket_io_instance->recv_bytes, XIO_RECEIVE_BUFFER_SIZE, 0); if ((received > 0)) { if (socket_io_instance->on_bytes_received != NULL) { /* Explicitly ignoring here the result of the callback */ (void)socket_io_instance->on_bytes_received(socket_io_instance->on_bytes_received_context, socket_io_instance->recv_bytes, received); } } else if (received == 0) { indicate_error(socket_io_instance); } else { int last_error = WSAGetLastError(); if (last_error != WSAEWOULDBLOCK && last_error != ERROR_SUCCESS) { LogError("Socketio_Failure: Receiving data from endpoint: %d.", last_error); indicate_error(socket_io_instance); } } } while (received > 0 && socket_io_instance->io_state == IO_STATE_OPEN); } } else { //Handle async socket_open operation within socket_dowork if (socket_io_instance->io_state == IO_STATE_OPENING) { if (lookup_address(socket_io_instance) != 0) { LogError("lookup_address failed"); (void)closesocket(socket_io_instance->socket); socket_io_instance->socket = INVALID_SOCKET; socket_io_instance->io_state = IO_STATE_CLOSED; } else if (socket_io_instance->io_state == IO_STATE_OPEN && initiate_socket_connection(socket_io_instance) != 0) { LogError("initialize_socket_connection failed"); (void)closesocket(socket_io_instance->socket); socket_io_instance->socket = INVALID_SOCKET; socket_io_instance->io_state = IO_STATE_CLOSED; } } } } } static int set_keepalive(SOCKET_IO_INSTANCE* socket_io, struct tcp_keepalive* keepAlive) { int result; DWORD bytesReturned; int err = WSAIoctl(socket_io->socket, SIO_KEEPALIVE_VALS, keepAlive, sizeof(struct tcp_keepalive), NULL, 0, &bytesReturned, NULL, NULL); if (err != 0) { LogError("Failure: setting keep-alive on the socket: %d.", err == SOCKET_ERROR ? WSAGetLastError() : err); result = MU_FAILURE; } else { socket_io->keep_alive = *keepAlive; result = 0; } return result; } static int socketio_setaddresstype_option(SOCKET_IO_INSTANCE* socket_io_instance, const char* addressType) { int result; if (socket_io_instance->io_state != IO_STATE_CLOSED) { LogError("Socket's type can only be changed when in state 'IO_STATE_CLOSED'. Current state=%d", socket_io_instance->io_state); result = MU_FAILURE; } #ifdef AF_UNIX_ON_WINDOWS else if (strcmp(addressType, OPTION_ADDRESS_TYPE_DOMAIN_SOCKET) == 0) { socket_io_instance->address_type = ADDRESS_TYPE_DOMAIN_SOCKET; result = 0; } #endif else if (strcmp(addressType, OPTION_ADDRESS_TYPE_IP_SOCKET) == 0) { socket_io_instance->address_type = ADDRESS_TYPE_IP; result = 0; } else { LogError("Address type %s is not supported", addressType); result = MU_FAILURE; } return result; } int socketio_setoption(CONCRETE_IO_HANDLE socket_io, const char* optionName, const void* value) { int result; if (socket_io == NULL || optionName == NULL || value == NULL) { result = MU_FAILURE; } else { SOCKET_IO_INSTANCE* socket_io_instance = (SOCKET_IO_INSTANCE*)socket_io; if (strcmp(optionName, "tcp_keepalive") == 0) { struct tcp_keepalive keepAlive = socket_io_instance->keep_alive; keepAlive.onoff = *(int *)value; result = set_keepalive(socket_io_instance, &keepAlive); } else if (strcmp(optionName, "tcp_keepalive_time") == 0) { unsigned long kaTime = *(int *)value * 1000; // convert to ms struct tcp_keepalive keepAlive = socket_io_instance->keep_alive; keepAlive.keepalivetime = kaTime; result = set_keepalive(socket_io_instance, &keepAlive); } else if (strcmp(optionName, "tcp_keepalive_interval") == 0) { unsigned long kaInterval = *(int *)value * 1000; // convert to ms struct tcp_keepalive keepAlive = socket_io_instance->keep_alive; keepAlive.keepaliveinterval = kaInterval; result = set_keepalive(socket_io_instance, &keepAlive); } else if (strcmp(optionName, OPTION_ADDRESS_TYPE) == 0) { result = socketio_setaddresstype_option(socket_io_instance, (const char*)value); } else { result = MU_FAILURE; } } return result; } const IO_INTERFACE_DESCRIPTION* socketio_get_interface_description(void) { return &socket_io_interface_description; } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/srw_lock.c000066400000000000000000000355061455573770000331550ustar00rootroot00000000000000// Copyright (C) Microsoft Corporation. All rights reserved. #include #include #include "windows.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/timer.h" #include "azure_c_shared_utility/string_utils.h" #include "azure_c_shared_utility/srw_lock.h" /* vocabulary: blaBlaCount = values of counter for event blabla blablaCounts = sum of individual blablaCountEnd-blablaCountBegin (always a sum of durations of Counts) time = blablaCounts/freq */ #define TIME_BETWEEN_STATISTICS_LOG 600 /*in seconds, so every 10 minutes*/ typedef struct SRW_LOCK_HANDLE_DATA_TAG { SRWLOCK lock; LARGE_INTEGER freq; volatile LONG64 nCalls_AcquireSRWLockExclusive; /*number of calls to AcquireSRWLockExclusive*/ volatile LONG64 totalCounts_AcquireSRWLockExclusive; /*how many counts were spent taking the lock (that is, just before and after AcquireSRWLockExclusive call*/ volatile LONG64 totalCounts_ReleaseSRWLockExclusive; /*how many counts were spent releasing the exclusive SRW that is, just before and after ReleaseSRWLockExclusive call*/ volatile LONG64 lastCount_AcquireSRWLockExclusive; /*last time the lock was taken exclusively*/ volatile LONG64 totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive; /*how much time the lock was taken in total in exclusive mode*/ volatile LONG64 nCalls_AcquireSRWLockShared; /*number of calls to AcquireSRWLockShared*/ volatile LONG64 totalCounts_AcquireSRWLockShared; /*how many counts were spent taking the lock (that is, just before and after AcquireSRWLockShared */ volatile LONG64 totalCounts_ReleaseSRWLockShared; /*how many counts were spent releasing the shared SRW that is, just before and after ReleaseSRWLockShared call*/ volatile LONG nSharedReaders; /*if lock_shared is granted, then there are 1 more readers... when readers gets to 0, the shared "locked" count can be updated*/ volatile LONG64 firstCount_AcquireSRWLockShared; /*first time the lock was taken in shared mode*/ volatile LONG64 totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared; /*how much time the lock was taken from the first granted shared access to the last released shared access*/ LARGE_INTEGER handleCreateCount; /*when the handle was created*/ TIMER_HANDLE timer; char* lockName; bool doStatistics; }SRW_LOCK_HANDLE_DATA; static void LogStatistics(SRW_LOCK_HANDLE handle, const char* reason) { LARGE_INTEGER now; (void)QueryPerformanceCounter(&now); /*print statistics*/ LogInfo("srw_lock_statistics reason:%s SRW_LOCK_HANDLE handle %p lock_name=%s\n" "freq=%" PRId64 ",\n" "nCalls_AcquireSRWLockExclusive=%" PRId64 ",\n" "totalCounts_AcquireSRWLockExclusive=%" PRId64 ",\n" "totalCounts_ReleaseSRWLockExclusive=%" PRId64 ",\n" "totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive=%" PRId64 ",\n" "nCalls_AcquireSRWLockShared=%" PRId64 ",\n" "totalCounts_AcquireSRWLockShared=%" PRId64 ",\n" "totalCounts_ReleaseSRWLockShared=%" PRId64 ",\n" "totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared=%" PRId64 ",\n" "totalCountsBetween_Create_and_Now=%" PRId64 ",\n" "totalTimeBetween_Create_and_Now[s]=%.2f, \n" "totalTimeBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive[s]=%.2f, \n" "totalTimeBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive[%%]=%.2f, \n" "averageTimeBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive[us]=%.2f, \n" "totalTimeBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared[s]=%.2f, \n" "totalTimeBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared[%%]=%.2f", reason, handle, handle->lockName, handle->freq.QuadPart, InterlockedAdd64(&handle->nCalls_AcquireSRWLockExclusive, 0), InterlockedAdd64(&handle->totalCounts_AcquireSRWLockExclusive, 0), InterlockedAdd64(&handle->totalCounts_ReleaseSRWLockExclusive, 0), InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive, 0), InterlockedAdd64(&handle->nCalls_AcquireSRWLockShared, 0), InterlockedAdd64(&handle->totalCounts_AcquireSRWLockShared, 0), InterlockedAdd64(&handle->totalCounts_ReleaseSRWLockShared, 0), InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared, 0), /*"totalTimeBetween_Create_and_Now[s]*/ now.QuadPart - handle->handleCreateCount.QuadPart, (double)(now.QuadPart -handle->handleCreateCount.QuadPart)/ (double)handle->freq.QuadPart, (double)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive, 0) / (double)handle->freq.QuadPart, (double)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive, 0) / (double)(now.QuadPart - handle->handleCreateCount.QuadPart) *100, (InterlockedAdd64(&handle->nCalls_AcquireSRWLockExclusive, 0)>0?(double)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive, 0)*1000000 / (double)(now.QuadPart - handle->handleCreateCount.QuadPart) / InterlockedAdd64(&handle->nCalls_AcquireSRWLockExclusive, 0):-1), (double)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared , 0) / (double)handle->freq.QuadPart, (double)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared, 0) / (double)(now.QuadPart - handle->handleCreateCount.QuadPart) * 100 ); } SRW_LOCK_HANDLE srw_lock_create(bool do_statistics, const char* lock_name) { SRW_LOCK_HANDLE result; /*Codes_SRS_SRW_LOCK_02_001: [ srw_lock_create shall allocate memory for SRW_LOCK_HANDLE. ]*/ result = calloc(1, sizeof(SRW_LOCK_HANDLE_DATA)); if (result == NULL) { /*return as is*/ LogError("failure in malloc(sizeof(SRW_LOCK_HANDLE_DATA)=%zu)", sizeof(SRW_LOCK_HANDLE_DATA)); } else { /*Codes_SRS_SRW_LOCK_02_023: [ If do_statistics is true then srw_lock_create shall copy lock_name. ]*/ if (do_statistics && ((result->lockName= sprintf_char("%s", MU_P_OR_NULL(lock_name))) == NULL) ) { LogError("failure in sprintf_char(\"%%s\", lock_name=%s)", MU_P_OR_NULL(lock_name)); } else { /*Codes_SRS_SRW_LOCK_02_024: [ If do_statistics is true then srw_lock_create shall create a new TIMER_HANDLE by calling timer_create. ]*/ if( do_statistics && ((result->timer = timer_create())==NULL) ) { LogError("failure in timer_create()"); } else { result->doStatistics = do_statistics; /*Codes_SRS_SRW_LOCK_02_015: [ srw_lock_create shall call InitializeSRWLock. ]*/ InitializeSRWLock(&result->lock); (void)QueryPerformanceFrequency(&result->freq); (void)InterlockedExchange64(&result->nCalls_AcquireSRWLockExclusive, 0); (void)InterlockedExchange64(&result->nCalls_AcquireSRWLockShared, 0); (void)InterlockedExchange64(&result->totalCounts_AcquireSRWLockExclusive, 0); (void)InterlockedExchange64(&result->totalCounts_ReleaseSRWLockExclusive, 0); (void)InterlockedExchange64(&result->totalCounts_AcquireSRWLockShared, 0); (void)InterlockedExchange64(&result->totalCounts_ReleaseSRWLockShared, 0); (void)InterlockedExchange64(&result->totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive, 0); (void)InterlockedExchange(&result->nSharedReaders, 0); (void)InterlockedExchange64(&result->totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared, 0); (void)QueryPerformanceCounter(&result->handleCreateCount); if (do_statistics) { LogInfo("srw_lock_create returns %p for lock_name=%s", result, MU_P_OR_NULL(lock_name)); } /*Codes_SRS_SRW_LOCK_02_003: [ srw_lock_create shall succeed and return a non-NULL value. ]*/ goto allOk; //timer_destroy(result->timer); } /*Codes_SRS_SRW_LOCK_02_004: [ If there are any failures then srw_lock_create shall fail and return NULL. ]*/ do_statistics ? free(result->lockName) : (void)0; } free(result); result = NULL; } allOk:; return result; } void srw_lock_acquire_exclusive(SRW_LOCK_HANDLE handle) { /*Codes_SRS_SRW_LOCK_02_022: [ If handle is NULL then srw_lock_acquire_exclusive shall return. ]*/ if (handle == NULL) { LogError("invalid argument SRW_LOCK_HANDLE handle=%p", handle); } else { if (!handle->doStatistics) { AcquireSRWLockExclusive(&handle->lock); } else { LARGE_INTEGER start, stop; (void)QueryPerformanceCounter(&start); /*Codes_SRS_SRW_LOCK_02_006: [ srw_lock_acquire_exclusive shall call AcquireSRWLockExclusive. ]*/ AcquireSRWLockExclusive(&handle->lock); (void)QueryPerformanceCounter(&stop); /*measure acquire time*/ (void)InterlockedIncrement64(&handle->nCalls_AcquireSRWLockExclusive); (void)InterlockedAdd64(&handle->totalCounts_AcquireSRWLockExclusive, stop.QuadPart - start.QuadPart); /*piggyback on the lock itself to print the statistics "until now" - note - does not include the current Lock call*/ /*Codes_SRS_SRW_LOCK_02_025: [ If do_statistics is true and if the timer created has recorded more than TIME_BETWEEN_STATISTICS_LOG seconds then statistics will be logged and the timer shall be started again. ]*/ if (timer_get_elapsed(handle->timer) >= TIME_BETWEEN_STATISTICS_LOG) { timer_start(handle->timer); LogStatistics(handle, "periodic logging almost every " MU_TOSTRING(TIME_BETWEEN_STATISTICS_LOG) " seconds"); } (void)InterlockedExchange64(&handle->lastCount_AcquireSRWLockExclusive, stop.QuadPart); } } } void srw_lock_release_exclusive(SRW_LOCK_HANDLE handle) { /*Codes_SRS_SRW_LOCK_02_009: [ If handle is NULL then srw_lock_release_exclusive shall return. ]*/ if (handle == NULL) { LogError("invalid argument SRW_LOCK_HANDLE handle=%p", handle); } else { if (!handle->doStatistics) { ReleaseSRWLockExclusive(&handle->lock); } else { LARGE_INTEGER start, stop; LARGE_INTEGER lastAcquireCount_exclusive_copy; lastAcquireCount_exclusive_copy.QuadPart = InterlockedAdd64(&handle->lastCount_AcquireSRWLockExclusive, 0); (void)QueryPerformanceCounter(&start); /*Codes_SRS_SRW_LOCK_02_010: [ srw_lock_release_exclusive shall call ReleaseSRWLockExclusive. ]*/ ReleaseSRWLockExclusive(&handle->lock); (void)QueryPerformanceCounter(&stop); /*measure release time*/ (void)InterlockedAdd64(&handle->totalCounts_ReleaseSRWLockExclusive, (stop.QuadPart - start.QuadPart)); (void)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockExclusive_and_ReleaseSRWLockExclusive, (stop.QuadPart - lastAcquireCount_exclusive_copy.QuadPart)); } } } void srw_lock_acquire_shared(SRW_LOCK_HANDLE handle) { /*Codes_SRS_SRW_LOCK_02_017: [ If handle is NULL then srw_lock_acquire_shared shall return. ]*/ if (handle == NULL) { LogError("invalid argument SRW_LOCK_HANDLE handle=%p", handle); } else { if (!handle->doStatistics) { AcquireSRWLockShared(&handle->lock); } else { LARGE_INTEGER start, stop; (void)QueryPerformanceCounter(&start); /*Codes_SRS_SRW_LOCK_02_018: [ srw_lock_acquire_shared shall call AcquireSRWLockShared. ]*/ AcquireSRWLockShared(&handle->lock); (void)QueryPerformanceCounter(&stop); /*measure acquire time*/ /*there is one more shared reader*/ /*is this the first reader?*/ if (InterlockedIncrement(&handle->nSharedReaders) == 1) { (void)InterlockedExchange64(&handle->firstCount_AcquireSRWLockShared, stop.QuadPart); } (void)InterlockedIncrement64(&handle->nCalls_AcquireSRWLockShared); (void)InterlockedAdd64(&handle->totalCounts_AcquireSRWLockShared, stop.QuadPart - start.QuadPart); /*Codes_SRS_SRW_LOCK_02_026: [ If do_statistics is true and the timer created has recorded more than TIME_BETWEEN_STATISTICS_LOG seconds then statistics will be logged and the timer shall be started again. ]*/ if (timer_get_elapsed(handle->timer) >= TIME_BETWEEN_STATISTICS_LOG) { timer_start(handle->timer); LogStatistics(handle, "periodic logging almost every " MU_TOSTRING(TIME_BETWEEN_STATISTICS_LOG) " seconds"); } } } } void srw_lock_release_shared(SRW_LOCK_HANDLE handle) { /*Codes_SRS_SRW_LOCK_02_020: [ If handle is NULL then srw_lock_release_shared shall return. ]*/ if (handle == NULL) { LogError("invalid argument SRW_LOCK_HANDLE handle=%p", handle); } else { if (!handle->doStatistics) { ReleaseSRWLockShared(&handle->lock); } else { LARGE_INTEGER start, stop; LARGE_INTEGER firstCount_AcquireSRWLockShared_copy; firstCount_AcquireSRWLockShared_copy.QuadPart = InterlockedAdd64(&handle->firstCount_AcquireSRWLockShared, 0); (void)QueryPerformanceCounter(&start); /*Codes_SRS_SRW_LOCK_02_021: [ srw_lock_release_shared shall call ReleaseSRWLockShared. ]*/ ReleaseSRWLockShared(&handle->lock); (void)QueryPerformanceCounter(&stop); /*measure release time*/ if (InterlockedDecrement(&handle->nSharedReaders) == 0) { (void)InterlockedAdd64(&handle->totalCountsBetween_AcquireSRWLockShared_and_ReleaseSRWLockShared, (stop.QuadPart - firstCount_AcquireSRWLockShared_copy.QuadPart)); } (void)InterlockedAdd64(&handle->totalCounts_ReleaseSRWLockShared, (stop.QuadPart - start.QuadPart)); } } } void srw_lock_destroy(SRW_LOCK_HANDLE handle) { /*Codes_SRS_SRW_LOCK_02_011: [ If handle is NULL then srw_lock_destroy shall return. ]*/ if (handle == NULL) { LogError("invalid arguments SRW_LOCK_HANDLE handle=%p", handle); } else { if (handle->doStatistics) { LogStatistics(handle, "srw_lock_destroy was called"); timer_destroy(handle->timer); free(handle->lockName); } /*Codes_SRS_SRW_LOCK_02_012: [ srw_lock_destroy shall free all used resources. ]*/ /*there's no deinit for a SRW, since it is a static construct*/ free(handle); } } string_utils.c000066400000000000000000000154431455573770000337770ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (C) Microsoft Corporation. All rights reserved. /*poor man's string routines*/ #include #include #include #include "windows.h" #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/string_utils.h" IMPLEMENT_MOCKABLE_FUNCTION(, char*, vsprintf_char, const char*, format, va_list, va) { char* result; int neededSize = vsnprintf(NULL, 0, format, va); if (neededSize < 0) { LogError("failure in vsnprintf"); result = NULL; } else { result = (char*)malloc(((unsigned long long)neededSize + 1) * sizeof(char)); if (result == NULL) { LogError("failure in malloc"); /*return as is*/ } else { if (vsnprintf(result, (unsigned long long)neededSize + 1, format, va) != neededSize) { LogError("inconsistent vsnprintf behavior"); free(result); result = NULL; } } } return result; } IMPLEMENT_MOCKABLE_FUNCTION(, wchar_t*, vsprintf_wchar, const wchar_t*, format, va_list, va) { wchar_t* result; int neededSize = vswprintf(NULL, 0, format, va); if (neededSize < 0) { LogError("failure in swprintf"); result = NULL; } else { result = (wchar_t*)malloc(((unsigned long long)neededSize + 1)*sizeof(wchar_t)); if (result == NULL) { LogError("failure in malloc"); /*return as is*/ } else { if (vswprintf(result, (unsigned long long)neededSize + 1, format, va) != neededSize) { LogError("inconsistent vswprintf behavior"); free(result); result = NULL; } } } return result; } /*returns a char* that is as if printed by printf*/ /*needs to be free'd after usage*/ char* sprintf_char_function(const char* format, ...) { char* result; va_list va; va_start(va, format); result = vsprintf_char(format, va); va_end(va); return result; } wchar_t* sprintf_wchar_function(const wchar_t* format, ...) { wchar_t* result; va_list va; va_start(va, format); result = vsprintf_wchar(format, va); va_end(va); return result; } /*takes a FILETIME, returns a nice string representation of it*/ char* FILETIME_toAsciiArray(const FILETIME* fileTime) { char* result; if (fileTime == NULL) { LogError("invalid argument const FILETIME* fileTime=%p", fileTime); result = NULL; } else { FILETIME localFileTime; if (FileTimeToLocalFileTime(fileTime, &localFileTime) == 0) { LogLastError("failure in FileTimeToLocalFileTime"); result = NULL; } else { SYSTEMTIME systemTime; if (FileTimeToSystemTime(&localFileTime, &systemTime) == 0) { LogLastError("failure in FileTimeToLocalFileTime"); result = NULL; } else { char localDate[255]; if (GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &systemTime, NULL, localDate, sizeof(localDate)/sizeof(localDate[0])) == 0) { LogLastError("failure in GetDateFormat"); result = NULL; } else { char localTime[255]; if (GetTimeFormat(LOCALE_USER_DEFAULT, 0, &systemTime, NULL, localTime, sizeof(localTime)/sizeof(localTime[0])) == 0) { LogLastError("failure in GetTimeFormat"); result = NULL; } else { result = sprintf_char("%s %s", localDate, localTime); /*return as is*/ } } } } } return result; } IMPLEMENT_MOCKABLE_FUNCTION(, wchar_t*, mbs_to_wcs, const char*, source) { wchar_t *result; if (source == NULL) { LogError("invalid argument const char* source=%s", MU_P_OR_NULL(source)); result = NULL; } else { const char* sameAsSource = source; /*assuming source is a multibyte character string*/ mbstate_t state = { 0 };/*initial state!*/ size_t nwc = mbsrtowcs(NULL, &sameAsSource, 0, &state); /*note 350 from C standard seems to indicate that NULL is a valid pointer to pass here*/ if (nwc == (size_t)(-1)) { LogError("failure to get the length of the string %s in multibyte characters", strerror(errno)); result = NULL; } else { result = (wchar_t*)malloc(sizeof(wchar_t)*(nwc+1)); if (result == NULL) { LogError("failure in malloc"); /*return as is*/ } else { size_t nwc2 = mbsrtowcs(result, &sameAsSource, nwc+1, &state); if (nwc2 != nwc) { LogError("unexpected inconsistency in mbsrtowcs"); } else { /*all is fine*/ goto allOk; } free(result); result = NULL; } allOk:; } } return result; } IMPLEMENT_MOCKABLE_FUNCTION(, char*, wcs_to_mbs, const wchar_t*, source) { char *result; if (source == NULL) { LogError("invalid argument const wchar_t* source=%ls", MU_WP_OR_NULL(source)); result = NULL; } else { const wchar_t* sameAsSource = source; mbstate_t state = { 0 };/*initial state!*/ size_t nc = wcsrtombs(NULL, &sameAsSource, 0, &state); if (nc == (size_t)(-1)) { LogError("failure to get the length of the string %s in characters", strerror(errno)); result = NULL; } else { result = (char*)malloc(sizeof(char)*(nc + 1)); if (result == NULL) { LogError("failure in malloc"); /*return as is*/ } else { size_t nc2 = wcsrtombs(result, &sameAsSource, nc + 1, &state); if (nc2 != nc) { LogError("unexpected inconsistency in wcsrtombs"); } else { /*all is fine*/ goto allOk; } free(result); result = NULL; } allOk:; } } return result; } tcpsocketconnection_c.cpp000066400000000000000000000044541455573770000361720ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "mbed.h" #include #include "TCPSocketConnection.h" #include "azure_c_shared_utility/tcpsocketconnection_c.h" TCPSOCKETCONNECTION_HANDLE tcpsocketconnection_create(void) { return new TCPSocketConnection(); } void tcpsocketconnection_set_blocking(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, bool blocking, unsigned int timeout) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; tsc->set_blocking(blocking, timeout); } void tcpsocketconnection_destroy(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle) { delete (TCPSocketConnection*)tcpSocketConnectionHandle; } int tcpsocketconnection_connect(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, const char* host, const int port) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; return tsc->connect(host, port); } bool tcpsocketconnection_is_connected(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; return tsc->is_connected(); } void tcpsocketconnection_close(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; tsc->close(); } int tcpsocketconnection_send(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, const char* data, int length) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; return tsc->send((char*)data, length); } int tcpsocketconnection_send_all(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, const char* data, int length) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; return tsc->send_all((char*)data, length); } int tcpsocketconnection_receive(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, char* data, int length) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; return tsc->receive(data, length); } int tcpsocketconnection_receive_all(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, char* data, int length) { TCPSocketConnection* tsc = (TCPSocketConnection*)tcpSocketConnectionHandle; return tsc->receive_all(data, length); } tcpsocketconnection_mbed_os5.cpp000066400000000000000000000057521455573770000374470ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "mbed.h" #include #include "TCPSocket.h" #include "azure_c_shared_utility/tcpsocketconnection_c.h" // The NetworkInterface instance of network device extern NetworkInterface *_defaultSystemNetwork; static volatile bool tcpsocketconnection_isConnected = false; TCPSOCKETCONNECTION_HANDLE tcpsocketconnection_create(void) { TCPSocket* tcpSocket = new TCPSocket(); tcpSocket->open(_defaultSystemNetwork); return tcpSocket; } void tcpsocketconnection_set_blocking(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, bool blocking, unsigned int timeout) { if (tcpSocketConnectionHandle != NULL) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; tsc->set_blocking(blocking); tsc->set_timeout(timeout); } } void tcpsocketconnection_destroy(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle) { if (tcpSocketConnectionHandle != NULL) { delete (TCPSocket*)tcpSocketConnectionHandle; } } int tcpsocketconnection_connect(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, const char* host, const int port) { int ret = 0; if (tcpSocketConnectionHandle != NULL && !tcpsocketconnection_isConnected) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; if ( (ret = tsc->connect(host, port)) == 0) { tcpsocketconnection_isConnected = true; } } return ret; } bool tcpsocketconnection_is_connected(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; return tcpsocketconnection_isConnected; } void tcpsocketconnection_close(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle) { if (tcpSocketConnectionHandle != NULL && tcpsocketconnection_isConnected) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; tsc->close(); tcpsocketconnection_isConnected = false; } } int tcpsocketconnection_send(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, const char* data, int length) { if (tcpSocketConnectionHandle != NULL) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; return tsc->send((char*)data, length); } return -1; } int tcpsocketconnection_send_all(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, const char* data, int length) { if (tcpSocketConnectionHandle != NULL) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; return tsc->send((char*)data, length); } return -1; } int tcpsocketconnection_receive(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, char* data, int length) { if (tcpSocketConnectionHandle != NULL) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; return tsc->recv(data, length); } return -1; } int tcpsocketconnection_receive_all(TCPSOCKETCONNECTION_HANDLE tcpSocketConnectionHandle, char* data, int length) { if (tcpSocketConnectionHandle != NULL) { TCPSocket* tsc = (TCPSocket*)tcpSocketConnectionHandle; return tsc->recv(data, length); } return -1; } threadapi_pthreads.c000066400000000000000000000072001455573770000350740ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #define _DEFAULT_SOURCE #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/threadapi.h" #include #include #include #ifdef TI_RTOS #include #else #include #endif #include #include #include "azure_c_shared_utility/xlogging.h" MU_DEFINE_ENUM_STRINGS(THREADAPI_RESULT, THREADAPI_RESULT_VALUES); typedef struct THREAD_INSTANCE_TAG { pthread_t Pthread_handle; THREAD_START_FUNC ThreadStartFunc; void* Arg; } THREAD_INSTANCE; static void* ThreadWrapper(void* threadInstanceArg) { THREAD_INSTANCE* threadInstance = (THREAD_INSTANCE*)threadInstanceArg; int result = threadInstance->ThreadStartFunc(threadInstance->Arg); return (void*)(intptr_t)result; } THREADAPI_RESULT ThreadAPI_Create(THREAD_HANDLE* threadHandle, THREAD_START_FUNC func, void* arg) { THREADAPI_RESULT result; if ((threadHandle == NULL) || (func == NULL)) { result = THREADAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { THREAD_INSTANCE* threadInstance = malloc(sizeof(THREAD_INSTANCE)); if (threadInstance == NULL) { result = THREADAPI_NO_MEMORY; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { threadInstance->ThreadStartFunc = func; threadInstance->Arg = arg; int createResult = pthread_create(&threadInstance->Pthread_handle, NULL, ThreadWrapper, threadInstance); switch (createResult) { default: free(threadInstance); result = THREADAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); break; case 0: *threadHandle = threadInstance; result = THREADAPI_OK; break; case EAGAIN: free(threadInstance); result = THREADAPI_NO_MEMORY; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); break; } } } return result; } THREADAPI_RESULT ThreadAPI_Join(THREAD_HANDLE threadHandle, int* res) { THREADAPI_RESULT result; THREAD_INSTANCE* threadInstance = (THREAD_INSTANCE*)threadHandle; if (threadInstance == NULL) { result = THREADAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { void* threadResult; if (pthread_join(threadInstance->Pthread_handle, &threadResult) != 0) { result = THREADAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { if (res != NULL) { *res = (int)(intptr_t)threadResult; } result = THREADAPI_OK; } free(threadInstance); } return result; } void ThreadAPI_Exit(int res) { pthread_exit((void*)(intptr_t)res); } void ThreadAPI_Sleep(unsigned int milliseconds) { #ifdef TI_RTOS Task_sleep(milliseconds); #else time_t seconds = milliseconds / 1000; long nsRemainder = (milliseconds % 1000) * 1000000; struct timespec timeToSleep = { seconds, nsRemainder }; (void)nanosleep(&timeToSleep, NULL); #endif } threadapi_rtx_mbed.cpp000066400000000000000000000074031455573770000354330ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/threadapi.h" #include "azure_c_shared_utility/xlogging.h" #include "rtos.h" MU_DEFINE_ENUM_STRINGS(THREADAPI_RESULT, THREADAPI_RESULT_VALUES); #define MAX_THREADS 4 #define STACK_SIZE 0x4000 typedef struct _thread { Thread* thrd; osThreadId id; Queue result; } mbedThread; static mbedThread threads[MAX_THREADS] = { 0 }; typedef struct _create_param { THREAD_START_FUNC func; const void* arg; mbedThread *p_thread; } create_param; static void thread_wrapper(const void* createParamArg) { const create_param* p = (const create_param*)createParamArg; p->p_thread->id = Thread::gettid(); (*(p->func))((void*)p->arg); free((void*)p); } THREADAPI_RESULT ThreadAPI_Create(THREAD_HANDLE* threadHandle, THREAD_START_FUNC func, void* arg) { THREADAPI_RESULT result; if ((threadHandle == NULL) || (func == NULL)) { result = THREADAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { size_t slot; for (slot = 0; slot < MAX_THREADS; slot++) { if (threads[slot].id == NULL) break; } if (slot < MAX_THREADS) { create_param* param = (create_param*)malloc(sizeof(create_param)); if (param != NULL) { param->func = func; param->arg = arg; param->p_thread = threads + slot; threads[slot].thrd = new Thread(thread_wrapper, param, osPriorityNormal, STACK_SIZE); *threadHandle = (THREAD_HANDLE)(threads + slot); result = THREADAPI_OK; } else { result = THREADAPI_NO_MEMORY; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } } else { result = THREADAPI_NO_MEMORY; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } } return result; } THREADAPI_RESULT ThreadAPI_Join(THREAD_HANDLE thr, int *res) { THREADAPI_RESULT result = THREADAPI_OK; mbedThread* p = (mbedThread*)thr; if (p) { osEvent evt = p->result.get(); if (evt.status == osEventMessage) { Thread* t = p->thrd; if (res) { *res = (int)evt.value.p; } (void)t->terminate(); } else { result = THREADAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } } else { result = THREADAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } return result; } void ThreadAPI_Exit(int res) { mbedThread* p; for (p = threads; p < &threads[MAX_THREADS]; p++) { if (p->id == Thread::gettid()) { p->result.put((int*)res); break; } } } void ThreadAPI_Sleep(unsigned int millisec) { // // The timer on mbed seems to wrap around 65 seconds. Hmmm. // So we will do our waits in increments of 30 seconds. // const int thirtySeconds = 30000; int numberOfThirtySecondWaits = millisec / thirtySeconds; int remainderOfThirtySeconds = millisec % thirtySeconds; int i; for (i = 1; i <= numberOfThirtySecondWaits; i++) { Thread::wait(thirtySeconds); } Thread::wait(remainderOfThirtySeconds); } threadapi_win32.c000066400000000000000000000046571455573770000342410ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "windows.h" #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/threadapi.h" #include "azure_c_shared_utility/xlogging.h" MU_DEFINE_ENUM_STRINGS(THREADAPI_RESULT, THREADAPI_RESULT_VALUES); THREADAPI_RESULT ThreadAPI_Create(THREAD_HANDLE* threadHandle, THREAD_START_FUNC func, void* arg) { THREADAPI_RESULT result; if ((threadHandle == NULL) || (func == NULL)) { result = THREADAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { *threadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, arg, 0, NULL); if(*threadHandle == NULL) { result = (GetLastError() == ERROR_OUTOFMEMORY) ? THREADAPI_NO_MEMORY : THREADAPI_ERROR; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { result = THREADAPI_OK; } } return result; } THREADAPI_RESULT ThreadAPI_Join(THREAD_HANDLE threadHandle, int *res) { THREADAPI_RESULT result = THREADAPI_OK; if (threadHandle == NULL) { result = THREADAPI_INVALID_ARG; LogError("(result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(THREADAPI_RESULT, result)); } else { DWORD returnCode = WaitForSingleObject(threadHandle, INFINITE); if( returnCode != WAIT_OBJECT_0) { result = THREADAPI_ERROR; LogError("Error waiting for Single Object. Return Code: %d. Error Code: %d", returnCode, result); } else { if (res != NULL) { DWORD exit_code; if (!GetExitCodeThread(threadHandle, &exit_code)) //If thread end is signaled we need to get the Thread Exit Code; { result = THREADAPI_ERROR; LogError("Error Getting Exit Code. Error Code: %u.", (unsigned int)GetLastError()); } else { *res = (int)exit_code; } } } CloseHandle(threadHandle); } return result; } void ThreadAPI_Exit(int res) { ExitThread(res); } void ThreadAPI_Sleep(unsigned int milliseconds) { Sleep(milliseconds); } tickcounter_linux.c000066400000000000000000000037331455573770000350210ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/gballoc.h" #include #include "azure_c_shared_utility/tickcounter.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "linux_time.h" typedef struct TICK_COUNTER_INSTANCE_TAG { int64_t init_time_value; tickcounter_ms_t current_ms; } TICK_COUNTER_INSTANCE; TICK_COUNTER_HANDLE tickcounter_create(void) { TICK_COUNTER_INSTANCE* result = (TICK_COUNTER_INSTANCE*)malloc(sizeof(TICK_COUNTER_INSTANCE)); if (result != NULL) { set_time_basis(); result->init_time_value = get_time_ms(); if (result->init_time_value == INVALID_TIME_VALUE) { LogError("tickcounter failed: time return INVALID_TIME."); free(result); result = NULL; } else { result->current_ms = 0; } } return result; } void tickcounter_destroy(TICK_COUNTER_HANDLE tick_counter) { if (tick_counter != NULL) { free(tick_counter); } } int tickcounter_get_current_ms(TICK_COUNTER_HANDLE tick_counter, tickcounter_ms_t * current_ms) { int result; if (tick_counter == NULL || current_ms == NULL) { LogError("tickcounter failed: Invalid Arguments."); result = MU_FAILURE; } else { int64_t time_value = get_time_ms(); if (time_value == INVALID_TIME_VALUE) { result = MU_FAILURE; } else { TICK_COUNTER_INSTANCE* tick_counter_instance = (TICK_COUNTER_INSTANCE*)tick_counter; tick_counter_instance->current_ms = (tickcounter_ms_t) time_value - tick_counter_instance->init_time_value; *current_ms = tick_counter_instance->current_ms; result = 0; } } return result; } tickcounter_mbed.cpp000066400000000000000000000026401455573770000351250ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "mbed.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/tickcounter.h" class TICK_COUNTER_INSTANCE_TAG { public: clock_t last_clock_value; tickcounter_ms_t current_ms; }; TICK_COUNTER_HANDLE tickcounter_create(void) { TICK_COUNTER_INSTANCE_TAG* result; result = new TICK_COUNTER_INSTANCE_TAG(); result->last_clock_value = clock(); result->current_ms = result->last_clock_value * 1000 / CLOCKS_PER_SEC; return result; } void tickcounter_destroy(TICK_COUNTER_HANDLE tick_counter) { if (tick_counter != NULL) { delete tick_counter; } } int tickcounter_get_current_ms(TICK_COUNTER_HANDLE tick_counter, tickcounter_ms_t * current_ms) { int result; if (tick_counter == NULL || current_ms == NULL) { result = MU_FAILURE; } else { TICK_COUNTER_INSTANCE_TAG* tick_counter_instance = (TICK_COUNTER_INSTANCE_TAG*)tick_counter; clock_t clock_value = clock(); tick_counter_instance->current_ms += (clock_value - tick_counter_instance->last_clock_value) * 1000 / CLOCKS_PER_SEC; tick_counter_instance->last_clock_value = clock_value; *current_ms = tick_counter_instance->current_ms; result = 0; } return result; } tickcounter_mbed_os5.cpp000066400000000000000000000044211455573770000357120ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "mbed.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/tickcounter.h" //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // The tick counter from mbed OS will be overflow (go back to zero) after approximately 70 minutes (4294s). // So here extend the tick counter 64bit. static Ticker *cycle_ticker = NULL; static volatile uint32_t last_ticker_us = 0; static volatile uint64_t long_ticker_ms = 0; #define TICKER_INTERVAL 60.0 static uint64_t system_tick_counter_read(void) { uint64_t result; uint32_t t; core_util_critical_section_enter(); t = us_ticker_read(); if (t < last_ticker_us) { // overflowed long_ticker_ms += 0xFFFFFFFF / 1000; } last_ticker_us = t; result = long_ticker_ms + t / 1000; core_util_critical_section_exit(); return result; } static void cycle_accumulator(void) { system_tick_counter_read(); } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // The tickcounter typedef struct TICK_COUNTER_INSTANCE_TAG { uint64_t current_ms; } TICK_COUNTER_INSTANCE; TICK_COUNTER_HANDLE tickcounter_create(void) { core_util_critical_section_enter(); if (cycle_ticker == NULL) { cycle_ticker = new Ticker(); cycle_ticker->attach(cycle_accumulator, TICKER_INTERVAL); } core_util_critical_section_exit(); TICK_COUNTER_INSTANCE *result; result = new TICK_COUNTER_INSTANCE; result->current_ms = system_tick_counter_read(); return result; } void tickcounter_destroy(TICK_COUNTER_HANDLE tick_counter) { if (tick_counter != NULL) { delete tick_counter; } } int tickcounter_get_current_ms(TICK_COUNTER_HANDLE tick_counter, tickcounter_ms_t *current_ms) { int result; if (tick_counter == NULL || current_ms == NULL) { result = MU_FAILURE; } else { tick_counter->current_ms = system_tick_counter_read(); *current_ms = tick_counter->current_ms; result = 0; } return result; } tickcounter_tirtos.c000066400000000000000000000037601455573770000352060ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "azure_c_shared_utility/gballoc.h" #include #include #include "azure_c_shared_utility/tickcounter.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #define INVALID_TIME_VALUE (time_t)(-1) typedef struct TICK_COUNTER_INSTANCE_TAG { time_t init_time_value; tickcounter_ms_t current_ms; } TICK_COUNTER_INSTANCE; TICK_COUNTER_HANDLE tickcounter_create(void) { TICK_COUNTER_INSTANCE* result = (TICK_COUNTER_INSTANCE*)malloc(sizeof(TICK_COUNTER_INSTANCE)); if (result != NULL) { result->init_time_value = time(NULL); if (result->init_time_value == INVALID_TIME_VALUE) { LogError("tickcounter failed: time return INVALID_TIME."); free(result); result = NULL; } else { result->current_ms = 0; } } return result; } void tickcounter_destroy(TICK_COUNTER_HANDLE tick_counter) { if (tick_counter != NULL) { free(tick_counter); } } int tickcounter_get_current_ms(TICK_COUNTER_HANDLE tick_counter, tickcounter_ms_t * current_ms) { int result; if (tick_counter == NULL || current_ms == NULL) { LogError("tickcounter failed: Invalid Arguments."); result = MU_FAILURE; } else { time_t time_value = time(NULL); if (time_value == INVALID_TIME_VALUE) { result = MU_FAILURE; } else { TICK_COUNTER_INSTANCE* tick_counter_instance = (TICK_COUNTER_INSTANCE*)tick_counter; tick_counter_instance->current_ms = (tickcounter_ms_t)(difftime(time_value, tick_counter_instance->init_time_value) * 1000); *current_ms = tick_counter_instance->current_ms; result = 0; } } return result; } tickcounter_win32.c000066400000000000000000000076101455573770000346220ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/tickcounter.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #define INVALID_TIME_VALUE (time_t)(-1) typedef struct TICK_COUNTER_INSTANCE_TAG { LARGE_INTEGER perf_freqency; LARGE_INTEGER last_perf_counter; time_t backup_time_value; tickcounter_ms_t current_ms; } TICK_COUNTER_INSTANCE; TICK_COUNTER_HANDLE tickcounter_create(void) { TICK_COUNTER_INSTANCE* result = (TICK_COUNTER_INSTANCE*)malloc(sizeof(TICK_COUNTER_INSTANCE)); if (result != NULL) { if (!QueryPerformanceFrequency(&result->perf_freqency)) { result->backup_time_value = time(NULL); if (result->backup_time_value == INVALID_TIME_VALUE) { LogError("tickcounter failed: time return INVALID_TIME."); free(result); result = NULL; } else { result->current_ms = 0; } } else { if (!QueryPerformanceCounter(&result->last_perf_counter)) { LogError("tickcounter failed: QueryPerformanceCounter failed %d.", GetLastError()); free(result); result = NULL; } else { result->backup_time_value = INVALID_TIME_VALUE; result->current_ms = 0; } } } return result; } void tickcounter_destroy(TICK_COUNTER_HANDLE tick_counter) { if (tick_counter != NULL) { free(tick_counter); } } int tickcounter_get_current_ms(TICK_COUNTER_HANDLE tick_counter, tickcounter_ms_t* current_ms) { int result; if (tick_counter == NULL || current_ms == NULL) { LogError("tickcounter failed: Invalid Arguments."); result = MU_FAILURE; } else { TICK_COUNTER_INSTANCE* tick_counter_instance = (TICK_COUNTER_INSTANCE*)tick_counter; if (tick_counter_instance->backup_time_value == INVALID_TIME_VALUE) { // If the QueryPerformanceCounter is available use this LARGE_INTEGER curr_perf_item; if (!QueryPerformanceCounter(&curr_perf_item)) { LogError("tickcounter failed: QueryPerformanceCounter failed %d.", GetLastError() ); result = MU_FAILURE; } else { LARGE_INTEGER perf_in_ms; LONGLONG remainder; perf_in_ms.QuadPart = (curr_perf_item.QuadPart - tick_counter_instance->last_perf_counter.QuadPart) * 1000000; remainder = (perf_in_ms.QuadPart % tick_counter_instance->perf_freqency.QuadPart) / 1000000; perf_in_ms.QuadPart /= tick_counter_instance->perf_freqency.QuadPart; tick_counter_instance->current_ms += perf_in_ms.QuadPart; tick_counter_instance->last_perf_counter = curr_perf_item; tick_counter_instance->last_perf_counter.QuadPart -= remainder; *current_ms = tick_counter_instance->current_ms / 1000; result = 0; } } else { time_t time_value = time(NULL); if (time_value == INVALID_TIME_VALUE) { result = MU_FAILURE; } else { tick_counter_instance->current_ms = (tickcounter_ms_t)(difftime(time_value, tick_counter_instance->backup_time_value) * 1000); *current_ms = tick_counter_instance->current_ms; result = 0; } } } return result; } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/timer.c000066400000000000000000000040771455573770000324510ustar00rootroot00000000000000// Copyright (C) Microsoft Corporation. All rights reserved. #include "windows.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/timer.h" typedef struct TIMER_HANDLE_DATA_TAG { LARGE_INTEGER freq; LARGE_INTEGER startTime; }TIMER_HANDLE_DATA; TIMER_HANDLE timer_create(void) { TIMER_HANDLE result; result = malloc(sizeof(TIMER_HANDLE_DATA)); if (result == NULL) { LogError("failure in malloc"); /*return as is*/ } else { (void)QueryPerformanceFrequency(&(result->freq)); /* from MSDN: On systems that run Windows XP or later, the function will always succeed and will thus never return zero.*/ /*return as is*/ (void)QueryPerformanceCounter(&(result->startTime)); /*from MSDN: On systems that run Windows XP or later, the function will always succeed and will thus never return zero.*/ } return result; } void timer_start(TIMER_HANDLE timer) { if (timer == NULL) { LogError("invalid arg TIMER_HANDLE timer=%p", timer); } else { (void)QueryPerformanceCounter(&(timer->startTime)); /*from MSDN: On systems that run Windows XP or later, the function will always succeed and will thus never return zero.*/ } } double timer_get_elapsed(TIMER_HANDLE timer) { double result; if (timer == NULL) { LogError("invalid arg TIMER_HANDLE timer=%p", timer); result = -1.0; } else { LARGE_INTEGER stopTime; (void)QueryPerformanceCounter(&stopTime); result = ((double)(stopTime.QuadPart - timer->startTime.QuadPart) / (double)timer->freq.QuadPart); } return result; } double timer_get_elapsed_ms(TIMER_HANDLE timer) { double result = timer_get_elapsed(timer); return result < 0 ? result : result * 1000; } void timer_destroy(TIMER_HANDLE timer) { if (timer == NULL) { LogError("invalid arg TIMER_HANDLE timer=%p", timer); } else { free(timer); } } tlsio_bearssl.c000066400000000000000000001570461455573770000341240ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. // Portions of this code are based upon code in BearSSL. License included below. /* * Copyright (c) 2017 Thomas Pornin * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include #include "bearssl.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/singlylinkedlist.h" #include "azure_c_shared_utility/vector.h" #include "azure_c_shared_utility/buffer_.h" #include "azure_c_shared_utility/tlsio_bearssl.h" static const char *const OPTION_UNDERLYING_IO_OPTIONS = "underlying_io_options"; typedef enum TLSIO_STATE_ENUM_TAG { TLSIO_STATE_NOT_OPEN, TLSIO_STATE_OPENING_UNDERLYING_IO, TLSIO_STATE_IN_HANDSHAKE, TLSIO_STATE_OPEN, TLSIO_STATE_CLOSING, TLSIO_STATE_ERROR } TLSIO_STATE_ENUM; typedef struct PENDING_TLS_IO_TAG { unsigned char* bytes; size_t size; ON_SEND_COMPLETE on_send_complete; void* callback_context; SINGLYLINKEDLIST_HANDLE pending_io_list; } PENDING_TLS_IO; typedef struct { int key_type; /* BR_KEYTYPE_RSA or BR_KEYTYPE_EC */ union { br_rsa_private_key rsa; br_ec_private_key ec; } key; } private_key; typedef struct TLS_IO_INSTANCE_TAG { XIO_HANDLE socket_io; ON_BYTES_RECEIVED on_bytes_received; ON_IO_OPEN_COMPLETE on_io_open_complete; ON_IO_CLOSE_COMPLETE on_io_close_complete; ON_IO_ERROR on_io_error; void *on_bytes_received_context; void *on_io_open_complete_context; void *on_io_close_complete_context; void *on_io_error_context; TLSIO_STATE_ENUM tlsio_state; unsigned char *socket_io_read_bytes; size_t socket_io_read_byte_count; ON_SEND_COMPLETE on_send_complete; void *on_send_complete_callback_context; SINGLYLINKEDLIST_HANDLE pending_toencrypt_list; SINGLYLINKEDLIST_HANDLE pending_todecrypt_list; br_ssl_client_context sc; br_x509_minimal_context xc; br_sslio_context ioc; br_x509_trust_anchor *tas; br_x509_certificate *x509_cert; size_t x509_cert_len; private_key *x509_pk; size_t ta_count; char *trusted_certificates; char *x509_certificate; char *x509_private_key; unsigned char iobuf[BR_SSL_BUFSIZE_BIDI]; char *hostname; } TLS_IO_INSTANCE; typedef struct { char *name; unsigned char *data; size_t data_len; } pem_object; static void indicate_error(TLS_IO_INSTANCE *tls_io_instance) { if ((tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) || (tls_io_instance->tlsio_state == TLSIO_STATE_ERROR)) { return; } tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_error != NULL) { tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } } static void indicate_open_complete(TLS_IO_INSTANCE *tls_io_instance, IO_OPEN_RESULT open_result) { if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, open_result); } } static int add_pending_operation(SINGLYLINKEDLIST_HANDLE list, const unsigned char *buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void *context) { int result; PENDING_TLS_IO* pending_tls_io = (PENDING_TLS_IO*)malloc(sizeof(PENDING_TLS_IO)); if (pending_tls_io == NULL) { result = MU_FAILURE; } else { pending_tls_io->bytes = (unsigned char*)malloc(size); if (pending_tls_io->bytes == NULL) { LogError("Allocation Failure: Unable to allocate pending list."); free(pending_tls_io); result = MU_FAILURE; } else { pending_tls_io->size = size; pending_tls_io->on_send_complete = on_send_complete; pending_tls_io->callback_context = context; (void)memcpy(pending_tls_io->bytes, buffer, size); if (singlylinkedlist_add(list, pending_tls_io) == NULL) { LogError("Failure: Unable to add tls io to pending list."); free(pending_tls_io->bytes); free(pending_tls_io); result = MU_FAILURE; } else { result = 0; } } } return result; } static void on_underlying_io_open_complete(void *context, IO_OPEN_RESULT open_result) { if (context == NULL) { LogError("Invalid context NULL value passed"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; if (open_result != IO_OPEN_OK) { xio_close(tls_io_instance->socket_io, NULL, NULL); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); } else { tls_io_instance->tlsio_state = TLSIO_STATE_IN_HANDSHAKE; } } } static void on_underlying_io_bytes_received(void *context, const unsigned char *buffer, size_t size) { if (context != NULL) { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; // Dump this on the queue and let dowork deal with it add_pending_operation(tls_io_instance->pending_todecrypt_list, buffer, size, NULL, NULL); } } static void on_underlying_io_error(void *context) { if (context == NULL) { LogError("Invalid context NULL value passed"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; switch (tls_io_instance->tlsio_state) { default: case TLSIO_STATE_NOT_OPEN: case TLSIO_STATE_ERROR: break; case TLSIO_STATE_OPENING_UNDERLYING_IO: case TLSIO_STATE_IN_HANDSHAKE: xio_close(tls_io_instance->socket_io, NULL, NULL); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); break; case TLSIO_STATE_OPEN: indicate_error(tls_io_instance); break; } } } static void on_underlying_io_close_complete_during_close(void *context) { if (context == NULL) { LogError("NULL value passed in context"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; if (tls_io_instance->on_io_close_complete != NULL) { tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context); } } } static void vblob_append(void *cc, const void *data, size_t len) { int result = BUFFER_append_build((BUFFER_HANDLE)cc, (const unsigned char *)data, len); if (result != 0) { // Unfortunately the design does not allow for this error to be passed back LogError("Failed to reallocate pem decode buffer"); } } VECTOR_HANDLE decode_pem(const void *src, size_t len) { VECTOR_HANDLE pem_list; br_pem_decoder_context pc; pem_object po; //pem_object *pos; const unsigned char *buf; BUFFER_HANDLE bv = NULL; int inobj; int extra_nl; size_t i; pem_list = VECTOR_create(sizeof(pem_object)); if (pem_list == NULL) { LogError("Unable to allocate vectore to decode PEM"); } else { br_pem_decoder_init(&pc); buf = src; inobj = 0; po.name = NULL; po.data = NULL; po.data_len = 0; extra_nl = 1; while (len > 0) { size_t tlen; tlen = br_pem_decoder_push(&pc, buf, len); buf += tlen; len -= tlen; switch (br_pem_decoder_event(&pc)) { case BR_PEM_BEGIN_OBJ: inobj = 1; if (0 != mallocAndStrcpy_s(&po.name, br_pem_decoder_name(&pc))) { LogError("Unable to allocate memory for certificate name"); break; } bv = BUFFER_new(); if (bv == NULL) { LogError("Unable to allocate buffer to decode pem"); len = 0; extra_nl = 0; } else { br_pem_decoder_setdest(&pc, vblob_append, bv); } break; case BR_PEM_END_OBJ: if (inobj) { po.data = BUFFER_u_char(bv); po.data_len = BUFFER_length(bv); free(bv); VECTOR_push_back(pem_list, &po, 1); po.name = NULL; po.data = NULL; po.data_len = 0; inobj = 0; } break; case BR_PEM_ERROR: LogError("ERROR: invalid PEM encoding"); inobj = 1; break; } /* * We add an extra newline at the end, in order to * support PEM files that lack the newline on their last * line (this is somewhat invalid, but PEM format is not * standardised and such files do exist in the wild, so * we'd better accept them). */ if (len == 0 && extra_nl) { extra_nl = 0; buf = (const unsigned char *)"\n"; len = 1; } } if (inobj) { LogError("Unable to decode pem"); for (i = 0; i < VECTOR_size(pem_list); i++) { free(((pem_object *)VECTOR_element(pem_list, i))->name); free(((pem_object *)VECTOR_element(pem_list, i))->data); } VECTOR_clear(pem_list); free(po.name); BUFFER_delete(bv); pem_list = NULL; } } return pem_list; } static void free_private_key(private_key *privkey) { switch (privkey->key_type) { case BR_KEYTYPE_RSA: free(privkey->key.rsa.iq); free(privkey->key.rsa.dq); free(privkey->key.rsa.dp); free(privkey->key.rsa.q); free(privkey->key.rsa.p); break; case BR_KEYTYPE_EC: free(privkey->key.ec.x); break; default: LogError("Unknown private key type %d", privkey->key_type); } } static private_key *decode_key(const unsigned char *buf, size_t len) { br_skey_decoder_context dc; int result; private_key *sk; int curve; uint32_t supp; br_skey_decoder_init(&dc); br_skey_decoder_push(&dc, buf, len); result = br_skey_decoder_last_error(&dc); if (result != 0) { LogError("Error decoding private key: %d", result); sk = NULL; } else { switch (br_skey_decoder_key_type(&dc)) { const br_rsa_private_key *rk; const br_ec_private_key *ek; case BR_KEYTYPE_RSA: rk = br_skey_decoder_get_rsa(&dc); if (NULL == (sk = (private_key *)malloc(sizeof *sk))) { LogError("Failed to allocate memory for RSA key structure"); } else { memset(sk, 0, sizeof(private_key)); if ( NULL == (sk->key.rsa.p = (unsigned char *)malloc(rk->plen)) || NULL == (sk->key.rsa.q = (unsigned char *)malloc(rk->plen)) || NULL == (sk->key.rsa.dp = (unsigned char *)malloc(rk->plen)) || NULL == (sk->key.rsa.dq = (unsigned char *)malloc(rk->plen)) || NULL == (sk->key.rsa.iq = (unsigned char *)malloc(rk->plen)) ) { LogError("Failed to allocate memory for RSA key structure"); free_private_key(sk); sk = NULL; } else { sk->key_type = BR_KEYTYPE_RSA; sk->key.rsa.n_bitlen = rk->n_bitlen; sk->key.rsa.plen = rk->plen; sk->key.rsa.qlen = rk->qlen; sk->key.rsa.dplen = rk->dplen; sk->key.rsa.dqlen = rk->dqlen; sk->key.rsa.iqlen = rk->iqlen; memcpy(sk->key.rsa.p, rk->p, rk->plen); memcpy(sk->key.rsa.q, rk->q, rk->qlen); memcpy(sk->key.rsa.dp, rk->dp, rk->dplen); memcpy(sk->key.rsa.dq, rk->dq, rk->dqlen); memcpy(sk->key.rsa.iq, rk->iq, rk->iqlen); } } break; case BR_KEYTYPE_EC: ek = br_skey_decoder_get_ec(&dc); if (NULL == (sk = (private_key *)malloc(sizeof *sk))) { LogError("Failed to allocate memory for EC key structure"); } else { memset(sk, 0, sizeof(private_key)); if (NULL == (sk->key.ec.x = (unsigned char *)malloc(ek->xlen))) { LogError("Failed to allocate memory for EC key structure"); free(sk); sk = NULL; } else { sk->key_type = BR_KEYTYPE_EC; sk->key.ec.curve = ek->curve; memcpy(sk->key.ec.x, ek->x, ek->xlen); sk->key.ec.xlen = ek->xlen; curve = sk->key.ec.curve; supp = br_ec_get_default()->supported_curves; if (curve > 31 || !((supp >> curve) & 1)) { LogError("Private key curve (%d) is not supported\n", curve); free_private_key(sk); free(sk); sk = NULL; } } } break; default: LogError("Unknown key type: %d", br_skey_decoder_key_type(&dc)); sk = NULL; break; } } return sk; } static private_key *read_private_key(const unsigned char *buf, size_t len) { static const char RSA_PRIVATE_KEY[] = "RSA PRIVATE KEY"; static const char EC_PRIVATE_KEY[] = "EC PRIVATE KEY"; static const char PRIVATE_KEY[] = "PRIVATE KEY"; static const int RSA_PRIVATE_KEY_LENGTH = sizeof(RSA_PRIVATE_KEY) - 1; static const int EC_PRIVATE_KEY_LENGTH = sizeof(EC_PRIVATE_KEY) - 1; static const int PRIVATE_KEY_LENGTH = sizeof(PRIVATE_KEY) - 1; private_key *sk = NULL; VECTOR_HANDLE pos; // vector of pem_object pem_object *work; size_t u; pos = decode_pem(buf, len); if (pos != NULL) { for (u = 0; u < VECTOR_size(pos); u++) { work = (pem_object *)VECTOR_element(pos, u); if (0 == memcmp(work->name, RSA_PRIVATE_KEY, RSA_PRIVATE_KEY_LENGTH) || 0 == memcmp(work->name, EC_PRIVATE_KEY, EC_PRIVATE_KEY_LENGTH) || 0 == memcmp(work->name, RSA_PRIVATE_KEY, RSA_PRIVATE_KEY_LENGTH)) { sk = decode_key(work->data, work->data_len); break; } } if (u >= VECTOR_size(pos)) { LogError("No private key found in X.509 private key option"); sk = NULL; } for (u = 0; u < VECTOR_size(pos); u++) { free(((pem_object *)VECTOR_element(pos, u))->name); free(((pem_object *)VECTOR_element(pos, u))->data); } VECTOR_destroy(pos); } else { sk = NULL; } return sk; } static VECTOR_HANDLE read_certificates_string(const char *buf, size_t len) { VECTOR_HANDLE cert_list; //(br_x509_certificate) cert_list = VEC_INIT; VECTOR_HANDLE pem_list; size_t u; int result = 0; static const char CERTIFICATE[] = "CERTIFICATE"; static const char X509_CERTIFICATE[] = "X509 CERTIFICATE"; static const int CERTIFICATE_LEN = sizeof(CERTIFICATE) - 1; static const int X509_CERTIFICATE_LEN = sizeof(X509_CERTIFICATE) - 1; cert_list = VECTOR_create(sizeof(br_x509_certificate)); if (cert_list == NULL) { LogError("Unable to allocate memory to decode pem strings"); VECTOR_destroy(cert_list); cert_list = NULL; } else { pem_list = decode_pem(buf, len); if (pem_list == NULL) { LogError("Failed to decode pem"); VECTOR_destroy(cert_list); cert_list = NULL; } else { for (u = 0; u < VECTOR_size(pem_list); u++) { if (0 == memcmp(CERTIFICATE, ((pem_object *)VECTOR_element(pem_list, u))->name, CERTIFICATE_LEN) || 0 == memcmp(X509_CERTIFICATE, ((pem_object *)VECTOR_element(pem_list, u))->name, X509_CERTIFICATE_LEN)) { br_x509_certificate xc; xc.data = ((pem_object *)VECTOR_element(pem_list, u))->data; xc.data_len = ((pem_object *)VECTOR_element(pem_list, u))->data_len; ((pem_object *)VECTOR_element(pem_list, u))->data = NULL; ((pem_object *)VECTOR_element(pem_list, u))->data_len = 0; free(((pem_object *)VECTOR_element(pem_list, u))->name); ((pem_object *)VECTOR_element(pem_list, u))->name = NULL; result = VECTOR_push_back(cert_list, &xc, 1); if (result != 0) { LogError("Failed to add certificate to vector"); break; } } else { LogError("Unable to determine the certificate type"); } } // If we enter this loop something failed for (; u < VECTOR_size(pem_list); u++) { free(((pem_object *)VECTOR_element(pem_list, u))->name); free(((pem_object *)VECTOR_element(pem_list, u))->data); } VECTOR_destroy(pem_list); if (0 == VECTOR_size(cert_list)) { fprintf(stderr, "No certificate in string"); result = MU_FAILURE; } if (result != 0) { for (u = 0; u < VECTOR_size(cert_list); u++) { free(((br_x509_certificate*)VECTOR_element(cert_list, u))->data); } VECTOR_destroy(cert_list); cert_list = NULL; } } } return cert_list; } static void dn_append(void *ctx, const void *buf, size_t len) { if (0 != (BUFFER_append_build((BUFFER_HANDLE)ctx, buf, len))) { // Design does not allow this error to be reported to caller LogError("Failed to append data"); } } void free_ta_contents(br_x509_trust_anchor *ta) { free(ta->dn.data); switch (ta->pkey.key_type) { case BR_KEYTYPE_RSA: free(ta->pkey.key.rsa.n); free(ta->pkey.key.rsa.e); break; case BR_KEYTYPE_EC: free(ta->pkey.key.ec.q); break; } } void free_certificates(br_x509_certificate *certs, size_t num) { size_t u; for (u = 0; u < num; u ++) { free(certs[u].data); } } static int certificate_to_trust_anchor(br_x509_certificate *xc, br_x509_trust_anchor *ta) { br_x509_decoder_context dc; br_x509_pkey *pk; BUFFER_HANDLE vdn; //br_x509_trust_anchor *ta; int result = 0; vdn = BUFFER_new(); if (NULL == vdn) { LogError("Failed to allocate memory to decode x509 certificate"); result = MU_FAILURE; } else { memset(ta, 0, sizeof(br_x509_trust_anchor)); br_x509_decoder_init(&dc, dn_append, vdn); br_x509_decoder_push(&dc, xc->data, xc->data_len); pk = br_x509_decoder_get_pkey(&dc); if (pk == NULL) { LogError("ERROR: CA decoding failed with error %d", br_x509_decoder_last_error(&dc)); BUFFER_delete(vdn); } else { ta->dn.data = BUFFER_u_char(vdn); ta->dn.len = BUFFER_length(vdn); free(vdn); ta->flags = 0; if (br_x509_decoder_isCA(&dc)) { ta->flags |= BR_X509_TA_CA; } switch (pk->key_type) { case BR_KEYTYPE_RSA: ta->pkey.key_type = BR_KEYTYPE_RSA; ta->pkey.key.rsa.nlen = pk->key.rsa.nlen; ta->pkey.key.rsa.elen = pk->key.rsa.elen; if (NULL == (ta->pkey.key.rsa.n = (unsigned char *)malloc(ta->pkey.key.rsa.nlen)) || NULL == ( ta->pkey.key.rsa.e = (unsigned char *)malloc(ta->pkey.key.rsa.elen))) { LogError("Unable to allocate memory"); free_ta_contents(ta); result = MU_FAILURE; } else { memcpy(ta->pkey.key.rsa.n, pk->key.rsa.n, ta->pkey.key.rsa.nlen); memcpy(ta->pkey.key.rsa.e, pk->key.rsa.e, ta->pkey.key.rsa.elen); result = 0; } break; case BR_KEYTYPE_EC: ta->pkey.key_type = BR_KEYTYPE_EC; ta->pkey.key.ec.curve = pk->key.ec.curve; ta->pkey.key.ec.qlen = pk->key.ec.qlen; if (NULL == (ta->pkey.key.ec.q = (unsigned char *)malloc(ta->pkey.key.ec.qlen))) { LogError("Unable to allocate memory"); free_ta_contents(ta); result = MU_FAILURE; } else { memcpy(ta->pkey.key.ec.q, pk->key.ec.q, ta->pkey.key.ec.qlen); result = 0; } break; default: fprintf(stderr, "ERROR: unsupported public key type in CA\n"); free_ta_contents(ta); result = MU_FAILURE; } } } return result; } static size_t get_trusted_anchors(const char *certificates, size_t len, br_x509_trust_anchor *anchOut[]) { // Converts a PEM certificate in a string into the format required by BearSSL VECTOR_HANDLE xcs; br_x509_trust_anchor work; br_x509_trust_anchor *anchArray; size_t u; size_t v; size_t num; int result; xcs = read_certificates_string(certificates, len); num = VECTOR_size(xcs); if (VECTOR_size(xcs) == 0) { LogError("No certificates found in string"); } else { anchArray = (br_x509_trust_anchor *)malloc(sizeof(br_x509_trust_anchor) * num); if (anchArray == NULL) { LogError("Memory allocation for trust anchors failed"); } else { *anchOut = anchArray; for (u = 0; u < num; u++) { result = certificate_to_trust_anchor((br_x509_certificate *)VECTOR_element(xcs, u), &work); if (result != 0) { for (v = 0; v < u; v++) { free_ta_contents((anchOut[u])); } free(anchArray); *anchOut = NULL; num = 0; break; } anchArray[u] = work; } } } free_certificates((br_x509_certificate *)VECTOR_front(xcs), VECTOR_size(xcs)); VECTOR_destroy(xcs); return num; } static int get_cert_signer_algo(br_x509_certificate *xc) { br_x509_decoder_context dc; int result; br_x509_decoder_init(&dc, 0, 0); br_x509_decoder_push(&dc, xc->data, xc->data_len); result = br_x509_decoder_last_error(&dc); if (result != 0) { LogError("Failed to get signer algorithm %d\n", result); result = 0; } else { result = br_x509_decoder_get_signer_key_type(&dc); } return result; } CONCRETE_IO_HANDLE tlsio_bearssl_create(void *io_create_parameters) { TLSIO_CONFIG *tls_io_config = (TLSIO_CONFIG *)io_create_parameters; TLS_IO_INSTANCE *result; if (tls_io_config == NULL) { LogError("NULL tls_io_config"); result = NULL; } else { /* Codes_SRS_TLSIO_BEAR_OS5_TLS_99_006: [ The tlsio_bearssl_create shall return NULL if allocating memory for TLS_IO_INSTANCE failed. ]*/ result = calloc(1, sizeof(TLS_IO_INSTANCE)); if (result != NULL) { SOCKETIO_CONFIG socketio_config; const IO_INTERFACE_DESCRIPTION *underlying_io_interface; void *io_interface_parameters; if (tls_io_config->underlying_io_interface != NULL) { underlying_io_interface = tls_io_config->underlying_io_interface; io_interface_parameters = tls_io_config->underlying_io_parameters; } else { socketio_config.hostname = tls_io_config->hostname; socketio_config.port = tls_io_config->port; socketio_config.accepted_socket = NULL; underlying_io_interface = socketio_get_interface_description(); io_interface_parameters = &socketio_config; } if (underlying_io_interface == NULL) { free(result); result = NULL; LogError("Failed getting socket IO interface description."); } else { mallocAndStrcpy_s(&result->hostname, tls_io_config->hostname); if (result->hostname == NULL) { free(result); result = NULL; } else { result->socket_io = xio_create(underlying_io_interface, io_interface_parameters); if (result->socket_io == NULL) { LogError("socket xio create failed"); free(result->hostname); free(result); result = NULL; } else { result->pending_toencrypt_list = singlylinkedlist_create(); result->pending_todecrypt_list = singlylinkedlist_create(); result->trusted_certificates = NULL; result->x509_certificate = NULL; result->x509_private_key = NULL; result->tas = NULL; result->x509_cert = NULL; result->x509_pk = NULL; result->tlsio_state = TLSIO_STATE_NOT_OPEN; } } } } } return result; } void tlsio_bearssl_destroy(CONCRETE_IO_HANDLE tls_io) { size_t i; LIST_ITEM_HANDLE first_pending_io; if (tls_io == NULL) { LogError("NULL handle"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->socket_io_read_bytes != NULL) { free(tls_io_instance->socket_io_read_bytes); tls_io_instance->socket_io_read_bytes = NULL; } xio_destroy(tls_io_instance->socket_io); first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_toencrypt_list); while (first_pending_io != NULL) { PENDING_TLS_IO *pending_tls_io = (PENDING_TLS_IO *)singlylinkedlist_item_get_value(first_pending_io); if (pending_tls_io != NULL) { free(pending_tls_io->bytes); free(pending_tls_io); } (void)singlylinkedlist_remove(tls_io_instance->pending_toencrypt_list, first_pending_io); first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_toencrypt_list); } singlylinkedlist_destroy(tls_io_instance->pending_toencrypt_list); tls_io_instance->pending_toencrypt_list = NULL; first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_todecrypt_list); while (first_pending_io != NULL) { PENDING_TLS_IO *pending_tls_io = (PENDING_TLS_IO *)singlylinkedlist_item_get_value(first_pending_io); if (pending_tls_io != NULL) { free(pending_tls_io->bytes); free(pending_tls_io); } (void)singlylinkedlist_remove(tls_io_instance->pending_todecrypt_list, first_pending_io); first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_todecrypt_list); } singlylinkedlist_destroy(tls_io_instance->pending_todecrypt_list); tls_io_instance->pending_todecrypt_list = NULL; if (tls_io_instance->hostname != NULL) { free(tls_io_instance->hostname); tls_io_instance->hostname = NULL; } if (tls_io_instance->trusted_certificates != NULL) { free(tls_io_instance->trusted_certificates); tls_io_instance->trusted_certificates = NULL; if (tls_io_instance->tas != NULL) { // Free the memory if it has been previously allocated for (i = 0; i < tls_io_instance->ta_count; i++) { free_ta_contents(&(tls_io_instance->tas[i])); } free(tls_io_instance->tas); tls_io_instance->tas = NULL; tls_io_instance->ta_count = 0; } } if (tls_io_instance->x509_certificate != NULL) { free(tls_io_instance->x509_certificate); tls_io_instance->x509_certificate = NULL; if (tls_io_instance->x509_cert != NULL) { free_certificates(tls_io_instance->x509_cert, tls_io_instance->x509_cert_len); free(tls_io_instance->x509_cert); tls_io_instance->x509_cert = NULL; } } if (tls_io_instance->x509_private_key != NULL) { free(tls_io_instance->x509_private_key); tls_io_instance->x509_private_key = NULL; if (tls_io_instance->x509_pk != NULL) { free_private_key(tls_io_instance->x509_pk); free(tls_io_instance->x509_pk); tls_io_instance->x509_pk = NULL; } } free(tls_io); } } int tlsio_bearssl_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void *on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void *on_bytes_received_context, ON_IO_ERROR on_io_error, void *on_io_error_context) { int result = 0; unsigned int cert_signer_algo; if (tls_io == NULL) { LogError("NULL tls_io"); result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { LogError("TLS already open"); result = MU_FAILURE; } else { tls_io_instance->on_bytes_received = on_bytes_received; tls_io_instance->on_bytes_received_context = on_bytes_received_context; tls_io_instance->on_io_open_complete = on_io_open_complete; tls_io_instance->on_io_open_complete_context = on_io_open_complete_context; tls_io_instance->on_io_error = on_io_error; tls_io_instance->on_io_error_context = on_io_error_context; tls_io_instance->tlsio_state = TLSIO_STATE_OPENING_UNDERLYING_IO; if (tls_io_instance->ta_count == 0) { LogError("Trusted certificates are required but missing"); result = MU_FAILURE; } else { if ((tls_io_instance->x509_pk == NULL && tls_io_instance->x509_cert != NULL) || (tls_io_instance->x509_pk != NULL && tls_io_instance->x509_cert == NULL)) { LogError("X.509 certificate and private key need to be both present or both absent"); result = MU_FAILURE; } else { br_ssl_client_init_full(&tls_io_instance->sc, &tls_io_instance->xc, tls_io_instance->tas, tls_io_instance->ta_count); br_ssl_engine_set_buffer(&tls_io_instance->sc.eng, tls_io_instance->iobuf, sizeof(tls_io_instance->iobuf), 1); br_ssl_client_reset(&tls_io_instance->sc, tls_io_instance->hostname, 0); if (tls_io_instance->x509_cert != NULL) { switch (tls_io_instance->x509_pk->key_type) { case BR_KEYTYPE_RSA: br_ssl_client_set_single_rsa(&tls_io_instance->sc, tls_io_instance->x509_cert, tls_io_instance->x509_cert_len, &tls_io_instance->x509_pk->key.rsa, br_rsa_pkcs1_sign_get_default()); break; case BR_KEYTYPE_EC: cert_signer_algo = get_cert_signer_algo(tls_io_instance->x509_cert); if (cert_signer_algo == 0) { result = MU_FAILURE; } else { br_ssl_client_set_single_ec(&tls_io_instance->sc, tls_io_instance->x509_cert, tls_io_instance->x509_cert_len, &tls_io_instance->x509_pk->key.ec, BR_KEYTYPE_KEYX | BR_KEYTYPE_SIGN, cert_signer_algo, br_ec_get_default(), br_ecdsa_sign_asn1_get_default()); } break; default: LogError("Unrecognized private key type"); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } } if (result == 0) { if (xio_open(tls_io_instance->socket_io, on_underlying_io_open_complete, tls_io_instance, on_underlying_io_bytes_received, tls_io_instance, on_underlying_io_error, tls_io_instance) != 0) { LogError("Underlying IO open failed"); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } } } } } } return result; } int tlsio_bearssl_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void *callback_context) { int result = 0; if (tls_io == NULL) { LogError("NULL tls_io"); result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if ((tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) || (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING)) { LogError("Invalid state"); result = MU_FAILURE; } else { tls_io_instance->on_io_close_complete = on_io_close_complete; tls_io_instance->on_io_close_complete_context = callback_context; tls_io_instance->tlsio_state = TLSIO_STATE_CLOSING; xio_close(tls_io_instance->socket_io, on_underlying_io_close_complete_during_close, tls_io_instance); result = 0; } } return result; } int tlsio_bearssl_send(CONCRETE_IO_HANDLE tls_io, const void *buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void *callback_context) { int result; if ((tls_io == NULL) || (buffer == NULL) || (size == 0)) { // Invalid arguments LogError("Invalid argument: tls_io is NULL"); result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN && tls_io_instance->tlsio_state != TLSIO_STATE_IN_HANDSHAKE && tls_io_instance->tlsio_state != TLSIO_STATE_OPENING_UNDERLYING_IO) { LogError("TLS is not open"); result = MU_FAILURE; } else { if (add_pending_operation(tls_io_instance->pending_toencrypt_list, buffer, size, on_send_complete, callback_context) != 0) { LogError("Failure: add_pending_io failed."); result = MU_FAILURE; } else { result = 0; } } } return result; } void tlsio_bearssl_dowork(CONCRETE_IO_HANDLE tls_io) { unsigned char *buffer; size_t bufferLen; unsigned long bearResult; int lasterr; if (tls_io != NULL) { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) { // Not open do nothing } else { if (tls_io_instance->tlsio_state != TLSIO_STATE_OPENING_UNDERLYING_IO && tls_io_instance->tlsio_state != TLSIO_STATE_CLOSING) { bearResult = br_ssl_engine_current_state(&tls_io_instance->sc.eng); if (bearResult & BR_SSL_SENDREC) { // The engine has data to send buffer = br_ssl_engine_sendrec_buf(&tls_io_instance->sc.eng, &bufferLen); if (xio_send(tls_io_instance->socket_io, buffer, bufferLen, NULL, NULL) != 0) { LogError("Error in xio_send."); indicate_error(tls_io_instance); } else { br_ssl_engine_sendrec_ack(&tls_io_instance->sc.eng, bufferLen); } } bearResult = br_ssl_engine_current_state(&tls_io_instance->sc.eng); if (bearResult & BR_SSL_RECVREC) { // The engine can accept data from the peer if there is any LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_todecrypt_list); if (first_pending_io != NULL) { PENDING_TLS_IO *pending_tls_io = (PENDING_TLS_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_tls_io != NULL) { buffer = br_ssl_engine_recvrec_buf(&tls_io_instance->sc.eng, &bufferLen); if (bufferLen == 0) { LogError("Zero length buffer returned by BearSSL"); indicate_error(tls_io_instance); } else { if (pending_tls_io->size < bufferLen) { bufferLen = pending_tls_io->size; } memcpy(buffer, pending_tls_io->bytes, bufferLen); br_ssl_engine_recvrec_ack(&tls_io_instance->sc.eng, bufferLen); if (bufferLen < pending_tls_io->size) { pending_tls_io->size -= bufferLen; memcpy(pending_tls_io->bytes, pending_tls_io->bytes + bufferLen, pending_tls_io->size); } else { free(pending_tls_io->bytes); free(pending_tls_io); (void)singlylinkedlist_remove(tls_io_instance->pending_todecrypt_list, first_pending_io); } } } } } bearResult = br_ssl_engine_current_state(&tls_io_instance->sc.eng); if (bearResult & BR_SSL_SENDAPP) { if (tls_io_instance->tlsio_state == TLSIO_STATE_IN_HANDSHAKE) { tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_OK); } // Engine is ready for application data - send it if we have any LIST_ITEM_HANDLE first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_toencrypt_list); if (first_pending_io != NULL) { PENDING_TLS_IO *pending_tls_io = (PENDING_TLS_IO*)singlylinkedlist_item_get_value(first_pending_io); if (pending_tls_io != NULL) { buffer = br_ssl_engine_sendapp_buf(&tls_io_instance->sc.eng, &bufferLen); if (pending_tls_io->size < bufferLen) { bufferLen = pending_tls_io->size; } memcpy(buffer, pending_tls_io->bytes, bufferLen); br_ssl_engine_sendapp_ack(&tls_io_instance->sc.eng, bufferLen); if (bufferLen < pending_tls_io->size) { pending_tls_io->size -= bufferLen; memcpy(pending_tls_io->bytes, pending_tls_io->bytes + bufferLen, pending_tls_io->size); } else { pending_tls_io->on_send_complete(pending_tls_io->callback_context, IO_SEND_OK); free(pending_tls_io->bytes); free(pending_tls_io); (void)singlylinkedlist_remove(tls_io_instance->pending_toencrypt_list, first_pending_io); br_ssl_engine_flush(&tls_io_instance->sc.eng, 0); } } } } bearResult = br_ssl_engine_current_state(&tls_io_instance->sc.eng); if (bearResult & BR_SSL_RECVAPP) { // Application data is waiting to be forwarded buffer = br_ssl_engine_recvapp_buf(&tls_io_instance->sc.eng, &bufferLen); tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, buffer, bufferLen); br_ssl_engine_recvapp_ack(&tls_io_instance->sc.eng, bufferLen); } } if ((lasterr = br_ssl_engine_last_error(&tls_io_instance->sc.eng)) != 0) { LogError("BearSSL reported an error: %d", lasterr); indicate_error(tls_io_instance); } xio_dowork(tls_io_instance->socket_io); } } } // This function will clone an option given by name and value static void *tlsio_bearssl_CloneOption(const char *name, const void *value) { void *result = NULL; if (name == NULL || value == NULL) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); result = NULL; } else { if (strcmp(name, OPTION_UNDERLYING_IO_OPTIONS) == 0) { result = (void*)OptionHandler_Clone((OPTIONHANDLER_HANDLE)value); } else if (strcmp(name, OPTION_TRUSTED_CERT) == 0) { if (mallocAndStrcpy_s((char **)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s TrustedCerts value"); result = NULL; } else { // return as is } } else if (strcmp(name, SU_OPTION_X509_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509certificate value"); result = NULL; } else { // return as is } } else if (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509privatekey value"); result = NULL; } else { // return as is } } else if (strcmp(name, OPTION_X509_ECC_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509EccCertificate value"); result = NULL; } else { // return as is } } else if (strcmp(name, OPTION_X509_ECC_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509EccKey value"); result = NULL; } else { // return as is } } else { LogError("not handled option : %s", name); result = NULL; } } return result; } // This function destroys an option previously created static void tlsio_bearssl_DestroyOption(const char *name, const void *value) { // Since all options for this layer are actually string copies., disposing of one is just a matter calling free if (name == NULL || value == NULL) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); } else { if ( (strcmp(name, OPTION_TRUSTED_CERT) == 0) || (strcmp(name, SU_OPTION_X509_CERT) == 0) || (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) || (strcmp(name, OPTION_X509_ECC_CERT) == 0) || (strcmp(name, OPTION_X509_ECC_KEY) == 0) ) { free((void*)value); } else if (strcmp(name, OPTION_UNDERLYING_IO_OPTIONS) == 0) { OptionHandler_Destroy((OPTIONHANDLER_HANDLE)value); } else { LogError("not handled option : %s", name); } } } int tlsio_bearssl_setoption(CONCRETE_IO_HANDLE tls_io, const char *optionName, const void *value) { int result = 0; size_t i; VECTOR_HANDLE certs; if (tls_io == NULL || optionName == NULL) { result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { if (tls_io_instance->tas != NULL) { // Free the memory if it has been previously allocated for (i = 0; i < tls_io_instance->ta_count; i++) { free_ta_contents(&(tls_io_instance->tas[i])); } free(tls_io_instance->tas); tls_io_instance->tas = NULL; tls_io_instance->ta_count = 0; free(tls_io_instance->trusted_certificates); tls_io_instance->trusted_certificates = NULL; } if (value != NULL) { mallocAndStrcpy_s(&tls_io_instance->trusted_certificates, (const char *)value); if (tls_io_instance->trusted_certificates == NULL) { LogError("Failed to allocate memory for certificate string"); result = MU_FAILURE; } else { tls_io_instance->ta_count = get_trusted_anchors((const char*)value, strlen((const char *)value) + 1, &tls_io_instance->tas); if (tls_io_instance->ta_count == 0) { LogError("Failed to extract certificate from option value"); result = MU_FAILURE; } else { result = 0; } } } } else if (strcmp(optionName, OPTION_UNDERLYING_IO_OPTIONS) == 0) { if (OptionHandler_FeedOptions((OPTIONHANDLER_HANDLE)value, (void*)tls_io_instance->socket_io) != OPTIONHANDLER_OK) { LogError("failed feeding options to underlying I/O instance"); result = MU_FAILURE; } else { result = 0; } } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { if (tls_io_instance->x509_certificate != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->x509_certificate); } if (mallocAndStrcpy_s(&tls_io_instance->x509_certificate, (const char *)value) != 0) { LogError("unable to mallocAndStrcpy_s on certificate"); result = MU_FAILURE; } else { if (tls_io_instance->x509_cert != NULL) { free_certificates(tls_io_instance->x509_cert, tls_io_instance->x509_cert_len); free(tls_io_instance->x509_cert); tls_io_instance->x509_cert = NULL; } certs = read_certificates_string(value, strlen(value)); tls_io_instance->x509_cert_len = VECTOR_size(certs); tls_io_instance->x509_cert = VECTOR_front(certs); free(certs); result = 0; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { if (tls_io_instance->x509_private_key != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->x509_private_key); } if (mallocAndStrcpy_s(&tls_io_instance->x509_private_key, (const char *)value) != 0) { LogError("unable to mallocAndStrcpy_s on private key"); result = MU_FAILURE; } else { if (tls_io_instance->x509_pk != NULL) { free_private_key(tls_io_instance->x509_pk); free(tls_io_instance->x509_pk); tls_io_instance->x509_pk = NULL; } tls_io_instance->x509_pk = read_private_key(value, strlen(value)); result = 0; } } else if (strcmp(optionName, OPTION_SET_TLS_RENEGOTIATION) == 0) { // No need to do anything for BearSSL result = 0; } else { // tls_io_instance->socket_io is never NULL result = xio_setoption(tls_io_instance->socket_io, optionName, value); } } return result; } OPTIONHANDLER_HANDLE tlsio_bearssl_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result = NULL; if (handle == NULL) { LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle=%p", handle); result = NULL; } else { result = OptionHandler_Create(tlsio_bearssl_CloneOption, tlsio_bearssl_DestroyOption, tlsio_bearssl_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); /*return as is*/ } else { // This layer cares about the certificates TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)handle; OPTIONHANDLER_HANDLE underlying_io_options; if ((underlying_io_options = xio_retrieveoptions(tls_io_instance->socket_io)) == NULL) { LogError("unable to retrieve underlying_io options"); OptionHandler_Destroy(result); result = NULL; } else { if (OptionHandler_AddOption(result, OPTION_UNDERLYING_IO_OPTIONS, underlying_io_options) != OPTIONHANDLER_OK) { LogError("unable to save underlying_io options"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->trusted_certificates != NULL && OptionHandler_AddOption(result, OPTION_TRUSTED_CERT, tls_io_instance->trusted_certificates) != OPTIONHANDLER_OK) { LogError("unable to save TrustedCerts option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->x509_certificate != NULL && OptionHandler_AddOption(result, SU_OPTION_X509_CERT, tls_io_instance->x509_certificate) != OPTIONHANDLER_OK) { LogError("unable to save x509certificate option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->x509_private_key != NULL && OptionHandler_AddOption(result, SU_OPTION_X509_PRIVATE_KEY, tls_io_instance->x509_private_key) != OPTIONHANDLER_OK) { LogError("unable to save x509privatekey option"); OptionHandler_Destroy(result); result = NULL; } else { /*all is fine, all interesting options have been saved*/ /*return as is*/ } OptionHandler_Destroy(underlying_io_options); } } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_bearssl_interface_description = { tlsio_bearssl_retrieveoptions, tlsio_bearssl_create, tlsio_bearssl_destroy, tlsio_bearssl_open, tlsio_bearssl_close, tlsio_bearssl_send, tlsio_bearssl_dowork, tlsio_bearssl_setoption}; const IO_INTERFACE_DESCRIPTION *tlsio_bearssl_get_interface_description(void) { return &tlsio_bearssl_interface_description; } tlsio_mbedtls.c000066400000000000000000001143621455573770000341150ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include #include "mbedtls/debug.h" #include "mbedtls/ssl.h" #include "mbedtls/entropy.h" #include "mbedtls/ctr_drbg.h" #include "mbedtls/error.h" #include "mbedtls/certs.h" #include "mbedtls/entropy_poll.h" #include "mbedtls/pk.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/tlsio_mbedtls.h" #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/threadapi.h" static const char *const OPTION_UNDERLYING_IO_OPTIONS = "underlying_io_options"; #define HANDSHAKE_TIMEOUT_MS 5000 #define HANDSHAKE_WAIT_INTERVAL_MS 10 typedef enum TLSIO_STATE_ENUM_TAG { TLSIO_STATE_NOT_OPEN, TLSIO_STATE_OPENING_UNDERLYING_IO, TLSIO_STATE_IN_HANDSHAKE, TLSIO_STATE_OPEN, TLSIO_STATE_CLOSING, TLSIO_STATE_ERROR } TLSIO_STATE_ENUM; typedef struct SEND_COMPLETE_INFO_TAG { bool is_fragmented_req; IO_SEND_RESULT last_fragmented_req_status; ON_SEND_COMPLETE on_send_complete; void *on_send_complete_callback_context; } SEND_COMPLETE_INFO; typedef struct TLS_IO_INSTANCE_TAG { XIO_HANDLE socket_io; ON_BYTES_RECEIVED on_bytes_received; ON_IO_OPEN_COMPLETE on_io_open_complete; ON_IO_CLOSE_COMPLETE on_io_close_complete; ON_IO_ERROR on_io_error; void *on_bytes_received_context; void *on_io_open_complete_context; void *on_io_close_complete_context; void *on_io_error_context; TLSIO_STATE_ENUM tlsio_state; unsigned char *socket_io_read_bytes; size_t socket_io_read_byte_count; SEND_COMPLETE_INFO send_complete_info; mbedtls_entropy_context entropy; mbedtls_ctr_drbg_context ctr_drbg; mbedtls_ssl_context ssl; mbedtls_ssl_config config; mbedtls_x509_crt trusted_certificates_parsed; mbedtls_ssl_session ssn; char *trusted_certificates; bool invoke_on_send_complete_callback_for_fragments; char *hostname; mbedtls_x509_crt owncert; mbedtls_pk_context pKey; char* x509_certificate; char* x509_private_key; int tls_status; } TLS_IO_INSTANCE; typedef enum TLS_STATE_TAG { TLS_STATE_NOT_INITIALIZED, TLS_STATE_INITIALIZED, TLS_STATE_CLOSING, } TLS_STATE; static void indicate_error(TLS_IO_INSTANCE *tls_io_instance) { if ((tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) && (tls_io_instance->tlsio_state != TLSIO_STATE_ERROR)) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_error != NULL) { tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } } } static void indicate_open_complete(TLS_IO_INSTANCE *tls_io_instance, IO_OPEN_RESULT open_result) { if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, open_result); } } static int decode_ssl_received_bytes(TLS_IO_INSTANCE *tls_io_instance) { int result = 0; unsigned char buffer[64]; int rcv_bytes = 1; while (rcv_bytes > 0) { rcv_bytes = mbedtls_ssl_read(&tls_io_instance->ssl, buffer, sizeof(buffer)); if (rcv_bytes > 0) { if (tls_io_instance->on_bytes_received != NULL) { tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, buffer, rcv_bytes); } } } return result; } static bool is_fragmented_send_request(TLS_IO_INSTANCE *tls_io_instance, size_t send_size) { #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) size_t max_len = mbedtls_ssl_get_max_frag_len(&tls_io_instance->ssl); #else size_t max_len = MBEDTLS_SSL_MAX_CONTENT_LEN; (void)tls_io_instance; #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */ bool result; if (send_size > max_len) { result = true; } else { result = false; } return result; } static void on_underlying_io_open_complete(void *context, IO_OPEN_RESULT open_result) { if (context == NULL) { LogError("Invalid context NULL value passed"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; int result = 0; if (open_result != IO_OPEN_OK) { xio_close(tls_io_instance->socket_io, NULL, NULL); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); } else { tls_io_instance->tlsio_state = TLSIO_STATE_IN_HANDSHAKE; do { result = mbedtls_ssl_handshake(&tls_io_instance->ssl); } while (result == MBEDTLS_ERR_SSL_WANT_READ || result == MBEDTLS_ERR_SSL_WANT_WRITE); if (result == 0) { tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_OK); } else { if (result == MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED) { LogError("Failure in ssl handshake has the server certificate been added?"); } else { LogError("Failure ssl handshake %d", result); } xio_close(tls_io_instance->socket_io, NULL, NULL); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); } } } } static void on_underlying_io_bytes_received(void *context, const unsigned char *buffer, size_t size) { if (context != NULL) { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; unsigned char *new_socket_io_read_bytes = (unsigned char *)realloc(tls_io_instance->socket_io_read_bytes, tls_io_instance->socket_io_read_byte_count + size); if (new_socket_io_read_bytes == NULL) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { tls_io_instance->socket_io_read_bytes = new_socket_io_read_bytes; (void)memcpy(tls_io_instance->socket_io_read_bytes + tls_io_instance->socket_io_read_byte_count, buffer, size); tls_io_instance->socket_io_read_byte_count += size; } } else { LogError("NULL value passed in context"); } } static void on_underlying_io_error(void *context) { if (context == NULL) { LogError("Invalid context NULL value passed"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; switch (tls_io_instance->tlsio_state) { default: case TLSIO_STATE_NOT_OPEN: case TLSIO_STATE_ERROR: break; case TLSIO_STATE_OPENING_UNDERLYING_IO: case TLSIO_STATE_IN_HANDSHAKE: // Existing socket impls are all synchronous close, and this // adapter does not yet support async close. xio_close(tls_io_instance->socket_io, NULL, NULL); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); break; case TLSIO_STATE_OPEN: indicate_error(tls_io_instance); break; } } } static void on_underlying_io_close_complete_during_close(void *context) { if (context == NULL) { LogError("NULL value passed in context"); } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; if (tls_io_instance->on_io_close_complete != NULL) { tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context); } } } static int on_io_recv(void *context, unsigned char *buf, size_t sz) { int result; if (context == NULL) { LogError("Invalid context NULL value passed"); result = MBEDTLS_ERR_SSL_BAD_INPUT_DATA; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; unsigned char *new_socket_io_read_bytes; int pending = 0; while (tls_io_instance->socket_io_read_byte_count == 0) { xio_dowork(tls_io_instance->socket_io); if (tls_io_instance->tlsio_state == TLSIO_STATE_OPEN) { break; } else if (tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN || tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING || tls_io_instance->tlsio_state == TLSIO_STATE_ERROR) { // Underlying io error, exit. return MBEDTLS_ERR_SSL_INTERNAL_ERROR; } else { // Handkshake if (tls_io_instance->socket_io_read_byte_count == 0) { if (pending++ >= HANDSHAKE_TIMEOUT_MS / HANDSHAKE_WAIT_INTERVAL_MS) { // The connection is close from server side and no response. LogError("Tlsio_Failure: encountered unknow connection issue, the connection will be restarted."); indicate_error(tls_io_instance); return MBEDTLS_ERR_SSL_INTERNAL_ERROR; } ThreadAPI_Sleep(HANDSHAKE_WAIT_INTERVAL_MS); } } } result = (int) tls_io_instance->socket_io_read_byte_count; if (result > (int)sz) { result = (int)sz; } if (result > 0) { (void)memcpy((void *)buf, tls_io_instance->socket_io_read_bytes, result); (void)memmove(tls_io_instance->socket_io_read_bytes, tls_io_instance->socket_io_read_bytes + result, tls_io_instance->socket_io_read_byte_count - result); tls_io_instance->socket_io_read_byte_count -= result; if (tls_io_instance->socket_io_read_byte_count > 0) { new_socket_io_read_bytes = (unsigned char *)realloc(tls_io_instance->socket_io_read_bytes, tls_io_instance->socket_io_read_byte_count); if (new_socket_io_read_bytes != NULL) { tls_io_instance->socket_io_read_bytes = new_socket_io_read_bytes; } } else { free(tls_io_instance->socket_io_read_bytes); tls_io_instance->socket_io_read_bytes = NULL; } } if ((result == 0) && (tls_io_instance->tlsio_state == TLSIO_STATE_OPEN)) { result = MBEDTLS_ERR_SSL_WANT_READ; } } return result; } static void on_send_complete(void* context, IO_SEND_RESULT send_result) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE *)context; if (tls_io_instance != NULL) { // update fragment status if (tls_io_instance->send_complete_info.is_fragmented_req) { tls_io_instance->send_complete_info.last_fragmented_req_status = send_result; } if (tls_io_instance->send_complete_info.on_send_complete != NULL && tls_io_instance->tlsio_state != TLSIO_STATE_CLOSING) { // trigger callback always on failure, otherwise call it on last fragment completion // In case of http communication (ie blob upload), the callback is called with each fragment if((tls_io_instance->invoke_on_send_complete_callback_for_fragments && tls_io_instance->send_complete_info.is_fragmented_req)|| (send_result != IO_SEND_OK || !tls_io_instance->send_complete_info.is_fragmented_req)) { void *ctx = tls_io_instance->send_complete_info.on_send_complete_callback_context; tls_io_instance->send_complete_info.on_send_complete(ctx, send_result); } } } else { LogError("Invalid context NULL value passed"); } } static int on_io_send(void *context, const unsigned char *buf, size_t sz) { int result; if (context == NULL) { LogError("Invalid context NULL value passed"); result = 0; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)context; ON_SEND_COMPLETE on_complete_callback = NULL; context = NULL; // Only allow Application data type message to send on_send_complete callback. if (tls_io_instance->ssl.out_msgtype == MBEDTLS_SSL_MSG_APPLICATION_DATA) { on_complete_callback = on_send_complete; context = tls_io_instance; } if (xio_send(tls_io_instance->socket_io, buf, sz, on_complete_callback, context) != 0) { indicate_error(tls_io_instance); result = 0; } else { result = (int)sz; } } return result; } static int tlsio_entropy_poll(void *v, unsigned char *output, size_t len, size_t *olen) { (void)v; int result = 0; srand((unsigned int)time(NULL)); for (uint16_t i = 0; i < len; i++) { output[i] = rand() % 256; } *olen = len; return result; } // Un-initialize mbedTLS static void mbedtls_uninit(TLS_IO_INSTANCE *tls_io_instance) { if (tls_io_instance->tls_status != TLS_STATE_NOT_INITIALIZED) { // mbedTLS cleanup... mbedtls_ssl_free(&tls_io_instance->ssl); mbedtls_ssl_session_free(&tls_io_instance->ssn); mbedtls_ssl_config_free(&tls_io_instance->config); mbedtls_x509_crt_free(&tls_io_instance->trusted_certificates_parsed); mbedtls_x509_crt_free(&tls_io_instance->owncert); mbedtls_pk_free(&tls_io_instance->pKey); mbedtls_ctr_drbg_free(&tls_io_instance->ctr_drbg); mbedtls_entropy_free(&tls_io_instance->entropy); tls_io_instance->tls_status = TLS_STATE_NOT_INITIALIZED; } else { LogError("Uninitialzing when not previously initialized"); } } static void mbedtls_init(TLS_IO_INSTANCE *tls_io_instance) { const char* pers = "azure_iot_client"; if (tls_io_instance->tls_status != TLS_STATE_INITIALIZED) { if (tls_io_instance->tls_status == TLS_STATE_CLOSING) { // The underlying connection has been closed, so here un-initialize first mbedtls_uninit(tls_io_instance); } // mbedTLS initialize... mbedtls_x509_crt_init(&tls_io_instance->trusted_certificates_parsed); mbedtls_x509_crt_init(&tls_io_instance->owncert); mbedtls_pk_init(&tls_io_instance->pKey); mbedtls_entropy_init(&tls_io_instance->entropy); // Add a weak entropy source here,avoid some platform doesn't have strong / hardware entropy mbedtls_entropy_add_source(&tls_io_instance->entropy, tlsio_entropy_poll, NULL, MBEDTLS_ENTROPY_MAX_GATHER, MBEDTLS_ENTROPY_SOURCE_WEAK); mbedtls_ctr_drbg_init(&tls_io_instance->ctr_drbg); mbedtls_ctr_drbg_seed(&tls_io_instance->ctr_drbg, mbedtls_entropy_func, &tls_io_instance->entropy, (const unsigned char *)pers, strlen(pers)); mbedtls_ssl_config_init(&tls_io_instance->config); mbedtls_ssl_config_defaults(&tls_io_instance->config, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT); mbedtls_ssl_conf_rng(&tls_io_instance->config, mbedtls_ctr_drbg_random, &tls_io_instance->ctr_drbg); mbedtls_ssl_conf_authmode(&tls_io_instance->config, MBEDTLS_SSL_VERIFY_REQUIRED); mbedtls_ssl_conf_min_version(&tls_io_instance->config, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3); // v1.2 mbedtls_ssl_init(&tls_io_instance->ssl); mbedtls_ssl_set_bio(&tls_io_instance->ssl, tls_io_instance, on_io_send, on_io_recv, NULL); mbedtls_ssl_set_hostname(&tls_io_instance->ssl, tls_io_instance->hostname); mbedtls_ssl_session_init(&tls_io_instance->ssn); mbedtls_ssl_set_session(&tls_io_instance->ssl, &tls_io_instance->ssn); mbedtls_ssl_setup(&tls_io_instance->ssl, &tls_io_instance->config); tls_io_instance->tls_status = TLS_STATE_INITIALIZED; } } CONCRETE_IO_HANDLE tlsio_mbedtls_create(void *io_create_parameters) { TLSIO_CONFIG *tls_io_config = (TLSIO_CONFIG *)io_create_parameters; TLS_IO_INSTANCE *result; if (tls_io_config == NULL) { LogError("NULL tls_io_config"); result = NULL; } else { // Codes_SRS_TLSIO_MBED_OS5_TLS_99_006: [ The tlsio_mbedtls_create shall return NULL if allocating memory for TLS_IO_INSTANCE failed. ] result = calloc(1, sizeof(TLS_IO_INSTANCE)); if (result != NULL) { SOCKETIO_CONFIG socketio_config; const IO_INTERFACE_DESCRIPTION *underlying_io_interface; void *io_interface_parameters; if (tls_io_config->underlying_io_interface != NULL) { underlying_io_interface = tls_io_config->underlying_io_interface; io_interface_parameters = tls_io_config->underlying_io_parameters; } else { socketio_config.hostname = tls_io_config->hostname; socketio_config.port = tls_io_config->port; socketio_config.accepted_socket = NULL; underlying_io_interface = socketio_get_interface_description(); io_interface_parameters = &socketio_config; } if (underlying_io_interface == NULL) { free(result); result = NULL; LogError("Failed getting socket IO interface description."); } else { if (mallocAndStrcpy_s((char **)&result->hostname, tls_io_config->hostname) != 0) { free(result); result = NULL; LogError("Failure allocating hostname."); } else if ((result->socket_io = xio_create(underlying_io_interface, io_interface_parameters)) == NULL) { LogError("socket xio create failed"); free(result->hostname); free(result); result = NULL; } else { result->tls_status = TLS_STATE_NOT_INITIALIZED; mbedtls_init((void*)result); result->tlsio_state = TLSIO_STATE_NOT_OPEN; result->invoke_on_send_complete_callback_for_fragments = tls_io_config->invoke_on_send_complete_callback_for_fragments; } } } else { LogError("Failure allocating TLS object"); } } return result; } void tlsio_mbedtls_destroy(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; mbedtls_uninit(tls_io_instance); xio_close(tls_io_instance->socket_io, NULL, NULL); if (tls_io_instance->socket_io_read_bytes != NULL) { free(tls_io_instance->socket_io_read_bytes); tls_io_instance->socket_io_read_bytes = NULL; } xio_destroy(tls_io_instance->socket_io); if (tls_io_instance->hostname != NULL) { free(tls_io_instance->hostname); tls_io_instance->hostname = NULL; } if (tls_io_instance->trusted_certificates != NULL) { free(tls_io_instance->trusted_certificates); tls_io_instance->trusted_certificates = NULL; } if (tls_io_instance->x509_certificate != NULL) { free(tls_io_instance->x509_certificate); tls_io_instance->x509_certificate = NULL; } if (tls_io_instance->x509_private_key != NULL) { free(tls_io_instance->x509_private_key); tls_io_instance->x509_private_key = NULL; } free(tls_io); } } int tlsio_mbedtls_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void *on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void *on_bytes_received_context, ON_IO_ERROR on_io_error, void *on_io_error_context) { int result = 0; if (tls_io == NULL) { LogError("Invalid parameter specified tls_io: NULL"); result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { LogError("IO should not be open: %d", tls_io_instance->tlsio_state); result = MU_FAILURE; } else { tls_io_instance->on_bytes_received = on_bytes_received; tls_io_instance->on_bytes_received_context = on_bytes_received_context; tls_io_instance->on_io_open_complete = on_io_open_complete; tls_io_instance->on_io_open_complete_context = on_io_open_complete_context; tls_io_instance->on_io_error = on_io_error; tls_io_instance->on_io_error_context = on_io_error_context; tls_io_instance->tlsio_state = TLSIO_STATE_OPENING_UNDERLYING_IO; mbedtls_ssl_session_reset(&tls_io_instance->ssl); if (xio_open(tls_io_instance->socket_io, on_underlying_io_open_complete, tls_io_instance, on_underlying_io_bytes_received, tls_io_instance, on_underlying_io_error, tls_io_instance) != 0) { LogError("Underlying IO open failed"); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } } } return result; } int tlsio_mbedtls_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void *callback_context) { int result = 0; if (tls_io == NULL) { LogError("Invalid parameter specified tls_io: NULL"); result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if ((tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) || (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING)) { LogError("IO should not be closed: %d", tls_io_instance->tlsio_state); result = MU_FAILURE; } else { int is_error = tls_io_instance->tlsio_state == TLSIO_STATE_ERROR; tls_io_instance->tlsio_state = TLSIO_STATE_CLOSING; if (tls_io_instance->tls_status == TLS_STATE_INITIALIZED) { if (is_error) { // forced shutdown if tls is in ERROR state mbedtls_ssl_session_reset(&tls_io_instance->ssl); } else { // Tell the peer that you're going to close mbedtls_ssl_close_notify(&tls_io_instance->ssl); } tls_io_instance->tls_status = TLS_STATE_CLOSING; } tls_io_instance->on_io_close_complete = on_io_close_complete; tls_io_instance->on_io_close_complete_context = callback_context; if (xio_close(tls_io_instance->socket_io, on_underlying_io_close_complete_during_close, tls_io_instance) != 0) { LogError("xio_close failed"); result = MU_FAILURE; } else { result = 0; } } } return result; } int tlsio_mbedtls_send(CONCRETE_IO_HANDLE tls_io, const void *buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void *callback_context) { int result = 0; if (tls_io == NULL || (buffer == NULL) || (size == 0)) { LogError("Invalid parameter specified tls_io: %p, buffer: %p, size: %ul", tls_io, buffer, (unsigned int)size); result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN) { LogError("Invalid state specified %d", tls_io_instance->tlsio_state); result = MU_FAILURE; } else { tls_io_instance->send_complete_info.on_send_complete = on_send_complete; tls_io_instance->send_complete_info.on_send_complete_callback_context = callback_context; tls_io_instance->send_complete_info.last_fragmented_req_status = IO_SEND_OK; int out_left = (int)size; result = 0; do { tls_io_instance->send_complete_info.is_fragmented_req = is_fragmented_send_request(tls_io_instance, out_left); unsigned char *buf = (unsigned char *)buffer + size - out_left; int ret = mbedtls_ssl_write(&tls_io_instance->ssl, buf, out_left); if (ret < 0) { LogError("Unexpected data size returned from mbedtls_ssl_write %d/%d", ret, (int)size); result = MU_FAILURE; break; } else if (tls_io_instance->send_complete_info.last_fragmented_req_status != IO_SEND_OK) { LogError("Failed to send last fragment with error:0x%0x, aborting whole send", tls_io_instance->send_complete_info.last_fragmented_req_status); result = MU_FAILURE; break; } out_left -= ret; } while (out_left > 0); // remove on send complete info memset((void*)&tls_io_instance->send_complete_info, 0, sizeof(tls_io_instance->send_complete_info)); } } return result; } void tlsio_mbedtls_dowork(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (tls_io_instance->tlsio_state == TLSIO_STATE_IN_HANDSHAKE || tls_io_instance->tlsio_state == TLSIO_STATE_OPEN) { decode_ssl_received_bytes(tls_io_instance); } xio_dowork(tls_io_instance->socket_io); } } // this function will clone an option given by name and value static void *tlsio_mbedtls_CloneOption(const char *name, const void *value) { void *result = NULL; if (name == NULL || value == NULL) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); result = NULL; } else { if (strcmp(name, OPTION_UNDERLYING_IO_OPTIONS) == 0) { result = (void*)OptionHandler_Clone((OPTIONHANDLER_HANDLE)value); } else if (strcmp(name, OPTION_TRUSTED_CERT) == 0) { if (mallocAndStrcpy_s((char **)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s TrustedCerts value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509certificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509privatekey value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_X509_ECC_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509EccCertificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_X509_ECC_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509EccKey value"); result = NULL; } else { /*return as is*/ } } else { LogError("not handled option : %s", name); result = NULL; } } return result; } // this function destroys an option previously created static void tlsio_mbedtls_DestroyOption(const char *name, const void *value) { // since all options for this layer are actually string copies., disposing of one is just calling free if (name == NULL || value == NULL) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); } else { if ( (strcmp(name, OPTION_TRUSTED_CERT) == 0) || (strcmp(name, SU_OPTION_X509_CERT) == 0) || (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) || (strcmp(name, OPTION_X509_ECC_CERT) == 0) || (strcmp(name, OPTION_X509_ECC_KEY) == 0) ) { free((void*)value); } else if (strcmp(name, OPTION_UNDERLYING_IO_OPTIONS) == 0) { OptionHandler_Destroy((OPTIONHANDLER_HANDLE)value); } else { LogError("not handled option : %s", name); } } } int tlsio_mbedtls_setoption(CONCRETE_IO_HANDLE tls_io, const char *optionName, const void *value) { int result = 0; if (tls_io == NULL || optionName == NULL) { result = MU_FAILURE; } else { TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)tls_io; if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { if (tls_io_instance->trusted_certificates != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->trusted_certificates); tls_io_instance->trusted_certificates = NULL; } if (mallocAndStrcpy_s(&tls_io_instance->trusted_certificates, (const char *)value) != 0) { LogError("unable to mallocAndStrcpy_s"); result = MU_FAILURE; } else { int parse_result = mbedtls_x509_crt_parse(&tls_io_instance->trusted_certificates_parsed, (const unsigned char *)value, (int)(strlen(value) + 1)); if (parse_result != 0) { LogInfo("Malformed pem certificate"); free(tls_io_instance->trusted_certificates); tls_io_instance->trusted_certificates = NULL; result = MU_FAILURE; } else { mbedtls_ssl_conf_ca_chain(&tls_io_instance->config, &tls_io_instance->trusted_certificates_parsed, NULL); } } } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { char* temp_cert; if (mallocAndStrcpy_s(&temp_cert, (const char *)value) != 0) { LogError("unable to mallocAndStrcpy_s on certificate"); result = MU_FAILURE; } else if (mbedtls_x509_crt_parse(&tls_io_instance->owncert, (const unsigned char *)temp_cert, (int)(strlen(temp_cert) + 1)) != 0) { LogError("failure parsing certificate"); free(temp_cert); result = MU_FAILURE; } else if (mbedtls_pk_get_type(&tls_io_instance->pKey) != MBEDTLS_PK_NONE && mbedtls_ssl_conf_own_cert(&tls_io_instance->config, &tls_io_instance->owncert, &tls_io_instance->pKey) != 0) { LogError("failure calling mbedtls_ssl_conf_own_cert"); free(temp_cert); result = MU_FAILURE; } else { if (tls_io_instance->x509_certificate != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->x509_certificate); } tls_io_instance->x509_certificate = temp_cert; result = 0; } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { char* temp_key; if (mallocAndStrcpy_s(&temp_key, (const char *)value) != 0) { LogError("unable to mallocAndStrcpy_s on private key"); result = MU_FAILURE; } else if (mbedtls_pk_parse_key(&tls_io_instance->pKey, (const unsigned char *)temp_key, (int)(strlen(temp_key) + 1), NULL, 0) != 0) { LogError("failure calling mbedtls_pk_parse_key"); free(temp_key); result = MU_FAILURE; } else if (tls_io_instance->owncert.version > 0 && mbedtls_ssl_conf_own_cert(&tls_io_instance->config, &tls_io_instance->owncert, &tls_io_instance->pKey)) { LogError("failure calling mbedtls_ssl_conf_own_cert"); free(temp_key); result = MU_FAILURE; } else { if (tls_io_instance->x509_private_key != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->x509_private_key); } tls_io_instance->x509_private_key = temp_key; result = 0; } } else if (strcmp(optionName, OPTION_UNDERLYING_IO_OPTIONS) == 0) { if (OptionHandler_FeedOptions((OPTIONHANDLER_HANDLE)value, (void*)tls_io_instance->socket_io) != OPTIONHANDLER_OK) { LogError("failed feeding options to underlying I/O instance"); result = MU_FAILURE; } else { result = 0; } } else if (strcmp(optionName, OPTION_SET_TLS_RENEGOTIATION) == 0) { if (value == NULL) { LogError("Invalid value set for tls renegotiation"); result = MU_FAILURE; } else { bool set_renegotiation = *((bool*)(value)); mbedtls_ssl_conf_renegotiation(&tls_io_instance->config, set_renegotiation ? 1 : 0); result = 0; } } else { // tls_io_instance->socket_io is never NULL result = xio_setoption(tls_io_instance->socket_io, optionName, value); } } return result; } OPTIONHANDLER_HANDLE tlsio_mbedtls_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result = NULL; if (handle == NULL) { LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle=%p", handle); result = NULL; } else { result = OptionHandler_Create(tlsio_mbedtls_CloneOption, tlsio_mbedtls_DestroyOption, tlsio_mbedtls_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); // return as is } else { // this layer cares about the certificates TLS_IO_INSTANCE *tls_io_instance = (TLS_IO_INSTANCE *)handle; OPTIONHANDLER_HANDLE underlying_io_options; if ((underlying_io_options = xio_retrieveoptions(tls_io_instance->socket_io)) == NULL) { LogError("unable to retrieve underlying_io options"); OptionHandler_Destroy(result); result = NULL; } else { if (OptionHandler_AddOption(result, OPTION_UNDERLYING_IO_OPTIONS, underlying_io_options) != OPTIONHANDLER_OK) { LogError("unable to save underlying_io options"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->trusted_certificates != NULL && OptionHandler_AddOption(result, OPTION_TRUSTED_CERT, tls_io_instance->trusted_certificates) != OPTIONHANDLER_OK) { LogError("unable to save TrustedCerts option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->x509_certificate != NULL && OptionHandler_AddOption(result, SU_OPTION_X509_CERT, tls_io_instance->x509_certificate) != OPTIONHANDLER_OK) { LogError("unable to save x509certificate option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->x509_private_key != NULL && OptionHandler_AddOption(result, SU_OPTION_X509_PRIVATE_KEY, tls_io_instance->x509_private_key) != OPTIONHANDLER_OK) { LogError("unable to save x509privatekey option"); OptionHandler_Destroy(result); result = NULL; } else { // all is fine, all interesting options have been saved // return as is } OptionHandler_Destroy(underlying_io_options); } } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_mbedtls_interface_description = { tlsio_mbedtls_retrieveoptions, tlsio_mbedtls_create, tlsio_mbedtls_destroy, tlsio_mbedtls_open, tlsio_mbedtls_close, tlsio_mbedtls_send, tlsio_mbedtls_dowork, tlsio_mbedtls_setoption }; const IO_INTERFACE_DESCRIPTION *tlsio_mbedtls_get_interface_description(void) { return &tlsio_mbedtls_interface_description; } tlsio_openssl.c000066400000000000000000001705251455573770000341510ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include "openssl/ssl.h" #include "openssl/err.h" #include "openssl/crypto.h" #include "openssl/opensslv.h" #include "openssl/engine.h" #include #include #include #include "azure_c_shared_utility/lock.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/tlsio_openssl.h" #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "azure_c_shared_utility/x509_openssl.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/const_defines.h" typedef enum TLSIO_STATE_TAG { TLSIO_STATE_NOT_OPEN, TLSIO_STATE_OPENING_UNDERLYING_IO, TLSIO_STATE_IN_HANDSHAKE, // TLSIO_STATE_HANDSHAKE_FAILED is an ephemeral state signalling successful socket // operation but with rejected handshake. The tlsio will never be in this state // at the start of any of the API calls. TLSIO_STATE_HANDSHAKE_FAILED, TLSIO_STATE_OPEN, TLSIO_STATE_CLOSING, TLSIO_STATE_ERROR } TLSIO_STATE; typedef enum TLSIO_VERSION_TAG { VERSION_1_0 = 10, VERSION_1_1 = 11, VERSION_1_2 = 12, } TLSIO_VERSION; static bool is_an_opening_state(TLSIO_STATE state) { // TLSIO_STATE_HANDSHAKE_FAILED is deliberately not one of these states. return state == TLSIO_STATE_OPENING_UNDERLYING_IO || state == TLSIO_STATE_IN_HANDSHAKE; } typedef int(*TLS_CERTIFICATE_VALIDATION_CALLBACK)(X509_STORE_CTX*, void*); typedef struct TLS_IO_INSTANCE_TAG { XIO_HANDLE underlying_io; ON_BYTES_RECEIVED on_bytes_received; ON_IO_OPEN_COMPLETE on_io_open_complete; ON_IO_CLOSE_COMPLETE on_io_close_complete; ON_IO_ERROR on_io_error; void* on_bytes_received_context; void* on_io_open_complete_context; void* on_io_close_complete_context; void* on_io_error_context; SSL* ssl; SSL_CTX* ssl_context; BIO* in_bio; BIO* out_bio; TLSIO_STATE tlsio_state; char* certificate; char* cipher_list; const char* x509_certificate; const char* x509_private_key; TLSIO_VERSION tls_version; TLS_CERTIFICATE_VALIDATION_CALLBACK tls_validation_callback; void* tls_validation_callback_data; char* hostname; char* engine_id; bool ignore_host_name_check; ENGINE* engine; OPTION_OPENSSL_KEY_TYPE x509_private_key_type; } TLS_IO_INSTANCE; struct CRYPTO_dynlock_value { LOCK_HANDLE lock; }; static const char* const OPTION_UNDERLYING_IO_OPTIONS = "underlying_io_options"; #define SSL_DO_HANDSHAKE_SUCCESS 1 /*this function will clone an option given by name and value*/ static void* tlsio_openssl_CloneOption(const char* name, const void* value) { void* result; if ( (name == NULL) || (value == NULL) ) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); result = NULL; } else { if (strcmp(name, OPTION_UNDERLYING_IO_OPTIONS) == 0) { result = (void*)OptionHandler_Clone((OPTIONHANDLER_HANDLE)value); } else if (strcmp(name, OPTION_TRUSTED_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s TrustedCerts value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_OPENSSL_CIPHER_SUITE) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s CipherSuite value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509certificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509privatekey value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_X509_ECC_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509EccCertificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_X509_ECC_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509EccKey value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_TLS_VERSION) == 0) { int int_value; if (*(TLSIO_VERSION*)value == VERSION_1_0) { int_value = 10; } else if (*(TLSIO_VERSION*)value == VERSION_1_1) { int_value = 11; } else if (*(TLSIO_VERSION*)value == VERSION_1_2) { int_value = 12; } else { LogError("Unexpected TLS version value (%d)", *(int*)value); int_value = -1; } if (int_value < 0) { result = NULL; } else { int* value_clone; if ((value_clone = (int*)malloc(sizeof(int))) == NULL) { LogError("Failed cloning tls_version option"); } else { *value_clone = int_value; } result = value_clone; } } else if ( (strcmp(name, "tls_validation_callback") == 0) || (strcmp(name, "tls_validation_callback_data") == 0) ) { result = (void*)value; } else if (strcmp(name, OPTION_OPENSSL_ENGINE) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s Engine value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_OPENSSL_PRIVATE_KEY_TYPE) == 0) { OPTION_OPENSSL_KEY_TYPE key_type_value = *((OPTION_OPENSSL_KEY_TYPE*)value); OPTION_OPENSSL_KEY_TYPE* value_clone; if ((value_clone = (OPTION_OPENSSL_KEY_TYPE*)malloc(sizeof(OPTION_OPENSSL_KEY_TYPE))) == NULL) { LogError("Failed cloning cert or private key option"); } else { *value_clone = key_type_value; } result = value_clone; } else { LogError("not handled option : %s", name); result = NULL; } } return result; } /*this function destroys an option previously created*/ static void tlsio_openssl_DestroyOption(const char* name, const void* value) { /*since all options for this layer are actually string copies., disposing of one is just calling free*/ if ( (name == NULL) || (value == NULL) ) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); } else { if ( (strcmp(name, OPTION_TRUSTED_CERT) == 0) || (strcmp(name, OPTION_OPENSSL_CIPHER_SUITE) == 0) || (strcmp(name, SU_OPTION_X509_CERT) == 0) || (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) || (strcmp(name, OPTION_X509_ECC_CERT) == 0) || (strcmp(name, OPTION_X509_ECC_KEY) == 0) || (strcmp(name, OPTION_TLS_VERSION) == 0) || (strcmp(name, OPTION_OPENSSL_ENGINE) == 0) || (strcmp(name, OPTION_OPENSSL_PRIVATE_KEY_TYPE) == 0) ) { free((void*)value); } else if ( (strcmp(name, "tls_validation_callback") == 0) || (strcmp(name, "tls_validation_callback_data") == 0) ) { // nothing to free. } else if (strcmp(name, OPTION_UNDERLYING_IO_OPTIONS) == 0) { OptionHandler_Destroy((OPTIONHANDLER_HANDLE)value); } else { LogError("not handled option : %s", name); } } } static OPTIONHANDLER_HANDLE tlsio_openssl_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result; if (handle == NULL) { LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle=%p", handle); result = NULL; } else { result = OptionHandler_Create(tlsio_openssl_CloneOption, tlsio_openssl_DestroyOption, tlsio_openssl_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); /*return as is*/ } else { /*this layer cares about the certificates and the x509 credentials*/ TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)handle; OPTIONHANDLER_HANDLE underlying_io_options; if ((underlying_io_options = xio_retrieveoptions(tls_io_instance->underlying_io)) == NULL) { LogError("unable to retrieve underlying_io options"); OptionHandler_Destroy(result); result = NULL; } else { if (OptionHandler_AddOption(result, OPTION_UNDERLYING_IO_OPTIONS, underlying_io_options) != OPTIONHANDLER_OK) { LogError("unable to save underlying_io options"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->certificate != NULL) && (OptionHandler_AddOption(result, OPTION_TRUSTED_CERT, tls_io_instance->certificate) != OPTIONHANDLER_OK) ) { LogError("unable to save TrustedCerts option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->cipher_list != NULL) && (OptionHandler_AddOption(result, OPTION_OPENSSL_CIPHER_SUITE, tls_io_instance->cipher_list) != OPTIONHANDLER_OK) ) { LogError("unable to save CipherSuite option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->x509_certificate != NULL && (OptionHandler_AddOption(result, SU_OPTION_X509_CERT, tls_io_instance->x509_certificate) != OPTIONHANDLER_OK) ) { LogError("unable to save x509 certificate option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->x509_private_key != NULL && (OptionHandler_AddOption(result, SU_OPTION_X509_PRIVATE_KEY, tls_io_instance->x509_private_key) != OPTIONHANDLER_OK) ) { LogError("unable to save x509 privatekey option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->tls_version != 0 && (OptionHandler_AddOption(result, OPTION_TLS_VERSION, &tls_io_instance->tls_version) != OPTIONHANDLER_OK) ) { LogError("unable to save tls_version option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->engine_id != NULL) && (OptionHandler_AddOption(result, OPTION_OPENSSL_ENGINE, tls_io_instance->engine_id) != OPTIONHANDLER_OK) ) { LogError("unable to save Engine option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->x509_private_key_type != KEY_TYPE_DEFAULT) && (OptionHandler_AddOption(result, OPTION_OPENSSL_PRIVATE_KEY_TYPE, &tls_io_instance->x509_private_key_type)) ) { LogError("unable to save x509PrivatekeyType option"); OptionHandler_Destroy(result); result = NULL; } else if (tls_io_instance->tls_validation_callback != NULL) { #ifdef WIN32 #pragma warning(push) #pragma warning(disable:4152) #endif void* ptr = tls_io_instance->tls_validation_callback; #ifdef WIN32 #pragma warning(pop) #endif if (OptionHandler_AddOption(result, "tls_validation_callback", (const char*)ptr) != OPTIONHANDLER_OK) { LogError("unable to save tls_validation_callback option"); OptionHandler_Destroy(result); result = NULL; } if (OptionHandler_AddOption(result, "tls_validation_callback_data", (const char*)tls_io_instance->tls_validation_callback_data) != OPTIONHANDLER_OK) { LogError("unable to save tls_validation_callback_data option"); OptionHandler_Destroy(result); result = NULL; } } else { /*all is fine, all interesting options have been saved*/ /*return as is*/ } // Must destroy since OptionHandler_AddOption creates a copy of it. OptionHandler_Destroy(underlying_io_options); } } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_openssl_interface_description = { tlsio_openssl_retrieveoptions, tlsio_openssl_create, tlsio_openssl_destroy, tlsio_openssl_open, tlsio_openssl_close, tlsio_openssl_send, tlsio_openssl_dowork, tlsio_openssl_setoption }; static LOCK_HANDLE * openssl_locks = NULL; static void openssl_lock_unlock_helper(LOCK_HANDLE lock, int lock_mode, const char* file, int line) { #ifdef NO_LOGGING // Avoid unused variable warning when logging not compiled in (void)file; (void)line; #endif if (lock_mode & CRYPTO_LOCK) { if (Lock(lock) != LOCK_OK) { LogError("Failed to lock openssl lock (%s:%d)", file, line); } } else { if (Unlock(lock) != LOCK_OK) { LogError("Failed to unlock openssl lock (%s:%d)", file, line); } } } static void log_ERR_get_error(const char* message) { char buf[128]; AZURE_UNREFERENCED_PARAMETER(buf); unsigned long error; int i; if (message != NULL) { LogError("%s", message); } error = ERR_get_error(); for (i = 0; 0 != error; i++) { LogError(" [%d] %s", i, ERR_error_string(error, buf)); error = ERR_get_error(); } } static STATIC_VAR_UNUSED struct CRYPTO_dynlock_value* openssl_dynamic_locks_create_cb(const char* file, int line) { #ifdef NO_LOGGING // Avoid unused variable warning when logging not compiled in (void)file; (void)line; #endif struct CRYPTO_dynlock_value* result; result = malloc(sizeof(struct CRYPTO_dynlock_value)); if (result == NULL) { LogError("Failed to allocate lock! Out of memory (%s:%d).", file, line); } else { result->lock = Lock_Init(); if (result->lock == NULL) { LogError("Failed to create lock for dynamic lock (%s:%d).", file, line); free(result); result = NULL; } } return result; } static STATIC_VAR_UNUSED void openssl_dynamic_locks_lock_unlock_cb(int lock_mode, struct CRYPTO_dynlock_value* dynlock_value, const char* file, int line) { openssl_lock_unlock_helper(dynlock_value->lock, lock_mode, file, line); } static STATIC_VAR_UNUSED void openssl_dynamic_locks_destroy_cb(struct CRYPTO_dynlock_value* dynlock_value, const char* file, int line) { (void)file; (void)line; Lock_Deinit(dynlock_value->lock); free(dynlock_value); } static void openssl_dynamic_locks_uninstall(void) { #if (OPENSSL_VERSION_NUMBER >= 0x00906000) CRYPTO_set_dynlock_create_callback(NULL); CRYPTO_set_dynlock_lock_callback(NULL); CRYPTO_set_dynlock_destroy_callback(NULL); #endif } static void openssl_dynamic_locks_install(void) { #if (OPENSSL_VERSION_NUMBER >= 0x00906000) CRYPTO_set_dynlock_destroy_callback(openssl_dynamic_locks_destroy_cb); CRYPTO_set_dynlock_lock_callback(openssl_dynamic_locks_lock_unlock_cb); CRYPTO_set_dynlock_create_callback(openssl_dynamic_locks_create_cb); #endif } static void STATIC_VAR_UNUSED openssl_static_locks_lock_unlock_cb(int lock_mode, int lock_index, const char * file, int line) { if (lock_index < 0 || lock_index >= CRYPTO_num_locks()) { LogError("Bad lock index %d passed (%s:%d)", lock_index, file, line); } else { openssl_lock_unlock_helper(openssl_locks[lock_index], lock_mode, file, line); } } static void openssl_static_locks_uninstall(void) { if (openssl_locks != NULL) { int i; CRYPTO_set_locking_callback(NULL); for (i = 0; i < CRYPTO_num_locks(); i++) { if (openssl_locks[i] != NULL) { Lock_Deinit(openssl_locks[i]); } } free(openssl_locks); openssl_locks = NULL; } else { LogError("Locks already uninstalled"); } } static int openssl_static_locks_install(void) { int result; if (openssl_locks != NULL) { LogInfo("Locks already initialized"); result = MU_FAILURE; } else { openssl_locks = malloc(CRYPTO_num_locks() * sizeof(LOCK_HANDLE)); if (openssl_locks == NULL) { LogError("Failed to allocate locks"); result = MU_FAILURE; } else { int i; for (i = 0; i < CRYPTO_num_locks(); i++) { openssl_locks[i] = Lock_Init(); if (openssl_locks[i] == NULL) { LogError("Failed to allocate lock %d", i); break; } } if (i != CRYPTO_num_locks()) { int j; for (j = 0; j < i; j++) { Lock_Deinit(openssl_locks[j]); } result = MU_FAILURE; } else { CRYPTO_set_locking_callback(openssl_static_locks_lock_unlock_cb); result = 0; } } } return result; } static void indicate_error(TLS_IO_INSTANCE* tls_io_instance) { if (tls_io_instance->on_io_error == NULL) { LogError("NULL on_io_error."); } else { tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } } static void indicate_open_complete(TLS_IO_INSTANCE* tls_io_instance, IO_OPEN_RESULT open_result) { if (tls_io_instance->on_io_open_complete == NULL) { LogError("NULL on_io_open_complete."); } else { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, open_result); } } static int write_outgoing_bytes(TLS_IO_INSTANCE* tls_io_instance, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; size_t pending = BIO_ctrl_pending(tls_io_instance->out_bio); if (pending == 0) { result = 0; } else { unsigned char* bytes_to_send = malloc(pending); if (bytes_to_send == NULL) { LogError("NULL bytes_to_send."); result = MU_FAILURE; } else { if (BIO_read(tls_io_instance->out_bio, bytes_to_send, (int)pending) != (int)pending) { log_ERR_get_error("BIO_read not in pending state."); result = MU_FAILURE; } else { if (xio_send(tls_io_instance->underlying_io, bytes_to_send, pending, on_send_complete, callback_context) != 0) { LogError("Error in xio_send."); result = MU_FAILURE; } else { result = 0; } } free(bytes_to_send); } } return result; } // Non-NULL tls_io_instance is guaranteed by callers. // We are in TLSIO_STATE_IN_HANDSHAKE when entering this method. static void send_handshake_bytes(TLS_IO_INSTANCE* tls_io_instance) { int hsret; // ERR_clear_error must be called before any call that might set an // SSL_get_error result ERR_clear_error(); hsret = SSL_do_handshake(tls_io_instance->ssl); if (hsret != SSL_DO_HANDSHAKE_SUCCESS) { int ssl_err = SSL_get_error(tls_io_instance->ssl, hsret); if (ssl_err != SSL_ERROR_WANT_READ && ssl_err != SSL_ERROR_WANT_WRITE) { if (ssl_err == SSL_ERROR_SSL) { LogError("%s", ERR_error_string(ERR_get_error(), NULL)); } else { LogError("SSL handshake failed: %d", ssl_err); } tls_io_instance->tlsio_state = TLSIO_STATE_HANDSHAKE_FAILED; } else { if (write_outgoing_bytes(tls_io_instance, NULL, NULL) != 0) { LogError("Error in write_outgoing_bytes."); tls_io_instance->tlsio_state = TLSIO_STATE_HANDSHAKE_FAILED; } } } else { tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_OK); } } void engine_destroy(TLS_IO_INSTANCE* tls) { if(tls->engine != NULL) { ENGINE_free(tls->engine); // Release structural reference. tls->engine = NULL; } } int engine_load(TLS_IO_INSTANCE* tls) { int result; // TLSIO is only responsible for the Engine structural reference. tls->engine = ENGINE_by_id(tls->engine_id); if (tls->engine == NULL) { log_ERR_get_error("unable to load engine by ID."); result = MU_FAILURE; } else { result = 0; } return result; } static void close_openssl_instance(TLS_IO_INSTANCE* tls_io_instance) { if (tls_io_instance->ssl != NULL) { SSL_free(tls_io_instance->ssl); tls_io_instance->ssl = NULL; } if (tls_io_instance->ssl_context != NULL) { SSL_CTX_free(tls_io_instance->ssl_context); tls_io_instance->ssl_context = NULL; } } static void on_underlying_io_close_complete(void* context) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; switch (tls_io_instance->tlsio_state) { default: case TLSIO_STATE_NOT_OPEN: case TLSIO_STATE_OPEN: case TLSIO_STATE_IN_HANDSHAKE: case TLSIO_STATE_HANDSHAKE_FAILED: case TLSIO_STATE_ERROR: break; case TLSIO_STATE_OPENING_UNDERLYING_IO: tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); break; case TLSIO_STATE_CLOSING: tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; if (tls_io_instance->on_io_close_complete != NULL) { tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context); } break; } close_openssl_instance(tls_io_instance); } static void on_underlying_io_open_complete(void* context, IO_OPEN_RESULT open_result) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (tls_io_instance->tlsio_state == TLSIO_STATE_OPENING_UNDERLYING_IO) { if (open_result == IO_OPEN_OK) { tls_io_instance->tlsio_state = TLSIO_STATE_IN_HANDSHAKE; // Begin the handshake process here. It continues in on_underlying_io_bytes_received send_handshake_bytes(tls_io_instance); } else { tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); LogError("Invalid tlsio_state. Expected state is TLSIO_STATE_OPENING_UNDERLYING_IO."); } } } static void on_underlying_io_error(void* context) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; switch (tls_io_instance->tlsio_state) { default: break; case TLSIO_STATE_OPENING_UNDERLYING_IO: case TLSIO_STATE_IN_HANDSHAKE: tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); break; case TLSIO_STATE_OPEN: indicate_error(tls_io_instance); break; } } static int decode_ssl_received_bytes(TLS_IO_INSTANCE* tls_io_instance) { int result = 0; unsigned char buffer[64]; int rcv_bytes = 1; while (rcv_bytes > 0) { if (tls_io_instance->ssl == NULL) { LogError("SSL channel closed in decode_ssl_received_bytes."); result = MU_FAILURE; return result; } rcv_bytes = SSL_read(tls_io_instance->ssl, buffer, sizeof(buffer)); if (rcv_bytes > 0) { if (tls_io_instance->on_bytes_received == NULL) { LogError("NULL on_bytes_received."); } else { tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, buffer, rcv_bytes); } } } return result; } static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; int written = BIO_write(tls_io_instance->in_bio, buffer, (int)size); if (written != (int)size) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); log_ERR_get_error("Error in BIO_write."); } else { switch (tls_io_instance->tlsio_state) { default: break; case TLSIO_STATE_IN_HANDSHAKE: send_handshake_bytes(tls_io_instance); break; case TLSIO_STATE_OPEN: if (decode_ssl_received_bytes(tls_io_instance) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); LogError("Error in decode_ssl_received_bytes."); } break; } } } static int add_certificate_to_store(TLS_IO_INSTANCE* tls_io_instance, const char* certValue) { int result = 0; if (certValue != NULL) { X509_STORE* cert_store = SSL_CTX_get_cert_store(tls_io_instance->ssl_context); if (cert_store == NULL) { log_ERR_get_error("failure in SSL_CTX_get_cert_store."); result = MU_FAILURE; } else { #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER) const BIO_METHOD* bio_method; #else BIO_METHOD* bio_method; #endif bio_method = BIO_s_mem(); if (bio_method == NULL) { log_ERR_get_error("failure in BIO_s_mem"); result = MU_FAILURE; } else { BIO* cert_memory_bio = BIO_new(bio_method); if (cert_memory_bio == NULL) { log_ERR_get_error("failure in BIO_new"); result = MU_FAILURE; } else { int puts_result = BIO_puts(cert_memory_bio, certValue); if (puts_result < 0) { log_ERR_get_error("failure in BIO_puts"); result = MU_FAILURE; } else { if ((size_t)puts_result != strlen(certValue)) { log_ERR_get_error("mismatching legths"); result = MU_FAILURE; } else { X509* certificate; while ((certificate = PEM_read_bio_X509(cert_memory_bio, NULL, NULL, NULL)) != NULL) { if (!X509_STORE_add_cert(cert_store, certificate)) { X509_free(certificate); log_ERR_get_error("failure in X509_STORE_add_cert"); break; } X509_free(certificate); } if (certificate == NULL) { result = 0;/*all is fine*/ } else { /*previous while loop terminated unfortunately*/ result = MU_FAILURE; } } } BIO_free(cert_memory_bio); } } } } return result; } static int enable_domain_check(TLS_IO_INSTANCE* tlsInstance) { int result = 0; if (!tlsInstance->ignore_host_name_check) { #if (OPENSSL_VERSION_NUMBER < 0x10002000L) #error "OpenSSL v1.0.2 or above required. See https://wiki.openssl.org/index.php/Hostname_validation for details." #endif X509_VERIFY_PARAM *param = SSL_get0_param(tlsInstance->ssl); X509_VERIFY_PARAM_set_hostflags(param, 0); if (!(X509_VERIFY_PARAM_set1_ip_asc(param, tlsInstance->hostname) || X509_VERIFY_PARAM_set1_host(param, tlsInstance->hostname, strlen(tlsInstance->hostname)))) { result = MU_FAILURE; } else { SSL_set_verify(tlsInstance->ssl, SSL_VERIFY_PEER, NULL); } } return result; } static int create_openssl_instance(TLS_IO_INSTANCE* tlsInstance) { int result; const SSL_METHOD* method = NULL; #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || (OPENSSL_VERSION_NUMBER >= 0x20000000L) if (tlsInstance->tls_version == VERSION_1_2) { method = TLSv1_2_method(); } else if (tlsInstance->tls_version == VERSION_1_1) { method = TLSv1_1_method(); } else { method = TLSv1_method(); } #else { method = TLS_method(); } #endif tlsInstance->ssl_context = SSL_CTX_new(method); if (tlsInstance->ssl_context == NULL) { log_ERR_get_error("Failed allocating OpenSSL context."); result = MU_FAILURE; } else if ((tlsInstance->engine_id != NULL) && (engine_load(tlsInstance) != 0)) { SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; result = MU_FAILURE; } else if ((tlsInstance->cipher_list != NULL) && (SSL_CTX_set_cipher_list(tlsInstance->ssl_context, tlsInstance->cipher_list)) != 1) { engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("unable to set cipher list."); result = MU_FAILURE; } else if (add_certificate_to_store(tlsInstance, tlsInstance->certificate) != 0) { engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("unable to add_certificate_to_store."); result = MU_FAILURE; } /*x509 authentication can only be build before underlying connection is realized*/ else if ( (tlsInstance->x509_certificate != NULL) && (tlsInstance->x509_private_key != NULL) && (x509_openssl_add_credentials( tlsInstance->ssl_context, tlsInstance->x509_certificate, tlsInstance->x509_private_key, tlsInstance->x509_private_key_type, tlsInstance->engine) != 0) ) { engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("unable to use x509 authentication"); result = MU_FAILURE; } else { SSL_CTX_set_cert_verify_callback(tlsInstance->ssl_context, tlsInstance->tls_validation_callback, tlsInstance->tls_validation_callback_data); tlsInstance->in_bio = BIO_new(BIO_s_mem()); if (tlsInstance->in_bio == NULL) { engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("Failed BIO_new for in BIO."); result = MU_FAILURE; } else { tlsInstance->out_bio = BIO_new(BIO_s_mem()); if (tlsInstance->out_bio == NULL) { (void)BIO_free(tlsInstance->in_bio); engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("Failed BIO_new for out BIO."); result = MU_FAILURE; } else { if ((BIO_set_mem_eof_return(tlsInstance->in_bio, -1) <= 0) || (BIO_set_mem_eof_return(tlsInstance->out_bio, -1) <= 0)) { (void)BIO_free(tlsInstance->in_bio); (void)BIO_free(tlsInstance->out_bio); engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; LogError("Failed BIO_set_mem_eof_return."); result = MU_FAILURE; } else { SSL_CTX_set_verify(tlsInstance->ssl_context, SSL_VERIFY_PEER, NULL); // Specifies that the default locations for which CA certificates are loaded should be used. if (SSL_CTX_set_default_verify_paths(tlsInstance->ssl_context) != 1) { // This is only a warning to the user. They can still specify the certificate via SetOption. LogInfo("WARNING: Unable to specify the default location for CA certificates on this platform."); } tlsInstance->ssl = SSL_new(tlsInstance->ssl_context); if (tlsInstance->ssl == NULL) { (void)BIO_free(tlsInstance->in_bio); (void)BIO_free(tlsInstance->out_bio); engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("Failed creating OpenSSL instance."); result = MU_FAILURE; } else if (SSL_set_tlsext_host_name(tlsInstance->ssl, tlsInstance->hostname) != 1) { SSL_free(tlsInstance->ssl); tlsInstance->ssl = NULL; (void)BIO_free(tlsInstance->in_bio); (void)BIO_free(tlsInstance->out_bio); engine_destroy(tlsInstance); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("Failed setting SNI hostname hint."); result = MU_FAILURE; } else if (enable_domain_check(tlsInstance)) { SSL_free(tlsInstance->ssl); tlsInstance->ssl = NULL; (void)BIO_free(tlsInstance->in_bio); (void)BIO_free(tlsInstance->out_bio); SSL_CTX_free(tlsInstance->ssl_context); tlsInstance->ssl_context = NULL; log_ERR_get_error("Failed to configure domain name verification."); result = MU_FAILURE; } else { SSL_set_bio(tlsInstance->ssl, tlsInstance->in_bio, tlsInstance->out_bio); SSL_set_connect_state(tlsInstance->ssl); result = 0; } } } } } return result; } int tlsio_openssl_init(void) { (void)SSL_library_init(); SSL_load_error_strings(); ERR_load_BIO_strings(); OpenSSL_add_all_algorithms(); if (openssl_static_locks_install() != 0) { LogInfo("Failed to install static locks in OpenSSL!"); return MU_FAILURE; } openssl_dynamic_locks_install(); return 0; } void tlsio_openssl_deinit(void) { openssl_dynamic_locks_uninstall(); openssl_static_locks_uninstall(); #if (OPENSSL_VERSION_NUMBER >= 0x00907000L) && (FIPS_mode_set) FIPS_mode_set(0); #endif CRYPTO_set_locking_callback(NULL); CRYPTO_set_id_callback(NULL); ERR_free_strings(); EVP_cleanup(); #if (OPENSSL_VERSION_NUMBER < 0x10000000L) ERR_remove_state(0); #elif (OPENSSL_VERSION_NUMBER < 0x10100000L) || (OPENSSL_VERSION_NUMBER >= 0x20000000L) ERR_remove_thread_state(NULL); #endif #if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && (OPENSSL_VERSION_NUMBER < 0x10010000L) && (SSL_COMP_free_compression_methods) SSL_COMP_free_compression_methods(); #endif CRYPTO_cleanup_all_ex_data(); } CONCRETE_IO_HANDLE tlsio_openssl_create(void* io_create_parameters) { TLSIO_CONFIG* tls_io_config = io_create_parameters; TLS_IO_INSTANCE* result; if (tls_io_config == NULL) { result = NULL; LogError("NULL tls_io_config."); } else { result = malloc(sizeof(TLS_IO_INSTANCE)); if (result == NULL) { LogError("Failed allocating TLSIO instance."); } else if (mallocAndStrcpy_s(&result->hostname, tls_io_config->hostname) != 0) { LogError("Failed copying the target hostname."); free(result); result = NULL; } else { SOCKETIO_CONFIG socketio_config; const IO_INTERFACE_DESCRIPTION* underlying_io_interface; void* io_interface_parameters; if (tls_io_config->underlying_io_interface != NULL) { underlying_io_interface = tls_io_config->underlying_io_interface; io_interface_parameters = tls_io_config->underlying_io_parameters; } else { socketio_config.hostname = tls_io_config->hostname; socketio_config.port = tls_io_config->port; socketio_config.accepted_socket = NULL; underlying_io_interface = socketio_get_interface_description(); io_interface_parameters = &socketio_config; } if (underlying_io_interface == NULL) { free(result->hostname); free(result); result = NULL; LogError("Failed getting socket IO interface description."); } else { result->certificate = NULL; result->cipher_list = NULL; result->in_bio = NULL; result->out_bio = NULL; result->on_bytes_received = NULL; result->on_bytes_received_context = NULL; result->on_io_open_complete = NULL; result->on_io_open_complete_context = NULL; result->on_io_close_complete = NULL; result->on_io_close_complete_context = NULL; result->on_io_error = NULL; result->on_io_error_context = NULL; result->ssl = NULL; result->ssl_context = NULL; result->tls_validation_callback = NULL; result->tls_validation_callback_data = NULL; result->x509_certificate = NULL; result->x509_private_key = NULL; result->ignore_host_name_check = false; result->engine_id = NULL; result->engine = NULL; result->x509_private_key_type = KEY_TYPE_DEFAULT; result->tls_version = VERSION_1_2; result->underlying_io = xio_create(underlying_io_interface, io_interface_parameters); if (result->underlying_io == NULL) { free(result->hostname); free(result); result = NULL; LogError("Failed xio_create."); } else { result->tlsio_state = TLSIO_STATE_NOT_OPEN; } } } } return result; } void tlsio_openssl_destroy(CONCRETE_IO_HANDLE tls_io) { if (tls_io == NULL) { LogError("NULL tls_io."); } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; engine_destroy(tls_io_instance); if (tls_io_instance->certificate != NULL) { free(tls_io_instance->certificate); tls_io_instance->certificate = NULL; } if (tls_io_instance->cipher_list != NULL) { free(tls_io_instance->cipher_list); tls_io_instance->cipher_list = NULL; } free((void*)tls_io_instance->x509_certificate); free((void*)tls_io_instance->x509_private_key); close_openssl_instance(tls_io_instance); if (tls_io_instance->underlying_io != NULL) { xio_destroy(tls_io_instance->underlying_io); tls_io_instance->underlying_io = NULL; } free(tls_io_instance->hostname); if (tls_io_instance->engine_id != NULL) { free(tls_io_instance->engine_id); tls_io_instance->engine_id = NULL; } free(tls_io); } } int tlsio_openssl_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; if (tls_io == NULL) { result = MU_FAILURE; LogError("NULL tls_io."); } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { LogError("Invalid tlsio_state. Expected state is TLSIO_STATE_NOT_OPEN."); result = MU_FAILURE; } else { tls_io_instance->on_io_open_complete = on_io_open_complete; tls_io_instance->on_io_open_complete_context = on_io_open_complete_context; tls_io_instance->on_bytes_received = on_bytes_received; tls_io_instance->on_bytes_received_context = on_bytes_received_context; tls_io_instance->on_io_error = on_io_error; tls_io_instance->on_io_error_context = on_io_error_context; tls_io_instance->tlsio_state = TLSIO_STATE_OPENING_UNDERLYING_IO; if (create_openssl_instance(tls_io_instance) != 0) { LogError("Failed creating the OpenSSL instance."); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } else if (xio_open(tls_io_instance->underlying_io, on_underlying_io_open_complete, tls_io_instance, on_underlying_io_bytes_received, tls_io_instance, on_underlying_io_error, tls_io_instance) != 0) { LogError("Failed opening the underlying I/O."); close_openssl_instance(tls_io_instance); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } else { result = 0; } } } return result; } /* Codes_SRS_TLSIO_30_009: [ The phrase "enter TLSIO_STATE_EXT_CLOSING" means the adapter shall iterate through any unsent messages in the queue and shall delete each message after calling its on_send_complete with the associated callback_context and IO_SEND_CANCELLED. ]*/ /* Codes_SRS_TLSIO_30_006: [ The phrase "enter TLSIO_STATE_EXT_CLOSED" means the adapter shall forcibly close any existing connections then call the on_io_close_complete function and pass the on_io_close_complete_context that was supplied in tlsio_close_async. ]*/ /* Codes_SRS_TLSIO_30_051: [ On success, if the underlying TLS does not support asynchronous closing, then the adapter shall enter TLSIO_STATE_EXT_CLOSED immediately after entering TLSIO_STATE_EX_CLOSING. ]*/ int tlsio_openssl_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result; /* Codes_SRS_TLSIO_30_050: [ If the tlsio_handle parameter is NULL, tlsio_close_async shall log an error and return _FAILURE_. ]*/ if (tls_io == NULL) { LogError("NULL tls_io."); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_ERROR && tls_io_instance->tlsio_state != TLSIO_STATE_OPEN) { /* Codes_RS_TLSIO_30_053: [ If the adapter is in any state other than TLSIO_STATE_EXT_OPEN or TLSIO_STATE_EXT_ERROR then tlsio_close_async shall log that tlsio_close_async has been called and then continue normally. ]*/ // LogInfo rather than LogError because this is an unusual but not erroneous situation LogInfo("Closing tlsio from a state other than TLSIO_STATE_EXT_OPEN or TLSIO_STATE_EXT_ERROR"); } if (is_an_opening_state(tls_io_instance->tlsio_state)) { /* Codes_SRS_TLSIO_30_057: [ On success, if the adapter is in TLSIO_STATE_EXT_OPENING, it shall call on_io_open_complete with the on_io_open_complete_context supplied in tlsio_open_async and IO_OPEN_CANCELLED. This callback shall be made before changing the internal state of the adapter. ]*/ tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_CANCELLED); } if (tls_io_instance->tlsio_state == TLSIO_STATE_OPEN) { // Attempt a graceful shutdown /* Codes_SRS_TLSIO_30_056: [ On success the adapter shall enter TLSIO_STATE_EX_CLOSING. ]*/ tls_io_instance->tlsio_state = TLSIO_STATE_CLOSING; tls_io_instance->on_io_close_complete = on_io_close_complete; tls_io_instance->on_io_close_complete_context = callback_context; // xio_close is guaranteed to succeed from the open state, and the callback completes the // transition into TLSIO_STATE_NOT_OPEN if (xio_close(tls_io_instance->underlying_io, on_underlying_io_close_complete, tls_io_instance) != 0) { close_openssl_instance(tls_io_instance); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; } } else { // Just force the shutdown /* Codes_SRS_TLSIO_30_056: [ On success the adapter shall enter TLSIO_STATE_EX_CLOSING. ]*/ /* Codes_SRS_TLSIO_30_051: [ On success, if the underlying TLS does not support asynchronous closing or if the adapter is not in TLSIO_STATE_EXT_OPEN, then the adapter shall enter TLSIO_STATE_EXT_CLOSED immediately after entering TLSIO_STATE_EXT_CLOSING. ]*/ // Current implementations of xio_close will fail if not in the open state, but we don't care (void)xio_close(tls_io_instance->underlying_io, NULL, NULL); close_openssl_instance(tls_io_instance); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; } result = 0; } /* Codes_SRS_TLSIO_30_054: [ On failure, the adapter shall not call on_io_close_complete. ]*/ return result; } int tlsio_openssl_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if (tls_io == NULL) { LogError("NULL tls_io."); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN) { LogError("Invalid tlsio_state. Expected state is TLSIO_STATE_OPEN."); result = MU_FAILURE; } else { int res; if (tls_io_instance->ssl == NULL) { LogError("SSL channel closed in tlsio_openssl_send."); result = MU_FAILURE; return result; } res = SSL_write(tls_io_instance->ssl, buffer, (int)size); if (res != (int)size) { log_ERR_get_error("SSL_write error."); result = MU_FAILURE; } else { if (write_outgoing_bytes(tls_io_instance, on_send_complete, callback_context) != 0) { LogError("Error in write_outgoing_bytes."); result = MU_FAILURE; } else { result = 0; } } } } return result; } void tlsio_openssl_dowork(CONCRETE_IO_HANDLE tls_io) { if (tls_io == NULL) { LogError("NULL tls_io."); } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; switch (tls_io_instance->tlsio_state) { case TLSIO_STATE_OPENING_UNDERLYING_IO: case TLSIO_STATE_IN_HANDSHAKE: case TLSIO_STATE_OPEN: /* this is needed in order to pump out bytes produces by OpenSSL for things like renegotiation */ write_outgoing_bytes(tls_io_instance, NULL, NULL); break; case TLSIO_STATE_NOT_OPEN: case TLSIO_STATE_HANDSHAKE_FAILED: case TLSIO_STATE_CLOSING: case TLSIO_STATE_ERROR: default: break; } if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { /* Same behavior as schannel */ xio_dowork(tls_io_instance->underlying_io); if (tls_io_instance->tlsio_state == TLSIO_STATE_HANDSHAKE_FAILED) { // The handshake failed so we need to close. The tlsio becomes aware of the // handshake failure during an on_bytes_received while the underlying // xio_dowork is pumping data out of the socket in a while loop. The tlsio can't // close down during the callback because that would mean the xio_dowork would // be trying to read from a closed socket. So instead, the tlsio sets its state // to TLSIO_STATE_HANDSHAKE_FAILED during the on_bytes_received callback, // can then gracefully shut things down here. // // Set the state to TLSIO_STATE_ERROR so close won't gripe about the state tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; tlsio_openssl_close(tls_io_instance, NULL, NULL); indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); } } } } int tlsio_openssl_setoption(CONCRETE_IO_HANDLE tls_io, const char* optionName, const void* value) { int result; if (tls_io == NULL || optionName == NULL) { result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { const char* cert = (const char*)value; size_t len; if (tls_io_instance->certificate != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->certificate); tls_io_instance->certificate = NULL; } // Store the certificate len = strlen(cert); tls_io_instance->certificate = malloc(len + 1); if (tls_io_instance->certificate == NULL) { result = MU_FAILURE; } else { strcpy(tls_io_instance->certificate, cert); result = 0; } // If we're previously connected then add the cert to the context if (tls_io_instance->ssl_context != NULL) { result = add_certificate_to_store(tls_io_instance, cert); } } else if (strcmp(OPTION_OPENSSL_CIPHER_SUITE, optionName) == 0) { if (tls_io_instance->cipher_list != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->cipher_list); tls_io_instance->cipher_list = NULL; } // Store the cipher suites if (mallocAndStrcpy_s((char**)&tls_io_instance->cipher_list, value) != 0) { LogError("unable to mallocAndStrcpy_s %s", optionName); result = MU_FAILURE; } else { result = 0; } } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { if (tls_io_instance->x509_certificate != NULL) { LogError("unable to set x509 options more than once"); result = MU_FAILURE; } else { /*let's make a copy of this option*/ if (mallocAndStrcpy_s((char**)&tls_io_instance->x509_certificate, value) != 0) { LogError("unable to mallocAndStrcpy_s %s", optionName); result = MU_FAILURE; } else { result = 0; } } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { if (tls_io_instance->x509_private_key != NULL) { LogError("unable to set more than once x509 options"); result = MU_FAILURE; } else { /*let's make a copy of this option*/ if (mallocAndStrcpy_s((char**)&tls_io_instance->x509_private_key, value) != 0) { LogError("unable to mallocAndStrcpy_s %s", optionName); result = MU_FAILURE; } else { result = 0; } } } else if (strcmp(OPTION_OPENSSL_ENGINE, optionName) == 0) { ENGINE_load_builtin_engines(); if (mallocAndStrcpy_s((char**)&tls_io_instance->engine_id, value) != 0) { LogError("unable to mallocAndStrcpy_s %s", optionName); result = MU_FAILURE; } else { result = 0; } } else if (strcmp(OPTION_OPENSSL_PRIVATE_KEY_TYPE, optionName) == 0) { const OPTION_OPENSSL_KEY_TYPE type = *(const OPTION_OPENSSL_KEY_TYPE*)value; switch (type) { case KEY_TYPE_DEFAULT: case KEY_TYPE_ENGINE: tls_io_instance->x509_private_key_type = type; result = 0; break; default: LogError("Unknown x509PrivatekeyType type %d", type); result = MU_FAILURE; } } else if (strcmp("tls_validation_callback", optionName) == 0) { #ifdef WIN32 #pragma warning(push) #pragma warning(disable:4055) #endif // WIN32 tls_io_instance->tls_validation_callback = (TLS_CERTIFICATE_VALIDATION_CALLBACK)value; #ifdef WIN32 #pragma warning(pop) #endif // WIN32 if (tls_io_instance->ssl_context != NULL) { SSL_CTX_set_cert_verify_callback(tls_io_instance->ssl_context, tls_io_instance->tls_validation_callback, tls_io_instance->tls_validation_callback_data); } result = 0; } else if (strcmp("tls_validation_callback_data", optionName) == 0) { tls_io_instance->tls_validation_callback_data = (void*)value; if (tls_io_instance->ssl_context != NULL) { SSL_CTX_set_cert_verify_callback(tls_io_instance->ssl_context, tls_io_instance->tls_validation_callback, tls_io_instance->tls_validation_callback_data); } result = 0; } else if (strcmp(OPTION_TLS_VERSION, optionName) == 0) { if (tls_io_instance->ssl_context != NULL) { LogError("Unable to set the tls version after the tls connection is established"); result = MU_FAILURE; } else { const int version_option = *(const int*)value; if (version_option == 0 || version_option == 10) { tls_io_instance->tls_version = VERSION_1_0; } else if (version_option == 11) { tls_io_instance->tls_version = VERSION_1_1; } else if (version_option == 12) { tls_io_instance->tls_version = VERSION_1_2; } else { LogInfo("Value of TLS version option %d is not found shall default to version 1.2", version_option); tls_io_instance->tls_version = VERSION_1_2; } result = 0; } } else if (strcmp(optionName, OPTION_UNDERLYING_IO_OPTIONS) == 0) { if (OptionHandler_FeedOptions((OPTIONHANDLER_HANDLE)value, (void*)tls_io_instance->underlying_io) != OPTIONHANDLER_OK) { LogError("failed feeding options to underlying I/O instance"); result = MU_FAILURE; } else { result = 0; } } else if (strcmp(optionName, OPTION_SET_TLS_RENEGOTIATION) == 0) { // No need to do anything for Openssl result = 0; } else if (strcmp("ignore_host_name_check", optionName) == 0) { bool* server_name_check = (bool*)value; tls_io_instance->ignore_host_name_check = *server_name_check; result = 0; } else { if (tls_io_instance->underlying_io == NULL) { result = MU_FAILURE; } else { result = xio_setoption(tls_io_instance->underlying_io, optionName, value); } } } return result; } const IO_INTERFACE_DESCRIPTION* tlsio_openssl_get_interface_description(void) { return &tlsio_openssl_interface_description; } tlsio_schannel.c000066400000000000000000001631511455573770000342560ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #define SECURITY_WIN32 #define SEC_TCHAR SEC_CHAR #include #include #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/tlsio_schannel.h" #include "azure_c_shared_utility/socketio.h" #include "windows.h" #include "sspi.h" #include "schannel.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/x509_schannel.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "azure_c_shared_utility/singlylinkedlist.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/gballoc.h" #define TLSIO_STATE_VALUES \ TLSIO_STATE_NOT_OPEN, \ TLSIO_STATE_OPENING_UNDERLYING_IO, \ TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT, \ TLSIO_STATE_HANDSHAKE_SERVER_HELLO_RECEIVED, \ TLSIO_STATE_RENEGOTIATE, \ TLSIO_STATE_OPEN, \ TLSIO_STATE_CLOSING, \ TLSIO_STATE_ERROR MU_DEFINE_ENUM(TLSIO_STATE, TLSIO_STATE_VALUES); MU_DEFINE_ENUM_STRINGS(TLSIO_STATE, TLSIO_STATE_VALUES); typedef struct PENDING_SEND_TAG { unsigned char* bytes; size_t length; ON_SEND_COMPLETE on_send_complete; void* on_send_complete_context; } PENDING_SEND; typedef struct TLS_IO_INSTANCE_TAG { XIO_HANDLE socket_io; ON_IO_OPEN_COMPLETE on_io_open_complete; ON_IO_CLOSE_COMPLETE on_io_close_complete; ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; void* on_io_open_complete_context; void* on_io_close_complete_context; void* on_bytes_received_context; void* on_io_error_context; CtxtHandle security_context; TLSIO_STATE tlsio_state; SEC_TCHAR* host_name; CredHandle credential_handle; bool credential_handle_allocated; bool ignore_server_name_check; unsigned char* received_bytes; size_t received_byte_count; size_t buffer_size; size_t needed_bytes; char* x509certificate; char* x509privatekey; X509_SCHANNEL_HANDLE x509_schannel_handle; SINGLYLINKEDLIST_HANDLE pending_io_list; // Certificate to check server certificate chains to, overriding built-in Windows certificate store certificates. char* trustedCertificate; } TLS_IO_INSTANCE; /*this function will clone an option given by name and value*/ static void* tlsio_schannel_CloneOption(const char* name, const void* value) { void* result; if ( (name == NULL) || (value == NULL) ) { LogError("invalid parameter detected: const char* name = %p, const void* value = %p", name, value); result = NULL; } else { if (strcmp(name, SU_OPTION_X509_CERT) == 0 || strcmp(name, OPTION_X509_ECC_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0) { LogError("unable to mallocAndStrcpy_s x509certificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0 || strcmp(name, OPTION_X509_ECC_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0) { LogError("unable to mallocAndStrcpy_s x509privatekey value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, OPTION_TRUSTED_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0) { LogError("unable to mallocAndStrcpy_s TrustedCerts value"); result = NULL; } else { /*return as is*/ } } else { LogError("not handled option : %s", name); result = NULL; } } return result; } /*this function destroys an option previously created*/ static void tlsio_schannel_DestroyOption(const char* name, const void* value) { /*since all options for this layer are actually string copies., disposing of one is just calling free*/ if ( (name == NULL) || (value == NULL) ) { LogError("invalid parameter detected: const char* name = %p, const void* value = %p", name, value); } else { if ( (strcmp(name, SU_OPTION_X509_CERT) == 0) || (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) || (strcmp(name, OPTION_X509_ECC_CERT) == 0) || (strcmp(name, OPTION_X509_ECC_KEY) == 0) || (strcmp(name, OPTION_TRUSTED_CERT) == 0) ) { free((void*)value); } else { LogError("not handled option : %s", name); } } } static OPTIONHANDLER_HANDLE tlsio_schannel_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result; if (handle == NULL) { LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle = %p", handle); result = NULL; } else { result = OptionHandler_Create(tlsio_schannel_CloneOption, tlsio_schannel_DestroyOption, tlsio_schannel_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); /*return as is*/ } else { /*this layer cares about the certificates and the x509 credentials*/ TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)handle; if ( (tls_io_instance->x509certificate != NULL) && (OptionHandler_AddOption(result, "x509certificate", tls_io_instance->x509certificate) != OPTIONHANDLER_OK) ) { LogError("unable to save x509certificate option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->trustedCertificate != NULL) && (OptionHandler_AddOption(result, OPTION_TRUSTED_CERT, tls_io_instance->trustedCertificate) != OPTIONHANDLER_OK) ) { LogError("unable to save TrustedCerts option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->x509privatekey != NULL) && (OptionHandler_AddOption(result, "x509privatekey", tls_io_instance->x509privatekey) != OPTIONHANDLER_OK) ) { LogError("unable to save x509privatekey option"); OptionHandler_Destroy(result); result = NULL; } else { /*all is fine, all interesting options have been saved*/ /*return as is*/ } } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_schannel_interface_description = { tlsio_schannel_retrieveoptions, tlsio_schannel_create, tlsio_schannel_destroy, tlsio_schannel_open, tlsio_schannel_close, tlsio_schannel_send, tlsio_schannel_dowork, tlsio_schannel_setoption }; static void indicate_error(TLS_IO_INSTANCE* tls_io_instance) { if (tls_io_instance->on_io_error != NULL) { tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } } static int resize_receive_buffer(TLS_IO_INSTANCE* tls_io_instance, size_t needed_buffer_size) { int result; if (needed_buffer_size > tls_io_instance->buffer_size) { unsigned char* new_buffer = (unsigned char*) realloc(tls_io_instance->received_bytes, needed_buffer_size); if (new_buffer == NULL) { LogError("realloc failed"); result = MU_FAILURE; } else { tls_io_instance->received_bytes = new_buffer; tls_io_instance->buffer_size = needed_buffer_size; result = 0; } } else { result = 0; } return result; } static void on_underlying_io_close_complete(void* context) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING) { tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; if (tls_io_instance->on_io_close_complete != NULL) { tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context); } /* Free security context resources corresponding to creation with open */ DeleteSecurityContext(&tls_io_instance->security_context); if (tls_io_instance->credential_handle_allocated) { (void)FreeCredentialHandle(&tls_io_instance->credential_handle); tls_io_instance->credential_handle_allocated = false; } } } // This callback usage needs to be either verified and commented or integrated into // the state machine. static void unchecked_on_send_complete(void* context, IO_SEND_RESULT send_result) { (void)context; (void)send_result; } static void send_client_hello(TLS_IO_INSTANCE* tls_io_instance) { SecBuffer init_security_buffers[2]; ULONG context_attributes; SECURITY_STATUS status; SCHANNEL_CRED auth_data; PCCERT_CONTEXT certContext; auth_data.dwVersion = SCHANNEL_CRED_VERSION; if (tls_io_instance->x509_schannel_handle != NULL) { certContext = x509_schannel_get_certificate_context(tls_io_instance->x509_schannel_handle); auth_data.cCreds = 1; auth_data.paCred = &certContext; } else { auth_data.cCreds = 0; auth_data.paCred = NULL; } auth_data.hRootStore = NULL; auth_data.cSupportedAlgs = 0; auth_data.palgSupportedAlgs = NULL; auth_data.grbitEnabledProtocols = 0; auth_data.dwMinimumCipherStrength = 0; auth_data.dwMaximumCipherStrength = 0; auth_data.dwSessionLifespan = 0; #if defined(SCH_USE_STRONG_CRYPTO) auth_data.dwFlags = SCH_USE_STRONG_CRYPTO | SCH_CRED_NO_DEFAULT_CREDS; #else auth_data.dwFlags = SCH_CRED_NO_DEFAULT_CREDS; #endif if (tls_io_instance->ignore_server_name_check) { auth_data.dwFlags |= SCH_CRED_NO_SERVERNAME_CHECK; } auth_data.dwCredFormat = 0; if (tls_io_instance->trustedCertificate != NULL) { // SCH_CRED_MANUAL_CRED_VALIDATION flag signals to schannel to NOT use // the Windows certificate store, but instead have application verify // certificate. auth_data.dwFlags |= SCH_CRED_MANUAL_CRED_VALIDATION; } status = AcquireCredentialsHandle(NULL, UNISP_NAME, SECPKG_CRED_OUTBOUND, NULL, &auth_data, NULL, NULL, &tls_io_instance->credential_handle, NULL); if (status != SEC_E_OK) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { SecBufferDesc security_buffers_desc; tls_io_instance->credential_handle_allocated = true; init_security_buffers[0].cbBuffer = 0; init_security_buffers[0].BufferType = SECBUFFER_TOKEN; init_security_buffers[0].pvBuffer = NULL; init_security_buffers[1].cbBuffer = 0; init_security_buffers[1].BufferType = SECBUFFER_EMPTY; init_security_buffers[1].pvBuffer = 0; security_buffers_desc.cBuffers = 2; security_buffers_desc.pBuffers = init_security_buffers; security_buffers_desc.ulVersion = SECBUFFER_VERSION; status = InitializeSecurityContext(&tls_io_instance->credential_handle, NULL, tls_io_instance->host_name, ISC_REQ_EXTENDED_ERROR | ISC_REQ_STREAM | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_USE_SUPPLIED_CREDS, 0, 0, NULL, 0, &tls_io_instance->security_context, &security_buffers_desc, &context_attributes, NULL); if ((status == SEC_I_COMPLETE_NEEDED) || (status == SEC_I_CONTINUE_NEEDED) || (status == SEC_I_COMPLETE_AND_CONTINUE)) { if (xio_send(tls_io_instance->socket_io, init_security_buffers[0].pvBuffer, init_security_buffers[0].cbBuffer, unchecked_on_send_complete, NULL) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { /* set the needed bytes to 1, to get on the next byte how many we actually need */ tls_io_instance->needed_bytes = 1; if (resize_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { tls_io_instance->tlsio_state = TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT; } } } if (init_security_buffers[0].pvBuffer != NULL) { FreeContextBuffer(init_security_buffers[0].pvBuffer); } if (init_security_buffers[1].pvBuffer != NULL) { FreeContextBuffer(init_security_buffers[1].pvBuffer); } } } static void on_underlying_io_open_complete(void* context, IO_OPEN_RESULT io_open_result) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (tls_io_instance->tlsio_state != TLSIO_STATE_OPENING_UNDERLYING_IO) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { if (io_open_result != IO_OPEN_OK) { tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } } else { send_client_hello(tls_io_instance); } } } static int verify_custom_certificate_if_needed(TLS_IO_INSTANCE* tls_io_instance) { int result; if (tls_io_instance->trustedCertificate == NULL) { // If there is no trusted certificate set by API caller, then we'll rely on implicit Windows certificate store to verify the certificate. result = 0; } else { PCERT_CONTEXT serverCertificateToVerify = NULL; SECURITY_STATUS status = QueryContextAttributes(&tls_io_instance->security_context, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &serverCertificateToVerify); if (status != SEC_E_OK) { LogError("QueryContextAttributes failed: %x", status); result = MU_FAILURE; } else if (x509_verify_certificate_in_chain(tls_io_instance->trustedCertificate, serverCertificateToVerify) != 0) { LogError("Failed to verify trusted certificate in chain"); result = MU_FAILURE; } else { result = 0; } if (serverCertificateToVerify) { CertFreeCertificateContext(serverCertificateToVerify); } } return result; } static int set_receive_buffer(TLS_IO_INSTANCE* tls_io_instance, size_t buffer_size) { int result; unsigned char* new_buffer = (unsigned char*) realloc(tls_io_instance->received_bytes, buffer_size); if (new_buffer == NULL) { LogError("realloc failed"); result = MU_FAILURE; } else { tls_io_instance->received_bytes = new_buffer; tls_io_instance->buffer_size = buffer_size; result = 0; } return result; } static int send_chunk(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if ((tls_io == NULL) || (buffer == NULL) || (size == 0)) { LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p, const void* buffer = %p, size_t size = %lu", tls_io, buffer, (unsigned long)size); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN) { LogError("invalid tls_io_instance->tlsio_state: %" PRI_MU_ENUM "", MU_ENUM_VALUE(TLSIO_STATE, tls_io_instance->tlsio_state)); result = MU_FAILURE; } else { SecPkgContext_StreamSizes sizes; SECURITY_STATUS status = QueryContextAttributes(&tls_io_instance->security_context, SECPKG_ATTR_STREAM_SIZES, &sizes); if (status != SEC_E_OK) { LogError("QueryContextAttributes failed: %x", status); result = MU_FAILURE; } else { SecBuffer security_buffers[4]; SecBufferDesc security_buffers_desc; size_t needed_buffer = sizes.cbHeader + size + sizes.cbTrailer; unsigned char* out_buffer = (unsigned char*)malloc(needed_buffer); if (out_buffer == NULL) { LogError("malloc failed"); result = MU_FAILURE; } else { (void)memcpy(out_buffer + sizes.cbHeader, buffer, size); security_buffers[0].BufferType = SECBUFFER_STREAM_HEADER; security_buffers[0].cbBuffer = sizes.cbHeader; security_buffers[0].pvBuffer = out_buffer; security_buffers[1].BufferType = SECBUFFER_DATA; security_buffers[1].cbBuffer = (unsigned long)size; security_buffers[1].pvBuffer = out_buffer + sizes.cbHeader; security_buffers[2].BufferType = SECBUFFER_STREAM_TRAILER; security_buffers[2].cbBuffer = sizes.cbTrailer; security_buffers[2].pvBuffer = out_buffer + sizes.cbHeader + size; security_buffers[3].cbBuffer = 0; security_buffers[3].BufferType = SECBUFFER_EMPTY; security_buffers[3].pvBuffer = 0; security_buffers_desc.cBuffers = sizeof(security_buffers) / sizeof(security_buffers[0]); security_buffers_desc.pBuffers = security_buffers; security_buffers_desc.ulVersion = SECBUFFER_VERSION; status = EncryptMessage(&tls_io_instance->security_context, 0, &security_buffers_desc, 0); if (FAILED(status)) { LogError("EncryptMessage failed: %x", status); result = MU_FAILURE; } else { if (xio_send(tls_io_instance->socket_io, out_buffer, security_buffers[0].cbBuffer + security_buffers[1].cbBuffer + security_buffers[2].cbBuffer, on_send_complete, callback_context) != 0) { LogError("xio_send failed"); result = MU_FAILURE; } else { result = 0; } } free(out_buffer); } } } } return result; } static int internal_send(TLS_IO_INSTANCE* tls_io_instance, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; while (size > 0) { size_t to_send = 16 * 1024; if (to_send > size) { to_send = size; } if (send_chunk(tls_io_instance, buffer, to_send, (to_send == size) ? on_send_complete : NULL, callback_context) != 0) { break; } size -= to_send; buffer = ((const unsigned char*)buffer) + to_send; } if (size > 0) { LogError("send_chunk failed"); result = MU_FAILURE; } else { result = 0; } return result; } static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; size_t consumed_bytes; if (resize_receive_buffer(tls_io_instance, tls_io_instance->received_byte_count + size) == 0) { (void)memcpy(tls_io_instance->received_bytes + tls_io_instance->received_byte_count, buffer, size); tls_io_instance->received_byte_count += size; if (size > tls_io_instance->needed_bytes) { tls_io_instance->needed_bytes = 0; } else { tls_io_instance->needed_bytes -= size; } /* Drain what we received */ while (tls_io_instance->needed_bytes == 0) { if ((tls_io_instance->tlsio_state == TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT) || (tls_io_instance->tlsio_state == TLSIO_STATE_RENEGOTIATE)) { SecBuffer input_buffers[2]; SecBuffer output_buffers[2]; SecBufferDesc input_buffers_desc; SecBufferDesc output_buffers_desc; SECURITY_STATUS status; unsigned long flags; ULONG context_attributes; /* we need to try and perform the second (next) step of the init */ input_buffers[0].cbBuffer = (unsigned long)tls_io_instance->received_byte_count; input_buffers[0].BufferType = SECBUFFER_TOKEN; input_buffers[0].pvBuffer = (void*)tls_io_instance->received_bytes; input_buffers[1].cbBuffer = 0; input_buffers[1].BufferType = SECBUFFER_EMPTY; input_buffers[1].pvBuffer = 0; input_buffers_desc.cBuffers = 2; input_buffers_desc.pBuffers = input_buffers; input_buffers_desc.ulVersion = SECBUFFER_VERSION; output_buffers[0].cbBuffer = 0; output_buffers[0].BufferType = SECBUFFER_TOKEN; output_buffers[0].pvBuffer = NULL; output_buffers[1].cbBuffer = 0; output_buffers[1].BufferType = SECBUFFER_EMPTY; output_buffers[1].pvBuffer = 0; output_buffers_desc.cBuffers = 2; output_buffers_desc.pBuffers = output_buffers; output_buffers_desc.ulVersion = SECBUFFER_VERSION; flags = ISC_REQ_EXTENDED_ERROR | ISC_REQ_STREAM | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_USE_SUPPLIED_CREDS; status = InitializeSecurityContext(&tls_io_instance->credential_handle, &tls_io_instance->security_context, tls_io_instance->host_name, flags, 0, 0, &input_buffers_desc, 0, &tls_io_instance->security_context, &output_buffers_desc, &context_attributes, NULL); switch (status) { case SEC_E_INCOMPLETE_MESSAGE: if (input_buffers[1].BufferType != SECBUFFER_MISSING) { //If SECBUFFER_MISSING not sent, try to read byte by byte. tls_io_instance->needed_bytes = 1; } else { tls_io_instance->needed_bytes = input_buffers[1].cbBuffer; } if (resize_receive_buffer(tls_io_instance, tls_io_instance->received_byte_count + tls_io_instance->needed_bytes) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } } break; case SEC_E_OK: consumed_bytes = tls_io_instance->received_byte_count; /* Any extra bytes left over or did we fully consume the receive buffer? */ if (input_buffers[1].BufferType == SECBUFFER_EXTRA) { consumed_bytes -= input_buffers[1].cbBuffer; (void)memmove(tls_io_instance->received_bytes, tls_io_instance->received_bytes + consumed_bytes, tls_io_instance->received_byte_count - consumed_bytes); } tls_io_instance->received_byte_count -= consumed_bytes; /* if nothing more to consume, set the needed bytes to 1, to get on the next byte how many we actually need */ tls_io_instance->needed_bytes = tls_io_instance->received_byte_count == 0 ? 1 : 0; if (verify_custom_certificate_if_needed(tls_io_instance) != 0) { LogError("Unable to verify server certificate against custom server trusted certificate"); if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } } else if (set_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } } else { if (tls_io_instance->tlsio_state == TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT) { tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_OK); } } else { LIST_ITEM_HANDLE first_pending_io; tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SEND* pending_send = (PENDING_SEND*)singlylinkedlist_item_get_value(first_pending_io); if (pending_send == NULL) { LogError("Failure: retrieving pending IO from list"); indicate_error(tls_io_instance); break; } else { if (internal_send(tls_io_instance, pending_send->bytes, pending_send->length, pending_send->on_send_complete, pending_send->on_send_complete_context) != 0) { LogError("send failed"); indicate_error(tls_io_instance); } else { if (singlylinkedlist_remove(tls_io_instance->pending_io_list, first_pending_io) != 0) { LogError("Failure: removing pending IO from list"); indicate_error(tls_io_instance); } } } } } } break; case SEC_I_COMPLETE_NEEDED: case SEC_I_CONTINUE_NEEDED: case SEC_I_COMPLETE_AND_CONTINUE: if ((output_buffers[0].cbBuffer > 0) && xio_send(tls_io_instance->socket_io, output_buffers[0].pvBuffer, output_buffers[0].cbBuffer, unchecked_on_send_complete, NULL) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } } else { consumed_bytes = tls_io_instance->received_byte_count; /* Any extra bytes left over or did we fully consume the receive buffer? */ if (input_buffers[1].BufferType == SECBUFFER_EXTRA) { consumed_bytes -= input_buffers[1].cbBuffer; (void)memmove(tls_io_instance->received_bytes, tls_io_instance->received_bytes + consumed_bytes, tls_io_instance->received_byte_count - consumed_bytes); } tls_io_instance->received_byte_count -= consumed_bytes; /* if nothing more to consume, set the needed bytes to 1, to get on the next byte how many we actually need */ tls_io_instance->needed_bytes = tls_io_instance->received_byte_count == 0 ? 1 : 0; if (set_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } } else { if (tls_io_instance->tlsio_state != TLSIO_STATE_RENEGOTIATE) { tls_io_instance->tlsio_state = TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT; } } } break; case SEC_E_UNTRUSTED_ROOT: tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } break; default: { LPVOID srcText = NULL; if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, status, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&srcText, 0, NULL) > 0) { LogError("[%#x] %s", status, (LPTSTR)srcText); LocalFree(srcText); } else { LogError("[%#x]", status); } tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } break; } FreeContextBuffer(output_buffers[0].pvBuffer); FreeContextBuffer(output_buffers[1].pvBuffer); } else if (tls_io_instance->tlsio_state == TLSIO_STATE_OPEN) { SecBuffer security_buffers[4]; SecBufferDesc security_buffers_desc; SECURITY_STATUS status; security_buffers[0].BufferType = SECBUFFER_DATA; security_buffers[0].pvBuffer = tls_io_instance->received_bytes; security_buffers[0].cbBuffer = (unsigned long)tls_io_instance->received_byte_count; security_buffers[1].BufferType = SECBUFFER_EMPTY; security_buffers[2].BufferType = SECBUFFER_EMPTY; security_buffers[3].BufferType = SECBUFFER_EMPTY; security_buffers_desc.cBuffers = sizeof(security_buffers) / sizeof(security_buffers[0]); security_buffers_desc.pBuffers = security_buffers; security_buffers_desc.ulVersion = SECBUFFER_VERSION; status = DecryptMessage(&tls_io_instance->security_context, &security_buffers_desc, 0, NULL); switch (status) { case SEC_E_INCOMPLETE_MESSAGE: if (security_buffers[1].BufferType != SECBUFFER_MISSING) { //If SECBUFFER_MISSING not sent, try to read byte by byte. tls_io_instance->needed_bytes = 1; } else { tls_io_instance->needed_bytes = security_buffers[1].cbBuffer; } if (resize_receive_buffer(tls_io_instance, tls_io_instance->received_byte_count + tls_io_instance->needed_bytes) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } break; case SEC_E_OK: if (security_buffers[1].BufferType != SECBUFFER_DATA) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { size_t i; /* notify of the received data */ if (tls_io_instance->on_bytes_received != NULL) { tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, (const unsigned char *) security_buffers[1].pvBuffer, security_buffers[1].cbBuffer); } consumed_bytes = tls_io_instance->received_byte_count; for (i = 0; i < sizeof(security_buffers) / sizeof(security_buffers[0]); i++) { /* Any extra bytes left over or did we fully consume the receive buffer? */ if (security_buffers[i].BufferType == SECBUFFER_EXTRA) { consumed_bytes -= security_buffers[i].cbBuffer; (void)memmove(tls_io_instance->received_bytes, tls_io_instance->received_bytes + consumed_bytes, tls_io_instance->received_byte_count - consumed_bytes); break; } } tls_io_instance->received_byte_count -= consumed_bytes; /* if nothing more to consume, set the needed bytes to 1, to get on the next byte how many we actually need */ tls_io_instance->needed_bytes = tls_io_instance->received_byte_count == 0 ? 1 : 0; if (set_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } } break; case SEC_I_RENEGOTIATE: { SecBuffer input_buffers[2]; SecBuffer output_buffers[2]; SecBufferDesc input_buffers_desc; SecBufferDesc output_buffers_desc; unsigned long flags; ULONG context_attributes; /* we need to try and perform the second (next) step of the init */ input_buffers[0].cbBuffer = (unsigned long)tls_io_instance->received_byte_count; input_buffers[0].BufferType = SECBUFFER_TOKEN; input_buffers[0].pvBuffer = (void*)tls_io_instance->received_bytes; input_buffers[1].cbBuffer = 0; input_buffers[1].BufferType = SECBUFFER_EMPTY; input_buffers[1].pvBuffer = 0; input_buffers_desc.cBuffers = 2; input_buffers_desc.pBuffers = input_buffers; input_buffers_desc.ulVersion = SECBUFFER_VERSION; output_buffers[0].cbBuffer = 0; output_buffers[0].BufferType = SECBUFFER_TOKEN; output_buffers[0].pvBuffer = NULL; output_buffers[1].cbBuffer = 0; output_buffers[1].BufferType = SECBUFFER_EMPTY; output_buffers[1].pvBuffer = 0; output_buffers_desc.cBuffers = 2; output_buffers_desc.pBuffers = output_buffers; output_buffers_desc.ulVersion = SECBUFFER_VERSION; flags = ISC_REQ_EXTENDED_ERROR | ISC_REQ_STREAM | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_USE_SUPPLIED_CREDS; status = InitializeSecurityContext(&tls_io_instance->credential_handle, &tls_io_instance->security_context, tls_io_instance->host_name, flags, 0, 0, &input_buffers_desc, 0, &tls_io_instance->security_context, &output_buffers_desc, &context_attributes, NULL); if ((status == SEC_I_COMPLETE_NEEDED) || (status == SEC_I_CONTINUE_NEEDED) || (status == SEC_I_COMPLETE_AND_CONTINUE)) { /* This needs to account for EXTRA */ tls_io_instance->received_byte_count = 0; if (xio_send(tls_io_instance->socket_io, output_buffers[0].pvBuffer, output_buffers[0].cbBuffer, unchecked_on_send_complete, NULL) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { tls_io_instance->needed_bytes = 1; if (resize_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0) { tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { tls_io_instance->tlsio_state = TLSIO_STATE_RENEGOTIATE; } } } FreeContextBuffer(output_buffers[0].pvBuffer); FreeContextBuffer(output_buffers[1].pvBuffer); break; } default: { LPVOID srcText = NULL; if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, status, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&srcText, 0, NULL) > 0) { LogError("[%#x] %s", status, (LPTSTR)srcText); LocalFree(srcText); } else { LogError("[%#x]", status); } tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } break; } } else { /* Received data in error or other state */ break; } } } } static void on_underlying_io_error(void* context) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; switch (tls_io_instance->tlsio_state) { default: case TLSIO_STATE_NOT_OPEN: case TLSIO_STATE_ERROR: break; case TLSIO_STATE_OPENING_UNDERLYING_IO: case TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT: case TLSIO_STATE_HANDSHAKE_SERVER_HELLO_RECEIVED: tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR); } break; case TLSIO_STATE_CLOSING: tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; if (tls_io_instance->on_io_close_complete != NULL) { tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context); } break; case TLSIO_STATE_OPEN: tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); break; } } CONCRETE_IO_HANDLE tlsio_schannel_create(void* io_create_parameters) { TLSIO_CONFIG* tls_io_config = (TLSIO_CONFIG *) io_create_parameters; TLS_IO_INSTANCE* result; if (tls_io_config == NULL) { LogError("invalid argument detected: void* io_create_parameters = %p", tls_io_config); result = NULL; } else { result = (TLS_IO_INSTANCE*)malloc(sizeof(TLS_IO_INSTANCE)); if (result == NULL) { LogError("malloc failed"); } else { (void)memset(result, 0, sizeof(TLS_IO_INSTANCE)); result->host_name = (SEC_TCHAR*)malloc(sizeof(SEC_TCHAR) * (1 + strlen(tls_io_config->hostname))); if (result->host_name == NULL) { LogError("malloc failed"); free(result); result = NULL; } else { SOCKETIO_CONFIG socketio_config; const IO_INTERFACE_DESCRIPTION* underlying_io_interface; void* io_interface_parameters; (void)strcpy(result->host_name, tls_io_config->hostname); if (tls_io_config->underlying_io_interface != NULL) { underlying_io_interface = tls_io_config->underlying_io_interface; io_interface_parameters = tls_io_config->underlying_io_parameters; } else { socketio_config.hostname = tls_io_config->hostname; socketio_config.port = tls_io_config->port; socketio_config.accepted_socket = NULL; underlying_io_interface = socketio_get_interface_description(); io_interface_parameters = &socketio_config; } if (underlying_io_interface == NULL) { LogError("socketio_get_interface_description failed"); free(result->host_name); free(result); result = NULL; } else { result->socket_io = xio_create(underlying_io_interface, io_interface_parameters); if (result->socket_io == NULL) { LogError("xio_create failed"); free(result->host_name); free(result); result = NULL; } else { result->pending_io_list = singlylinkedlist_create(); if (result->pending_io_list == NULL) { LogError("Failed creating pending IO list."); xio_destroy(result->socket_io); free(result->host_name); free(result); result = NULL; } else { result->received_bytes = NULL; result->received_byte_count = 0; result->buffer_size = 0; result->tlsio_state = TLSIO_STATE_NOT_OPEN; result->x509certificate = NULL; result->x509privatekey = NULL; result->x509_schannel_handle = NULL; } } } } } } return result; } void tlsio_schannel_destroy(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; LIST_ITEM_HANDLE first_pending_io; if (tls_io_instance->credential_handle_allocated) { (void)FreeCredentialHandle(&tls_io_instance->credential_handle); tls_io_instance->credential_handle_allocated = false; } if (tls_io_instance->received_bytes != NULL) { free(tls_io_instance->received_bytes); } if (tls_io_instance->trustedCertificate != NULL) { free(tls_io_instance->trustedCertificate); } if (tls_io_instance->x509_schannel_handle != NULL) { x509_schannel_destroy(tls_io_instance->x509_schannel_handle); } if (tls_io_instance->x509certificate != NULL) { free(tls_io_instance->x509certificate); } if (tls_io_instance->x509privatekey != NULL) { free(tls_io_instance->x509privatekey); } xio_destroy(tls_io_instance->socket_io); free(tls_io_instance->host_name); first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_io_list); while (first_pending_io != NULL) { PENDING_SEND* pending_send = (PENDING_SEND*)singlylinkedlist_item_get_value(first_pending_io); if (pending_send == NULL) { LogError("Failure: retrieving socket from list"); indicate_error(tls_io_instance); break; } else { if (pending_send->on_send_complete != NULL) { pending_send->on_send_complete(pending_send->on_send_complete_context, IO_SEND_CANCELLED); } if (singlylinkedlist_remove(tls_io_instance->pending_io_list, first_pending_io) != 0) { LogError("Failure: removing pending IO from list"); } } } singlylinkedlist_destroy(tls_io_instance->pending_io_list); free(tls_io); } } int tlsio_schannel_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; if (tls_io == NULL) { LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p", tls_io); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { LogError("invalid tls_io_instance->tlsio_state = %" PRI_MU_ENUM "", MU_ENUM_VALUE(TLSIO_STATE, tls_io_instance->tlsio_state)); result = MU_FAILURE; } else { tls_io_instance->on_io_open_complete = on_io_open_complete; tls_io_instance->on_io_open_complete_context = on_io_open_complete_context; tls_io_instance->on_bytes_received = on_bytes_received; tls_io_instance->on_bytes_received_context = on_bytes_received_context; tls_io_instance->on_io_error = on_io_error; tls_io_instance->on_io_error_context = on_io_error_context; tls_io_instance->tlsio_state = TLSIO_STATE_OPENING_UNDERLYING_IO; if (xio_open(tls_io_instance->socket_io, on_underlying_io_open_complete, tls_io_instance, on_underlying_io_bytes_received, tls_io_instance, on_underlying_io_error, tls_io_instance) != 0) { LogError("xio_open failed"); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } else { result = 0; } } } return result; } int tlsio_schannel_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result = 0; if (tls_io == NULL) { LogError("invalid argument detected: tls_io = %p", tls_io); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if ((tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) || (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING)) { LogError("invalid tls_io_instance->tlsio_state = %" PRI_MU_ENUM "", MU_ENUM_VALUE(TLSIO_STATE, tls_io_instance->tlsio_state)); result = MU_FAILURE; } else { tls_io_instance->tlsio_state = TLSIO_STATE_CLOSING; tls_io_instance->on_io_close_complete = on_io_close_complete; tls_io_instance->on_io_close_complete_context = callback_context; if (xio_close(tls_io_instance->socket_io, on_underlying_io_close_complete, tls_io_instance) != 0) { LogError("xio_close failed"); result = MU_FAILURE; } else { result = 0; } } } return result; } int tlsio_schannel_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state == TLSIO_STATE_RENEGOTIATE) { /* add to pending list */ PENDING_SEND* new_pending_send = (PENDING_SEND*)calloc(1, sizeof(PENDING_SEND)); if (new_pending_send == NULL) { LogError("Cannot allocate memory for pending IO"); result = MU_FAILURE; } else { new_pending_send->bytes = (unsigned char*)malloc(size); if (new_pending_send->bytes == NULL) { LogError("Cannot allocate memory for pending IO payload"); result = MU_FAILURE; } else { (void)memcpy(new_pending_send->bytes, buffer, size); new_pending_send->length = size; new_pending_send->on_send_complete = on_send_complete; new_pending_send->on_send_complete_context = callback_context; if (singlylinkedlist_add(tls_io_instance->pending_io_list, new_pending_send) == NULL) { LogError("Cannot add pending IO to list"); result = MU_FAILURE; } else { result = 0; } } } } else { if (internal_send((TLS_IO_INSTANCE*)tls_io, buffer, size, on_send_complete, callback_context) != 0) { LogError("send failed"); result = MU_FAILURE; } else { result = 0; } } return result; } void tlsio_schannel_dowork(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; xio_dowork(tls_io_instance->socket_io); } } int tlsio_schannel_setoption(CONCRETE_IO_HANDLE tls_io, const char* optionName, const void* value) { int result; if (tls_io == NULL || optionName == NULL) { LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p, const char* optionName = %p", tls_io, optionName); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { if (tls_io_instance->x509certificate != NULL) { LogError("x509certificate has already been specified"); result = MU_FAILURE; } else { tls_io_instance->x509certificate = (char *)tlsio_schannel_CloneOption(optionName, value); if (tls_io_instance->x509certificate == NULL) { LogError("tlsio_schannel_CloneOption failed"); result = MU_FAILURE; } else { if (tls_io_instance->x509privatekey != NULL) { tls_io_instance->x509_schannel_handle = x509_schannel_create(tls_io_instance->x509certificate, tls_io_instance->x509privatekey); if (tls_io_instance->x509_schannel_handle == NULL) { LogError("x509_schannel_create failed"); result = MU_FAILURE; } else { /*all is fine, the x509 shall be used later*/ result = 0; } } else { result = 0; /*all is fine, maybe x509 privatekey will come and then x509 is set*/ } } } } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { if (tls_io_instance->x509privatekey != NULL) { LogError("x509privatekey has already been specified"); result = MU_FAILURE; } else { tls_io_instance->x509privatekey = (char *)tlsio_schannel_CloneOption(optionName, value); if (tls_io_instance->x509privatekey == NULL) { LogError("tlsio_schannel_CloneOption failed"); result = MU_FAILURE; } else { if (tls_io_instance->x509certificate != NULL) { tls_io_instance->x509_schannel_handle = x509_schannel_create(tls_io_instance->x509certificate, tls_io_instance->x509privatekey); if (tls_io_instance->x509_schannel_handle == NULL) { LogError("x509_schannel_create failed"); result = MU_FAILURE; } else { /*all is fine, the x509 shall be used later*/ result = 0; } } else { result = 0; /*all is fine, maybe x509 cert will come and then x509 is set*/ } } } } else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { if (value == NULL) { LogError("Invalid paramater: OPTION_TRUSTED_CERT value=NULL"); result = MU_FAILURE; } else { if (tls_io_instance->trustedCertificate != NULL) { free(tls_io_instance->trustedCertificate); tls_io_instance->trustedCertificate = NULL; } if (mallocAndStrcpy_s((char**)&tls_io_instance->trustedCertificate, value) != 0) { LogError("unable to mallocAndStrcpy_s %s", optionName); result = MU_FAILURE; } else { result = 0; } } } else if (strcmp("ignore_server_name_check", optionName) == 0) { bool* server_name_check = (bool*)value; tls_io_instance->ignore_server_name_check = *server_name_check; result = 0; } else if (tls_io_instance->socket_io == NULL) { LogError("tls_io_instance->socket_io is not set"); result = MU_FAILURE; } else if (strcmp(optionName, OPTION_SET_TLS_RENEGOTIATION) == 0) { // No need to do anything for Schannel result = 0; } else { result = xio_setoption(tls_io_instance->socket_io, optionName, value); } } return result; } const IO_INTERFACE_DESCRIPTION* tlsio_schannel_get_interface_description(void) { return &tlsio_schannel_interface_description; } tlsio_template.c000066400000000000000000000144511455573770000342740ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/shared_util_options.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/gballoc.h" #define TLSIO_STATE_VALUES \ TLSIO_STATE_NOT_OPEN, \ TLSIO_STATE_OPENING_UNDERLYING_IO, \ TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT, \ TLSIO_STATE_HANDSHAKE_SERVER_HELLO_RECEIVED, \ TLSIO_STATE_RENEGOTIATE, \ TLSIO_STATE_OPEN, \ TLSIO_STATE_CLOSING, \ TLSIO_STATE_ERROR MU_DEFINE_ENUM(TLSIO_STATE, TLSIO_STATE_VALUES); MU_DEFINE_ENUM_STRINGS(TLSIO_STATE, TLSIO_STATE_VALUES); typedef struct TLS_IO_INSTANCE_TAG { XIO_HANDLE socket_io; ON_IO_OPEN_COMPLETE on_io_open_complete; ON_IO_CLOSE_COMPLETE on_io_close_complete; ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; void* on_io_open_complete_context; void* on_io_close_complete_context; void* on_bytes_received_context; void* on_io_error_context; } TLS_IO_INSTANCE; /*this function will clone an option given by name and value*/ static void* tlsio_template_CloneOption(const char* name, const void* value) { void* result; if (name == NULL || value == NULL) { LogError("invalid parameter detected: const char* name = %p, const void* value = %p", name, value); result = NULL; } else { result = NULL; } return result; } /*this function destroys an option previously created*/ static void tlsio_template_DestroyOption(const char* name, const void* value) { /*since all options for this layer are actually string copies., disposing of one is just calling free*/ if (name == NULL || value == NULL) { LogError("invalid parameter detected: const char* name = %p, const void* value = %p", name, value); } } static OPTIONHANDLER_HANDLE tlsio_template_retrieveoptions(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result; if (handle == NULL) { LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle = %p", handle); result = NULL; } else { result = OptionHandler_Create(tlsio_template_CloneOption, tlsio_template_DestroyOption, tlsio_template_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); /*return as is*/ } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_template_interface_description = { tlsio_template_retrieveoptions, tlsio_template_create, tlsio_template_destroy, tlsio_template_open, tlsio_template_close, tlsio_template_send, tlsio_template_dowork, tlsio_template_setoption }; static void indicate_error(TLS_IO_INSTANCE* tls_io_instance) { if (tls_io_instance->on_io_error != NULL) { tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } } CONCRETE_IO_HANDLE tlsio_template_create(void* io_create_parameters) { TLSIO_CONFIG* tls_io_config = (TLSIO_CONFIG *)io_create_parameters; TLS_IO_INSTANCE* result; if (tls_io_config == NULL) { LogError("invalid argument detected: void* io_create_parameters = %p", tls_io_config); result = NULL; } else { result = (TLS_IO_INSTANCE*)malloc(sizeof(TLS_IO_INSTANCE)); if (result == NULL) { LogError("malloc failed"); } else { (void)memset(result, 0, sizeof(TLS_IO_INSTANCE)); } } return result; } void tlsio_template_destroy(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; free(tls_io_instance); } } int tlsio_template_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; (void)on_io_open_complete; (void)on_io_open_complete_context; (void)on_bytes_received; (void)on_bytes_received_context; (void)on_io_error; (void)on_io_error_context; if (tls_io == NULL) { LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p", tls_io); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; (void)tls_io_instance; result = 0; } return result; } int tlsio_template_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result = 0; (void)callback_context; (void)on_io_close_complete; if (tls_io == NULL) { LogError("invalid argument detected: tls_io = %p", tls_io); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; (void)tls_io_instance; result = 0; } return result; } int tlsio_template_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; (void)buffer; (void)size; (void)on_send_complete; (void)callback_context; TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; (void)tls_io_instance; result = 0; return result; } void tlsio_template_dowork(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; (void)tls_io_instance; } } int tlsio_template_setoption(CONCRETE_IO_HANDLE tls_io, const char* optionName, const void* value) { int result; (void)value; if (tls_io == NULL || optionName == NULL) { LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p, const char* optionName = %p", tls_io, optionName); result = MU_FAILURE; } else { result = 0; } return result; } const IO_INTERFACE_DESCRIPTION* tlsio_template_get_interface_description(void) { return &tlsio_template_interface_description; } tlsio_wolfssl.c000066400000000000000000001014771455573770000341570ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #define WOLFSSL_OPTIONS_IGNORE_SYS #include "wolfssl/options.h" #include "wolfssl/ssl.h" #include "wolfssl/error-ssl.h" #include "wolfssl/wolfcrypt/types.h" #include #include #include #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/tlsio_wolfssl.h" #include "azure_c_shared_utility/socketio.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/shared_util_options.h" typedef enum TLSIO_STATE_ENUM_TAG { TLSIO_STATE_NOT_OPEN, TLSIO_STATE_OPENING_UNDERLYING_IO, TLSIO_STATE_IN_HANDSHAKE, TLSIO_STATE_OPEN, TLSIO_STATE_CLOSING, TLSIO_STATE_ERROR } TLSIO_STATE_ENUM; typedef struct TLS_IO_INSTANCE_TAG { XIO_HANDLE socket_io; ON_BYTES_RECEIVED on_bytes_received; ON_IO_OPEN_COMPLETE on_io_open_complete; ON_IO_CLOSE_COMPLETE on_io_close_complete; ON_IO_ERROR on_io_error; void* on_bytes_received_context; void* on_io_open_complete_context; void* on_io_close_complete_context; void* on_io_error_context; WOLFSSL* ssl; WOLFSSL_CTX* ssl_context; TLSIO_STATE_ENUM tlsio_state; unsigned char* socket_io_read_bytes; size_t socket_io_read_byte_count; ON_SEND_COMPLETE on_send_complete; void* on_send_complete_callback_context; char* certificate; char* x509certificate; char* x509privatekey; int wolfssl_device_id; char* hostname; bool ignore_host_name_check; } TLS_IO_INSTANCE; STATIC_VAR_UNUSED const char* const OPTION_WOLFSSL_SET_DEVICE_ID = "SetDeviceId"; static const size_t SOCKET_READ_LIMIT = 5; /*this function will clone an option given by name and value*/ static void* tlsio_wolfssl_CloneOption(const char* name, const void* value) { void* result; if ((name == NULL) || (value == NULL)) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); result = NULL; } else { if (strcmp(name, OPTION_TRUSTED_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s TrustedCerts value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_CERT) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509certificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) { if (mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s x509privatekey value"); result = NULL; } else { /*return as is*/ } } #ifdef INVALID_DEVID else if(strcmp(name, OPTION_WOLFSSL_SET_DEVICE_ID) == 0 ) { int* value_clone; if ((value_clone = malloc(sizeof(int))) == NULL) { LogError("unable to clone device id option"); } else { *value_clone = *(int*)value; } result = value_clone; } #endif else { LogError("not handled option : %s", name); result = NULL; } } return result; } /*this function destroys an option previously created*/ static void tlsio_wolfssl_DestroyOption(const char* name, const void* value) { /*since all options for this layer are actually string copies., disposing of one is just calling free*/ if ((name == NULL) || (value == NULL)) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); } else { if ((strcmp(name, OPTION_TRUSTED_CERT) == 0) || (strcmp(name, SU_OPTION_X509_CERT) == 0) || (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) || (strcmp(name, OPTION_WOLFSSL_SET_DEVICE_ID) == 0)) { free((void*)value); } else { LogError("not handled option : %s", name); } } } static OPTIONHANDLER_HANDLE tlsio_wolfssl_retrieveoptions(CONCRETE_IO_HANDLE tls_io) { OPTIONHANDLER_HANDLE result; if (tls_io == NULL) { LogError("NULL tls_io parameter"); result = NULL; } else { result = OptionHandler_Create(tlsio_wolfssl_CloneOption, tlsio_wolfssl_DestroyOption, tlsio_wolfssl_setoption); if (result == NULL) { LogError("unable to OptionHandler_Create"); /*return as is*/ } else { /*this layer cares about the certificates and the x509 credentials*/ TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if ( (tls_io_instance->x509certificate != NULL) && (OptionHandler_AddOption(result, SU_OPTION_X509_CERT, tls_io_instance->x509certificate) != OPTIONHANDLER_OK) ) { LogError("unable to save x509certificate option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->x509privatekey != NULL) && (OptionHandler_AddOption(result, SU_OPTION_X509_PRIVATE_KEY, tls_io_instance->x509privatekey) != OPTIONHANDLER_OK) ) { LogError("unable to save x509privatekey option"); OptionHandler_Destroy(result); result = NULL; } else if ( (tls_io_instance->certificate != NULL) && (OptionHandler_AddOption(result, OPTION_TRUSTED_CERT, tls_io_instance->certificate) != OPTIONHANDLER_OK) ) { LogError("unable to save TrustedCerts option"); OptionHandler_Destroy(result); result = NULL; } #ifdef INVALID_DEVID else if ( (tls_io_instance->wolfssl_device_id != INVALID_DEVID) && (OptionHandler_AddOption(result, OPTION_WOLFSSL_SET_DEVICE_ID, &tls_io_instance->wolfssl_device_id) != OPTIONHANDLER_OK) ) { LogError("unable to save deviceid option"); OptionHandler_Destroy(result); result = NULL; } #endif else { /*all is fine, all interesting options have been saved*/ /*return as is*/ } } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_wolfssl_interface_description = { tlsio_wolfssl_retrieveoptions, tlsio_wolfssl_create, tlsio_wolfssl_destroy, tlsio_wolfssl_open, tlsio_wolfssl_close, tlsio_wolfssl_send, tlsio_wolfssl_dowork, tlsio_wolfssl_setoption }; static void indicate_error(TLS_IO_INSTANCE* tls_io_instance) { if (tls_io_instance->on_io_error != NULL) { tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } } static void indicate_open_complete(TLS_IO_INSTANCE* tls_io_instance, IO_OPEN_RESULT open_result) { if (tls_io_instance->on_io_open_complete != NULL) { tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, open_result); } } static int decode_ssl_received_bytes(TLS_IO_INSTANCE* tls_io_instance) { int result = 0; unsigned char buffer[64]; int rcv_bytes = 0; do { rcv_bytes = wolfSSL_read(tls_io_instance->ssl, buffer, sizeof(buffer)); if (rcv_bytes > 0) { if (tls_io_instance->on_bytes_received != NULL) { tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, buffer, rcv_bytes); } } } while (rcv_bytes > 0); return result; } static void on_underlying_io_open_complete(void* context, IO_OPEN_RESULT open_result) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (open_result != IO_OPEN_OK) { LogError("Underlying IO open failed"); tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); } else { int res; tls_io_instance->tlsio_state = TLSIO_STATE_IN_HANDSHAKE; res = wolfSSL_connect(tls_io_instance->ssl); if (res != SSL_SUCCESS) { // Error codes explained in https://www.wolfssl.com/docs/wolfssl-manual/appendix-c/ LogError("WolfSSL connect failed (%d)", wolfSSL_get_error(tls_io_instance->ssl, res)); indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; } } } static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size) { if (context != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; unsigned char* new_socket_io_read_bytes = (unsigned char*)realloc(tls_io_instance->socket_io_read_bytes, tls_io_instance->socket_io_read_byte_count + size); if (new_socket_io_read_bytes == NULL) { LogError("Failed allocating memory for received bytes"); tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); } else { tls_io_instance->socket_io_read_bytes = new_socket_io_read_bytes; (void)memcpy(tls_io_instance->socket_io_read_bytes + tls_io_instance->socket_io_read_byte_count, buffer, size); tls_io_instance->socket_io_read_byte_count += size; } } else { LogInfo("Supplied context is NULL on bytes_received"); } } static void on_underlying_io_error(void* context) { if (context != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; switch (tls_io_instance->tlsio_state) { default: LogError("Unknown TLS IO WolfSSL state: %d", (int)tls_io_instance->tlsio_state); break; case TLSIO_STATE_NOT_OPEN: case TLSIO_STATE_ERROR: break; case TLSIO_STATE_OPENING_UNDERLYING_IO: case TLSIO_STATE_IN_HANDSHAKE: tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_open_complete(tls_io_instance, IO_OPEN_ERROR); break; case TLSIO_STATE_OPEN: tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); break; } } else { LogInfo("Supplied context is NULL on io_error"); } } static void on_underlying_io_close_complete(void* context) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (tls_io_instance->tlsio_state != TLSIO_STATE_CLOSING) { LogError("on_underlying_io_close_complete called when not in CLOSING state"); } else { if (tls_io_instance->on_io_close_complete != NULL) { tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context); } tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; } } static int on_io_recv(WOLFSSL *ssl, char *buf, int sz, void *context) { int result; if (context != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; unsigned char* new_socket_io_read_bytes; size_t socket_reads = 0; AZURE_UNREFERENCED_PARAMETER(ssl); while (tls_io_instance->socket_io_read_byte_count == 0 && socket_reads < SOCKET_READ_LIMIT) { xio_dowork(tls_io_instance->socket_io); if (tls_io_instance->tlsio_state != TLSIO_STATE_IN_HANDSHAKE) { break; } socket_reads++; } result = tls_io_instance->socket_io_read_byte_count; if (result > sz) { result = sz; } if (result > 0) { (void)memcpy(buf, tls_io_instance->socket_io_read_bytes, result); (void)memmove(tls_io_instance->socket_io_read_bytes, tls_io_instance->socket_io_read_bytes + result, tls_io_instance->socket_io_read_byte_count - result); tls_io_instance->socket_io_read_byte_count -= result; if (tls_io_instance->socket_io_read_byte_count > 0) { new_socket_io_read_bytes = (unsigned char*)realloc(tls_io_instance->socket_io_read_bytes, tls_io_instance->socket_io_read_byte_count); if (new_socket_io_read_bytes != NULL) { tls_io_instance->socket_io_read_bytes = new_socket_io_read_bytes; } } else { free(tls_io_instance->socket_io_read_bytes); tls_io_instance->socket_io_read_bytes = NULL; } } if (tls_io_instance->tlsio_state == TLSIO_STATE_ERROR) { result = WOLFSSL_CBIO_ERR_GENERAL; } else if ( (result == 0) && (tls_io_instance->tlsio_state == TLSIO_STATE_OPEN)) { #ifdef HAVE_SECURE_RENEGOTIATION if (wolfSSL_SSL_renegotiate_pending(tls_io_instance->ssl) == 0) // SERVER_HELLODONE_COMPLETE { result = WOLFSSL_CBIO_ERR_WANT_READ; } // If Server Hello not complete during renegotiation, do not return error. #else result = WOLFSSL_CBIO_ERR_WANT_READ; #endif } else if ((result == 0) && (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING || tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN)) { result = WOLFSSL_CBIO_ERR_CONN_CLOSE; } } else { result = WOLFSSL_CBIO_ERR_GENERAL; } return result; } static int on_io_send(WOLFSSL *ssl, char *buf, int sz, void *context) { int result; AZURE_UNREFERENCED_PARAMETER(ssl); TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (xio_send(tls_io_instance->socket_io, buf, sz, tls_io_instance->on_send_complete, tls_io_instance->on_send_complete_callback_context) != 0) { LogError("Failed sending bytes through underlying IO"); tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; indicate_error(tls_io_instance); result = WOLFSSL_CBIO_ERR_GENERAL; } else { result = sz; } return result; } static int on_handshake_done(WOLFSSL* ssl, void* context) { AZURE_UNREFERENCED_PARAMETER(ssl); TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context; if (tls_io_instance->tlsio_state != TLSIO_STATE_IN_HANDSHAKE) { LogInfo("on_handshake_done called when not in IN_HANDSHAKE state"); } else { tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; indicate_open_complete(tls_io_instance, IO_OPEN_OK); } return 0; } static int add_certificate_to_store(TLS_IO_INSTANCE* tls_io_instance) { int result; if (tls_io_instance->certificate != NULL) { int res = wolfSSL_CTX_load_verify_buffer(tls_io_instance->ssl_context, (const unsigned char*)tls_io_instance->certificate, strlen(tls_io_instance->certificate), SSL_FILETYPE_PEM); if (res != SSL_SUCCESS) { LogError("wolfSSL_CTX_load_verify_buffer failed"); result = MU_FAILURE; } else { result = 0; } } else { result = 0; } return result; } static int x509_wolfssl_add_credentials(WOLFSSL* ssl, char* x509certificate, char* x509privatekey) { int result; if (wolfSSL_use_certificate_chain_buffer(ssl, (unsigned char*)x509certificate, strlen(x509certificate)) != SSL_SUCCESS) { LogError("unable to load x509 client certificate"); result = MU_FAILURE; } else if (wolfSSL_use_PrivateKey_buffer(ssl, (unsigned char*)x509privatekey, strlen(x509privatekey), SSL_FILETYPE_PEM) != SSL_SUCCESS) { LogError("unable to load x509 client private key"); result = MU_FAILURE; } else { result = 0; } return result; } static void destroy_wolfssl_instance(TLS_IO_INSTANCE* tls_io_instance) { wolfSSL_free(tls_io_instance->ssl); tls_io_instance->ssl = NULL; } static int create_wolfssl_instance(TLS_IO_INSTANCE* tls_io_instance) { int result; tls_io_instance->ssl = wolfSSL_new(tls_io_instance->ssl_context); if (tls_io_instance->ssl == NULL) { LogError("Failed to add certificates to store"); result = MU_FAILURE; } else { tls_io_instance->socket_io_read_bytes = NULL; tls_io_instance->socket_io_read_byte_count = 0; tls_io_instance->on_send_complete = NULL; tls_io_instance->on_send_complete_callback_context = NULL; #ifdef INVALID_DEVID tls_io_instance->wolfssl_device_id = INVALID_DEVID; #endif wolfSSL_set_using_nonblock(tls_io_instance->ssl, 1); wolfSSL_SetHsDoneCb(tls_io_instance->ssl, on_handshake_done, tls_io_instance); wolfSSL_SetIOWriteCtx(tls_io_instance->ssl, tls_io_instance); wolfSSL_SetIOReadCtx(tls_io_instance->ssl, tls_io_instance); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = 0; #ifdef HAVE_SECURE_RENEGOTIATION if (wolfSSL_UseSecureRenegotiation(tls_io_instance->ssl) != SSL_SUCCESS) { LogError("unable to enable secure renegotiation"); result = MU_FAILURE; } #endif } return result; } static int enable_domain_check(TLS_IO_INSTANCE* tls_io_instance) { int result = 0; if (!tls_io_instance->ignore_host_name_check) { if (wolfSSL_check_domain_name(tls_io_instance->ssl, tls_io_instance->hostname) != WOLFSSL_SUCCESS) { result = MU_FAILURE; } } return result; } static int prepare_wolfssl_open(TLS_IO_INSTANCE* tls_io_instance) { int result; if (enable_domain_check(tls_io_instance)) { LogError("Failed to configure domain name verification"); result = MU_FAILURE; } else if (add_certificate_to_store(tls_io_instance) != 0) { LogError("Failed to add certificates to store"); result = MU_FAILURE; } /*x509 authentication can only be build before underlying connection is realized*/ else if ((tls_io_instance->x509certificate != NULL) && (tls_io_instance->x509privatekey != NULL) && (x509_wolfssl_add_credentials(tls_io_instance->ssl, tls_io_instance->x509certificate, tls_io_instance->x509privatekey) != 0)) { destroy_wolfssl_instance(tls_io_instance); LogError("unable to use x509 authentication"); result = MU_FAILURE; } else { result = 0; } return result; } int tlsio_wolfssl_init(void) { (void)wolfSSL_library_init(); wolfSSL_load_error_strings(); return 0; } void tlsio_wolfssl_deinit(void) { } CONCRETE_IO_HANDLE tlsio_wolfssl_create(void* io_create_parameters) { TLS_IO_INSTANCE* result; if (io_create_parameters == NULL) { LogError("NULL io_create_parameters"); result = NULL; } else { TLSIO_CONFIG* tls_io_config = io_create_parameters; result = (TLS_IO_INSTANCE*)malloc(sizeof(TLS_IO_INSTANCE)); if (result == NULL) { LogError("Failed allocating memory for the TLS IO instance."); } else { (void)memset(result, 0, sizeof(TLS_IO_INSTANCE)); result->tlsio_state = TLSIO_STATE_NOT_OPEN; result->ssl_context = wolfSSL_CTX_new(wolfTLSv1_2_client_method()); if (result->ssl_context == NULL) { LogError("Cannot create the wolfSSL context"); free(result); result = NULL; } else if (mallocAndStrcpy_s(&result->hostname, tls_io_config->hostname) != 0) { LogError("Failed copying the target hostname."); free(result); result = NULL; } else { // Set the recv and send function on the wolfssl context object wolfSSL_SetIOSend(result->ssl_context, on_io_send); wolfSSL_SetIORecv(result->ssl_context, on_io_recv); SOCKETIO_CONFIG socketio_config; const IO_INTERFACE_DESCRIPTION* underlying_io_interface; void* io_interface_parameters; if (tls_io_config->underlying_io_interface != NULL) { underlying_io_interface = tls_io_config->underlying_io_interface; io_interface_parameters = tls_io_config->underlying_io_parameters; } else { socketio_config.hostname = tls_io_config->hostname; socketio_config.port = tls_io_config->port; socketio_config.accepted_socket = NULL; underlying_io_interface = socketio_get_interface_description(); io_interface_parameters = &socketio_config; } if (underlying_io_interface == NULL) { LogError("Failed getting socket IO interface description."); wolfSSL_CTX_free(result->ssl_context); free(result->hostname); free(result); result = NULL; } else { result->socket_io = xio_create(underlying_io_interface, io_interface_parameters); if (result->socket_io == NULL) { LogError("Failure connecting to underlying socket_io"); wolfSSL_CTX_free(result->ssl_context); free(result->hostname); free(result); result = NULL; } else if (create_wolfssl_instance(result) != 0) { LogError("Failure connecting to underlying socket_io"); wolfSSL_CTX_free(result->ssl_context); free(result->hostname); free(result); result = NULL; } } } } } return result; } void tlsio_wolfssl_destroy(CONCRETE_IO_HANDLE tls_io) { if (tls_io != NULL) { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->socket_io_read_bytes != NULL) { free(tls_io_instance->socket_io_read_bytes); tls_io_instance->socket_io_read_bytes = NULL; } if (tls_io_instance->certificate != NULL) { free(tls_io_instance->certificate); tls_io_instance->certificate = NULL; } if (tls_io_instance->x509certificate != NULL) { free(tls_io_instance->x509certificate); tls_io_instance->x509certificate = NULL; } if (tls_io_instance->x509privatekey != NULL) { free(tls_io_instance->x509privatekey); tls_io_instance->x509privatekey = NULL; } destroy_wolfssl_instance(tls_io_instance); wolfSSL_CTX_free(tls_io_instance->ssl_context); tls_io_instance->ssl_context = NULL; xio_destroy(tls_io_instance->socket_io); free(tls_io_instance->hostname); free(tls_io); } } int tlsio_wolfssl_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; if (tls_io == NULL) { LogError("NULL tls_io instance"); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { LogError("Invalid state encountered."); result = MU_FAILURE; } else { tls_io_instance->on_bytes_received = on_bytes_received; tls_io_instance->on_bytes_received_context = on_bytes_received_context; tls_io_instance->on_io_open_complete = on_io_open_complete; tls_io_instance->on_io_open_complete_context = on_io_open_complete_context; tls_io_instance->on_io_error = on_io_error; tls_io_instance->on_io_error_context = on_io_error_context; tls_io_instance->tlsio_state = TLSIO_STATE_OPENING_UNDERLYING_IO; if (prepare_wolfssl_open(tls_io_instance) != 0) { LogError("Cannot create wolfssl instance."); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } else if (xio_open(tls_io_instance->socket_io, on_underlying_io_open_complete, tls_io_instance, on_underlying_io_bytes_received, tls_io_instance, on_underlying_io_error, tls_io_instance) != 0) { LogError("Cannot open the underlying IO."); tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; result = MU_FAILURE; } else { result = 0; } } } return result; } int tlsio_wolfssl_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context) { int result = 0; if (tls_io == NULL) { LogError("NULL tls_io handle."); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if ((tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) || (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING)) { LogError("Close called while not open."); result = MU_FAILURE; } else { tls_io_instance->tlsio_state = TLSIO_STATE_CLOSING; tls_io_instance->on_io_close_complete = on_io_close_complete; tls_io_instance->on_io_close_complete_context = callback_context; if (xio_close(tls_io_instance->socket_io, on_underlying_io_close_complete, tls_io_instance) != 0) { LogError("xio_close failed."); result = MU_FAILURE; } else { result = 0; } } } return result; } int tlsio_wolfssl_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context) { int result; if (tls_io == NULL || buffer == NULL || size == 0) { LogError("Invalid parameter specified tls_io: %p, buffer: %p, size: %ul", tls_io, buffer, (unsigned int)size); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN) { LogError("send called while not open"); result = MU_FAILURE; } else { tls_io_instance->on_send_complete = on_send_complete; tls_io_instance->on_send_complete_callback_context = callback_context; int res = wolfSSL_write(tls_io_instance->ssl, buffer, size); if ((res < 0) || ((size_t)res != size)) // Best way I can think of to safely compare an int to a size_t { LogError("Error writing data through WolfSSL"); result = MU_FAILURE; } else { result = 0; } // remove on send complete and callback context tls_io_instance->on_send_complete = NULL; tls_io_instance->on_send_complete_callback_context = NULL; } } return result; } void tlsio_wolfssl_dowork(CONCRETE_IO_HANDLE tls_io) { if (tls_io == NULL) { LogError("NULL tls_io"); } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (tls_io_instance->tlsio_state == TLSIO_STATE_IN_HANDSHAKE || tls_io_instance->tlsio_state == TLSIO_STATE_OPEN || tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING) { decode_ssl_received_bytes(tls_io_instance); } xio_dowork(tls_io_instance->socket_io); } } static int process_option(char** destination, const char* name, const char* value) { (void) name; int result; if (*destination != NULL) { free(*destination); *destination = NULL; } if (mallocAndStrcpy_s(destination, value) != 0) { LogError("unable to process option %s",name); result = MU_FAILURE; } else { result = 0; } return result; } #if defined(LIBWOLFSSL_VERSION_HEX) && LIBWOLFSSL_VERSION_HEX >= 0x04000000 static void logging_callback(const int logLevel, const char *const logMessage) { if (logLevel == ERROR_LOG) { LogError("tlsio_wolfssl: %s", logMessage); } else { LogInfo("tlsio_wolfssl: %s", logMessage); } } #endif // LIBWOLFSSL_VERSION_HEX >= 0x04000000 int tlsio_wolfssl_setoption(CONCRETE_IO_HANDLE tls_io, const char* optionName, const void* value) { int result; if (tls_io == NULL || optionName == NULL) { LogError("Bad arguments, tls_io = %p, optionName = %p", tls_io, optionName); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0) { result = process_option(&tls_io_instance->certificate, optionName, value); } else if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0) { result = process_option(&tls_io_instance->x509certificate, optionName, value); } else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0) { result = process_option(&tls_io_instance->x509privatekey, optionName, value); } else if (strcmp(optionName, OPTION_SET_TLS_RENEGOTIATION) == 0) { // No need to do anything for WolfSSL result = 0; } #ifdef INVALID_DEVID else if (strcmp(OPTION_WOLFSSL_SET_DEVICE_ID, optionName) == 0) { int device_id = *((int *)value); if (tls_io_instance->ssl != NULL && wolfSSL_SetDevId(tls_io_instance->ssl, device_id) != WOLFSSL_SUCCESS) { LogError("Failure setting device id on ssl"); result = MU_FAILURE; } else { // Save the device Id even if ssl object not yet created. tls_io_instance->wolfssl_device_id = device_id; result = 0; } } #endif else if (strcmp("ignore_host_name_check", optionName) == 0) { bool* server_name_check = (bool*)value; tls_io_instance->ignore_host_name_check = *server_name_check; result = 0; } #if defined(LIBWOLFSSL_VERSION_HEX) && LIBWOLFSSL_VERSION_HEX >= 0x04000000 else if (strcmp("debug_log", optionName) == 0) { bool* enable_debug_logging = (bool*)value; if (enable_debug_logging) { if (!wolfSSL_Debugging_ON()) { LogError("wolfSSL_Debugging_ON failed."); result = MU_FAILURE; } else if (!wolfSSL_SetLoggingCb(&logging_callback)) { LogError("wolfSSL_SetLoggingCb failed."); result = MU_FAILURE; } else { result = 0; } } } #endif // LIBWOLFSSL_VERSION_HEX >= 0x04000000 else { if (tls_io_instance->socket_io == NULL) { LogError("NULL underlying IO handle"); result = MU_FAILURE; } else { result = xio_setoption(tls_io_instance->socket_io, optionName, value); } } } return result; } const IO_INTERFACE_DESCRIPTION* tlsio_wolfssl_get_interface_description(void) { return &tlsio_wolfssl_interface_description; } uniqueid_azsphere.c000066400000000000000000000056301455573770000347720ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/uniqueid.h" #include "azure_c_shared_utility/xlogging.h" #define UUID_LENGTH 36 MU_DEFINE_ENUM_STRINGS(UNIQUEID_RESULT, UNIQUEID_RESULT_VALUES); // UUID fields as specified in RFC 4122 typedef struct UUID_TAG { uint32_t time_low; uint16_t time_mid; uint16_t time_hi_and_version; uint16_t clock_seq_and_variant; uint8_t node[6]; } UUID; // lowercase uuid format expected by azure iot sdk static const char* uuid_format = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"; UNIQUEID_RESULT UniqueId_Generate(char* uid, size_t len) { UNIQUEID_RESULT result; /* Codes_SRS_UNIQUEID_07_002: [If uid is NULL then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ /* Codes_SRS_UNIQUEID_07_003: [If len is less then 37 then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ if (uid == NULL || len < (UUID_LENGTH + 1)) // UUID_LENGTH + 1 to compensate "/0" { result = UNIQUEID_INVALID_ARG; LogError("Buffer Size is Null or Shorter than 37 Characters. (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(UNIQUEID_RESULT, result)); } else { // generate version 4 uuid UUID unique_id; // get random bytes ssize_t bytes_got = getrandom(&unique_id, sizeof(unique_id), GRND_NONBLOCK); if (bytes_got != sizeof(unique_id)) { LogError("Failed to obtain random numbers from getrandom."); result = UNIQUEID_ERROR; } else { // format as version 4 (random) uuid variant 2 unique_id.clock_seq_and_variant = (unique_id.clock_seq_and_variant & 0x3FFF) | 0x8000; unique_id.time_hi_and_version = (unique_id.time_hi_and_version & 0x0FFF) | 0x4000; /* Codes_SRS_UNIQUEID_07_001: [UniqueId_Generate shall create a unique Id 36 character long string.] */ // write out unique_id as string memset(uid, 0, len); int chars_written = snprintf(uid, len, uuid_format, unique_id.time_low, unique_id.time_mid, unique_id.time_hi_and_version, unique_id.clock_seq_and_variant >> 8, unique_id.clock_seq_and_variant & 0xFF, unique_id.node[0], unique_id.node[1], unique_id.node[2], unique_id.node[3], unique_id.node[4], unique_id.node[5]); if (chars_written != UUID_LENGTH) { LogError("Failed to convert binary uuid to string format."); result = UNIQUEID_ERROR; } else { result = UNIQUEID_OK; } } } return result; } uniqueid_linux.c000066400000000000000000000023461455573770000343110ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include #include #include "azure_macro_utils/macro_utils.h" #include "azure_c_shared_utility/uniqueid.h" #include "azure_c_shared_utility/xlogging.h" MU_DEFINE_ENUM_STRINGS(UNIQUEID_RESULT, UNIQUEID_RESULT_VALUES); UNIQUEID_RESULT UniqueId_Generate(char* uid, size_t len) { UNIQUEID_RESULT result; /* Codes_SRS_UNIQUEID_07_002: [If uid is NULL then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ /* Codes_SRS_UNIQUEID_07_003: [If len is less then 37 then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ if (uid == NULL || len < 37) { result = UNIQUEID_INVALID_ARG; LogError("Buffer Size is Null. (result = %" PRI_MU_ENUM ")", MU_ENUM_VALUE(UNIQUEID_RESULT, result)); } else { uuid_t uuidVal; uuid_generate(uuidVal); /* Codes_SRS_UNIQUEID_07_001: [UniqueId_Generate shall create a unique Id 36 character long string.] */ memset(uid, 0, len); uuid_unparse(uuidVal, uid); result = UNIQUEID_OK; } return result; } uniqueid_stub.c000066400000000000000000000050551455573770000341270ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include "azure_c_shared_utility/uniqueid.h" #include "azure_c_shared_utility/xlogging.h" #include MU_DEFINE_ENUM_STRINGS(UNIQUEID_RESULT, UNIQUEID_RESULT_VALUES); static const char tochar[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; static void generate128BitUUID(unsigned char* arrayOfByte) { size_t arrayIndex; for (arrayIndex = 0; arrayIndex < 16; arrayIndex++) { arrayOfByte[arrayIndex] = (unsigned char)rand(); } // // Stick in the version field for random uuid. // arrayOfByte[7] &= 0x0f; //clear the bit field arrayOfByte[7] |= 0x40; //set the ones we care about // // Stick in the variant field for the random uuid. // arrayOfByte[8] &= 0xf3; // Clear arrayOfByte[8] |= 0x08; // Set } // TODO: The User will need to call srand before calling this function UNIQUEID_RESULT UniqueId_Generate(char* uid, size_t len) { UNIQUEID_RESULT result; unsigned char arrayOfChar[16]; /* Codes_SRS_UNIQUEID_07_002: [If uid is NULL then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ /* Codes_SRS_UNIQUEID_07_003: [If len is less then 37 then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ if (uid == NULL || len < 37) { result = UNIQUEID_INVALID_ARG; LogError("Buffer Size is Null or length is less then 37 bytes"); } else { size_t arrayIndex; size_t shiftCount; size_t characterPosition = 0; /* Codes_SRS_UNIQUEID_07_001: [UniqueId_Generate shall create a unique Id 36 character long string.] */ generate128BitUUID(arrayOfChar); for (arrayIndex = 0; arrayIndex < 16; arrayIndex++) { for (shiftCount = 0; shiftCount <= 1; shiftCount++) { char hexChar = tochar[arrayOfChar[arrayIndex] & 0xf]; if ((characterPosition == 8) || (characterPosition == 13) || (characterPosition == 18) || (characterPosition == 23)) { uid[characterPosition] = '-'; characterPosition++; } uid[characterPosition] = hexChar; characterPosition++; arrayOfChar[arrayIndex] = arrayOfChar[arrayIndex] >> 4; } } uid[characterPosition] = 0; result = UNIQUEID_OK; } return result; } uniqueid_win32.c000066400000000000000000000036641455573770000341200ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include #include #include "azure_c_shared_utility/uniqueid.h" #include "azure_c_shared_utility/xlogging.h" #include "rpc.h" MU_DEFINE_ENUM_STRINGS(UNIQUEID_RESULT, UNIQUEID_RESULT_VALUES); UNIQUEID_RESULT UniqueId_Generate(char* uid, size_t len) { UNIQUEID_RESULT result; /* Codes_SRS_UNIQUEID_07_002: [If uid is NULL then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ /* Codes_SRS_UNIQUEID_07_003: [If len is less then 37 then UniqueId_Generate shall return UNIQUEID_INVALID_ARG] */ if (uid == NULL || len < 37) { result = UNIQUEID_INVALID_ARG; LogError("Buffer Size is Null or length is less then 37 bytes"); } else { UUID uuidVal; RPC_STATUS status = UuidCreate(&uuidVal); if (status != RPC_S_OK && status != RPC_S_UUID_LOCAL_ONLY) { LogError("Unable to aquire unique Id"); result = UNIQUEID_ERROR; } else { unsigned char* randomResult; status = UuidToStringA(&uuidVal, &randomResult); if (status != RPC_S_OK) { LogError("Unable to convert Id to string"); result = UNIQUEID_ERROR; } else { size_t cpyLen; /* Codes_SRS_UNIQUEID_07_001: [UniqueId_Generate shall create a unique Id 36 character long string.] */ memset(uid, 0, len); cpyLen = strlen((char*)randomResult); if (cpyLen > len - 1) { cpyLen = len - 1; } (void)memcpy(uid, randomResult, cpyLen); RpcStringFreeA(&randomResult); result = UNIQUEID_OK; } } } return result; } x509_openssl.c000066400000000000000000000376511455573770000335260ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "azure_c_shared_utility/x509_openssl.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/const_defines.h" #include "azure_c_shared_utility/shared_util_options.h" #include "openssl/bio.h" #include "openssl/rsa.h" #include "openssl/x509.h" #include "openssl/pem.h" #include "openssl/err.h" #include "openssl/engine.h" #ifdef __APPLE__ #ifndef EVP_PKEY_id #define EVP_PKEY_id(evp_key) evp_key->type #endif // EVP_PKEY_id #endif // __APPLE__ static void log_ERR_get_error(const char* message) { char buf[128]; AZURE_UNREFERENCED_PARAMETER(buf); unsigned long error; int i; if (message != NULL) { LogError("%s", message); } error = ERR_get_error(); for (i = 0; 0 != error; i++) { LogError(" [%d] %s", i, ERR_error_string(error, buf)); error = ERR_get_error(); } } static int load_certificate_chain(SSL_CTX* ssl_ctx, const char* certificate) { int result; BIO* bio_cert; X509* x509_value; if ((bio_cert = BIO_new_mem_buf((char*)certificate, -1)) == NULL) { log_ERR_get_error("cannot create BIO"); result = MU_FAILURE; } else { /* Codes_SRS_X509_OPENSSL_07_005: [ x509_openssl_add_ecc_credentials shall load the cert chain by calling PEM_read_bio_X509_AUX and SSL_CTX_use_certification. ] */ if ((x509_value = PEM_read_bio_X509_AUX(bio_cert, NULL, NULL, NULL)) == NULL) { log_ERR_get_error("Failure PEM_read_bio_X509_AUX"); result = MU_FAILURE; } else { if (SSL_CTX_use_certificate(ssl_ctx, x509_value) != 1) { log_ERR_get_error("Failure PEM_read_bio_X509_AUX"); result = MU_FAILURE; } else { X509* ca_chain; result = 0; // If we could set up our certificate, now proceed to the CA // certificates. /* Codes_SRS_X509_OPENSSL_07_006: [ If successful x509_openssl_add_ecc_credentials shall to import each certificate in the cert chain. ] */ #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER) SSL_CTX_clear_extra_chain_certs(ssl_ctx); #else if (ssl_ctx->extra_certs != NULL) { sk_X509_pop_free(ssl_ctx->extra_certs, X509_free); ssl_ctx->extra_certs = NULL; } #endif while ((ca_chain = PEM_read_bio_X509(bio_cert, NULL, NULL, NULL)) != NULL) { if (SSL_CTX_add_extra_chain_cert(ssl_ctx, ca_chain) != 1) { X509_free(ca_chain); result = MU_FAILURE; break; } } if (result != 0) { // When the while loop ends, it's usually just EOF. unsigned long err_value = ERR_peek_last_error(); if (ERR_GET_LIB(err_value) == ERR_LIB_PEM && ERR_GET_REASON(err_value) == PEM_R_NO_START_LINE) { ERR_clear_error(); result = 0; } else { result = MU_FAILURE; } } } X509_free(x509_value); } BIO_free(bio_cert); } /* Codes_SRS_X509_OPENSSL_07_007: [ If any failure is encountered x509_openssl_add_ecc_credentials shall return a non-zero value. ] */ return result; } static int load_ecc_key(SSL_CTX* ssl_ctx, EVP_PKEY* evp_key) { int result; /* Codes_SRS_X509_OPENSSL_07_004: [ x509_openssl_add_ecc_credentials shall import the certification using by the EVP_PKEY. ] */ if (SSL_CTX_use_PrivateKey(ssl_ctx, evp_key) != 1) { LogError("Failed SSL_CTX_use_PrivateKey"); result = MU_FAILURE; } else { result = 0; } /* Codes_SRS_X509_OPENSSL_07_007: [ If any failure is encountered x509_openssl_add_ecc_credentials shall return a non-zero value. ] */ return result; } static int load_key_RSA(SSL_CTX* ssl_ctx, EVP_PKEY* evp_key) { int result; /*Codes_SRS_X509_OPENSSL_02_005: [ x509_openssl_add_credentials shall use PEM_read_bio_RSAPrivateKey to read the x509 private key. ]*/ RSA* privatekey = EVP_PKEY_get1_RSA(evp_key); if (privatekey == NULL) { /*Codes_SRS_X509_OPENSSL_02_009: [ Otherwise x509_openssl_add_credentials shall fail and return a non-zero number. ]*/ log_ERR_get_error("Failure reading RSA private key"); result = MU_FAILURE; } else { /*Codes_SRS_X509_OPENSSL_02_007: [ x509_openssl_add_credentials shall use SSL_CTX_use_RSAPrivateKey to load the private key into the SSL context. ]*/ if (SSL_CTX_use_RSAPrivateKey(ssl_ctx, privatekey) != 1) { /*Codes_SRS_X509_OPENSSL_02_009: [ Otherwise x509_openssl_add_credentials shall fail and return a non-zero number. ]*/ log_ERR_get_error("Failure calling SSL_CTX_use_RSAPrivateKey"); result = MU_FAILURE; } else { /*all is fine*/ /*Codes_SRS_X509_OPENSSL_02_008: [ If no error occurs, then x509_openssl_add_credentials shall succeed and return 0. ]*/ result = 0; } RSA_free(privatekey); } return result; } int x509_openssl_add_pem_file_key(SSL_CTX* ssl_ctx, const char* x509privatekey) { int result; BIO* bio_key = BIO_new_mem_buf((char*)x509privatekey, -1); /*taking off the const from the pointer is needed on older versions of OPENSSL*/ if (bio_key == NULL) { log_ERR_get_error("cannot create private key BIO"); result = MU_FAILURE; } else { // Get the Private Key type EVP_PKEY* evp_key = PEM_read_bio_PrivateKey(bio_key, NULL, NULL, NULL); if (evp_key == NULL) { log_ERR_get_error("failure creating private key evp_key"); result = MU_FAILURE; } else { // Check the type for the EVP key int evp_type = EVP_PKEY_id(evp_key); if (evp_type == EVP_PKEY_RSA || evp_type == EVP_PKEY_RSA2) { if (load_key_RSA(ssl_ctx, evp_key) != 0) { LogError("failure loading RSA private key cert"); result = MU_FAILURE; } else { result = 0; } } else { if (load_ecc_key(ssl_ctx, evp_key) != 0) { LogError("failure loading ECC private key cert"); result = MU_FAILURE; } else { result = 0; } } EVP_PKEY_free(evp_key); } BIO_free(bio_key); } return result; } int x509_openssl_add_engine_key(SSL_CTX* ssl_ctx, const char* x509privatekey_id, ENGINE* engine) { int result; // Engine functional reference is short-lived, only within this function. if (!ENGINE_init(engine)) { log_ERR_get_error("unable to initialize ENGINE."); result = MU_FAILURE; } else { if (!ENGINE_set_default(engine, ENGINE_METHOD_ALL)) { log_ERR_get_error("unable to configure ENGINE."); result = MU_FAILURE; } else { EVP_PKEY* evp_key = ENGINE_load_private_key(engine, x509privatekey_id, NULL, NULL); if (evp_key == NULL) { log_ERR_get_error("unable to load private key from ENGINE."); result = MU_FAILURE; } else { if (load_ecc_key(ssl_ctx, evp_key) != 0) { LogError("unable to configure private key from ENGINE."); result = MU_FAILURE; } else { result = 0; } EVP_PKEY_free(evp_key); } } if (!ENGINE_finish(engine)) // Release functional reference. { log_ERR_get_error("unable to release ENGINE functional reference."); result = MU_FAILURE; } } return result; } int x509_openssl_add_credentials( SSL_CTX* ssl_ctx, const char* x509certificate, const char* x509privatekey, OPTION_OPENSSL_KEY_TYPE x509privatekeytype, ENGINE* engine) { int result; if (ssl_ctx == NULL || x509certificate == NULL || x509privatekey == NULL) { /*Codes_SRS_X509_OPENSSL_02_009: [ Otherwise x509_openssl_add_credentials shall fail and return a non-zero number. ]*/ LogError("invalid parameter detected: ssl_ctx=%p, x509certificate=%p, x509privatekey=%p", ssl_ctx, x509certificate, x509privatekey); result = MU_FAILURE; } else if ((x509privatekeytype == KEY_TYPE_ENGINE) && (engine == NULL)) { LogError("OpenSSL Engine must be configured when KEY_TYPE_ENGINE is used."); result = MU_FAILURE; } else { // Configure private key. if (x509privatekeytype == KEY_TYPE_DEFAULT) { result = x509_openssl_add_pem_file_key(ssl_ctx, x509privatekey); } else if (x509privatekeytype == KEY_TYPE_ENGINE) { result = x509_openssl_add_engine_key(ssl_ctx, x509privatekey, engine); } else { result = 0; } if (result == 0) { if (load_certificate_chain(ssl_ctx, x509certificate) != 0) { LogError("failure loading public cert or chain"); result = MU_FAILURE; } } } return result; } /*return 0 if everything was ok, any other number to signal an error*/ /*this function inserts a x509certificate+x509privatekey to a SSL_CTX (ssl context) in order to authenticate the device with the service*/ int x509_openssl_add_certificates(SSL_CTX* ssl_ctx, const char* certificates) { int result; /*Codes_SRS_X509_OPENSSL_02_010: [ If ssl_ctx is NULL then x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ /*Codes_SRS_X509_OPENSSL_02_011: [ If certificates is NULL then x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ if ((certificates == NULL) || (ssl_ctx == NULL)) { /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ LogError("invalid argument SSL_CTX* ssl_ctx=%p, const char* certificates=%s", ssl_ctx, MU_P_OR_NULL(certificates)); result = MU_FAILURE; } else { X509_STORE* cert_store = SSL_CTX_get_cert_store(ssl_ctx); if (cert_store == NULL) { /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ log_ERR_get_error("failure in SSL_CTX_get_cert_store."); result = MU_FAILURE; } else { /*Codes_SRS_X509_OPENSSL_02_012: [ x509_openssl_add_certificates shall get the memory BIO method function by calling BIO_s_mem. ]*/ #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER) const BIO_METHOD* bio_method; #else BIO_METHOD* bio_method; #endif bio_method = BIO_s_mem(); if (bio_method == NULL) { /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ log_ERR_get_error("failure in BIO_s_mem"); result = MU_FAILURE; } else { /*Codes_SRS_X509_OPENSSL_02_013: [ x509_openssl_add_certificates shall create a new memory BIO by calling BIO_new. ]*/ BIO* cert_memory_bio = BIO_new(bio_method); if (cert_memory_bio == NULL) { /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ log_ERR_get_error("failure in BIO_new"); result = MU_FAILURE; } else { /*Codes_SRS_X509_OPENSSL_02_014: [ x509_openssl_add_certificates shall load certificates into the memory BIO by a call to BIO_puts. ]*/ int puts_result = BIO_puts(cert_memory_bio, certificates); if ((puts_result<0) || (puts_result != (int)strlen(certificates))) { /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ log_ERR_get_error("failure in BIO_puts"); result = MU_FAILURE; } else { X509* certificate; /*Codes_SRS_X509_OPENSSL_02_015: [ x509_openssl_add_certificates shall retrieve each certificate by a call to PEM_read_bio_X509. ]*/ while ((certificate = PEM_read_bio_X509(cert_memory_bio, NULL, NULL, NULL)) != NULL) { /*Codes_SRS_X509_OPENSSL_02_016: [ x509_openssl_add_certificates shall add the certificate to the store by a call to X509_STORE_add_cert. ]*/ if (!X509_STORE_add_cert(cert_store, certificate)) { /*Codes_SRS_X509_OPENSSL_02_017: [ If X509_STORE_add_cert returns with error and that error is X509_R_CERT_ALREADY_IN_HASH_TABLE then x509_openssl_add_certificates shall ignore it as the certificate is already in the store. ]*/ /*if the certificate is already in the store, then ERR_peek_error would return REASON == X509_R_CERT_ALREADY_IN_HASH_TABLE, so that's no a "real" error*/ unsigned long error = ERR_peek_error(); if (ERR_GET_REASON(error) == X509_R_CERT_ALREADY_IN_HASH_TABLE) { /*not an error*/ } else { /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ log_ERR_get_error("failure in X509_STORE_add_cert"); X509_free(certificate); break; } } X509_free(certificate); } if (certificate == NULL) { /*Codes_SRS_X509_OPENSSL_02_019: [ Otherwise, x509_openssl_add_certificates shall succeed and return 0. ]*/ result = 0;/*all is fine*/ } else { /*previous while loop terminated unfortunately*/ /*Codes_SRS_X509_OPENSSL_02_018: [ In case of any failure x509_openssl_add_certificates shall fail and return a non-zero value. ]*/ result = MU_FAILURE; } } BIO_free(cert_memory_bio); } } } } return result; }x509_schannel.c000066400000000000000000000625541455573770000336360ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #include "windows.h" #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/x509_schannel.h" #include "azure_c_shared_utility/xlogging.h" #if _MSC_VER > 1500 #include #endif #define KEY_NAME L"AzureAliasKey" #define ECC_256_MAGIC_NUMBER 0x20 #define ECC_384_MAGIC_NUMBER 0x30 typedef enum x509_CERT_TYPE_TAG { x509_TYPE_RSA, x509_TYPE_ECC, x509_TYPE_UNKNOWN, } x509_CERT_TYPE; typedef struct X509_SCHANNEL_HANDLE_DATA_TAG { HCRYPTPROV hProv; HCRYPTKEY x509hcryptkey; PCCERT_CONTEXT x509certificate_context; x509_CERT_TYPE cert_type; } X509_SCHANNEL_HANDLE_DATA; static const char end_certificate_in_pem[] = "-----END CERTIFICATE-----"; static const size_t end_certificate_in_pem_length = sizeof(end_certificate_in_pem) - 1; static const char pem_crlf_value[] = "\r\n"; static const size_t pem_crlf_value_length = sizeof(pem_crlf_value) - 1; static unsigned char* convert_cert_to_binary(const char* crypt_value, DWORD crypt_value_in_len, DWORD* crypt_length) { unsigned char* result = NULL; DWORD result_length = 0; if (!CryptStringToBinaryA(crypt_value, crypt_value_in_len, CRYPT_STRING_ANY, NULL, &result_length, NULL, NULL)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("Failed determine crypt value size"); result = NULL; } else { if ((result = (unsigned char*)malloc(result_length)) == NULL) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogError("unable to allocate memory for crypt value"); } else { if (!CryptStringToBinaryA(crypt_value, 0, CRYPT_STRING_ANY, result, &result_length, NULL, NULL)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("Failed convert crypt value to binary"); free(result); result = NULL; } else { if (crypt_length != NULL) { *crypt_length = result_length; } } } } return result; } static unsigned char* decode_crypt_object(unsigned char* private_key, DWORD key_length, DWORD* blob_size, x509_CERT_TYPE* cert_type) { unsigned char* result; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable: 4306) #endif // _MSC_VER LPCSTR key_type = PKCS_RSA_PRIVATE_KEY; #ifdef _MSC_VER #pragma warning(pop) #endif // _MSC_VER DWORD private_key_blob_size = 0; /*Codes_SRS_X509_SCHANNEL_02_004: [ x509_schannel_create shall decode the private key by calling CryptDecodeObjectEx. ]*/ if (!CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, key_type, private_key, key_length, 0, NULL, NULL, &private_key_blob_size)) { #if _MSC_VER > 1500 key_type = X509_ECC_PRIVATE_KEY; if (!CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, key_type, private_key, key_length, 0, NULL, NULL, &private_key_blob_size)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("Failed to CryptDecodeObjectEx x509 private key"); *cert_type = x509_TYPE_UNKNOWN; } else { *cert_type = x509_TYPE_ECC; } #else /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("Failed to CryptDecodeObjectEx x509 private key"); *cert_type = x509_TYPE_UNKNOWN; #endif } else { *cert_type = x509_TYPE_RSA; } if (*cert_type != x509_TYPE_UNKNOWN) { if ((result = (unsigned char*)malloc(private_key_blob_size)) == NULL) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogError("unable to malloc for x509 private key blob"); } else { if (!CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, key_type, private_key, key_length, 0, NULL, result, &private_key_blob_size)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("Failed to CryptDecodeObjectEx x509 private key"); free(result); result = NULL; } else { if (blob_size != NULL) { *blob_size = private_key_blob_size; } } } } else { result = NULL; } return result; } static int set_ecc_certificate_info(X509_SCHANNEL_HANDLE_DATA* x509_handle, unsigned char* x509privatekeyBlob) { int result; #if _MSC_VER > 1500 SECURITY_STATUS status; CRYPT_BIT_BLOB* pPubKeyBlob = &x509_handle->x509certificate_context->pCertInfo->SubjectPublicKeyInfo.PublicKey; CRYPT_ECC_PRIVATE_KEY_INFO* pPrivKeyInfo = (CRYPT_ECC_PRIVATE_KEY_INFO*)x509privatekeyBlob; DWORD pubSize = pPubKeyBlob->cbData - 1; DWORD privSize = pPrivKeyInfo->PrivateKey.cbData; DWORD keyBlobSize = sizeof(BCRYPT_ECCKEY_BLOB) + pubSize + privSize; BYTE* pubKeyBuf = pPubKeyBlob->pbData + 1; BYTE* privKeyBuf = pPrivKeyInfo->PrivateKey.pbData; BCRYPT_ECCKEY_BLOB* pKeyBlob = (BCRYPT_ECCKEY_BLOB*)malloc(keyBlobSize); if (pKeyBlob == NULL) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogError("Failed to malloc NCrypt private key blob"); result = MU_FAILURE; } else { pKeyBlob->dwMagic = privSize == ECC_256_MAGIC_NUMBER ? BCRYPT_ECDSA_PRIVATE_P256_MAGIC : privSize == ECC_384_MAGIC_NUMBER ? BCRYPT_ECDSA_PRIVATE_P384_MAGIC : BCRYPT_ECDSA_PRIVATE_P521_MAGIC; pKeyBlob->cbKey = privSize; memcpy((BYTE*)(pKeyBlob + 1), pubKeyBuf, pubSize); memcpy((BYTE*)(pKeyBlob + 1) + pubSize, privKeyBuf, privSize); /* Codes_SRS_X509_SCHANNEL_02_005: [ x509_schannel_create shall call CryptAcquireContext. ] */ /* at this moment, both the private key and the certificate are decoded for further usage */ /* NOTE: As no WinCrypt key storage provider supports ECC keys, NCrypt is used instead */ status = NCryptOpenStorageProvider(&x509_handle->hProv, MS_KEY_STORAGE_PROVIDER, 0); if (status != ERROR_SUCCESS) { /* Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogError("NCryptOpenStorageProvider failed with error 0x%08X", status); result = MU_FAILURE; } else { SECURITY_STATUS status2; NCryptBuffer ncBuf = { sizeof(KEY_NAME), NCRYPTBUFFER_PKCS_KEY_NAME, KEY_NAME }; NCryptBufferDesc ncBufDesc; ncBufDesc.ulVersion = 0; ncBufDesc.cBuffers = 1; ncBufDesc.pBuffers = &ncBuf; CRYPT_KEY_PROV_INFO keyProvInfo = { KEY_NAME, MS_KEY_STORAGE_PROVIDER, 0, 0, 0, NULL, 0 }; /*Codes_SRS_X509_SCHANNEL_02_006: [ x509_schannel_create shall import the private key by calling CryptImportKey. ] */ /*NOTE: As no WinCrypt key storage provider supports ECC keys, NCrypt is used instead*/ status = NCryptImportKey(x509_handle->hProv, 0, BCRYPT_ECCPRIVATE_BLOB, &ncBufDesc, &x509_handle->x509hcryptkey, (BYTE*)pKeyBlob, keyBlobSize, NCRYPT_OVERWRITE_KEY_FLAG); if (status == ERROR_SUCCESS) { status2 = NCryptFreeObject(x509_handle->x509hcryptkey); if (status2 != ERROR_SUCCESS) { LogError("NCryptFreeObject for key handle failed with error 0x%08X", status2); } else { x509_handle->x509hcryptkey = 0; } } status2 = NCryptFreeObject(x509_handle->hProv); if (status2 != ERROR_SUCCESS) { LogError("NCryptFreeObject for provider handle failed with error 0x%08X", status2); } else { x509_handle->hProv = 0; } if (status != ERROR_SUCCESS) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogError("NCryptImportKey failed with error 0x%08X", status); result = MU_FAILURE; } else if (!CertSetCertificateContextProperty(x509_handle->x509certificate_context, CERT_KEY_PROV_INFO_PROP_ID, 0, &keyProvInfo)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("CertSetCertificateContextProperty failed to set NCrypt key handle property"); result = MU_FAILURE; } else { result = 0; } } free(pKeyBlob); } #else (void)x509_handle; (void)x509privatekeyBlob; LogError("SChannel ECC is not supported in this compliation"); result = MU_FAILURE; #endif return result; } static int set_rsa_certificate_info(X509_SCHANNEL_HANDLE_DATA* x509_handle, unsigned char* x509privatekeyBlob, DWORD x509privatekeyBlobSize) { int result; /*Codes_SRS_X509_SCHANNEL_02_005: [ x509_schannel_create shall call CryptAcquireContext. ]*/ /*at this moment, both the private key and the certificate are decoded for further usage*/ if (!CryptAcquireContext(&(x509_handle->hProv), NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("CryptAcquireContext failed"); result = MU_FAILURE; } else { /*Codes_SRS_X509_SCHANNEL_02_006: [ x509_schannel_create shall import the private key by calling CryptImportKey. ] */ if (!CryptImportKey(x509_handle->hProv, x509privatekeyBlob, x509privatekeyBlobSize, (HCRYPTKEY)NULL, 0, &(x509_handle->x509hcryptkey))) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("CryptImportKey for private key failed"); if (!CryptReleaseContext(x509_handle->hProv, 0)) { LogErrorWinHTTPWithGetLastErrorAsString("unable to CryptReleaseContext"); } result = MU_FAILURE; } else { /*Codes_SRS_X509_SCHANNEL_02_008: [ x509_schannel_create shall call set the certificate private key by calling CertSetCertificateContextProperty. ]*/ if (!CertSetCertificateContextProperty(x509_handle->x509certificate_context, CERT_KEY_PROV_HANDLE_PROP_ID, 0, (void*)x509_handle->hProv)) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("unable to CertSetCertificateContextProperty"); if (!CryptDestroyKey(x509_handle->x509hcryptkey)) { LogErrorWinHTTPWithGetLastErrorAsString("unable to CryptDestroyKey"); } if (!CryptReleaseContext(x509_handle->hProv, 0)) { LogErrorWinHTTPWithGetLastErrorAsString("unable to CryptReleaseContext"); } result = MU_FAILURE; } else { result = 0; } } } return result; } X509_SCHANNEL_HANDLE x509_schannel_create(const char* x509certificate, const char* x509privatekey) { X509_SCHANNEL_HANDLE_DATA* result; /*this is what happens with the x509 certificate and the x509 private key in this function*/ /* step 1: they are converted to binary form. step 1.1: the size of the binary form is computed step 1.2: the conversion happens step 2: the binary form is decoded step 2.1: the decoded form needed size is computed step 2.2: the decoded form is actually decoded step 3: a crypto provider is created step 4: the x509 private key is associated with the crypto provider step 5: a certificate context is created step 6: the certificate context is linked to the crypto provider */ /*Codes_SRS_X509_SCHANNEL_02_001: [ If x509certificate or x509privatekey are NULL then x509_schannel_create shall fail and return NULL. ]*/ if ( (x509certificate == NULL) || (x509privatekey == NULL) ) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogError("invalid argument const char* x509certificate=%p, const char* x509privatekey=%p", x509certificate, x509privatekey); result = NULL; } else { unsigned char* binaryx509Certificate; unsigned char* binaryx509privatekey; unsigned char* x509privatekeyBlob; DWORD binaryx509certificateSize; DWORD binaryx509privatekeySize; DWORD x509privatekeyBlobSize; result = (X509_SCHANNEL_HANDLE_DATA*)malloc(sizeof(X509_SCHANNEL_HANDLE_DATA)); if (result == NULL) { LogError("unable to malloc"); /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ /*return as is*/ } else { memset(result, 0, sizeof(X509_SCHANNEL_HANDLE_DATA)); /*Codes_SRS_X509_SCHANNEL_02_002: [ x509_schannel_create shall convert the certificate to binary form by calling CryptStringToBinaryA. ]*/ if ((binaryx509Certificate = convert_cert_to_binary(x509certificate, 0, &binaryx509certificateSize)) == NULL) { LogError("Failure converting x509 certificate"); free(result); result = NULL; } /*Codes_SRS_X509_SCHANNEL_02_003: [ x509_schannel_create shall convert the private key to binary form by calling CryptStringToBinaryA. ]*/ /*at this moment x509 certificate is ready to be used in CertCreateCertificateContext*/ else if ((binaryx509privatekey = convert_cert_to_binary(x509privatekey, 0, &binaryx509privatekeySize)) == NULL) { LogError("Failure converting x509 certificate"); free(binaryx509Certificate); free(result); result = NULL; } else if ((x509privatekeyBlob = decode_crypt_object(binaryx509privatekey, binaryx509privatekeySize, &x509privatekeyBlobSize, &result->cert_type)) == NULL) { LogError("Failure decoding x509 private key"); free(binaryx509Certificate); free(binaryx509privatekey); free(result); result = NULL; } else { /*Codes_SRS_X509_SCHANNEL_02_007: [ x509_schannel_create shall create a cerficate context by calling CertCreateCertificateContext. ]*/ PCCERT_CONTEXT cert_ctx = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, binaryx509Certificate, binaryx509certificateSize); if ((result->x509certificate_context = cert_ctx) == NULL) { /*Codes_SRS_X509_SCHANNEL_02_010: [ Otherwise, x509_schannel_create shall fail and return a NULL X509_SCHANNEL_HANDLE. ]*/ LogErrorWinHTTPWithGetLastErrorAsString("unable to CertCreateCertificateContext"); free(result); result = NULL; } else { /* Codes_SRS_X509_SCHANNEL_07_001: [ x509_schannel_create shall determine whether the certificate is of type RSA or ECC. ] */ if (result->cert_type == x509_TYPE_RSA) { if (set_rsa_certificate_info(result, x509privatekeyBlob, x509privatekeyBlobSize) != 0) { (void)CertFreeCertificateContext(result->x509certificate_context); free(result); result = NULL; } } else { if (set_ecc_certificate_info(result, x509privatekeyBlob) != 0) { (void)CertFreeCertificateContext(result->x509certificate_context); free(result); result = NULL; } } } free(x509privatekeyBlob); free(binaryx509privatekey); free(binaryx509Certificate); } } } return result; } void x509_schannel_destroy(X509_SCHANNEL_HANDLE x509_schannel_handle) { /*Codes_SRS_X509_SCHANNEL_02_011: [ If parameter x509_schannel_handle is NULL then x509_schannel_destroy shall do nothing. ]*/ if (x509_schannel_handle != NULL) { /*Codes_SRS_X509_SCHANNEL_02_012: [ Otherwise, x509_schannel_destroy shall free all used resources. ]*/ X509_SCHANNEL_HANDLE_DATA* x509crypto = (X509_SCHANNEL_HANDLE_DATA*)x509_schannel_handle; if (x509crypto->cert_type == x509_TYPE_RSA) { if (!CryptDestroyKey(x509crypto->x509hcryptkey)) { LogErrorWinHTTPWithGetLastErrorAsString("unable to CryptDestroyKey"); } if (!CryptReleaseContext(x509crypto->hProv, 0)) { LogErrorWinHTTPWithGetLastErrorAsString("unable to CryptReleaseContext"); } } else { #if _MSC_VER > 1500 if (x509crypto->x509hcryptkey != 0) { (void)NCryptFreeObject(x509crypto->x509hcryptkey); } if (x509crypto->hProv != 0) { (void)NCryptFreeObject(x509crypto->hProv); } #endif } if (!CertFreeCertificateContext(x509crypto->x509certificate_context)) { LogErrorWinHTTPWithGetLastErrorAsString("unable to CertFreeCertificateContext"); } free(x509crypto); } } PCCERT_CONTEXT x509_schannel_get_certificate_context(X509_SCHANNEL_HANDLE x509_schannel_handle) { PCCERT_CONTEXT result; if (x509_schannel_handle == NULL) { /*Codes_SRS_X509_SCHANNEL_02_013: [ If parameter x509_schannel_handle is NULL then x509_schannel_get_certificate_context shall return NULL. ]*/ result = NULL; } else { /*Codes_SRS_X509_SCHANNEL_02_014: [ Otherwise, x509_schannel_get_certificate_context shall return a non-NULL PCCERT_CONTEXT pointer. ]*/ X509_SCHANNEL_HANDLE_DATA* handleData = (X509_SCHANNEL_HANDLE_DATA*)x509_schannel_handle; result = handleData->x509certificate_context; } return result; } // For each certificate specified in trustedCertificate, add to hCertStore. Windows API's (namely // CryptStringToBinaryA & CertAddEncodedCertificateToStore) do not handle multiple certificates // at a time in a single call, so add_certificates_to_store() parses the PEM (delimited by "-----END CERTIFICATE-----") // to call Windows API a cert at a time. static int add_certificates_to_store(const char* trustedCertificate, HCERTSTORE hCertStore) { int result = 0; int numCertificatesAdded = 0; const char* trustedCertCurrentRead = trustedCertificate; unsigned char* trustedCertificateEncoded = NULL; while (result == 0) { const char* endCertificateCurrentRead; DWORD trustedCertificateEncodedLen; DWORD lastError; if ((endCertificateCurrentRead = strstr(trustedCertCurrentRead, end_certificate_in_pem)) == NULL) { if (numCertificatesAdded == 0) { LogError("Certificate missing closing %s. No certificates can be added to stare", end_certificate_in_pem); result = MU_FAILURE; } break; } endCertificateCurrentRead += end_certificate_in_pem_length; if (strncmp(endCertificateCurrentRead, pem_crlf_value, pem_crlf_value_length) == 0) { endCertificateCurrentRead += pem_crlf_value_length; } if ((trustedCertificateEncoded = convert_cert_to_binary(trustedCertCurrentRead, (DWORD)(endCertificateCurrentRead - trustedCertCurrentRead), &trustedCertificateEncodedLen)) == NULL) { LogError("Cannot encode trusted certificate"); result = MU_FAILURE; } else if (CertAddEncodedCertificateToStore(hCertStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, trustedCertificateEncoded, trustedCertificateEncodedLen, CERT_STORE_ADD_REPLACE_EXISTING, NULL) != TRUE) { lastError = GetLastError(); LogError("CertAddEncodedCertificateToStore failed with error 0x%08x", lastError); result = MU_FAILURE; } if (trustedCertificateEncoded != NULL) { free(trustedCertificateEncoded); } trustedCertCurrentRead = endCertificateCurrentRead; numCertificatesAdded++; } return result; } // x509_verify_certificate_in_chain determines whether the certificate in pCertContextToVerify // chains up to the PEM represented by trustedCertificate or not. int x509_verify_certificate_in_chain(const char* trustedCertificate, PCCERT_CONTEXT pCertContextToVerify) { int result; HCERTSTORE hCertStore = NULL; HCERTCHAINENGINE hChainEngine = NULL; PCCERT_CHAIN_CONTEXT pChainContextToVerify = NULL; DWORD lastError; if ((trustedCertificate == NULL) || (pCertContextToVerify == NULL)) { result = MU_FAILURE; } // Creates an in-memory certificate store that is destroyed at end of this function. else if (NULL == (hCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, CERT_STORE_CREATE_NEW_FLAG, NULL))) { lastError = GetLastError(); LogError("CertOpenStore failed with error 0x%08x", lastError); result = MU_FAILURE; } else if (add_certificates_to_store(trustedCertificate, hCertStore) != 0) { LogError("Cannot add certificates to store"); result = MU_FAILURE; } else { CERT_CHAIN_ENGINE_CONFIG EngineConfig; CERT_CHAIN_PARA ChainPara; CERT_CHAIN_POLICY_PARA PolicyPara; CERT_CHAIN_POLICY_STATUS PolicyStatus; memset(&EngineConfig, 0, sizeof(EngineConfig)); EngineConfig.cbSize = sizeof(EngineConfig); EngineConfig.dwFlags = CERT_CHAIN_ENABLE_CACHE_AUTO_UPDATE | CERT_CHAIN_ENABLE_SHARE_STORE; EngineConfig.hExclusiveRoot = hCertStore; memset(&ChainPara, 0, sizeof(ChainPara)); ChainPara.cbSize = sizeof(ChainPara); memset(&PolicyPara, 0, sizeof(PolicyPara)); PolicyPara.cbSize = sizeof(PolicyPara); memset(&PolicyStatus, 0, sizeof(PolicyStatus)); PolicyStatus.cbSize = sizeof(PolicyStatus); if (CertCreateCertificateChainEngine(&EngineConfig, &hChainEngine) != TRUE) { lastError = GetLastError(); LogError("CertCreateCertificateChainEngine failed with error 0x%08x", lastError); result = MU_FAILURE; } else if (CertGetCertificateChain(hChainEngine, pCertContextToVerify, NULL, pCertContextToVerify->hCertStore, &ChainPara, 0, NULL, &pChainContextToVerify) != TRUE) { lastError = GetLastError(); LogError("CertGetCertificateChain failed with error 0x%08x", lastError); result = MU_FAILURE; } else if (CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_SSL, pChainContextToVerify, &PolicyPara, &PolicyStatus) != TRUE) { lastError = GetLastError(); LogError("CertVerifyCertificateChainPolicy failed with error 0x%08x", lastError); result = MU_FAILURE; } else if (PolicyStatus.dwError != 0) { LogError("CertVerifyCertificateChainPolicy sets certificateStatus = 0x%08x", PolicyStatus.dwError); result = MU_FAILURE; } else { result = 0; } } if (pChainContextToVerify != NULL) { CertFreeCertificateChain(pChainContextToVerify); } if (hChainEngine != NULL) { CertFreeCertificateChainEngine(hChainEngine); } if (hCertStore != NULL) { CertCloseStore(hCertStore, 0); } return result; } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/000077500000000000000000000000001455573770000307735ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/cyclonessl/000077500000000000000000000000001455573770000331515ustar00rootroot00000000000000CMakeLists-cyclone.txt000066400000000000000000000103431455573770000372650ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/cyclonessl## CycloneSSL is NOT supported for the Azure C shared utilities. ## The code here is provided for reference purposes. ## ## A security audit is required if you attempt to bring this code back. ## The code below is the parts are from CMakeLists.txt that integrated CycloneSSL into the build. option(use_cyclonessl "set use_cyclonessl to ON if cyclonessl is to be used, set to OFF to not use cyclonessl" OFF) if(${use_cyclonessl} AND WIN32) set(cyclonessl_c_files $ENV{CycloneSSLDir}/cyclone_ssl/ssl_common.c $ENV{CycloneSSLDir}/cyclone_ssl/tls.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_cache.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_cipher_suites.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_client.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_common.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_io.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_misc.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_record.c $ENV{CycloneSSLDir}/cyclone_ssl/tls_server.c $ENV{CycloneSSLDir}/common/date_time.c $ENV{CycloneSSLDir}/common/debug.c $ENV{CycloneSSLDir}/common/endian.c $ENV{CycloneSSLDir}/common/os_port_windows.c $ENV{CycloneSSLDir}/cyclone_crypto/aes.c $ENV{CycloneSSLDir}/cyclone_crypto/aria.c $ENV{CycloneSSLDir}/cyclone_crypto/asn1.c $ENV{CycloneSSLDir}/cyclone_crypto/base64.c $ENV{CycloneSSLDir}/cyclone_crypto/camellia.c $ENV{CycloneSSLDir}/cyclone_crypto/chacha.c $ENV{CycloneSSLDir}/cyclone_crypto/chacha20_poly1305.c $ENV{CycloneSSLDir}/cyclone_crypto/cipher_mode_cbc.c $ENV{CycloneSSLDir}/cyclone_crypto/cipher_mode_ccm.c $ENV{CycloneSSLDir}/cyclone_crypto/cipher_mode_gcm.c $ENV{CycloneSSLDir}/cyclone_crypto/des.c $ENV{CycloneSSLDir}/cyclone_crypto/des3.c $ENV{CycloneSSLDir}/cyclone_crypto/dh.c $ENV{CycloneSSLDir}/cyclone_crypto/dsa.c $ENV{CycloneSSLDir}/cyclone_crypto/ec.c $ENV{CycloneSSLDir}/cyclone_crypto/ec_curves.c $ENV{CycloneSSLDir}/cyclone_crypto/ecdh.c $ENV{CycloneSSLDir}/cyclone_crypto/ecdsa.c $ENV{CycloneSSLDir}/cyclone_crypto/hmac.c $ENV{CycloneSSLDir}/cyclone_crypto/idea.c $ENV{CycloneSSLDir}/cyclone_crypto/md5.c $ENV{CycloneSSLDir}/cyclone_crypto/mpi.c $ENV{CycloneSSLDir}/cyclone_crypto/oid.c $ENV{CycloneSSLDir}/cyclone_crypto/pem.c $ENV{CycloneSSLDir}/cyclone_crypto/poly1305.c $ENV{CycloneSSLDir}/cyclone_crypto/rc4.c $ENV{CycloneSSLDir}/cyclone_crypto/rsa.c $ENV{CycloneSSLDir}/cyclone_crypto/seed.c $ENV{CycloneSSLDir}/cyclone_crypto/sha1.c $ENV{CycloneSSLDir}/cyclone_crypto/sha224.c $ENV{CycloneSSLDir}/cyclone_crypto/sha256.c $ENV{CycloneSSLDir}/cyclone_crypto/sha384.c $ENV{CycloneSSLDir}/cyclone_crypto/sha512.c $ENV{CycloneSSLDir}/cyclone_crypto/x509.c $ENV{CycloneSSLDir}/cyclone_crypto/yarrow.c ) include_directories($ENV{CycloneSSLDir}/common/) include_directories($ENV{CycloneSSLDir}/cyclone_ssl/) include_directories($ENV{CycloneSSLDir}/cyclone_crypto/) include_directories($ENV{CycloneSSLDir}/demo/x86/ssl_client_demo/src/) set_source_files_properties(${cyclonessl_c_files} PROPERTIES COMPILE_FLAGS "/wd4200 /wd4201 /wd4244 /wd4100 /wd4267 /wd4701 /wd4703 /wd4389 /wd4005") set_source_files_properties(./src/tlsio_cyclonessl.c ./src/tlsio_cyclonessl_socket_bsd.c PROPERTIES COMPILE_FLAGS "/wd4200 /wd4201 /wd4244 /wd4100 /wd4267 /wd4701 /wd4703 /wd4389 /wd4005 /wd4996") add_library(cyclonessl ${cyclonessl_c_files}) endif() if(${use_cyclonessl} AND WIN32) set(source_c_files ${source_c_files} ./src/tlsio_cyclonessl.c ./src/tlsio_cyclonessl_socket_bsd.c ) endif() if(${use_cyclonessl} AND WIN32) set(source_h_files ${source_h_files} ./inc/azure_c_shared_utility/tlsio_cyclonessl.h ./inc/azure_c_shared_utility/tlsio_cyclonessl_socket.h ) endif() if(${use_cyclonessl}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CYCLONESSL") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_CYCLONESSL") endif() if(${use_cyclonessl} AND WIN32) set(aziotsharedutil_target_libs ${aziotsharedutil_target_libs} cyclonessl) endif() readme.md000066400000000000000000000002721455573770000346520ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/cyclonessl**CycloneSSL is NOT supported for the Azure C shared utilities.** The code here is provided for reference purposes. A security audit is required if you attempt to bring this code back.tlsio_cyclonessl.c000066400000000000000000000740701455573770000366360ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/cyclonessl// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #error CycloneSSL is NOT supported for the Azure C shared utilities. #error The code here is provided for reference purposes. #error #error A security audit is required if you attempt to bring this code back. #include /* Using tlsio_cyclonessl requires: - Downloading the source code for CycloneSSL. - If using cmake, defining the environment variable CycloneSSLDir to point to the location of the unpacked CycloneSSL source - Using the use_cyclonessl cmake option Alternately if cmake is not used, one has to make sure that the CycloneSSL headers are in the include directlroy list. */ #if _WIN32 #define _WINERROR_ #include #endif #include #include #include #include #include "azure_c_shared_utility/gballoc.h" #include "azure_c_shared_utility/tlsio.h" #include "azure_c_shared_utility/tlsio_cyclonessl.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/crt_abstractions.h" #include "error.h" #include "yarrow.h" #include "tls.h" #include "azure_c_shared_utility/tlsio_cyclonessl_socket.h" typedef enum TLSIO_STATE_TAG { TLSIO_STATE_NOT_OPEN, TLSIO_STATE_OPEN, TLSIO_STATE_ERROR } TLSIO_STATE; typedef struct TLS_IO_INSTANCE_TAG { ON_BYTES_RECEIVED on_bytes_received; ON_IO_ERROR on_io_error; void* on_bytes_received_context; void* on_io_error_context; TLSIO_STATE tlsio_state; char* hostname; int port; char* certificate; YarrowContext yarrowContext; TlsContext *tlsContext; TlsSocket socket; } TLS_IO_INSTANCE; static int tlsio_cyclonessl_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* on_io_close_complete_context); /*this function will clone an option given by name and value*/ static void* tlsio_cyclonessl_clone_option(const char* name, const void* value) { void* result; /* Codes_SRS_TLSIO_CYCLONESSL_01_070: [ If the name or value arguments are NULL, tlsio_cyclonessl_clone_option shall return NULL. ]*/ if((name == NULL) || (value == NULL)) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); result = NULL; } else { if (strcmp(name, "TrustedCerts") == 0) { /* Codes_SRS_TLSIO_CYCLONESSL_01_071: [ tlsio_cyclonessl_clone_option shall clone the option named TrustedCerts by calling mallocAndStrcpy_s. ]*/ if(mallocAndStrcpy_s((char**)&result, value) != 0) { LogError("unable to mallocAndStrcpy_s TrustedCerts value"); result = NULL; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_072: [ On success it shall return a non-NULL pointer to the cloned option. ]*/ /*return as is*/ } } else { LogError("not handled option : %s", name); result = NULL; } } return result; } /*this function destroys an option previously created*/ static void tlsio_cyclonessl_destroy_option(const char* name, const void* value) { /*since all options for this layer are actually string copies., disposing of one is just calling free*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_074: [ If any of the arguments is NULL, tlsio_cyclonessl_destroy_option shall do nothing. ]*/ if ((name == NULL) || (value == NULL)) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); } else { if (strcmp(name, "TrustedCerts") == 0) { free((void*)value); } else { LogError("not handled option : %s", name); } } } /* Codes_SRS_TLSIO_CYCLONESSL_01_001: [ tlsio_cyclonessl_create shall create a new instance of the tlsio for Cyclone SSL. ]*/ static CONCRETE_IO_HANDLE tlsio_cyclonessl_create(void* io_create_parameters) { TLS_IO_INSTANCE* result; /* Codes_SRS_TLSIO_CYCLONESSL_01_002: [ If io_create_parameters is NULL, tlsio_cyclonessl_create shall fail and return NULL. ]*/ if (io_create_parameters == NULL) { result = NULL; LogError("NULL tls_io_config."); } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_003: [ io_create_parameters shall be used as a TLSIO_CONFIG\*. ]*/ TLSIO_CONFIG* tls_io_config = io_create_parameters; /* Codes_SRS_TLSIO_CYCLONESSL_01_004: [ If the hostname member is NULL, then tlsio_cyclonessl_create shall fail and return NULL. ]*/ if (tls_io_config->hostname == NULL) { result = NULL; LogError("NULL hostname in the TLS IO configuration."); } else { result = malloc(sizeof(TLS_IO_INSTANCE)); if (result == NULL) { /* Codes_SRS_TLSIO_CYCLONESSL_01_076: [ If allocating memory for the TLS IO instance fails then tlsio_cyclonessl_create shall fail and return NULL. ]*/ LogError("Failed allocating TLSIO instance."); } else { uint8_t seed[32]; size_t i; /* Codes_SRS_TLSIO_CYCLONESSL_01_005: [ tlsio_cyclonessl_create shall copy the hostname and port values for later use when the open of the underlying socket is needed. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_006: [ hostname shall be copied by calling mallocAndStrcpy_s. ]*/ if (mallocAndStrcpy_s(&result->hostname, tls_io_config->hostname) != 0) { /* Codes_SRS_TLSIO_CYCLONESSL_01_007: [ If mallocAndStrcpy_s fails then tlsio_cyclonessl_create shall fail and return NULL. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_018: [ When tlsio_cyclonessl_create fails, all allocated resources up to that point shall be freed. ]*/ LogError("Failed to copy the hostname."); free(result); result = NULL; } else { result->port = tls_io_config->port; result->certificate = NULL; result->on_bytes_received = NULL; result->on_bytes_received_context = NULL; result->on_io_error = NULL; result->on_io_error_context = NULL; result->tlsio_state = TLSIO_STATE_NOT_OPEN; result->socket = (TlsSocket)NULL; /* seed should be initialized with some random seed ... */ for (i = 0; i < 32; i++) { seed[i] = rand() * 255 / RAND_MAX; } /* Codes_SRS_TLSIO_CYCLONESSL_01_008: [ tlsio_cyclonessl_create shall initialize the yarrow context by calling yarrowInit. ]*/ if (yarrowInit(&result->yarrowContext) != NO_ERROR) { /* Codes_SRS_TLSIO_CYCLONESSL_01_009: [ If yarrowInit fails then tlsio_cyclonessl_create shall return NULL. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_018: [ When tlsio_cyclonessl_create fails, all allocated resources up to that point shall be freed. ]*/ LogError("yarrowInit failed"); free(result->hostname); free(result); result = NULL; } /* Codes_SRS_TLSIO_CYCLONESSL_01_010: [ The yarrow context shall be seeded with 32 bytes of randomly chosen data by calling yarrowSeed. ]*/ else if (yarrowSeed(&result->yarrowContext, seed, sizeof(seed)) != NO_ERROR) { /* Codes_SRS_TLSIO_CYCLONESSL_01_011: [ If yarrowSeed fails then tlsio_cyclonessl_create shall return NULL. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_018: [ When tlsio_cyclonessl_create fails, all allocated resources up to that point shall be freed. ]*/ LogError("yarrowInit seed failed"); yarrowRelease(&result->yarrowContext); free(result->hostname); free(result); result = NULL; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_012: [ tlsio_cyclonessl_create shall create a TLS context by calling tlsInit. ]*/ result->tlsContext = tlsInit(); if (result->tlsContext == NULL) { /* Codes_SRS_TLSIO_CYCLONESSL_01_013: [ If tlsInit fails then tlsio_cyclonessl_create shall return NULL. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_018: [ When tlsio_cyclonessl_create fails, all allocated resources up to that point shall be freed. ]*/ tlsFree(result->tlsContext); yarrowRelease(&result->yarrowContext); free(result->hostname); free(result); LogError("Creating the TLS context failed"); result = NULL; } /* Codes_SRS_TLSIO_CYCLONESSL_01_014: [ The TLS context shall be setup to operate as a client by calling tlsSetConnectionEnd with TLS_CONNECTION_END_CLIENT. ]*/ else if (tlsSetConnectionEnd(result->tlsContext, TLS_CONNECTION_END_CLIENT)) { /* Codes_SRS_TLSIO_CYCLONESSL_01_015: [ If tlsSetConnectionEnd fails then tlsio_cyclonessl_create shall return NULL. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_018: [ When tlsio_cyclonessl_create fails, all allocated resources up to that point shall be freed. ]*/ tlsFree(result->tlsContext); yarrowRelease(&result->yarrowContext); free(result->hostname); free(result); LogError("tlsSetConnectionEnd failed"); result = NULL; } /* Codes_SRS_TLSIO_CYCLONESSL_01_016: [ The pseudo random number generator to be used shall be set by calling tlsSetPrng with the yarrow instance as argument. ]*/ else if (tlsSetPrng(result->tlsContext, YARROW_PRNG_ALGO, &result->yarrowContext) != NO_ERROR) { /* Codes_SRS_TLSIO_CYCLONESSL_01_017: [ If tlsSetPrng fails then tlsio_cyclonessl_create shall return NULL. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_018: [ When tlsio_cyclonessl_create fails, all allocated resources up to that point shall be freed. ]*/ tlsFree(result->tlsContext); yarrowRelease(&result->yarrowContext); free(result->hostname); free(result); LogError("tlsSetPrng failed"); result = NULL; } } } } } } return result; } static void tlsio_cyclonessl_destroy(CONCRETE_IO_HANDLE tls_io) { /* Codes_SRS_TLSIO_CYCLONESSL_01_020: [ If tls_io is NULL, tlsio_cyclonessl_destroy shall do nothing. ]*/ if (tls_io == NULL) { LogError("NULL tls_io."); } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_019: [ tlsio_cyclonessl_destroy shall free the tlsio CycloneSSL instance. ]*/ TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; /* Codes_SRS_TLSIO_CYCLONESSL_01_081: [ tlsio_cyclonessl_destroy should close the IO if it was open before freeing all the resources. ]*/ tlsio_cyclonessl_close(tls_io, NULL, NULL); /* Codes_SRS_TLSIO_CYCLONESSL_01_022: [ The TLS context shall be freed by calling tlsFree. ]*/ tlsFree(tls_io_instance->tlsContext); /* Codes_SRS_TLSIO_CYCLONESSL_01_021: [ tlsio_cyclonessl_destroy shall deinitialize the yarrow context by calling yarrowRelease. ]*/ yarrowRelease(&tls_io_instance->yarrowContext); /* Codes_SRS_TLSIO_CYCLONESSL_01_077: [ All options cached via tlsio_cyclonessl_set_option shall also be freed. ]*/ if (tls_io_instance->certificate != NULL) { free(tls_io_instance->certificate); } free(tls_io_instance->hostname); free(tls_io); } } static int tlsio_cyclonessl_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context) { int result; /* Codes_SRS_TLSIO_CYCLONESSL_01_024: [ If any of the arguments tls_io, on_io_open_complete, on_bytes_received or on_io_error are NULL then tlsio_cyclonessl_open shall return a non-zero value. ]*/ if ((tls_io == NULL) || (on_io_open_complete == NULL) || (on_bytes_received == NULL) || (on_io_error == NULL)) { result = MU_FAILURE; LogError("NULL tls_io."); } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; /* Codes_SRS_TLSIO_CYCLONESSL_01_034: [ If tlsio_cyclonessl_open is called while the IO is open, tlsio_cyclonessl_open shall fail and return a non-zero value without performing any work to open the IO. ]*/ if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) { result = MU_FAILURE; LogError("Invalid tlsio_state. Expected state is TLSIO_STATE_NOT_OPEN."); } else { tls_io_instance->on_bytes_received = on_bytes_received; tls_io_instance->on_bytes_received_context = on_bytes_received_context; tls_io_instance->on_io_error = on_io_error; tls_io_instance->on_io_error_context = on_io_error_context; /* Codes_SRS_TLSIO_CYCLONESSL_01_025: [ tlsio_cyclonessl_open shall create a socket by calling tlsio_cyclonessl_socket_create, while passing to it the hostname and port that were saved in the tlsio_cyclonessl_create. ]*/ if (tlsio_cyclonessl_socket_create(tls_io_instance->hostname, tls_io_instance->port, &tls_io_instance->socket) != 0) { /* Codes_SRS_TLSIO_CYCLONESSL_01_026: [ If tlsio_cyclonessl_socket_create fails, then tlsio_cyclonessl_open shall return a non-zero value. ]*/ LogError("Error: Cannot open socket"); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_027: [ The socket created by tlsio_cyclonessl_socket_create shall be assigned to the TLS context by calling tlsSetSocket. ]*/ if (tlsSetSocket(tls_io_instance->tlsContext, tls_io_instance->socket)) { /* Codes_SRS_TLSIO_CYCLONESSL_01_028: [ If tlsSetSocket fails then tlsio_cyclonessl_open shall return a non-zero value. ]*/ tlsio_cyclonessl_socket_destroy(tls_io_instance->socket); tls_io_instance->socket = (TlsSocket)NULL; LogError("Error: tlsSetSocket"); result = MU_FAILURE; } else { unsigned char is_error = 0; if (tls_io_instance->certificate != NULL) { /* Codes_SRS_TLSIO_CYCLONESSL_01_078: [ If certificates have been set by using tlsio_cyclonessl_set_option then a call to tlsSetTrustedCaList shall be made to pass the certificates to CycloneSSL. ]*/ if (tlsSetTrustedCaList(tls_io_instance->tlsContext, tls_io_instance->certificate, strlen(tls_io_instance->certificate))) { is_error = 1; } } if (is_error) { /* Codes_SRS_TLSIO_CYCLONESSL_01_079: [ If tlsSetTrustedCaList fails then tlsio_cyclonessl_open shall return a non-zero value. ]*/ tlsio_cyclonessl_socket_destroy(tls_io_instance->socket); tls_io_instance->socket = (TlsSocket)NULL; LogError("tlsSetTrustedCaList failed"); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_031: [ tlsio_cyclonessl_open shall start the TLS handshake by calling tlsConnect. ]*/ if (tlsConnect(tls_io_instance->tlsContext)) { /* Codes_SRS_TLSIO_CYCLONESSL_01_032: [ If tlsConnect fails then tlsio_cyclonessl_open shall return a non-zero value. ]*/ tlsio_cyclonessl_socket_destroy(tls_io_instance->socket); tls_io_instance->socket = (TlsSocket)NULL; LogError("tlsConnect failed"); result = MU_FAILURE; } else { tls_io_instance->tlsio_state = TLSIO_STATE_OPEN; /* Codes_SRS_TLSIO_CYCLONESSL_01_033: [ If tlsConnect succeeds, the callback on_io_open_complete shall be called, while passing on_io_open_complete_context and IO_OPEN_OK as arguments. ]*/ on_io_open_complete(on_io_open_complete_context, IO_OPEN_OK); /* Codes_SRS_TLSIO_CYCLONESSL_01_023: [ tlsio_cyclonessl_open shall open the TLS io and on success it shall return 0. ]*/ result = 0; } } } } } } return result; } static int tlsio_cyclonessl_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* on_io_close_complete_context) { int result = 0; if (tls_io == NULL) { LogError("NULL tls_io."); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; /* Codes_SRS_TLSIO_CYCLONESSL_01_041: [ If tlsio_cyclonessl_close is called when not open, tlsio_cyclonessl_close shall fail and return a non-zero value. ]*/ if (tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) { result = MU_FAILURE; LogError("Invalid tlsio_state. Expected state is TLSIO_STATE_NOT_OPEN or TLSIO_STATE_CLOSING."); } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_037: [ tlsio_cyclonessl_close shall close the TLS connection by calling tlsShutdown. ]*/ if (tlsShutdown(tls_io_instance->tlsContext)) { /* Codes_SRS_TLSIO_CYCLONESSL_01_038: [ If tlsShutdown fails, tlsio_cyclonessl_close shall fail and return a non-zero value. ]*/ LogError("tlsShutdown failed\r\n"); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_039: [ tlsio_cyclonessl_destroy shall destroy the underlying socket by calling tlsio_cyclonessl_socket_destroy. ]*/ tlsio_cyclonessl_socket_destroy(tls_io_instance->socket); tls_io_instance->socket = (TlsSocket)NULL; tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN; /* Codes_SRS_TLSIO_CYCLONESSL_01_040: [ On success, on_io_close_complete shall be called while passing as argument on_io_close_complete_context. ]*/ if (on_io_close_complete != NULL) { on_io_close_complete(on_io_close_complete_context); } /* Codes_SRS_TLSIO_CYCLONESSL_01_035: [ tlsio_cyclonessl_close shall close the TLS IO and on success it shall return 0. ]*/ result = 0; } } } return result; } static int tlsio_cyclonessl_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* on_send_complete_context) { int result; /* Codes_SRS_TLSIO_CYCLONESSL_01_043: [ If any of the arguments tls_io or buffer is NULL, tlsio_cyclonessl_send shall fail and return a non-zero value. ]*/ if ((tls_io == NULL) || (buffer == NULL) || /* Codes_SRS_TLSIO_CYCLONESSL_01_044: [ If size is 0, tlsio_cyclonessl_send shall fail and return a non-zero value. ]*/ (size == 0)) { LogError("NULL tls_io."); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; /* Codes_SRS_TLSIO_CYCLONESSL_01_048: [ If tlsio_cyclonessl_send is called when the IO is not open, tlsio_cyclonessl_send shall fail and return a non-zero value. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_049: [ If the IO is in an error state (an error was reported through the on_io_error callback), tlsio_cyclonessl_send shall fail and return a non-zero value. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_056: [ Also the IO shall be considered in error and any subsequent calls to tlsio_cyclonessl_send shall fail. ]*/ if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN) { LogError("Invalid tlsio_state. Expected state is TLSIO_STATE_OPEN."); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_047: [ tlsio_cyclonessl_send shall send the bytes by calling tlsWrite and passing buffer and size as arguments. 0 shall be passed for the flags argument. ]*/ if (tlsWrite(tls_io_instance->tlsContext, buffer, size, 0) != 0) { LogError("SSL_write error."); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_045: [ on_send_complete shall be allowed to be NULL. ]*/ if (on_send_complete != NULL) { /* Codes_SRS_TLSIO_CYCLONESSL_01_046: [ On success, if a non-NULL value was passed for on_send_complete, then on_send_complete shall be called while passing to it the on_send_complete_context value. ]*/ on_send_complete(on_send_complete_context, IO_SEND_OK); } /* Codes_SRS_TLSIO_CYCLONESSL_01_042: [ tlsio_cyclonessl_send shall send the size bytes pointed to by buffer and on success it shall return 0. ]*/ result = 0; } } } return result; } static void tlsio_cyclonessl_dowork(CONCRETE_IO_HANDLE tls_io) { /* Codes_SRS_TLSIO_CYCLONESSL_01_051: [ If the tls_io argument is NULL, tlsio_cyclonessl_dowork shall do nothing. ]*/ if (tls_io == NULL) { LogError("NULL tls_io."); } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; /* Codes_SRS_TLSIO_CYCLONESSL_01_052: [ If the IO is not open (no open has been called or the IO has been closed) then tlsio_cyclonessl_dowork shall do nothing. ]*/ if ((tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN) && (tls_io_instance->tlsio_state != TLSIO_STATE_ERROR)) { unsigned char buffer[64]; size_t received; /* Codes_SRS_TLSIO_CYCLONESSL_01_050: [ tlsio_cyclonessl_dowork shall check if any bytes are available to be read from the CycloneSSL library and indicate those bytes as received. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_053: [ If the IO is open, tlsio_cyclonessl_dowork shall attempt to read 64 bytes from the TLS library by calling tlsRead. ]*/ /* Codes_SRS_TLSIO_CYCLONESSL_01_054: [ The flags argument for tlsRead shall be 0. ]*/ if (tlsRead(tls_io_instance->tlsContext, buffer, sizeof(buffer), &received, 0) != 0) { /* Codes_SRS_TLSIO_CYCLONESSL_01_055: [ If tlsRead fails, the error shall be indicated by calling the on_io_error callback passed in tlsio_cyclonessl_open, while passing the on_io_error_context to the callback. ]*/ LogError("Error received bytes"); /* Codes_SRS_TLSIO_CYCLONESSL_01_055: [ If tlsRead fails, the error shall be indicated by calling the on_io_error callback passed in tlsio_cyclonessl_open, while passing the on_io_error_context to the callback. ]*/ tls_io_instance->tlsio_state = TLSIO_STATE_ERROR; tls_io_instance->on_io_error(tls_io_instance->on_io_error_context); } else { if (received > 0) { /* Codes_SRS_TLSIO_CYCLONESSL_01_080: [ If any bytes are read from CycloneSSL they should be indicated via the on_bytes_received callback passed to tlsio_cyclonessl_open. ]*/ tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, buffer, received); } } } } } static int tlsio_cyclonessl_setoption(CONCRETE_IO_HANDLE tls_io, const char* optionName, const void* value) { int result; /* Tests_SRS_TLSIO_CYCLONESSL_01_057: [ If any of the arguments tls_io or option_name is NULL tlsio_cyclonessl_setoption shall return a non-zero value. ]*/ if ((tls_io == NULL) || (optionName == NULL)) { LogError("NULL tls_io"); result = MU_FAILURE; } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io; /* Codes_SRS_TLSIO_CYCLONESSL_01_060: [ - "TrustedCerts" - a char\* that shall be saved by tlsio_cyclonessl as it shall be given to the underlying CycloneSSL TLS context when the IO is open. ]*/ if (strcmp("TrustedCerts", optionName) == 0) { const char* cert = (const char*)value; /* Codes_SRS_TLSIO_CYCLONESSL_01_062: [ If a previous TrustedCerts option was saved, then the previous value shall be freed. ]*/ if (tls_io_instance->certificate != NULL) { // Free the memory if it has been previously allocated free(tls_io_instance->certificate); tls_io_instance->certificate = NULL; } /* Codes_SRS_TLSIO_CYCLONESSL_01_063: [ A NULL value shall be allowed for TrustedCerts, in which case the previously stored TrustedCerts option value shall be cleared. ]*/ if (cert == NULL) { result = 0; } else { // Store the certificate if (mallocAndStrcpy_s(&tls_io_instance->certificate, cert) != 0) { /* Codes_SRS_TLSIO_CYCLONESSL_01_061: [ If copying the char\* passed in value fails then tlsio_cyclonessl_setoption shall return a non-zero value. ]*/ LogError("Error allocating memory for certificates"); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_059: [ If the option was handled by tlsio_cyclonessl, then tlsio_cyclonessl_setoption shall return 0. ]*/ result = 0; } } } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_058: [ If the option_name argument indicates an option that is not handled by tlsio_cyclonessl, then tlsio_cyclonessl_setoption shall return a non-zero value. ]*/ LogError("Unrecognized option"); result = MU_FAILURE; } } return result; } static OPTIONHANDLER_HANDLE tlsio_cyclonessl_retrieve_options(CONCRETE_IO_HANDLE handle) { OPTIONHANDLER_HANDLE result; /* Codes_SRS_TLSIO_CYCLONESSL_01_064: [ If parameter handle is NULL then tlsio_cyclonessl_retrieve_options shall fail and return NULL. ]*/ if (handle == NULL) { LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle=%p", handle); result = NULL; } else { /* Codes_SRS_TLSIO_CYCLONESSL_01_065: [ tlsio_cyclonessl_retrieve_options shall produce an OPTIONHANDLER_HANDLE. ]*/ result = OptionHandler_Create(tlsio_cyclonessl_clone_option, tlsio_cyclonessl_destroy_option, tlsio_cyclonessl_setoption); if (result == NULL) { /* Codes_SRS_TLSIO_CYCLONESSL_01_068: [ If producing the OPTIONHANDLER_HANDLE fails then tlsio_cyclonessl_retrieve_options shall fail and return NULL. ]*/ LogError("unable to OptionHandler_Create"); /*return as is*/ } else { TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)handle; /* Codes_SRS_TLSIO_CYCLONESSL_01_066: [ tlsio_cyclonessl_retrieve_options shall add to it the options: ]*/ if ( (tls_io_instance->certificate != NULL) && /* Codes_SRS_TLSIO_CYCLONESSL_01_067: [ - TrustedCerts ]*/ (OptionHandler_AddOption(result, "TrustedCerts", tls_io_instance->certificate) != OPTIONHANDLER_OK) ) { LogError("unable to save TrustedCerts option"); OptionHandler_Destroy(result); result = NULL; } else { /*all is fine, all interesting options have been saved*/ /*return as is*/ } } } return result; } static const IO_INTERFACE_DESCRIPTION tlsio_cyclonessl_interface_description = { tlsio_cyclonessl_retrieve_options, tlsio_cyclonessl_create, tlsio_cyclonessl_destroy, tlsio_cyclonessl_open, tlsio_cyclonessl_close, tlsio_cyclonessl_send, tlsio_cyclonessl_dowork, tlsio_cyclonessl_setoption }; /* Codes_SRS_TLSIO_CYCLONESSL_01_069: [ tlsio_cyclonessl_get_interface_description shall return a pointer to an IO_INTERFACE_DESCRIPTION structure that contains pointers to the functions: tlsio_cyclonessl_retrieve_options, tlsio_cyclonessl_create, tlsio_cyclonessl_destroy, tlsio_cyclonessl_open, tlsio_cyclonessl_close, tlsio_cyclonessl_send and tlsio_cyclonessl_dowork. ]*/ const IO_INTERFACE_DESCRIPTION* tlsio_cyclonessl_get_interface_description(void) { return &tlsio_cyclonessl_interface_description; } tlsio_cyclonessl_socket.c000066400000000000000000000073031455573770000402010ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/cyclonessl// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #error CycloneSSL is NOT supported for the Azure C shared utilities. #error The code here is provided for reference purposes. #error #error A security audit is required if you attempt to bring this code back. #include #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "tls.h" #include "azure_c_shared_utility/tlsio_cyclonessl_socket.h" /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_001: [ tlsio_cyclonessl_socket_create shall create a new socket to be used by CycloneSSL. ]*/ int tlsio_cyclonessl_socket_create(const char* hostname, unsigned int port, TlsSocket* new_socket) { int result; /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_003: [ If hostname or socket is NULL, then tlsio_cyclonessl_socket_create shall fail and it shall return a non-zero value. ]*/ if ((hostname == NULL) || (new_socket == NULL)) { LogError("Invalid arguments: hostname = %p, new_socket = %p", hostname, new_socket); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_004: [ tlsio_cyclonessl_socket_create shall call socketOpen to create a TCP socket. ]*/ Socket* socket = socketOpen(SOCKET_TYPE_STREAM, SOCKET_IP_PROTO_TCP); if (socket == NULL) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_007: [ If any of the socket calls fails, then tlsio_cyclonessl_socket_create shall fail and return a non-zero value. ]*/ LogError("socketOpen failed, cannot create socket"); result = MU_FAILURE; } else { IpAddr ipAddr; /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_005: [ tlsio_cyclonessl_socket_create shall call getHostByName to obtain an IpAddr structure filled with the address of the hostname. ]*/ if (getHostByName(NULL, hostname, &ipAddr, 0) != 0) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_007: [ If any of the socket calls fails, then tlsio_cyclonessl_socket_create shall fail and return a non-zero value. ]*/ socketClose(socket); LogError("Cannot resolve host"); result = MU_FAILURE; } /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_006: [ tlsio_cyclonessl_socket_create shall call socketConnect and pass the obtained address in order to connect the socket. ]*/ else if (socketConnect(socket, &ipAddr, port) != 0) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_007: [ If any of the socket calls fails, then tlsio_cyclonessl_socket_create shall fail and return a non-zero value. ]*/ socketClose(socket); LogError("Failed to connect"); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_002: [ On success tlsio_cyclonessl_socket_create shall return 0 and fill in the socket handle in the new_socket out argument. ]*/ *new_socket = (TlsSocket)socket; result = 0; } } } return result; } void tlsio_cyclonessl_socket_destroy(TlsSocket socket) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_009: [ If socket is NULL, tlsio_cyclonessl_socket_destroy shall do nothing. ]*/ if (socket == NULL) { LogError("tlsio_cyclonessl_socket_destroy: NULL socket"); } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_01_008: [ tlsio_cyclonessl_socket_destroy shall close the socket passed as argument by calling the function socketClose. ]*/ socketClose(socket); } } tlsio_cyclonessl_socket_bsd.c000066400000000000000000000104051455573770000410260ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/archive/cyclonessl// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #error CycloneSSL is NOT supported for the Azure C shared utilities. #error The code here is provided for reference purposes. #error #error A security audit is required if you attempt to bring this code back. #include #if _WIN32 #define _WINERROR_ #include #include #endif #include #include "tls.h" #include "azure_c_shared_utility/optimize_size.h" #include "azure_c_shared_utility/xlogging.h" #include "azure_c_shared_utility/tlsio_cyclonessl_socket.h" /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_001: [ tlsio_cyclonessl_socket_create shall create a new socket to be used by CycloneSSL. ]*/ int tlsio_cyclonessl_socket_create(const char* hostname, unsigned int port, TlsSocket* new_socket) { int result; /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_002: [ If hostname or new_socket is NULL, then tlsio_cyclonessl_socket_create shall fail and it shall return a non-zero value. ]*/ if ((hostname == NULL) || (new_socket == NULL)) { LogError("Invalid arguments: hostname = %p, new_socket = %p", hostname, new_socket); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_003: [ tlsio_cyclonessl_socket_create shall call socket to create a TCP socket. ]*/ SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sock == (SOCKET)-1) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_007: [ If any of the socket calls fails, then tlsio_cyclonessl_socket_create shall fail and return a non-zero value. ]*/ LogError("Error: Cannot create socket (%d)\r\n", WSAGetLastError()); result = MU_FAILURE; } else { char portString[16]; ADDRINFO addrHint = { 0 }; ADDRINFO* addrInfo = NULL; addrHint.ai_family = AF_INET; addrHint.ai_socktype = SOCK_STREAM; addrHint.ai_protocol = 0; /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_004: [ tlsio_cyclonessl_socket_create shall call getaddrinfo to obtain a hint ADDRINFO. ]*/ if ((sprintf(portString, "%u", port) < 0) || (getaddrinfo(hostname, portString, &addrHint, &addrInfo) != 0)) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_007: [ If any of the socket calls fails, then tlsio_cyclonessl_socket_create shall fail and return a non-zero value. ]*/ LogError("Failure: getaddrinfo failure %d.", WSAGetLastError()); (void)closesocket(sock); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_006: [ tlsio_cyclonessl_socket_create shall call connect and pass the constructed address in order to connect the socket. ]*/ if (connect(sock, addrInfo->ai_addr, (int)addrInfo->ai_addrlen) < 0) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_007: [ If any of the socket calls fails, then tlsio_cyclonessl_socket_create shall fail and return a non-zero value. ]*/ LogError("Error: Failed to connect (%d)\r\n", WSAGetLastError()); closesocket(sock); result = MU_FAILURE; } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_008: [ On success tlsio_cyclonessl_socket_create shall return 0 and fill in the socket handle in the new_socket out argument. ]*/ *new_socket = (TlsSocket)sock; result = 0; } } } } return result; } void tlsio_cyclonessl_socket_destroy(TlsSocket socket) { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_010: [ If socket is INVALID_SOCKET (-1), tlsio_cyclonessl_socket_destroy shall do nothing. ]*/ if (socket == (SOCKET)-1) { LogError("Invalid socket\r\n"); } else { /* Codes_SRS_TLSIO_CYCLONESSL_SOCKET_BSD_01_009: [ tlsio_cyclonessl_socket_destroy shall close the socket passed as argument by calling the function close. ]*/ (void)closesocket((SOCKET)socket); } } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build/000077500000000000000000000000001455573770000304515ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build/.vsts-ci.yml000066400000000000000000000441431455573770000326500ustar00rootroot00000000000000name: $(BuildID)_$(BuildDefinitionName)_$(SourceBranchName)_$(Date:yyyyMMdd)$(Rev:.r) resources: - repo: self clean: true jobs: - job: checksubmodule pool: vmImage: 'ubuntu-20.04' steps: - script: | sudo apt-get update && apt-get install -y \ curl \ git \ python-software-properties \ build-essential \ pkg-config sudo curl -sL https://deb.nodesource.com/setup_6.x | bash - sudo apt-get install -y nodejs displayName: 'setup' - script: | npm install check_submodules ./../../node_modules/.bin/check_submodules . master displayName: 'build' - job: windowsx86 pool: vmImage: 'vs2017-win2016' steps: - script: | if exist jenkins\windows_c.cmd ( call "%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsDevCmd.bat" call jenkins\windows_c.cmd) displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: cd .. && rd /Q /S $(Agent.BuildDirectory)\s displayName: 'cleanup' condition: always() - job: raspberrypi variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/raspberrypi-c-buster:brown" pool: name: 'sdk-c--ubuntu-18' displayName: raspberrypi steps: - script: | chmod +x jenkins/raspberrypi_c_buster.sh ./jenkins/raspberrypi_c_buster.sh displayName: 'build' - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' - job: linuxoptions variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/vsts-linux-c-ubuntu" pool: name: 'sdk-c--ubuntu-18' displayName: 'linux-options' steps: - script: | if [ -f "jenkins/linux_c_option_test.sh" ] then sudo ./jenkins/linux_c_option_test.sh fi displayName: 'build' condition: always() - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: windowsdynamic pool: vmImage: 'vs2017-win2016' steps: - script: | if exist jenkins\windows_c_build_as_dynamic.cmd ( call "%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsDevCmd.bat" call jenkins\windows_c_build_as_dynamic.cmd) displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: cd .. && rd /Q /S $(Agent.BuildDirectory)\s displayName: 'cleanup' condition: always() - job: OSX pool: name: OSX steps: - script: | if [ -f "jenkins/osx_gcc_openssl.sh" ] then ./jenkins/osx_gcc_openssl.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: clang variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/ubuntu-clang" pool: name: 'sdk-c--ubuntu-18' displayName: 'clang' steps: - script: | if [ -f "jenkins/ubuntu_clang.sh" ] then export OPENSSL_ia32cap=0x00000000 sudo chmod -R 755 . sudo -E ./jenkins/ubuntu_clang.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: ubuntu1604 variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/linux-c-ubuntu" pool: name: 'sdk-c--ubuntu-18' displayName: 'ubuntu1604' steps: - script: | if [ -f "jenkins/ubuntu1604_c.sh" ] then export OPENSSL_ia32cap=0x00000000 sudo chmod -R 755 . sudo -E ./jenkins/ubuntu1604_c.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: debian variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/c-debian" pool: name: 'sdk-c--ubuntu-18' displayName: 'debian' steps: - script: | if [ -f "jenkins/debian_c.sh" ] then sudo chmod 755 jenkins/debian_c.sh sudo -E ./debian_c.sh sudo jenkins/debian_c.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: linux_mbed variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/linux-c-mbed" pool: name: 'sdk-c--ubuntu-18' displayName: 'linux_mbed' steps: - script: | if [ -f "jenkins/debian_c.sh" ] then sudo chmod 755 jenkins/linux_mbed.sh sudo -E ./jenkins/linux_mbed.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: wolfssl variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/vsts-c-wolfssl" pool: name: 'sdk-c--ubuntu-18' displayName: 'wolfssl' steps: - script: | cmake --version cc --version gcc --version make --version if [ -f "jenkins/linux_wolfssl.sh" ] then LD_LIBRARY_PATH=/usr/local/lib LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/my_library/ sudo jenkins/linux_wolfssl.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: bearssl variables: _PREVIEW_VSTS_DOCKER_IMAGE: "aziotbld/vsts-c-bearssl" pool: name: 'sdk-c--ubuntu-18' displayName: 'bearssl' steps: - script: | LD_LIBRARY_PATH=/usr/local/lib LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/my_library/ cd $(Build.SourcesDirectory) bearsslDir=/beary export bearsslDir sudo bash jenkins/linux_bearssl.sh displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: sudo rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() - job: windowsx64 pool: vmImage: 'vs2017-win2016' displayName: 'windowsx64' steps: - script: | if exist jenkins\windows_c.cmd ( call "%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsDevCmd.bat" call jenkins\windows_c.cmd --platform x64) displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: cd .. && rd /Q /S $(Agent.BuildDirectory)\s displayName: 'cleanup' condition: always() - job: xcodenative pool: name: OSX steps: - script: | if [ -f "jenkins/osx_xcode_native.sh" ] then DYLD_LIBRARY_PATH=/usr/local/Cellar/curl/7.61.0/lib ./jenkins/osx_xcode_native.sh fi displayName: 'build' env: IOTHUB_CONNECTION_STRING: $(IOTHUB-CONNECTION-STRING) IOTHUB_EVENTHUB_CONNECTION_STRING: $(IOTHUB-EVENTHUB-CONNECTION-STRING) IOTHUB_E2E_X509_CERT_BASE64: $(IOTHUB-E2E-X509-CERT-BASE64) IOTHUB_E2E_X509_PRIVATE_KEY_BASE64: $(IOTHUB-E2E-X509-PRIVATE-KEY-BASE64) IOTHUB_E2E_X509_THUMBPRINT: $(IOTHUB-E2E-X509-THUMBPRINT) IOTHUB_POLICY_KEY: $(IOTHUB-POLICY-KEY) IOTHUB_PARTITION_COUNT: $(IOTHUB-PARTITION-COUNT) STORAGE_ACCOUNT_CONNECTION_STRING: $(STORAGE-ACCOUNT-CONNECTION-STRING) IOT_DPS_CONNECTION_STRING: $(IOT-DPS-CONNECTION-STRING) IOT_DPS_ID_SCOPE: $(IOT-DPS-ID-SCOPE) IOTHUB_CA_ROOT_CERT: $(IOTHUB-CA-ROOT-CERT) IOTHUB_CA_ROOT_CERT_KEY: $(IOTHUB-CA-ROOT-CERT-KEY) IOT_DPS_GLOBAL_ENDPOINT: $(IOT-DPS-GLOBAL-ENDPOINT) IOTHUB_DEVICE_CONN_STRING_INVALIDCERT: $(IOTHUB-DEVICE-CONN-STRING-INVALIDCERT) IOTHUB_CONN_STRING_INVALIDCERT: $(IOTHUB-CONN-STRING-INVALIDCERT) DPS_GLOBALDEVICEENDPOINT_INVALIDCERT: $(DPS-GLOBALDEVICEENDPOINT-INVALIDCERT) PROVISIONING_CONNECTION_STRING_INVALIDCERT: $(PROVISIONING-CONNECTION-STRING-INVALIDCERT) - script: rm -rf $(Agent.BuildDirectory)/* displayName: 'cleanup' condition: always() azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/000077500000000000000000000000001455573770000313015ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/linux/000077500000000000000000000000001455573770000324405ustar00rootroot00000000000000build.sh000077500000000000000000000036331455573770000340240ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/linux#!/bin/bash #set -o pipefail # set -e script_dir=$(cd "$(dirname "$0")" && pwd) build_root=$(cd "${script_dir}/../.." && pwd) run_unit_tests=ON make_install= run_valgrind=0 run_unittests=OFF usage () { echo "build.sh [options]" echo "options" echo " -cl, --compileoption specify a compile option to be passed to gcc" echo " Example: -cl -O1 -cl ..." echo "-rv, --run_valgrind will execute ctest with valgrind" echo "--run-unittests run the unit tests" exit 1 } process_args () { save_next_arg=0 extracloptions=" " for arg in $* do if [ $save_next_arg == 1 ] then # save arg to pass to gcc extracloptions="$arg $extracloptions" save_next_arg=0 elif [ $save_next_arg == 2 ] then build_root="$arg" save_next_arg=0 else case "$arg" in "-cl" | "--compileoption" ) save_next_arg=1;; "-i" | "--install" ) make_install=1;; "-rv" | "--run_valgrind" ) run_valgrind=1;; "--run-unittests" ) run_unittests=ON;; "--build-root" ) save_next_arg=2;; * ) usage;; esac fi done } process_args $* log_dir=$build_root build_folder=$build_root"/cmake/shared-util_linux" # Set the default cores CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu) rm -r -f $build_folder mkdir -p $build_folder pushd $build_folder cmake -DcompileOption_C:STRING="$extracloptions" -Drun_valgrind:BOOL=$run_valgrind $build_root -Drun_unittests:BOOL=$run_unittests make --jobs=$CORES if [[ $make_install == 1 ]] ; then echo "Installing packaging" # install the package make install fi if [[ $run_valgrind == 1 ]] ; then #use doctored openssl export LD_LIBRARY_PATH=/usr/local/ssl/lib ctest -j $CORES --output-on-failure export LD_LIBRARY_PATH= else ctest -j $CORES -C "Debug" --output-on-failure fi popd azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed/000077500000000000000000000000001455573770000322105ustar00rootroot00000000000000CMakeLists.txt000066400000000000000000000005771455573770000347020ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. cmake_minimum_required (VERSION 3.5) set(shared_util_base_path ../..) set(mbed_project_base "azure_c_shared_utility" CACHE STRING "The item being built") include (${shared_util_base_path}/tools/mbed_build_scripts/mbedbldtemplate.txt) azure_c_shared_utility_filelist.txt000066400000000000000000000155161455573770000413360ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbedset(mbed_exported_project_files ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/agenttime.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/azure_base64.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/buffer_.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/connection_string_parser.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/condition.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/constbuffer.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/consolelogger.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/const_defines.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/constmap.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/crt_abstractions.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/doublylinkedlist.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/gb_stdio.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/gb_time.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/gballoc.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/hmac.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/hmacsha256.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/httpapi.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/httpapiex.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/httpapiexsas.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/httpheaders.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/singlylinkedlist.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/lock.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/macro_utils.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/map.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/optimize_size.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/platform.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/refcount.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/sastoken.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/sha.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/sha-private.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/shared_util_options.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/socketio.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/string_tokenizer.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/strings.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/strings_types.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/string_tokenizer_types.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/threadapi.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/tickcounter.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/tlsio.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/tlsio_wolfssl.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/uniqueid.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/uuid.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/urlencode.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/vector.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/xio.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/xlogging.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/umock_c_prod.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/optionhandler.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/tcpsocketconnection_c.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/vector_types.h ${CMAKE_CURRENT_SOURCE_DIR}/../../inc/azure_c_shared_utility/vector_types_internal.h ${CMAKE_CURRENT_SOURCE_DIR}/../../pal/linux/refcount_os.h ) set(mbed_project_files ${CMAKE_CURRENT_SOURCE_DIR}/../../src/azure_base64.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/buffer.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/constbuffer.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/connection_string_parser.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/constmap.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/crt_abstractions.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/consolelogger.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/doublylinkedlist.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/gb_stdio.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/gb_time.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/gballoc.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/hmac.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/hmacsha256.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/httpapiex.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/httpapiexsas.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/httpheaders.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/singlylinkedlist.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/map.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sastoken.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sha1.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sha224.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sha384-512.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/string_tokenizer.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/strings.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/tickcounter.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/urlencode.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/usha.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/vector.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/xio.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/optionhandler.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/xlogging.c ${CMAKE_CURRENT_SOURCE_DIR}/../../src/uuid.c ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/agenttime_mbed.c ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/condition_rtx_mbed.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/httpapi_compact.c ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/lock_rtx_mbed.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/platform_mbed.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/socketio_mbed.c ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/tcpsocketconnection_c.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/threadapi_rtx_mbed.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/tickcounter_mbed.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/tlsio_wolfssl.c ${CMAKE_CURRENT_SOURCE_DIR}/../../adapters/uniqueid_stub.c ) build.cmd000066400000000000000000000025361455573770000337230ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed @setlocal EnableExtensions EnableDelayedExpansion @echo off set current-path=%~dp0 rem // remove trailing slash set current-path=%current-path:~0,-1% set repo-build-root=%current-path%\..\.. rem // resolve to fully qualified path for %%i in ("%repo-build-root%") do set repo-build-root=%%~fi rem ----------------------------------------------------------------------------- rem -- build (clean) compilembed tool rem ----------------------------------------------------------------------------- call "%repo-build-root%\tools\compilembed\build.cmd" --clean if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- build iothub client samples rem ----------------------------------------------------------------------------- call %repo-build-root%\tools\mbed_build_scripts\release_mbed_project.cmd %repo-build-root%\build_all if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! goto :eof :compile setlocal EnableExtensions set "project_name=%~1" set "project_path=%~2" set "download_bin_path=%~3" set "cmake_project_bin_path=%project_name%_cmake_build" mkdir %cmake_project_bin_path% cd %cmake_project_bin_path% cmake -Dmbed_repo_name:string=%project_name% -Dmbed_output_bin_path:string=%download_bin_path% %project_path% set CMAKE_ERROR_CODE=!ERRORLEVEL! cd .. exit /b %CMAKE_ERROR_CODE% goto:eof azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed3/000077500000000000000000000000001455573770000322735ustar00rootroot00000000000000.yotta.json000066400000000000000000000001261455573770000343240ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed3{ "build": { "target": "frdm-k64f-gcc,*", "targetSetExplicitly": true } } build.cmd000066400000000000000000000011521455573770000337770ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed3@REM Copyright (c) Microsoft. All rights reserved. @REM Licensed under the MIT license. See LICENSE file in the project root for full license information. setlocal @REM Script arguments: @REM %1 File list for the project that is being built set project_path=..\.. set filelist=shared-util_filelist.txt if exist source rd /s /q source mkdir source echo Copying files ... for /f "tokens=*" %%i in (%filelist%) DO ( xcopy /y "%project_path%\%%i" "source" if !ERRORLEVEL! neq 0 goto :eof ) echo . yotta target frdm-k64f-gcc if !ERRORLEVEL! neq 0 goto :eof yotta build if !ERRORLEVEL! neq 0 goto :eof module.json000066400000000000000000000005741455573770000344020ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed3{ "name": "azure-c-shared-utility", "version": "0.0.2", "description": "Azure C shared utility library", "repository": { "url": "git@github.com:Azure/azure-c-shared-utility.git", "type": "git" }, "keywords": [], "author": "Microsoft", "license": "MIT", "dependencies": {}, "targetDependencies": { "arm": { "mbedtls": "^2.0.0" } } } shared-util_filelist.txt000066400000000000000000000021571455573770000370760ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/mbed3inc\agenttime.h inc\azure_base64.h inc\buffer_.h inc\condition.h inc\constbuffer.h inc\constmap.h inc\consolelogger.h inc\crt_abstractions.h inc\doublylinkedlist.h inc\gb_stdio.h inc\gb_time.h inc\gballoc.h inc\hmac.h inc\hmacsha256.h inc\httpapi.h inc\httpapiex.h inc\httpapiexsas.h inc\httpheaders.h inc\list.h inc\lock.h inc\macro_utils.h inc\map.h inc\mqttapi.h inc\platform.h inc\refcount.h inc\sastoken.h inc\sha.h inc\sha-private.h inc\shared_util_options.h inc\socketio.h inc\string_tokenizer.h inc\strings.h inc\threadapi.h inc\tickcounter.h inc\tlsio.h inc\tlsio_wolfssl.h inc\urlencode.h inc\vector.h inc\xio.h inc\xlogging.h inc\vector_types.h inc\vector_types_internal.h src\azure_base64.c src\buffer.c src\constbuffer.c src\consolelogger.c src\constmap.c src\crt_abstractions.c src\doublylinkedlist.c src\gb_stdio.c src\gb_time.c src\gballoc.c src\hmac.c src\hmacsha256.c src\httpapiex.c src\httpapiexsas.c src\httpheaders.c src\list.c src\map.c src\sastoken.c src\sha1.c src\sha224.c src\sha384-512.c src\string_tokenizer.c src\strings.c src\tickcounter.c src\urlencode.c src\usha.c src\vector.c src\xio.c src\xlogging.cazure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/000077500000000000000000000000001455573770000332255ustar00rootroot00000000000000linux/000077500000000000000000000000001455573770000343055ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packagingdebian/000077500000000000000000000000001455573770000355275ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linuxazure-c-shared-util-dev.dirs000066400000000000000000000000541455573770000427520ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianusr/lib/ usr/include/ usr/include/azureiot/ azure-c-shared-util-dev.install000066400000000000000000000000311455573770000434520ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianinc usr/include/azureiot azure-c-shared-util-lib.dirs000066400000000000000000000000151455573770000427370ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianusr/ usr/lib azure-c-shared-util-lib.install000066400000000000000000000000271455573770000434470ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debian/obj-*/lib*.a /usr/lib changelog-trusty000066400000000000000000000003361455573770000407530ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianazure-c-shared-util (0.2.0-1trusty) trusty; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Tue, 27 Sep 2016 17:00:00 +0000 changelog-vivid000066400000000000000000000003351455573770000405210ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianazure-c-shared-util (0.1.0-60vivid) vivid; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Thu, 29 Sep 2016 11:00:00 +0000 changelog-wily000066400000000000000000000003301455573770000403570ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianazure-c-shared-util (undefined) wily; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Thu, 29 Sep 2016 11:00:00 +0000 changelog-xenial000066400000000000000000000003401455573770000406540ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianazure-c-shared-util (0.2.0.0-1xenial) xenial; urgency=low * See https://github.com/Azure/azure-iot-sdk-c/releases for details of the release -- AzureIoT User Thu, 29 Sep 2016 11:00:00 +0000 compat000066400000000000000000000000021455573770000367250ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debian9 control000066400000000000000000000021541455573770000371340ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianSource: azure-c-shared-util Priority: optional Maintainer: Azure User Build-Depends: debhelper (>= 9), cmake (>= 2.8), uuid-dev, libssl-dev, libcurl4-openssl-dev, curl Standards-Version: 3.9.6 Section: libs Homepage: https://github.com/Azure/azure-c-shared-utility.git #Vcs-Git: git://anonscm.debian.org/collab-maint/azure-c-shared-util.git #Vcs-Browser: http://anonscm.debian.org/?p=collab-maint/azure-c-shared-util.git;a=summary Package: azure-c-shared-util-dev Section: libdevel Architecture: any Depends: azure-c-shared-util-lib (= ${binary:Version}), ${misc:Depends}, uuid-dev, libssl-dev, libcurl4-openssl-dev, curl Description: AzureIoT Shared Utility Development Library Package The Microsoft Azure shared utility development library used to develop applications for developers and IT Staff Package: azure-c-shared-util-lib Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, uuid-dev, libssl-dev, libcurl4-openssl-dev, curl Description: AzureIoT Shared Utility Library Package The Microsoft Azure shared utility library used to develop applications for developers and IT Staff copyright000066400000000000000000000025601455573770000374650ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianFormat: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: azure-c-shared-util Source: https://github.com/Azure/azure-c-shared-utility Files: * Copyright: 2015 AzureIoT User License: MIT Files: debian/* Copyright: 2015 AzureIoT User License: MIT License: MIT Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: . The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. . THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. docs000066400000000000000000000000001455573770000363700ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianrules000066400000000000000000000013371455573770000366100ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debian#!/usr/bin/make -f # See debhelper(7) (uncomment to enable) # output every command that modifies files on the build system. DH_VERBOSE = 1 # see EXAMPLES in dpkg-buildflags(1) and read /usr/share/dpkg/* DPKG_EXPORT_BUILDFLAGS = 1 include /usr/share/dpkg/default.mk # see FEATURE AREAS in dpkg-buildflags(1) #export DEB_BUILD_MAINT_OPTIONS = hardening=+all # see ENVIRONMENT in dpkg-buildflags(1) # package maintainers to append CFLAGS #export DEB_CFLAGS_MAINT_APPEND = -Wall -pedantic # package maintainers to append LDFLAGS #export DEB_LDFLAGS_MAINT_APPEND = -Wl,--as-needed # main packaging script based on dh7 syntax %: dh $@ --buildsystem=cmake --DSYSINSTALL_BINDINGS=ON override_dh_auto_configure: dh_auto_configure -- source/000077500000000000000000000000001455573770000370275ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debianformat000066400000000000000000000000151455573770000402360ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/linux/debian/source3.0 (native) windows/000077500000000000000000000000001455573770000346405ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packagingMicrosoft.Azure.C.SharedUtility.nuspec000066400000000000000000000045141455573770000440670ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/windows Microsoft.Azure.C.SharedUtility 1.1.4 Microsoft Azure C Shared Utility Microsoft Corp Azure-IoT https://github.com/Azure/azure-c-shared-utility/blob/master/LICENSE https://github.com/Azure/azure-c-shared-utility true Microsoft Azure C Shared Utility http://go.microsoft.com/fwlink/?LinkID=288890 This nuget package can be used to develop applications and libraries Copyright 2016 Microsoft Azure C Native x86 ARM x64 native package Microsoft.Azure.C.SharedUtility.targets000066400000000000000000000236641455573770000442520ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/windows static cdecl $(MSBuildThisFileDirectory)../../build/native/include/;%(AdditionalIncludeDirectories) $(MSBuildThisFileDirectory)../../build/native/include/;%(AdditionalIncludeDirectories) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/Win32/Debug/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/Win32/Release/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/x64/Debug/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/x64/Release/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/arm/Debug/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/arm/Release/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/arm64/Debug/aziotsharedutil.lib;%(AdditionalDependencies) Secur32.lib;ncrypt.lib;Ws2_32.lib;$(MSBuildThisFileDirectory)../../build/native/arm64/Release/aziotsharedutil.lib;%(AdditionalDependencies) Result = ((Text ?? "").Split(';').Contains(Library) ) ? Value : String.Empty; Microsoft.Azure.C.SharedUtility_thirdpartynotice.txt000066400000000000000000000011011455573770000470520ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/windowsThird Party Notices for Azure Shared Utility project This project incorporates material from the project(s) listed below (collectively, "Third Party Code"). Microsoft Corporation is not the original author of the Third Party Code. The original copyright notice and license, under which Microsoft Corporation received such Third Party Code, are set out below. This Third Party Code is licensed to you under their original license terms set forth below. Microsoft Corporation reserves all other rights not expressly granted, whether by implication, estoppel or otherwise. rebuild_nugets.cmd000066400000000000000000000100461455573770000403410ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/packaging/windows@REM Copyright (c) Microsoft. All rights reserved. @REM Licensed under the MIT license. See LICENSE file in the project root for full license information. @setlocal EnableExtensions EnableDelayedExpansion @echo off rem ----------------------------------------------------------------------------- rem -- setup path information rem ----------------------------------------------------------------------------- set current-path=%~dp0 rem // remove trailing slash set current-path=%current-path:~0,-1% echo Current Path: %current-path% set build-root=%current-path%\..\..\.. rem // resolve to fully qualified path for %%i in ("%build-root%") do set build-root=%%~fi set client-root=%current-path%\..\..\.. for %%i in ("%client-root%") do set client-root=%%~fi where /q nuget.exe if not !errorlevel! == 0 ( @Echo Azure Shared Utility needs to download nuget.exe from https://www.nuget.org/nuget.exe @Echo https://www.nuget.org choice /C yn /M "Do you want to download and run nuget.exe?" if not !errorlevel!==1 goto :eof rem if nuget.exe is not found, then ask user Powershell.exe wget -outf nuget.exe https://nuget.org/nuget.exe if not exist .\nuget.exe ( echo nuget does not exist exit /b 1 ) ) set build-path=%build-root%\cmake echo Build root is %build-root% echo Build path is %build-path% echo Client root is %client-root% if exist %build-path%\shared-util_output ( rmdir /s/q %build-path%\shared-util_output rem no error checking ) echo checking for nupkg if exist %build-root%\build_all\packaging\windows\*.nupkg ( echo deleting nupkg del %build-root%\build_all\packaging\windows\*.nupkg ) rem ----------------------------------------------------------------------------- rem -- build binaries rem ----------------------------------------------------------------------------- mkdir %build-path%\shared-util_output rem no error checking call %build-root%\build_all\windows\build.cmd --make_nuget yes if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- Copy Win32 binaries rem ----------------------------------------------------------------------------- rem -- Copy all Win32 files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\shared-util_Win32\Debug\*.* %build-path%\shared-util_output\win32\debug\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Copy all Win32 Release files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\shared-util_Win32\Release\*.* %build-path%\shared-util_output\win32\Release\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- Copy x64 binaries rem ----------------------------------------------------------------------------- rem -- Copy all x64 files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\shared-util_x64\Debug\*.* %build-path%\shared-util_output\x64\debug\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Copy all x64 Release files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\shared-util_x64\Release\*.* %build-path%\shared-util_output\x64\Release\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem ----------------------------------------------------------------------------- rem -- Copy x64 binaries rem ----------------------------------------------------------------------------- rem -- Copy all x64 files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\shared-util_arm\Debug\*.* %build-path%\shared-util_output\arm\debug\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Copy all x64 Release files from cmake build directory to the repo directory xcopy /q /y /R %build-path%\shared-util_arm\Release\*.* %build-path%\shared-util_output\arm\Release\*.* if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! rem -- Package Nuget nuget pack %build-root%\build_all\packaging\windows\Microsoft.Azure.C.SharedUtility.nuspec -OutputDirectory %build-root%\build_all\packaging\windows rmdir %build-path%\shared-util_output /S /Q echo doneazure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/tirtos/000077500000000000000000000000001455573770000326255ustar00rootroot00000000000000package.bld000066400000000000000000000077431455573770000346370ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/tirtos/* * ======== package.bld ======== */ var Build = xdc.useModule('xdc.bld.BuildEnvironment'); var Pkg = xdc.useModule('xdc.bld.PackageContents'); /* make command to search for the srcs */ Pkg.makePrologue = "vpath %.c ../../src ../../adapters"; /* lib/ is a generated directory that 'xdc clean' should remove */ Pkg.generatedFiles.$add("lib/"); var SRCS = [ "agenttime.c", "azure_base64.c", "buffer.c", "consolelogger.c", "constbuffer.c", "crt_abstractions.c", "doublylinkedlist.c", "gballoc.c", "hmac.c", "hmacsha256.c", "httpapi_tirtos.c", "httpapiex.c", "httpapiexsas.c", "httpheaders.c", "lock_pthreads.c", "map.c", "platform_stub.c", "sastoken.c", "sha1.c", "sha224.c", "sha384-512.c", "strings.c", "string_tokenizer.c", "threadapi_pthreads.c", "tickcounter_tirtos.c", "urlencode.c", "usha.c", "vector.c", "xlogging.c", "optionhandler.c" ]; /* Paths to external source libraries */ xdcargs = java.lang.System.getenv("XDCARGS").split(" "); var slIncs = ""; var ndkIncs = ""; var wolfsslIncs = ""; var commonIncs = "-I../../inc -I../../inc/azure_c_shared_utility -I../../pal/linux "; var pthreadIncs = ""; /* Parse out the XDCARGS options for the library source paths */ for (x = 0; x < xdcargs.length; x++) { if (xdcargs[x].match(/^CC3200SDK=/)) { slIncs = (xdcargs[x] + "").replace(/'/g, ''); slIncs = slIncs.substring(slIncs.indexOf('=') + 1); if (slIncs != "") { slIncs += "/simplelink"; slIncs = "-I" + slIncs + " -I" + slIncs + "/include "; } } if (xdcargs[x].match(/^NDK=/)) { ndkIncs = (xdcargs[x] + "").replace(/'/g, ''); ndkIncs = ndkIncs.substring(ndkIncs.indexOf('=') + 1); if (ndkIncs != "") { ndkIncs = "-I" + ndkIncs + "/packages/ti/ndk/inc/bsd "; } } if (xdcargs[x].match(/^BIOS=/)) { pthreadIncs = (xdcargs[x] + "").replace(/'/g, ''); pthreadIncs = pthreadIncs.substring(pthreadIncs.indexOf('=') + 1); if (pthreadIncs != "") { pthreadIncs = "-I" + pthreadIncs + "/packages/ti/sysbios/posix "; } } if (xdcargs[x].match(/^WOLFSSL=/)) { wolfsslIncs = (xdcargs[x] + "").replace(/'/g, ''); wolfsslIncs = wolfsslIncs.substring(wolfsslIncs.indexOf('=') + 1); if (wolfsslIncs != "") { wolfsslIncs = "-I" + wolfsslIncs; } } } if (ndkIncs != "") { if (wolfsslIncs == "") { print("Warning: Cannot find WolfSSL directory: '" + wolfsslPath + "'. Skipping TLS support build."); wolfsslIncs = ""; } var wolfsslPath = wolfsslIncs.substring(2); try { var f = new java.io.File(wolfsslPath); if (!f.exists()) { print("Warning: Cannot find WolfSSL directory: '" + wolfsslPath + "'. Skipping TLS support build."); wolfsslIncs = ""; } } catch(e) { print("Warning: Cannot find WolfSSL directory: '" + wolfsslPath + "'. Skipping TLS support build."); wolfsslIncs = ""; } } for (var i = 0; i < Build.targets.length; i++) { var profile = "release"; var target = Build.targets[i]; var extraOpts = commonIncs + pthreadIncs; if (slIncs != "") { Pkg.addLibrary("lib/common_sl", target, { profile: profile, defs: "-DNET_SL -DREFCOUNT_ATOMIC_DONTCARE " + extraOpts, incs: slIncs }).addObjects(SRCS); } if (ndkIncs != "") { if (wolfsslIncs != "") { Pkg.addLibrary("lib/common_ndk_wolfssl", target, { profile: profile, defs: "-DNET_NDK -DNET_WOLFSSL -DWOLFSSL_TIRTOS " + extraOpts, incs: ndkIncs + wolfsslIncs }).addObjects(SRCS) } Pkg.addLibrary("lib/common_ndk", target, { profile: profile, defs: "-DNET_NDK " + extraOpts, incs: ndkIncs }).addObjects(SRCS); } } package.xdc000066400000000000000000000001061455573770000346360ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/tirtos/* * ======== package.xdc ======== */ package build_all.tirtos { } azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/windows/000077500000000000000000000000001455573770000327735ustar00rootroot00000000000000build.cmd000066400000000000000000000126531455573770000345070ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/build_all/windows@REM Copyright (c) Microsoft. All rights reserved. @REM Licensed under the MIT license. See LICENSE file in the project root for full license information. @setlocal EnableExtensions EnableDelayedExpansion @echo off set CMAKE_DIR=shared-util_Win32 set MAKE_NUGET_PKG=no set SOLUTION_NAME=azure_c_shared_utility set current-path=%~dp0 rem // remove trailing slash set current-path=%current-path:~0,-1% set build-root=%current-path%\..\.. rem // resolve to fully qualified path for %%i in ("%build-root%") do set build-root=%%~fi rem ----------------------------------------------------------------------------- rem -- parse script arguments rem ----------------------------------------------------------------------------- rem // default build options set build-clean=0 set build-config= set build-platform=Win32 :args-loop if "%1" equ "" goto args-done if "%1" equ "-c" goto arg-build-clean if "%1" equ "--clean" goto arg-build-clean if "%1" equ "--config" goto arg-build-config if "%1" equ "--platform" goto arg-build-platform if "%1" equ "--make_nuget" goto arg-build-nuget if "%1" equ "--build-root" goto arg-build-root if "%1" equ "--solution-name" goto arg-solution-name call :usage && exit /b 1 :arg-build-clean set build-clean=1 goto args-continue :arg-build-config shift if "%1" equ "" call :usage && exit /b 1 set build-config=%1 goto args-continue :arg-build-platform shift if "%1" equ "" call :usage && exit /b 1 set build-platform=%1 if %build-platform% == x64 ( set CMAKE_DIR=shared-util_x64 ) else if %build-platform% == arm ( set CMAKE_DIR=shared-util_arm ) goto args-continue :arg-build-nuget shift if "%1" equ "" call :usage && exit /b 1 set MAKE_NUGET_PKG=%1 goto args-continue :arg-build-root shift if "%1" equ "" call :usage && exit /b 1 set build-root=%1 goto args-continue :arg-solution-name shift if "%1" equ "" call :usage && exit /b 1 set SOLUTION_NAME=%1 goto args-continue :args-continue shift goto args-loop :args-done rem ----------------------------------------------------------------------------- rem -- build with CMAKE rem ----------------------------------------------------------------------------- echo CMAKE Output Path: %build-root%\cmake\%CMAKE_DIR% if NOT EXIST %build-root%\cmake\%CMAKE_DIR% GOTO NO_CMAKE_DIR rmdir /s/q %build-root%\cmake\%CMAKE_DIR% rem no error checking :NO_CMAKE_DIR mkdir %build-root%\cmake\%CMAKE_DIR% rem no error checking pushd %build-root%\cmake\%CMAKE_DIR% if %MAKE_NUGET_PKG% == yes ( echo ***Running CMAKE for Win32 *** cmake %build-root% if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! popd echo *** Running CMAKE x64 *** if EXIST %build-root%\cmake\shared-util_x64 ( rmdir /s/q %build-root%\cmake\shared-util_x64 ) mkdir %build-root%\cmake\shared-util_x64 pushd %build-root%\cmake\shared-util_x64 cmake %build-root% -G "Visual Studio 15 2017" -A x64 if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! popd echo *** Running CMAKE ARM *** if EXIST %build-root%\cmake\shared-util_arm ( rmdir /s/q %build-root%\cmake\shared-util_arm ) mkdir %build-root%\cmake\shared-util_arm pushd %build-root%\cmake\shared-util_arm cmake %build-root% -G "Visual Studio 15 2017" -A ARM if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else if %build-platform% == Win32 ( echo ***Running CMAKE for Win32*** cmake %build-root% -G "Visual Studio 15 2017" -A Win32 -Drun_unittests:bool=ON -Duse_wsio:bool=ON -Drun_int_tests=ON if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else if %build-platform% == ARM ( echo ***Running CMAKE for ARM*** cmake %build-root% -G "Visual Studio 15 2017" -A ARM -Drun_unittests:bool=ON -Drun_int_tests=ON if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else ( echo ***Running CMAKE for Win64*** cmake %build-root% -G "Visual Studio 15 2017" -A x64 -Drun_unittests:bool=ON -Drun_int_tests=ON -Duse_cppunittest=ON if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) if %MAKE_NUGET_PKG% == yes ( echo running Win32 Shared Util echo ***Building all configurations*** msbuild /m %build-root%\cmake\shared-util_Win32\%SOLUTION_NAME%.sln /p:Configuration=Release msbuild /m %build-root%\cmake\shared-util_Win32\%SOLUTION_NAME%.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! msbuild /m %build-root%\cmake\shared-util_x64\%SOLUTION_NAME%.sln /p:Configuration=Release msbuild /m %build-root%\cmake\shared-util_x64\%SOLUTION_NAME%.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! msbuild /m %build-root%\cmake\shared-util_arm\%SOLUTION_NAME%.sln /p:Configuration=Release msbuild /m %build-root%\cmake\shared-util_arm\%SOLUTION_NAME%.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else ( if not defined build-config ( echo ***Building both configurations*** msbuild /m %SOLUTION_NAME%.sln /p:Configuration=Release msbuild /m %SOLUTION_NAME%.sln /p:Configuration=Debug if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) else ( echo ***Building %build-config% only*** msbuild /m %SOLUTION_NAME%.sln /p:Configuration=%build-config% if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) ctest -C "debug" -V if not !ERRORLEVEL!==0 exit /b !ERRORLEVEL! ) popd goto :eof :usage echo build.cmd [options] echo options: echo --clean [] Cleans the project echo --config ^ [Debug] build configuration (e.g. Debug, Release) echo --platform ^ [Win32] build platform (e.g. Win32, x64, arm, ...) echo --make_nuget ^ [no] generates the binaries to be used for nuget packaging (e.g. yes, no) goto :eof azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/configs/000077500000000000000000000000001455573770000310025ustar00rootroot00000000000000azure_c_shared_utilityConfig.cmake000066400000000000000000000011731455573770000376160ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/configs#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. if(UNIX) include(CMakeFindDependencyMacro) find_dependency(CURL) endif() include("${CMAKE_CURRENT_LIST_DIR}/azure_c_shared_utilityTargets.cmake") get_target_property(AZURE_C_SHARED_UTILITY_INCLUDES aziotsharedutil INTERFACE_INCLUDE_DIRECTORIES) set(AZURE_C_SHARED_UTILITY_INCLUDES ${AZURE_C_SHARED_UTILITY_INCLUDES} CACHE INTERNAL "") include("${CMAKE_CURRENT_LIST_DIR}/azure_c_shared_utilityFunctions.cmake") include("${CMAKE_CURRENT_LIST_DIR}/azure_iot_build_rules.cmake") azure_c_shared_utilityFunctions.cmake000066400000000000000000001002161455573770000403570ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/configs#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. function(target_link_libraries_with_arg_prefix arg_prefix whatIsBuilding lib) if(${arg_prefix} STREQUAL "debug") target_link_libraries(${whatIsBuilding} debug ${lib}) elseif(${arg_prefix} STREQUAL "optimized") target_link_libraries(${whatIsBuilding} optimized ${lib}) elseif(${arg_prefix} STREQUAL "general") target_link_libraries(${whatIsBuilding} general ${lib}) else() target_link_libraries(${whatIsBuilding} ${lib}) endif() endfunction() function(set_test_target_folder whatIsBuilding ext) if("${whatIsBuilding}" MATCHES ".*e2e.*") set_target_properties(${whatIsBuilding}_${ext} PROPERTIES FOLDER "tests/E2ETests") else() set_target_properties(${whatIsBuilding}_${ext} PROPERTIES FOLDER "tests/UnitTests") endif() endfunction() function(windows_unittests_add_dll whatIsBuilding) link_directories(${whatIsBuilding}_dll $ENV{VCInstallDir}UnitTest/lib) add_library(${whatIsBuilding}_dll SHARED ${${whatIsBuilding}_cpp_files} ${${whatIsBuilding}_h_files} ${${whatIsBuilding}_c_files} ${logging_files} ) set_test_target_folder(${whatIsBuilding} "dll") set(PARSING_ADDITIONAL_LIBS OFF) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) set(ARG_PREFIX "none") foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "ADDITIONAL_LIBS") SET(PARSING_ADDITIONAL_LIBS ON) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(ARG_PREFIX "none") #also unset all the other states set(skip_to_next TRUE) elseif(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_ADDITIONAL_LIBS OFF) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_ADDITIONAL_LIBS) if((${f} STREQUAL "debug") OR (${f} STREQUAL "optimized") OR (${f} STREQUAL "general")) SET(ARG_PREFIX ${f}) else() target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_dll ${f}) set(ARG_PREFIX "none") endif() endif() endif() endforeach() target_include_directories(${whatIsBuilding}_dll PUBLIC ${sharedutil_include_directories} $ENV{VCInstallDir}UnitTest/include) target_compile_definitions(${whatIsBuilding}_dll PUBLIC -DCPP_UNITTEST) target_link_libraries(${whatIsBuilding}_dll micromock_cpp_unittest umock_c ctest testrunnerswitcher) endfunction() function(windows_unittests_add_exe whatIsBuilding) add_executable(${whatIsBuilding}_exe ${${whatIsBuilding}_cpp_files} ${${whatIsBuilding}_h_files} ${${whatIsBuilding}_c_files} ${CMAKE_CURRENT_LIST_DIR}/main.c ${logging_files} ) set_test_target_folder(${whatIsBuilding} "exe") set(PARSING_ADDITIONAL_LIBS OFF) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) set(ARG_PREFIX "none") foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "ADDITIONAL_LIBS") SET(PARSING_ADDITIONAL_LIBS ON) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(ARG_PREFIX "none") #also unset all the other states set(skip_to_next TRUE) elseif(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_ADDITIONAL_LIBS OFF) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_ADDITIONAL_LIBS) if((${f} STREQUAL "debug") OR (${f} STREQUAL "optimized") OR (${f} STREQUAL "general")) SET(ARG_PREFIX ${f}) else() target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_exe ${f}) set(ARG_PREFIX "none") endif() endif() endif() endforeach() target_compile_definitions(${whatIsBuilding}_exe PUBLIC -DUSE_CTEST) target_include_directories(${whatIsBuilding}_exe PUBLIC ${sharedutil_include_directories}) target_link_libraries(${whatIsBuilding}_exe micromock_ctest umock_c ctest testrunnerswitcher) add_test(NAME ${whatIsBuilding} COMMAND ${whatIsBuilding}_exe) endfunction() #this function takes more than the 1 mandatory argument (whatIsBuilding) #the parameters are separated by "known" separators #for example, ADDITIONAL_LIBS starts a list of needed libraries function(linux_unittests_add_exe whatIsBuilding) add_executable(${whatIsBuilding}_exe ${${whatIsBuilding}_cpp_files} ${${whatIsBuilding}_h_files} ${${whatIsBuilding}_c_files} ${CMAKE_CURRENT_LIST_DIR}/main.c ${logging_files} ) set_test_target_folder(${whatIsBuilding} "exe") target_compile_definitions(${whatIsBuilding}_exe PUBLIC -DUSE_CTEST) target_include_directories(${whatIsBuilding}_exe PUBLIC ${sharedutil_include_directories}) #this part detects # - the additional libraries that might be needed. # additional libraries are started by ADDITIONAL_LIBS parameter and ended by any other known parameter (or end of variable arguments) # - a valgrind suppression file (VALGRIND_SUPPRESSIONS_FILE) for memcheck # the file name follows immediately after set(PARSING_ADDITIONAL_LIBS OFF) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) set(ARG_PREFIX "none") foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "ADDITIONAL_LIBS") SET(PARSING_ADDITIONAL_LIBS ON) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(ARG_PREFIX "none") set(skip_to_next TRUE) #also unset all the other states elseif(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_ADDITIONAL_LIBS OFF) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_ADDITIONAL_LIBS) if((${f} STREQUAL "debug") OR (${f} STREQUAL "optimized") OR (${f} STREQUAL "general")) SET(ARG_PREFIX ${f}) else() target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_exe ${f}) set(ARG_PREFIX "none") endif() elseif(PARSING_VALGRIND_SUPPRESSIONS_FILE) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER "--suppressions=${f}") endif() endif() endforeach() target_link_libraries(${whatIsBuilding}_exe micromock_ctest umock_c ctest) add_test(NAME ${whatIsBuilding} COMMAND $) if(${run_valgrind}) find_program(VALGRIND_FOUND NAMES valgrind) if(${VALGRIND_FOUND} STREQUAL VALGRIND_FOUND-NOTFOUND) message(WARNING "run_valgrind was TRUE, but valgrind was not found - there will be no tests run under valgrind") else() add_test(NAME ${whatIsBuilding}_valgrind COMMAND valgrind --num-callers=100 --error-exitcode=1 --leak-check=full --track-origins=yes ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) add_test(NAME ${whatIsBuilding}_helgrind COMMAND valgrind --tool=helgrind --num-callers=100 --error-exitcode=1 ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) add_test(NAME ${whatIsBuilding}_drd COMMAND valgrind --tool=drd --num-callers=100 --error-exitcode=1 ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) endif() endif() endfunction() function(build_test_artifacts whatIsBuilding use_gballoc) #the first argument is what is building #the second argument is whether the tests should be build with gballoc #defines or not #the following arguments are a list of libraries to link with if(${use_gballoc}) add_definitions(-DGB_MEASURE_MEMORY_FOR_THIS -DGB_DEBUG_ALLOC) else() endif() #setting #defines if(WIN32) add_definitions(-D_CRT_SECURE_NO_WARNINGS) else() endif() #setting includes set(sharedutil_include_directories ${sharedutil_include_directories} ${TESTRUNNERSWITCHER_INCLUDES} ${CTEST_INCLUDES} ${UMOCK_C_INCLUDES} ${AZURE_C_SHARED_UTILITY_INCLUDES}) set(sharedutil_include_directories ${sharedutil_include_directories} ${MICROMOCK_INC_FOLDER} ${TESTRUNNERSWITCHER_INC_FOLDER} ${CTEST_INC_FOLDER} ${SAL_INC_FOLDER} ${SHARED_UTIL_INC_FOLDER} ${SHARED_UTIL_SRC_FOLDER}) if(WIN32) else() include_directories(${sharedutil_include_directories}) endif() #setting logging_files add_definitions(-DLOGGER_DISABLE_PAL) if(DEFINED SHARED_UTIL_SRC_FOLDER) set(logging_files ${XLOGGING_C_FILE} ${LOGGING_C_FILE}) elseif(DEFINED SHARED_UTIL_FOLDER) set(logging_files ${XLOGGING_C_FILE} ${LOGGING_C_FILE}) else() message(FATAL_ERROR "No Shared Utility folder defined for src.") endif() #setting output type if(WIN32) if( (("${whatIsBuilding}" MATCHES ".*ut.*") AND ${run_unittests}) OR (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${run_e2e_tests}) OR (("${whatIsBuilding}" MATCHES ".*int.*") AND ${run_int_tests}) ) windows_unittests_add_exe(${whatIsBuilding} ${ARGN}) if (${use_cppunittest}) windows_unittests_add_dll(${whatIsBuilding} ${ARGN}) endif() else() if( (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${nuget_e2e_tests}) ) windows_unittests_add_exe(${whatIsBuilding}_nuget ${ARGN}) else() #do nothing endif() endif() else() if( (("${whatIsBuilding}" MATCHES ".*ut.*") AND ${run_unittests}) OR (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${run_e2e_tests}) OR (("${whatIsBuilding}" MATCHES ".*int.*") AND ${run_int_tests}) ) linux_unittests_add_exe(${whatIsBuilding} ${ARGN}) endif() endif() endfunction(build_test_artifacts) function(c_windows_unittests_add_dll whatIsBuilding folder) link_directories(${whatIsBuilding}_dll $ENV{VCInstallDir}UnitTest/lib) add_library(${whatIsBuilding}_testsonly_lib STATIC ${${whatIsBuilding}_test_files} ) SET(VAR 1) foreach(file ${${whatIsBuilding}_test_files}) set_source_files_properties(${file} PROPERTIES COMPILE_FLAGS -DCPPUNITTEST_SYMBOL=some_symbol_for_cppunittest_${VAR}) MATH(EXPR VAR "${VAR}+1") endforeach() set_target_properties(${whatIsBuilding}_testsonly_lib PROPERTIES FOLDER ${folder} ) target_include_directories(${whatIsBuilding}_testsonly_lib PUBLIC ${sharedutil_include_directories} $ENV{VCInstallDir}UnitTest/include) target_compile_definitions(${whatIsBuilding}_testsonly_lib PUBLIC -DCPP_UNITTEST) target_compile_options(${whatIsBuilding}_testsonly_lib PUBLIC /TP /EHsc) add_library(${whatIsBuilding}_dll SHARED ${${whatIsBuilding}_cpp_files} ${${whatIsBuilding}_h_files} ${${whatIsBuilding}_c_files} ${logging_files} ) set_target_properties(${whatIsBuilding}_dll PROPERTIES FOLDER ${folder}) set_source_files_properties(${${whatIsBuilding}_c_files} ${logging_files} PROPERTIES COMPILE_FLAGS /TC) set_source_files_properties(${${whatIsBuilding}_cpp_files} PROPERTIES COMPILE_FLAGS /TP) target_link_libraries(${whatIsBuilding}_dll umock_c ctest testrunnerswitcher ${whatIsBuilding}_testsonly_lib ) set(PARSING_ADDITIONAL_LIBS OFF) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) set(ARG_PREFIX "none") foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "ADDITIONAL_LIBS") SET(PARSING_ADDITIONAL_LIBS ON) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(ARG_PREFIX "none") #also unset all the other states set(skip_to_next TRUE) elseif(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_ADDITIONAL_LIBS OFF) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_ADDITIONAL_LIBS) if((${f} STREQUAL "debug") OR (${f} STREQUAL "optimized") OR (${f} STREQUAL "general")) SET(ARG_PREFIX ${f}) else() target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_dll ${f}) target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_testsonly_lib ${f}) set(ARG_PREFIX "none") endif() endif() endif() endforeach() SET(SPACES " ") SET(VAR 1) foreach(file ${${whatIsBuilding}_test_files}) # for x64 the underscore is not needed if (ARCHITECTURE STREQUAL "x86_64" OR ARCHITECTURE STREQUAL "ARM") set_property(TARGET ${whatIsBuilding}_dll APPEND_STRING PROPERTY LINK_FLAGS ${SPACES}/INCLUDE:"some_symbol_for_cppunittest_${VAR}") else() set_property(TARGET ${whatIsBuilding}_dll APPEND_STRING PROPERTY LINK_FLAGS ${SPACES}/INCLUDE:"_some_symbol_for_cppunittest_${VAR}") endif() MATH(EXPR VAR "${VAR}+1") endforeach() endfunction() function(c_windows_unittests_add_exe whatIsBuilding folder) add_executable(${whatIsBuilding}_exe ${${whatIsBuilding}_test_files} ${${whatIsBuilding}_cpp_files} ${${whatIsBuilding}_h_files} ${${whatIsBuilding}_c_files} ${CMAKE_CURRENT_LIST_DIR}/main.c ${logging_files} ) set_target_properties(${whatIsBuilding}_exe PROPERTIES FOLDER ${folder}) target_compile_definitions(${whatIsBuilding}_exe PUBLIC -DUSE_CTEST) target_include_directories(${whatIsBuilding}_exe PUBLIC ${sharedutil_include_directories}) target_link_libraries(${whatIsBuilding}_exe umock_c ctest testrunnerswitcher) set(PARSING_ADDITIONAL_LIBS OFF) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) set(ARG_PREFIX "none") foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "ADDITIONAL_LIBS") SET(PARSING_ADDITIONAL_LIBS ON) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(ARG_PREFIX "none") #also unset all the other states set(skip_to_next TRUE) elseif(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_ADDITIONAL_LIBS OFF) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_ADDITIONAL_LIBS) if((${f} STREQUAL "debug") OR (${f} STREQUAL "optimized") OR (${f} STREQUAL "general")) SET(ARG_PREFIX ${f}) else() target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_exe ${f}) set(ARG_PREFIX "none") endif() endif() endif() endforeach() add_test(NAME ${whatIsBuilding} COMMAND ${whatIsBuilding}_exe) endfunction() #this function takes more than the 1 mandatory argument (whatIsBuilding) #the parameters are separated by "known" separators #for example, ADDITIONAL_LIBS starts a list of needed libraries function(c_linux_unittests_add_exe whatIsBuilding folder) add_executable(${whatIsBuilding}_exe ${${whatIsBuilding}_test_files} ${${whatIsBuilding}_cpp_files} ${${whatIsBuilding}_h_files} ${${whatIsBuilding}_c_files} ${CMAKE_CURRENT_LIST_DIR}/main.c ${logging_files} ) set_target_properties(${whatIsBuilding}_exe PROPERTIES FOLDER ${folder}) target_compile_definitions(${whatIsBuilding}_exe PUBLIC -DUSE_CTEST) target_include_directories(${whatIsBuilding}_exe PUBLIC ${sharedutil_include_directories}) #this part detects # - the additional libraries that might be needed. # additional libraries are started by ADDITIONAL_LIBS parameter and ended by any other known parameter (or end of variable arguments) # - a valgrind suppression file (VALGRIND_SUPPRESSIONS_FILE) for memcheck # the file name follows immediately after set(PARSING_ADDITIONAL_LIBS OFF) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) set(ARG_PREFIX "none") foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "ADDITIONAL_LIBS") SET(PARSING_ADDITIONAL_LIBS ON) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(ARG_PREFIX "none") #also unset all the other states set(skip_to_next TRUE) elseif(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_ADDITIONAL_LIBS OFF) SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_ADDITIONAL_LIBS) if((${f} STREQUAL "debug") OR (${f} STREQUAL "optimized") OR (${f} STREQUAL "general")) SET(ARG_PREFIX ${f}) else() target_link_libraries_with_arg_prefix(${ARG_PREFIX} ${whatIsBuilding}_exe ${f}) set(ARG_PREFIX "none") endif() elseif(PARSING_VALGRIND_SUPPRESSIONS_FILE) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER "--suppressions=${f}") endif() endif() endforeach() target_link_libraries(${whatIsBuilding}_exe umock_c ctest m) add_test(NAME ${whatIsBuilding} COMMAND $) if(${run_valgrind}) find_program(VALGRIND_FOUND NAMES valgrind) if(${VALGRIND_FOUND} STREQUAL VALGRIND_FOUND-NOTFOUND) message(WARNING "run_valgrind was TRUE, but valgrind was not found - there will be no tests run under valgrind") else() add_test(NAME ${whatIsBuilding}_valgrind COMMAND valgrind --gen-suppressions=all --num-callers=100 --error-exitcode=1 --leak-check=full --track-origins=yes ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) add_test(NAME ${whatIsBuilding}_helgrind COMMAND valgrind --tool=helgrind --gen-suppressions=all --num-callers=100 --error-exitcode=1 ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) add_test(NAME ${whatIsBuilding}_drd COMMAND valgrind --tool=drd --gen-suppressions=all --num-callers=100 --error-exitcode=1 ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) endif() endif() endfunction() function(build_c_test_artifacts whatIsBuilding use_gballoc folder) #the first argument is what is building #the second argument is whether the tests should be build with gballoc #defines or not #the following arguments are a list of libraries to link with if(${use_gballoc}) add_definitions(-DGB_MEASURE_MEMORY_FOR_THIS -DGB_DEBUG_ALLOC) else() endif() #setting #defines if(WIN32) add_definitions(-D_CRT_SECURE_NO_WARNINGS) else() endif() #setting includes set(sharedutil_include_directories ${sharedutil_include_directories} ${TESTRUNNERSWITCHER_INCLUDES} ${CTEST_INCLUDES} ${UMOCK_C_INCLUDES} ${AZURE_C_SHARED_UTILITY_INCLUDES}) set(sharedutil_include_directories ${sharedutil_include_directories} ${MICROMOCK_INC_FOLDER} ${UMOCK_C_INC_FOLDER} ${TESTRUNNERSWITCHER_INC_FOLDER} ${CTEST_INC_FOLDER} ${SAL_INC_FOLDER} ${SHARED_UTIL_INC_FOLDER} ${SHARED_UTIL_SRC_FOLDER}) if(WIN32) else() include_directories(${sharedutil_include_directories}) endif() add_definitions(-DLOGGER_DISABLE_PAL) #setting logging_files if(DEFINED SHARED_UTIL_SRC_FOLDER) set(logging_files ${XLOGGING_C_FILE} ${LOGGING_C_FILE}) elseif(DEFINED SHARED_UTIL_FOLDER) set(logging_files ${XLOGGING_C_FILE} ${LOGGING_C_FILE}) else() message(FATAL_ERROR "No Shared Utility folder defined for includes/src.") endif() #setting output type if(WIN32) if( (("${whatIsBuilding}" MATCHES ".*ut.*") AND ${run_unittests}) OR (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${run_e2e_tests}) OR (("${whatIsBuilding}" MATCHES ".*int.*") AND ${run_int_tests}) ) if (${use_cppunittest}) c_windows_unittests_add_dll(${whatIsBuilding} ${folder} ${ARGN}) endif() c_windows_unittests_add_exe(${whatIsBuilding} ${folder} ${ARGN}) else() if( (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${nuget_e2e_tests}) ) c_windows_unittests_add_exe(${whatIsBuilding}_nuget ${folder} ${ARGN}) else() #do nothing endif() endif() else() if( (("${whatIsBuilding}" MATCHES ".*ut.*") AND ${run_unittests}) OR (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${run_e2e_tests}) OR (("${whatIsBuilding}" MATCHES ".*int.*") AND ${run_int_tests}) ) c_linux_unittests_add_exe(${whatIsBuilding} ${folder} ${ARGN}) endif() endif() endfunction() function(compile_c_test_artifacts_as whatIsBuilding compileAsWhat) if(WIN32) if( (("${whatIsBuilding}" MATCHES ".*ut.*") AND ${run_unittests}) OR (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${run_e2e_tests}) OR (("${whatIsBuilding}" MATCHES ".*int.*") AND ${run_int_tests}) ) if (${use_cppunittest}) if(${compileAsWhat} STREQUAL "C99") compileTargetAsC99(${whatIsBuilding}_dll) compileTargetAsC99(${whatIsBuilding}_testsonly_lib) endif() if(${compileAsWhat} STREQUAL "C11") compileTargetAsC11(${whatIsBuilding}_dll) compileTargetAsC11(${whatIsBuilding}_testsonly_lib) endif() endif() if(${compileAsWhat} STREQUAL "C99") compileTargetAsC99(${whatIsBuilding}_exe) endif() if(${compileAsWhat} STREQUAL "C11") compileTargetAsC11(${whatIsBuilding}_exe) endif() else() if( (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${nuget_e2e_tests}) ) if(${compileAsWhat} STREQUAL "C99") compileTargetAsC99(${whatIsBuilding}_exe) endif() if(${compileAsWhat} STREQUAL "C11") compileTargetAsC11(${whatIsBuilding}_exe) endif() else() #do nothing endif() endif() else() if( (("${whatIsBuilding}" MATCHES ".*ut.*") AND ${run_unittests}) OR (("${whatIsBuilding}" MATCHES ".*e2e.*") AND ${run_e2e_tests}) OR (("${whatIsBuilding}" MATCHES ".*int.*") AND ${run_int_tests}) ) if(${compileAsWhat} STREQUAL "C99") compileTargetAsC99(${whatIsBuilding}_exe) endif() if(${compileAsWhat} STREQUAL "C11") compileTargetAsC11(${whatIsBuilding}_exe) endif() endif() endif() endfunction() function(build_c_test_longhaul_test test_name test_c_files test_h_files) set(test_c_files ${CMAKE_CURRENT_LIST_DIR}/../common_longhaul/iothub_client_statistics.c ${CMAKE_CURRENT_LIST_DIR}/../common_longhaul/iothub_client_common_longhaul.c ${test_c_files} ) set(test_h_files ${CMAKE_CURRENT_LIST_DIR}/../common_longhaul/iothub_client_statistics.h ${CMAKE_CURRENT_LIST_DIR}/../common_longhaul/iothub_client_common_longhaul.h ${test_h_files} ) IF(WIN32) #windows needs this define add_definitions(-D_CRT_SECURE_NO_WARNINGS) add_definitions(-DGB_MEASURE_MEMORY_FOR_THIS -DGB_DEBUG_ALLOC) ENDIF(WIN32) #Conditionally use the SDK trusted certs in the samples if(${set_trusted_cert_in_samples}) add_definitions(-DSET_TRUSTED_CERT_IN_SAMPLES) include_directories(${PROJECT_SOURCE_DIR}/certs) set(samples_cert_file ${PROJECT_SOURCE_DIR}/certs/certs.c) endif() include_directories(${IOTHUB_TEST_INC_FOLDER}) include_directories(${IOTHUB_SERVICE_CLIENT_INC_FOLDER}) include_directories(.) add_executable(${test_name} ${test_c_files} ${test_h_files} ${samples_cert_file}) set(PARSING_VALGRIND_SUPPRESSIONS_FILE OFF) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER) foreach(f ${ARGN}) set(skip_to_next FALSE) if(${f} STREQUAL "VALGRIND_SUPPRESSIONS_FILE") SET(PARSING_VALGRIND_SUPPRESSIONS_FILE ON) set(skip_to_next TRUE) endif() if(NOT skip_to_next) if(PARSING_VALGRIND_SUPPRESSIONS_FILE) set(VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER "--suppressions=${f}") endif() endif() endforeach() if(${run_valgrind}) find_program(VALGRIND_FOUND NAMES valgrind) if(${VALGRIND_FOUND} STREQUAL VALGRIND_FOUND-NOTFOUND) message(WARNING "run_valgrind was TRUE, but valgrind was not found - there will be no tests run under valgrind") else() # below are the longhaul tests running under valgrind # These are currently disabled because the longhaul containers are still Ubuntu 16 andd need s to upgraded to Ubuntu 18 #add_test(NAME ${test_name}_valgrind COMMAND valgrind --gen-suppressions=all --num-callers=100 --error-exitcode=1 --leak-check=full --track-origins=yes ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) #add_test(NAME ${test_name}_helgrind COMMAND valgrind --tool=helgrind --gen-suppressions=all --num-callers=100 --error-exitcode=1 ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) #add_test(NAME ${test_name}_drd COMMAND valgrind --tool=drd --gen-suppressions=all --num-callers=100 --error-exitcode=1 ${VALGRIND_SUPPRESSIONS_FILE_EXTRA_PARAMETER} $) #set_tests_properties(${test_name}_valgrind PROPERTIES TIMEOUT 1296000) #set_tests_properties(${test_name}_helgrind PROPERTIES TIMEOUT 1296000) #set_tests_properties(${test_name}_drd PROPERTIES TIMEOUT 1296000) # run the lonhaul without using valgrind add_test(NAME ${test_name} COMMAND $) set_tests_properties(${test_name} PROPERTIES TIMEOUT 1296000) endif() else() add_test(NAME ${test_name} COMMAND $) set_tests_properties(${test_name} PROPERTIES TIMEOUT 1296000) endif() target_link_libraries(${test_name} iothub_test iothub_client) set_target_properties(${test_name} PROPERTIES FOLDER "tests/LongHaul") endfunction() # This function focuses on setting files which are unique to a given hardware platform. # The choice of tlsio is not unique per-platform, and is set in the main CMakeLists.txt function(set_platform_files c_shared_dir) if(WIN32) if(${use_condition}) set(CONDITION_C_FILE ${c_shared_dir}/adapters/condition_win32.c PARENT_SCOPE) endif() if(${use_etw} STREQUAL "OFF") set(XLOGGING_C_FILE ${c_shared_dir}/src/xlogging.c PARENT_SCOPE) set(LOGGING_C_FILE ${c_shared_dir}/src/consolelogger.c PARENT_SCOPE) set(LOGGING_H_FILE ${c_shared_dir}/inc/azure_c_shared_utility/consolelogger.h PARENT_SCOPE) elseif(${use_etw} STREQUAL "TRACELOGGING") set(XLOGGING_C_FILE ${c_shared_dir}/src/etwxlogging.c PARENT_SCOPE) set(LOGGING_C_FILE ${c_shared_dir}/src/etwlogger_driver.c PARENT_SCOPE) set(LOGGING_H_FILE ${c_shared_dir}/inc/azure_c_shared_utility/etwlogger_driver.h PARENT_SCOPE) elseif(${use_etw} STREQUAL "TRACELOGGING_WITH_CONSOLE") set(XLOGGING_C_FILE ${c_shared_dir}/src/etwxlogging.c PARENT_SCOPE) set(LOGGING_C_FILE ${c_shared_dir}/src/etwlogger_driver.c ${c_shared_dir}/src/consolelogger.c PARENT_SCOPE) set(LOGGING_H_FILE ${c_shared_dir}/inc/azure_c_shared_utility/etwlogger_driver.h ${c_shared_dir}/inc/azure_c_shared_utility/consolelogger.h PARENT_SCOPE) endif() set(THREAD_C_FILE ${c_shared_dir}/adapters/threadapi_win32.c PARENT_SCOPE) set(LOCK_C_FILE ${c_shared_dir}/adapters/lock_win32.c PARENT_SCOPE) set(SRW_LOCK_C_FILE ${c_shared_dir}/adapters/srw_lock.c PARENT_SCOPE) set(TIMER_C_FILE ${c_shared_dir}/adapters/timer.c PARENT_SCOPE) set(STRING_UTILS_C_FILE ${c_shared_dir}/adapters/string_utils.c PARENT_SCOPE) if (${use_builtin_httpapi}) set(HTTP_C_FILE ${c_shared_dir}/adapters/httpapi_compact.c PARENT_SCOPE) else() set(HTTP_C_FILE ${c_shared_dir}/adapters/httpapi_winhttp.c PARENT_SCOPE) endif() set(PLATFORM_C_FILE ${c_shared_dir}/adapters/platform_win32.c PARENT_SCOPE) if (${use_socketio}) set(SOCKETIO_C_FILE ${c_shared_dir}/adapters/socketio_win32.c PARENT_SCOPE) endif() set(TICKCOUTER_C_FILE ${c_shared_dir}/adapters/tickcounter_win32.c PARENT_SCOPE) if (${use_default_uuid}) set(UNIQUEID_C_FILE ${c_shared_dir}/adapters/uniqueid_stub.c PARENT_SCOPE) else() set(UNIQUEID_C_FILE ${c_shared_dir}/adapters/uniqueid_win32.c PARENT_SCOPE) endif() set(DNS_C_FILE ${c_shared_dir}/src/dns_resolver_sync.c PARENT_SCOPE) else() set(XLOGGING_C_FILE ${c_shared_dir}/src/xlogging.c PARENT_SCOPE) set(LOGGING_C_FILE ${c_shared_dir}/src/consolelogger.c PARENT_SCOPE) set(LOGGING_H_FILE ${c_shared_dir}/inc/azure_c_shared_utility/consolelogger.h PARENT_SCOPE) if(${use_condition}) set(CONDITION_C_FILE ${c_shared_dir}/adapters/condition_pthreads.c PARENT_SCOPE) endif() if (${use_builtin_httpapi}) set(HTTP_C_FILE ${c_shared_dir}/adapters/httpapi_compact.c PARENT_SCOPE) else() set(HTTP_C_FILE ${c_shared_dir}/adapters/httpapi_curl.c PARENT_SCOPE) endif() set(LOCK_C_FILE ${c_shared_dir}/adapters/lock_pthreads.c PARENT_SCOPE) if (use_applessl) set(PLATFORM_C_FILE ${c_shared_dir}/pal/ios-osx/platform_appleios.c PARENT_SCOPE) else() set(PLATFORM_C_FILE ${c_shared_dir}/adapters/platform_linux.c PARENT_SCOPE) endif() if (${use_socketio}) set(SOCKETIO_C_FILE ${c_shared_dir}/adapters/socketio_berkeley.c PARENT_SCOPE) endif() set(THREAD_C_FILE ${c_shared_dir}/adapters/threadapi_pthreads.c PARENT_SCOPE) set(TICKCOUTER_C_FILE ${c_shared_dir}/adapters/tickcounter_linux.c PARENT_SCOPE) if (${use_default_uuid}) set(UNIQUEID_C_FILE ${c_shared_dir}/adapters/uniqueid_stub.c PARENT_SCOPE) elseif(AZSPHERE) set(UNIQUEID_C_FILE ${c_shared_dir}/adapters/uniqueid_azsphere.c PARENT_SCOPE) else() set(UNIQUEID_C_FILE ${c_shared_dir}/adapters/uniqueid_linux.c PARENT_SCOPE) endif() if(${use_c_ares}) set(DNS_C_FILE ${c_shared_dir}/src/dns_resolver_ares.c PARENT_SCOPE) else() set(DNS_C_FILE ${c_shared_dir}/src/dns_resolver_sync.c PARENT_SCOPE) endif() endif() if(WIN32 OR MACOSX OR LINUX) set (ENVIRONMENT_VARIABLE_C_FILE ${c_shared_dir}/adapters/envvariable.c PARENT_SCOPE) endif() endfunction(set_platform_files) azure_iot_build_rules.cmake000066400000000000000000000276171455573770000363340ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/configs#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. # Silences a CMake warning, no apparent effect on the Azure IoT SDK if(POLICY CMP0042) cmake_policy(SET CMP0042 NEW) endif() #Use solution folders. set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Build with -fPIC always set(CMAKE_POSITION_INDEPENDENT_CODE TRUE) option(run_valgrind "set run_valgrind to ON if tests are to be run under valgrind/helgrind/drd. Default is OFF" OFF) set(compileOption_C "" CACHE STRING "passes a string to the command line of the C compiler") set(compileOption_CXX "" CACHE STRING "passes a string to the command line of the C++ compiler") # These are the include folders. (assumes that this file is in a subdirectory of c-utility) get_filename_component(SHARED_UTIL_FOLDER ${CMAKE_CURRENT_LIST_DIR} DIRECTORY) set(SHARED_UTIL_FOLDER "${SHARED_UTIL_FOLDER}" CACHE INTERNAL "this is the sharedLib directory" FORCE) set(SHARED_UTIL_INC_FOLDER ${SHARED_UTIL_FOLDER}/inc CACHE INTERNAL "this is what needs to be included if using sharedLib lib" FORCE) set(SHARED_UTIL_SRC_FOLDER ${SHARED_UTIL_FOLDER}/src CACHE INTERNAL "this is what needs to be included when doing include sources" FORCE) set(SHARED_UTIL_ADAPTER_FOLDER "${SHARED_UTIL_FOLDER}/adapters" CACHE INTERNAL "this is where the adapters live" FORCE) # PAL will eventually absorb the contents of SHARED_UTIL_ADAPTER_FOLDER set(SHARED_UTIL_PAL_FOLDER "${SHARED_UTIL_FOLDER}/pal" CACHE INTERNAL "this is the PAL common sources directory" FORCE) set(SHARED_UTIL_PAL_INC_FOLDER "${SHARED_UTIL_FOLDER}/pal/inc" CACHE INTERNAL "this is the PAL include directory" FORCE) #making a global variable to know if we are on linux, windows, or macosx. if(CMAKE_SYSTEM_NAME STREQUAL "Windows") set(WINDOWS TRUE) elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") set(LINUX TRUE) #on Linux, enable valgrind #these commands (MEMORYCHECK...) need to apear BEFORE include(CTest) or they will not have any effect find_program(MEMORYCHECK_COMMAND valgrind) set(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1") elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") set(MACOSX TRUE) endif() include(CTest) include_directories(${SHARED_UTIL_INC_FOLDER}) # OS-specific header files for ref counting if(MSVC) include_directories(${SHARED_UTIL_PAL_FOLDER}/windows) else() include_directories(${SHARED_UTIL_PAL_FOLDER}/linux) endif() # if the compiler check fails (such as for iOS) header search will also fail - this allows it to be suppressed if(NOT suppress_header_searches) include(CheckIncludeFiles) CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H) CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H) else() message(STATUS "Bypassing header search") set(HAVE_STDINT_H TRUE) set(HAVE_STDBOOL_H TRUE) endif() if ((NOT HAVE_STDINT_H) OR (NOT HAVE_STDBOOL_H)) include_directories(${SHARED_UTIL_INC_FOLDER}/azure_c_shared_utility/windowsce) endif() # System-specific compiler flags if(MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3") elseif(UNIX) #LINUX OR APPLE set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") if(NOT (IN_OPENWRT OR APPLE)) set (CMAKE_C_FLAGS "-D_POSIX_C_SOURCE=200112L ${CMAKE_C_FLAGS}") endif() endif() enable_testing() include(CheckSymbolExists) function(detect_architecture symbol arch) if (NOT DEFINED ARCHITECTURE OR ARCHITECTURE STREQUAL "") set(CMAKE_REQUIRED_QUIET 1) check_symbol_exists("${symbol}" "" ARCHITECTURE_${arch}) unset(CMAKE_REQUIRED_QUIET) # The output variable needs to be unique across invocations otherwise # CMake's crazy scope rules will keep it defined if (ARCHITECTURE_${arch}) set(ARCHITECTURE "${arch}" PARENT_SCOPE) set(ARCHITECTURE_${arch} 1 PARENT_SCOPE) add_definitions(-DARCHITECTURE_${arch}=1) endif() endif() endfunction() if (MSVC) detect_architecture("_M_AMD64" x86_64) detect_architecture("_M_IX86" x86) detect_architecture("_M_ARM" ARM) else() detect_architecture("__x86_64__" x86_64) detect_architecture("__i386__" x86) detect_architecture("__arm__" ARM) endif() if (NOT DEFINED ARCHITECTURE OR ARCHITECTURE STREQUAL "") set(ARCHITECTURE "GENERIC") endif() message(STATUS "target architecture: ${ARCHITECTURE}") # if any compiler has a command line switch called "OFF" then it will need special care if (NOT "${compileOption_C}" STREQUAL "") set(CMAKE_C_FLAGS "${compileOption_C} ${CMAKE_C_FLAGS}") endif() if (NOT "${compileOption_CXX}" STREQUAL "") set(CMAKE_CXX_FLAGS "${compileOption_CXX} ${CMAKE_CXX_FLAGS}") endif() include(CheckCXXCompilerFlag) CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX_FLAG_CXX11) macro(compileAsC99) if (CMAKE_VERSION VERSION_LESS "3.1") if (CMAKE_C_COMPILER_ID STREQUAL "GNU") set (CMAKE_C_FLAGS "--std=c99 ${CMAKE_C_FLAGS}") if (CXX_FLAG_CXX11) set (CMAKE_CXX_FLAGS "--std=c++11 ${CMAKE_CXX_FLAGS}") else() set (CMAKE_CXX_FLAGS "--std=c++0x ${CMAKE_CXX_FLAGS}") endif() endif() else() set (CMAKE_C_STANDARD 99) set (CMAKE_CXX_STANDARD 11) endif() endmacro(compileAsC99) macro(compileAsC11) if (CXX_FLAG_CXX11) if (CMAKE_VERSION VERSION_LESS "3.1") if (CMAKE_C_COMPILER_ID STREQUAL "GNU") set (CMAKE_C_FLAGS "--std=c11 ${CMAKE_C_FLAGS}") set (CMAKE_C_FLAGS "-D_POSIX_C_SOURCE=200112L ${CMAKE_C_FLAGS}") set (CMAKE_CXX_FLAGS "--std=c++11 ${CMAKE_CXX_FLAGS}") endif() else() set (CMAKE_C_STANDARD 11) set (CMAKE_CXX_STANDARD 11) endif() else() if (CMAKE_C_COMPILER_ID STREQUAL "GNU") set (CMAKE_C_FLAGS "--std=c99 ${CMAKE_C_FLAGS}") set (CMAKE_CXX_FLAGS "--std=c++0x ${CMAKE_CXX_FLAGS}") else() set (CMAKE_C_STANDARD 11) set (CMAKE_CXX_STANDARD 11) endif() endif() endmacro(compileAsC11) function(compileTargetAsC99 theTarget) if (CMAKE_VERSION VERSION_LESS "3.1") if (CMAKE_C_COMPILER_ID STREQUAL "GNU") set_target_properties(${theTarget} PROPERTIES COMPILE_FLAGS "--std=c99") endif() else() set_target_properties(${theTarget} PROPERTIES C_STANDARD 99) set_target_properties(${theTarget} PROPERTIES CXX_STANDARD 11) endif() endfunction() function(compileTargetAsC11 theTarget) if (CMAKE_VERSION VERSION_LESS "3.1") if (CMAKE_C_COMPILER_ID STREQUAL "GNU") if (CXX_FLAG_CXX11) set_target_properties(${theTarget} PROPERTIES COMPILE_FLAGS "--std=c11 -D_POSIX_C_SOURCE=200112L") else() set_target_properties(${theTarget} PROPERTIES COMPILE_FLAGS "--std=c99 -D_POSIX_C_SOURCE=200112L") endif() endif() else() set_target_properties(${theTarget} PROPERTIES C_STANDARD 11) set_target_properties(${theTarget} PROPERTIES CXX_STANDARD 11) endif() endfunction() macro(generate_cpp_wrapper setVar whatIsBuilding) file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${whatIsBuilding}.cxx "#include \"${CMAKE_CURRENT_SOURCE_DIR}/${whatIsBuilding}.c\"") set(${setVar} ${CMAKE_CURRENT_BINARY_DIR}/${whatIsBuilding}.cxx) endmacro(generate_cpp_wrapper) macro(generate_cppunittest_wrapper whatIsBuilding) if (${use_cppunittest} AND WIN32) file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${whatIsBuilding}.cxx "#include \"${CMAKE_CURRENT_SOURCE_DIR}/${whatIsBuilding}.c\"") set(${whatIsBuilding}_test_files ${CMAKE_CURRENT_BINARY_DIR}/${whatIsBuilding}.cxx) #CPP compiler on windows likes to complain about unused local function removed (C4505) #C compiler doesn't like to complain about the same thing set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4505") else() set(${whatIsBuilding}_test_files ${whatIsBuilding}.c) endif() endmacro(generate_cppunittest_wrapper) IF((WIN32) AND (NOT(MINGW))) #windows needs this define add_definitions(-D_CRT_SECURE_NO_WARNINGS) # Make warning as error add_definitions(/WX) ELSE() # Make warning as error set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") ENDIF() function(add_files_to_install filesToBeInstalled) set(INSTALL_H_FILES ${INSTALL_H_FILES} ${filesToBeInstalled} CACHE INTERNAL "Files that will be installed on the system") endfunction() # XCode and stricter warning levels such as -Wall and -Wextra warn about unused # variables and unused static functions, both of which are produced by serializer function(usePermissiveRulesForSamplesAndTests) if (NOT MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable -Wno-unused-function -Wno-missing-braces -Wno-strict-aliasing") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-variable -Wno-unused-function -Wno-missing-braces -Wno-strict-aliasing") if(NOT APPLE AND NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-but-set-variable -Wno-clobbered") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-but-set-variable -Wno-clobbered") endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" PARENT_SCOPE) endif() endfunction() # For targets which set warning switches as project properties (e.g. XCode) function(setTargetBuildProperties stbp_target) if(XCODE) set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_BOOL_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_COMMA "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_CONSTANT_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_EMPTY_BODY "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_INFINITE_RECURSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_INT_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_NON_LITERAL_NULL_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_OBJC_LITERAL_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_OBJC_ROOT_CLASS "YES_ERROR") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_RANGE_LOOP_ANALYSIS "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_STRICT_PROTOTYPES "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_SUSPICIOUS_MOVE "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN_UNREACHABLE_CODE "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_CLANG_WARN__DUPLICATE_METHOD_MATCH "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_64_TO_32_BIT_CONVERSION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_ABOUT_RETURN_TYPE "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_UNDECLARED_SELECTOR "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_UNINITIALIZED_AUTOS "YES_AGGRESSIVE") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_UNUSED_FUNCTION "YES") set_target_properties(${stbp_target} PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VARIABLE "YES") endif() endfunction() azure_iot_external_pal_unit_test_setup.cmake000066400000000000000000000015451455573770000420070ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/configs#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. cmake_minimum_required(VERSION 2.8.11) # quiet the CMake warning about unused command line args "use_wsio". This is from the c-utility CMake command. set(ignore_me ${use_wsio}) # Set up to make an external repo's unit tests include("${CMAKE_CURRENT_LIST_DIR}/azure_iot_build_rules.cmake") include("${SHARED_UTIL_FOLDER}/dependencies-test.cmake") add_subdirectory(${SHARED_UTIL_FOLDER}/testtools/ctest) add_subdirectory(${SHARED_UTIL_FOLDER}/testtools/testrunner) add_subdirectory(${SHARED_UTIL_FOLDER}/testtools/umock-c) #Setup the platform files in order to include the logging file definitions include("${SHARED_UTIL_FOLDER}/configs/azure_c_shared_utilityFunctions.cmake") set_platform_files(${SHARED_UTIL_FOLDER}) dependencies-test.cmake000066400000000000000000000003531455573770000337010ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. if(${use_installed_dependencies}) find_package(umock_c REQUIRED CONFIG) endif()azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/dependencies.cmake000066400000000000000000000017151455573770000330060ustar00rootroot00000000000000#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. if(NOT ${use_installed_dependencies}) if (NOT TARGET azure_macro_utils_c) if (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/azure-macro-utils-c/CMakeLists.txt) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/azure-macro-utils-c) else() message(FATAL_ERROR "Could not find azure-macro-utils-c source") endif() endif() if (NOT TARGET umock_c) if (EXISTS ${CMAKE_CURRENT_LIST_DIR}/deps/umock-c/CMakeLists.txt) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/umock-c) else() message(FATAL_ERROR "Could not find umock-c source") endif() endif() else() find_package(azure_macro_utils_c REQUIRED CONFIG) find_package(umock_c REQUIRED CONFIG) endif() include_directories(${MACRO_UTILS_INC_FOLDER}) include_directories(${UMOCK_C_INC_FOLDER}) azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/000077500000000000000000000000001455573770000303055ustar00rootroot00000000000000azure-macro-utils-c/000077500000000000000000000000001455573770000340315ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps.gitattributes000066400000000000000000000014461455573770000367310ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c# Default behavior: if Git thinks a file is text (as opposed to binary), it # will normalize line endings to LF in the repository, but convert to your # platform's native line endings on checkout (e.g., CRLF for Windows). * text=auto # Explicitly declare text files you want to always be normalized and converted # to native line endings on checkout. E.g., #*.c text # Declare files that will always have CRLF line endings on checkout. E.g., #*.sln text eol=crlf # Declare files that will always have LF line endings on checkout. E.g., *.sh text eol=lf # Denote all files that should not have line endings normalized, should not be # merged, and should not show in a textual diff. *.docm binary *.docx binary *.ico binary *.lib binary *.png binary *.pptx binary *.snk binary *.vsdx binary *.xps binary .gitignore000066400000000000000000000053111455573770000360210ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c# Compiled object files *.o *.opp # Compiled static libraries *.a ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.sln.docstates # Build results macro_utils_h_generator/.vs/** [Dd]ebug/ [Rr]elease/ x64/ [Bb]in/ [Oo]bj/ /build/release/Maven !/build/release/ [Cc]make/ # Enable "build/" folder in the NuGet Packages folder since NuGet packages use it for MSBuild targets !packages/*/build/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* *_i.c *_p.c *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *.log *.vspscc *.vssscc .builds *.pidb *.log *.scc # Visual C++ cache files ipch/ *.aps *.ncb *.opensdf *.sdf *.cachefile # Visual Studio profiler *.psess *.vsp *.vspx # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.VC.opendb # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # NCrunch *.ncrunch* .*crunch*.local.xml # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.Publish.xml # NuGet Packages Directory packages/ # Windows Azure Build Output csx *.build.csdef # Windows Store app package directory AppPackages/ # Others sql/ *.Cache ClientBin/ [Ss]tyle[Cc]op.* ~$* *~ *.dbmdl *.[Pp]ublish.xml *.pfx *.publishsettings *.jar # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file to a newer # Visual Studio version. Backup files are not needed, because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm # SQL Server files App_Data/*.mdf App_Data/*.ldf #LightSwitch generated files GeneratedArtifacts/ _Pvt_Extensions/ ModelManifest.xml # CPython & Wheels *.pyc *.pyd *.whl *.egg-info # ========================= # Windows detritus # ========================= # Windows image file caches Thumbs.db ehthumbs.db # Folder config file Desktop.ini # Recycle Bin used on file shares $RECYCLE.BIN/ # Mac desktop service store files .DS_Store # Visual studio build artifacts *.tlog *.lastbuildstate *.idb *.exp *.lib *.dll # Visual Studio Temporary files *.VC.db # Tools EXE that doesn't end up in a typical build directory common/tools/macro_utils_h_generator/macro_utils_h_generator.exe # VS Code stuff **/typings/** **/.vscode/** # C/C++ extension for VS Code .browse.VC.db* /cmake macro_utils_h_generator/macro_utils_h_generator.exe CMakeLists.txt000066400000000000000000000051331455573770000365730ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. cmake_minimum_required(VERSION 2.8.11) if(TARGET azure_macro_utils_c) return() endif() project(azure_macro_utils_c) set(AZURE_MACRO_UTILS_C_VERSION 1.1.0) option(run_int_tests "set run_int_tests to ON to run int tests (default is OFF)" OFF) #these are the include folders #the following "set" statement exports across the project a global variable called MACRO_UTILS_INC_FOLDER that expands to whatever needs to included when using macro_utils set(MACRO_UTILS_INC_FOLDER ${CMAKE_CURRENT_LIST_DIR}/inc CACHE INTERNAL "this is what needs to be included if using macro utils" FORCE) include(CTest) include(GNUInstallDirs) set(macro_utils_files inc/azure_macro_utils/macro_utils.h inc/azure_macro_utils/macro_utils_generated.h ) install(FILES ${macro_utils_files} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/azure_macro_utils") if("${CMAKE_VERSION}" VERSION_GREATER 3.0.0) add_library(azure_macro_utils_c INTERFACE) target_include_directories(azure_macro_utils_c INTERFACE $ $ ) install(TARGETS azure_macro_utils_c EXPORT azure_macro_utils_cTargets INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) #Install azure_iot_sdks set(package_location "cmake") include(CMakePackageConfigHelpers) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake" VERSION ${AZURE_MACRO_UTILS_C_VERSION} COMPATIBILITY SameMajorVersion ) configure_file("configs/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake" COPYONLY ) install(EXPORT azure_macro_utils_cTargets FILE "${PROJECT_NAME}Targets.cmake" DESTINATION ${package_location} ) install( FILES "configs/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake" DESTINATION ${package_location} ) else() message(STATUS "This version of CMake does not support interface targets. Only the Azure Macro Utils header file will be installed. To use Azure Macro Utils, simply add \"MACRO_UTILS_INC_FOLDER\" to your include directories as specified in the instructions on the GitHub README.") endif() if(${run_int_tests}) add_subdirectory(tests) endif() LICENSE000066400000000000000000000021541455573770000350400ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-cMicrosoft Azure IoT SDKs Copyright (c) Microsoft Corporation All rights reserved. MIT License Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.build/000077500000000000000000000000001455573770000351305ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-cdevops.yml000066400000000000000000000044401455573770000371550ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c/buildname: $(BuildID)_$(BuildDefinitionName)_$(SourceBranchName)_$(Date:yyyyMMdd)$(Rev:.r) resources: - repo: self clean: true jobs: - job: windowsx86 displayName: 'Build Windows x86' pool: name: Hosted VS2017 demands: - Cmd - msbuild - visualstudio steps: - task: BatchScript@1 displayName: 'Setup VS vars' inputs: filename: '"C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsDevCmd.bat"' modifyEnvironment: true - task: CMake@1 displayName: CMake inputs: cmakeArgs: '.. -Drun_int_tests:bool=ON -G "Visual Studio 15 2017"' - task: VSBuild@1 displayName: 'Build solution build\*.sln (RelWithDebInfo)' inputs: solution: 'build\*.sln' configuration: RelWithDebInfo clean: true maximumCpuCount: true - task: CmdLine@1 displayName: 'Run ctest (RelWithDebInfo)' inputs: filename: ctest arguments: '-C "RelWithDebInfo" -V --output-on-failure' workingFolder: build - job: windowsx64 displayName: 'Build Windows x64' pool: name: Hosted VS2017 demands: - Cmd - msbuild - visualstudio steps: - task: BatchScript@1 displayName: 'Setup VS vars' inputs: filename: '"C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\Common7\Tools\VsDevCmd.bat"' modifyEnvironment: true - task: CMake@1 displayName: CMake inputs: cmakeArgs: '.. -Drun_int_tests:bool=ON -G "Visual Studio 15 2017 Win64"' - task: VSBuild@1 displayName: 'Build solution build\*.sln (Debug)' inputs: solution: 'build\*.sln' configuration: Debug clean: true maximumCpuCount: true - task: CmdLine@1 displayName: 'Run ctest (Debug)' inputs: filename: ctest arguments: '-C "Debug" -V --output-on-failure' workingFolder: build - job: ubuntu1604 displayName: 'Build Linux Ubuntu 1604' pool: name: Hosted Ubuntu 1604 steps: - task: CMake@1 displayName: CMake inputs: cmakeArgs: '.. -Drun_int_tests:bool=ON' - script: 'make -j$(nproc)' workingDirectory: build displayName: make - task: CmdLine@1 displayName: 'Run ctest' inputs: filename: ctest arguments: '-C "Debug" -V --output-on-failure -j $(nproc)' workingFolder: build configs/000077500000000000000000000000001455573770000354615ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-cazure_macro_utils_cConfig.cmake000066400000000000000000000015151455573770000436440ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c/configs#Copyright (c) Microsoft. All rights reserved. #Licensed under the MIT license. See LICENSE file in the project root for full license information. set(MACRO_UTILS_INC_FOLDER "${CMAKE_CURRENT_LIST_DIR}/include" CACHE INTERNAL "this is what needs to be included if using macro utils" FORCE) if("${CMAKE_VERSION}" VERSION_GREATER 3.0.2) include("${CMAKE_CURRENT_LIST_DIR}/azure_macro_utils_cTargets.cmake") get_target_property(AZURE_MACRO_UTILS_C_INCLUDES azure_macro_utils_c INTERFACE_INCLUDE_DIRECTORIES) set(AZURE_MACRO_UTILS_C_INCLUDES ${AZURE_MACRO_UTILS_C_INCLUDES} CACHE INTERNAL "") else() message(STATUS "This version of CMake does not support interface targets. To use Azure Macro Utils, simply add \"MACRO_UTILS_INC_FOLDER\" to your include directories as specified in the instructions on the GitHub README.") endif()inc/000077500000000000000000000000001455573770000346025ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-cazure_macro_utils/000077500000000000000000000000001455573770000403315ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c/incmacro_utils.h000066400000000000000000000310751455573770000430310ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c/inc/azure_macro_utils// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. #ifndef MACRO_UTILS_H #define MACRO_UTILS_H #include "azure_macro_utils/macro_utils_generated.h" #ifdef __cplusplus #include #include extern "C" { #else #include #include #endif #if (defined OPTIMIZE_RETURN_CODES) #define MU_FAILURE 1 #else #define MU_FAILURE __LINE__ #endif /*"pointer or NULL" macro - because when printf-ing arguments NULL is not valid for %s (section 7.1.4 of C11 standard) */ #define MU_P_OR_NULL(p) (((p)!=NULL)?(p):"NULL") #define MU_WP_OR_NULL(p) (((p)!=NULL)?(p):L"NULL") #define MU_TOSTRING_(x) #x #define MU_TOSTRING(x) MU_TOSTRING_(x) #define MU_TRIGGER_PARENTHESIS(...) , #define MU_LPAREN ( #define MU_C2_(x,y) x##y #define MU_C2(x,y) MU_C2_(x,y) #define MU_C3(x,y,z) MU_C2(x, MU_C2(y,z)) #define MU_C4(x,y,z, u) MU_C2(MU_C2(x,y), MU_C2(z,u)) #define MU_C5(x,y,z,u, v) MU_C2(MU_C4(x,y, z, u), v) #define MU_C1_(x) x #define MU_C1(x) MU_C1_(x) #define MU_C2STRING(x,y) x y #define MU_C3STRING(x,y,z) x y z #define MU_C4STRING(x,y,z,u) x y z u #define MU_C5STRING(x,y,z,u,v) x y z u v /* we need some sort of macro that does: MU_IF(0, "true", "false") => "false" MU_IF(1, "true", "false") => "true" MU_IF(X, "true", "false") => "true" */ #define MU_INTERNALIF(x) MU_INTERNALIF##x #define MU_INTERNALIF0 #define MU_ISZERO(x) MU_COUNT_ARG(MU_INTERNALIF(x)) #define MU_IF(condition, trueBranch, falseBranch) MU_C2(MU_IF,MU_ISZERO(condition))(trueBranch, falseBranch) #define MU_IF0(trueBranch, falseBranch) falseBranch #define MU_IF1(trueBranch, falseBranch) trueBranch /*the following macro want to eat empty arguments from a list */ /*examples: */ /*MU_EAT_EMPTY_ARGS(, , X) expands to X */ #define MU_EXPAND_TO_NOTHING(arg) #define MU_EAT_EMPTY_ARG(arg_count, arg) MU_IF(MU_ISEMPTY(arg),,arg) MU_IF(MU_ISEMPTY(arg),MU_EXPAND_TO_NOTHING,MU_IFCOMMALOGIC)(MU_DEC(arg_count)) #define MU_EAT_EMPTY_ARGS(...) MU_FOR_EACH_1_COUNTED(MU_EAT_EMPTY_ARG, __VA_ARGS__) #define MU_DEFINE_ENUMERATION_CONSTANT(x) x, /*MU_DEFINE_ENUM_WITHOUT_INVALID goes to header*/ #define MU_DEFINE_ENUM_WITHOUT_INVALID(enumName, ...) typedef enum MU_C2(enumName, _TAG) { MU_FOR_EACH_1(MU_DEFINE_ENUMERATION_CONSTANT, __VA_ARGS__)} enumName; \ extern const char* MU_C2(enumName,Strings)(enumName value); \ extern int MU_C2(enumName, _FromString)(const char* enumAsString, enumName* destination); // this macro is a wrapper on top of MU_DEFINE_ENUM_WITHOUT_INVALID, adding an _INVALID value as the first enum value in the enum #define MU_DEFINE_ENUM(enumName, ...) \ MU_DEFINE_ENUM_WITHOUT_INVALID(enumName, MU_C2(enumName, _INVALID), __VA_ARGS__) #define MU_DEFINE_ENUMERATION_CONSTANT_AS_WIDESTRING(x) MU_C2(L, MU_TOSTRING(x)) , #define MU_DEFINE_ENUMERATION_CONSTANT_AS_STRING(x) MU_TOSTRING(x) , /*MU_DEFINE_ENUM_STRINGS_WITHOUT_INVALID goes to .c*/ #define MU_DEFINE_ENUM_STRINGS_WITHOUT_INVALID(enumName, ...) const char* MU_C2(enumName, StringStorage)[MU_COUNT_ARG(__VA_ARGS__)] = {MU_FOR_EACH_1(MU_DEFINE_ENUMERATION_CONSTANT_AS_STRING, __VA_ARGS__)}; \ const char* MU_C2(enumName,Strings)(enumName value) \ { \ if((int)value<0 || (int)value>=MU_COUNT_ARG(__VA_ARGS__)) \ { \ /*this is an error case*/ \ return "NULL"; \ } \ else \ { \ return MU_C2(enumName, StringStorage)[value]; \ } \ } \ int MU_C2(enumName, _FromString)(const char* enumAsString, enumName* destination) \ { \ if( \ (enumAsString==NULL) || (destination==NULL) \ ) \ { \ return MU_FAILURE; \ } \ else \ { \ size_t i; \ for(i=0;i=MU_COUNT_ARG(__VA_ARGS__)) \ { \ /*this is an error case*/ \ return "NULL"; \ } \ else \ { \ return MU_C2(enumName, StringStorage)[value]; \ } \ } // this macro is a wrapper on top of MU_DEFINE_LOCAL_ENUM_WITHOUT_INVALID, adding an _INVALID value as the first enum value in the enum #define MU_DEFINE_LOCAL_ENUM(enumName, ...) \ MU_DEFINE_LOCAL_ENUM_WITHOUT_INVALID(enumName, MU_C2(enumName, _INVALID), __VA_ARGS__) // this macro returns the number of enum values (taking into account that an invalid value is generated) #define MU_ENUM_VALUE_COUNT(...) (MU_COUNT_ARG(__VA_ARGS__) + 1) // this macro returns the number of enum 2 values (taking into account that an invalid value is generated) #define MU_ENUM_2_VALUE_COUNT(...) ((MU_COUNT_ARG(__VA_ARGS__) / 2) + 1) #define MU_ENUM_TO_STRING(enumName, enumValue) MU_C2(enumName, Strings)(enumValue) #define MU_STRING_TO_ENUM(stringValue, enumName, addressOfEnumVariable) MU_C2(enumName, _FromString)(stringValue, addressOfEnumVariable) #define MU_EMPTY() #define MACRO_UTILS_DELAY(id) id MU_EMPTY MU_LPAREN ) #define MU_DEFINE_ENUMERATION_CONSTANT_2(enumerationConstant, constantExpression) enumerationConstant = constantExpression, #define MU_DECLARE_ENUM_STRINGS_2(enumIdentifier, ...) extern const char* MU_C3(MU_, enumIdentifier,_ToString)(enumIdentifier enumerationConstant); #define MU_DEFINE_ENUM_2_WITHOUT_INVALID(enumIdentifier, ... ) typedef enum MU_C2(enumIdentifier, _TAG) {MU_FOR_EACH_2(MU_DEFINE_ENUMERATION_CONSTANT_2, __VA_ARGS__)} enumIdentifier; \ MU_DECLARE_ENUM_STRINGS_2(enumIdentifier, __VA_ARGS__) // this macro is a wrapper on top of MU_DEFINE_ENUM, adding an _INVALID value as the first enum value in the enum #define MU_DEFINE_ENUM_2(enumName, ...) \ MU_DEFINE_ENUM_2_WITHOUT_INVALID(enumName, MU_C2(enumName, _INVALID), (int)0xDDDDDDDD, __VA_ARGS__) typedef struct ENUM_VALUE_AND_STRING_TAG { int value; const char* valueAsString; }ENUM_VALUE_AND_STRING; #define MU_DEFINE_ENUM_VALUE_AND_STRING(enumerationConstant, constantExpression) {enumerationConstant, MU_TOSTRING(enumerationConstant)}, #define MU_DEFINE_ENUM_STRINGS_2(enumIdentifier, ... ) static const ENUM_VALUE_AND_STRING MU_C2(enumIdentifier, _ValuesAndStrings)[MU_DIV2(MU_COUNT_ARG(__VA_ARGS__))] ={MU_FOR_EACH_2(MU_DEFINE_ENUM_VALUE_AND_STRING, __VA_ARGS__)}; \ const char* MU_C3(MU_, enumIdentifier,_ToString)(enumIdentifier value) \ { \ for(size_t i=0;i X(e,f) X(c,d) X (a, b) in this order */ #define MU_FOR_EACH_2_REVERSE(MACRO_TO_INVOKE, ...) MU_C2(MU_FOR_EACH_2_REVERSE_, MU_C1(MU_COUNT_ARG(__VA_ARGS__))) MU_LPAREN MACRO_TO_INVOKE, __VA_ARGS__) #else #define MU_FOR_EACH_2(MACRO_TO_INVOKE, ...) MU_C2(MU_FOR_EACH_2_, MU_C1(MU_COUNT_ARG(__VA_ARGS__))) ( MACRO_TO_INVOKE, __VA_ARGS__) #define MU_FOR_EACH_2_COUNTED(MACRO_TO_INVOKE, ...) MU_C2(MU_FOR_EACH_2_COUNTED_, MU_C1(MU_COUNT_ARG(__VA_ARGS__))) ( MACRO_TO_INVOKE, __VA_ARGS__) #define MU_FOR_EACH_1_COUNTED(MACRO_TO_INVOKE, ...) MU_C2(MU_FOR_EACH_1_COUNTED_, MU_C1(MU_COUNT_ARG(__VA_ARGS__))) ( MACRO_TO_INVOKE, __VA_ARGS__) #define MU_FOR_EACH_2_REVERSE(MACRO_TO_INVOKE, ...) MU_C2(MU_FOR_EACH_2_REVERSE_, MU_C1(MU_COUNT_ARG(__VA_ARGS__))) ( MACRO_TO_INVOKE, __VA_ARGS__) #endif #ifdef _MSC_VER #define MU_EXPAND_OR_MU_C1(x) x #else #define MU_EXPAND_OR_MU_C1(...) __VA_ARGS__ #endif #define MU_EXPAND_ARGS(...) __VA_ARGS__ #define MU_EXPAND_TWICE(...) MU_EXPAND_ARGS(__VA_ARGS__) #define MU_DO_0(MACRO, ...) \ MACRO(0, __VA_ARGS__) #define MU_DO_1(MACRO, ...) \ MACRO(1, __VA_ARGS__) \ MU_DO_0(MACRO, __VA_ARGS__) #define MU_DO_2(MACRO, ...) \ MACRO(2, __VA_ARGS__) \ MU_DO_1(MACRO, __VA_ARGS__) #define MU_DO_3(MACRO, ...) \ MACRO(3, __VA_ARGS__) \ MU_DO_2(MACRO, __VA_ARGS__) #define MU_DO_4(MACRO, ...) \ MACRO(4, __VA_ARGS__) \ MU_DO_3(MACRO, __VA_ARGS__) #define MU_DO_5(MACRO, ...) \ MACRO(5, __VA_ARGS__) \ MU_DO_4(MACRO, __VA_ARGS__) #define MU_DO_6(MACRO, ...) \ MACRO(6, __VA_ARGS__) \ MU_DO_5(MACRO, __VA_ARGS__) #define MU_DO_7(MACRO, ...) \ MACRO(7, __VA_ARGS__) \ MU_DO_6(MACRO, __VA_ARGS__) #define MU_DO_8(MACRO, ...) \ MACRO(8, __VA_ARGS__) \ MU_DO_7(MACRO, __VA_ARGS__) #define MU_DO_9(MACRO, ...) \ MACRO(9, __VA_ARGS__) \ MU_DO_8(MACRO, __VA_ARGS__) #define MU_DO_10(MACRO, ...) \ MACRO(10, __VA_ARGS__) \ MU_DO_9(MACRO, __VA_ARGS__) #define MU_DO_11(MACRO, ...) \ MACRO(11, __VA_ARGS__) \ MU_DO_10(MACRO, __VA_ARGS__) #define MU_DO_12(MACRO, ...) \ MACRO(12, __VA_ARGS__) \ MU_DO_11(MACRO, __VA_ARGS__) #define MU_DO_13(MACRO, ...) \ MACRO(13, __VA_ARGS__) \ MU_DO_12(MACRO, __VA_ARGS__) #define MU_DO_14(MACRO, ...) \ MACRO(14, __VA_ARGS__) \ MU_DO_13(MACRO, __VA_ARGS__) #define MU_DO_15(MACRO, ...) \ MACRO(15, __VA_ARGS__) \ MU_DO_14(MACRO, __VA_ARGS__) #define MU_DO_16(MACRO, ...) \ MACRO(16, __VA_ARGS__) \ MU_DO_15(MACRO, __VA_ARGS__) #define MU_DO_17(MACRO, ...) \ MACRO(17, __VA_ARGS__) \ MU_DO_16(MACRO, __VA_ARGS__) #define MU_DO_18(MACRO, ...) \ MACRO(18, __VA_ARGS__) \ MU_DO_17(MACRO, __VA_ARGS__) #define MU_DO_19(MACRO, ...) \ MACRO(19, __VA_ARGS__) \ MU_DO_18(MACRO, __VA_ARGS__) #define MU_DO_20(MACRO, ...) \ MACRO(20, __VA_ARGS__) \ MU_DO_19(MACRO, __VA_ARGS__) #define MU_DO_21(MACRO, ...) \ MACRO(21, __VA_ARGS__) \ MU_DO_20(MACRO, __VA_ARGS__) #define MU_DO_22(MACRO, ...) \ MACRO(22, __VA_ARGS__) \ MU_DO_21(MACRO, __VA_ARGS__) #define MU_DO_23(MACRO, ...) \ MACRO(23, __VA_ARGS__) \ MU_DO_22(MACRO, __VA_ARGS__) #define MU_DO_24(MACRO, ...) \ MACRO(24, __VA_ARGS__) \ MU_DO_23(MACRO, __VA_ARGS__) #define MU_DO_25(MACRO, ...) \ MACRO(25, __VA_ARGS__) \ MU_DO_24(MACRO, __VA_ARGS__) #define MU_DO_26(MACRO, ...) \ MACRO(26, __VA_ARGS__) \ MU_DO_25(MACRO, __VA_ARGS__) #define MU_DO_27(MACRO, ...) \ MACRO(27, __VA_ARGS__) \ MU_DO_26(MACRO, __VA_ARGS__) #define MU_DO_28(MACRO, ...) \ MACRO(28, __VA_ARGS__) \ MU_DO_27(MACRO, __VA_ARGS__) #define MU_DO_29(MACRO, ...) \ MACRO(29, __VA_ARGS__) \ MU_DO_28(MACRO, __VA_ARGS__) #define MU_DO_30(MACRO, ...) \ MACRO(30, __VA_ARGS__) \ MU_DO_29(MACRO, __VA_ARGS__) #define MU_DO_31(MACRO, ...) \ MACRO(31, __VA_ARGS__) \ MU_DO_30(MACRO, __VA_ARGS__) #define MU_DO_32(MACRO, ...) \ MACRO(32, __VA_ARGS__) \ MU_DO_31(MACRO, __VA_ARGS__) #define MU_DO_33(MACRO, ...) \ MACRO(33, __VA_ARGS__) \ MU_DO_32(MACRO, __VA_ARGS__) #define MU_DO_34(MACRO, ...) \ MACRO(34, __VA_ARGS__) \ MU_DO_33(MACRO, __VA_ARGS__) #define MU_DO_35(MACRO, ...) \ MACRO(35, __VA_ARGS__) \ MU_DO_34(MACRO, __VA_ARGS__) #define MU_DO_36(MACRO, ...) \ MACRO(36, __VA_ARGS__) \ MU_DO_35(MACRO, __VA_ARGS__) #define MU_DO_37(MACRO, ...) \ MACRO(37, __VA_ARGS__) \ MU_DO_36(MACRO, __VA_ARGS__) #define MU_DO_38(MACRO, ...) \ MACRO(38, __VA_ARGS__) \ MU_DO_37(MACRO, __VA_ARGS__) #define MU_DO_39(MACRO, ...) \ MACRO(39, __VA_ARGS__) \ MU_DO_38(MACRO, __VA_ARGS__) #define MU_DO_40(MACRO, ...) \ MACRO(40, __VA_ARGS__) \ MU_DO_39(MACRO, __VA_ARGS__) #define MU_DO_41(MACRO, ...) \ MACRO(41, __VA_ARGS__) \ MU_DO_40(MACRO, __VA_ARGS__) #define MU_DO_42(MACRO, ...) \ MACRO(42, __VA_ARGS__) \ MU_DO_41(MACRO, __VA_ARGS__) #define MU_DO_43(MACRO, ...) \ MACRO(43, __VA_ARGS__) \ MU_DO_42(MACRO, __VA_ARGS__) #define MU_DO_44(MACRO, ...) \ MACRO(44, __VA_ARGS__) \ MU_DO_43(MACRO, __VA_ARGS__) #define MU_DO_45(MACRO, ...) \ MACRO(45, __VA_ARGS__) \ MU_DO_44(MACRO, __VA_ARGS__) #define MU_DO_46(MACRO, ...) \ MACRO(46, __VA_ARGS__) \ MU_DO_45(MACRO, __VA_ARGS__) #define MU_DO_47(MACRO, ...) \ MACRO(47, __VA_ARGS__) \ MU_DO_46(MACRO, __VA_ARGS__) #define MU_DO_48(MACRO, ...) \ MACRO(48, __VA_ARGS__) \ MU_DO_47(MACRO, __VA_ARGS__) #define MU_DO_49(MACRO, ...) \ MACRO(49, __VA_ARGS__) \ MU_DO_48(MACRO, __VA_ARGS__) #define MU_DO_50(MACRO, ...) \ MACRO(50, __VA_ARGS__) \ MU_DO_49(MACRO, __VA_ARGS__) #define MU_DO_51(MACRO, ...) \ MACRO(51, __VA_ARGS__) \ MU_DO_50(MACRO, __VA_ARGS__) #define MU_DO_52(MACRO, ...) \ MACRO(52, __VA_ARGS__) \ MU_DO_51(MACRO, __VA_ARGS__) #define MU_DO_53(MACRO, ...) \ MACRO(53, __VA_ARGS__) \ MU_DO_52(MACRO, __VA_ARGS__) #define MU_DO_54(MACRO, ...) \ MACRO(54, __VA_ARGS__) \ MU_DO_53(MACRO, __VA_ARGS__) #define MU_DO_55(MACRO, ...) \ MACRO(55, __VA_ARGS__) \ MU_DO_54(MACRO, __VA_ARGS__) #define MU_DO_56(MACRO, ...) \ MACRO(56, __VA_ARGS__) \ MU_DO_55(MACRO, __VA_ARGS__) #define MU_DO_57(MACRO, ...) \ MACRO(57, __VA_ARGS__) \ MU_DO_56(MACRO, __VA_ARGS__) #define MU_DO_58(MACRO, ...) \ MACRO(58, __VA_ARGS__) \ MU_DO_57(MACRO, __VA_ARGS__) #define MU_DO_59(MACRO, ...) \ MACRO(59, __VA_ARGS__) \ MU_DO_58(MACRO, __VA_ARGS__) #define MU_DO_60(MACRO, ...) \ MACRO(60, __VA_ARGS__) \ MU_DO_59(MACRO, __VA_ARGS__) #define MU_DO_61(MACRO, ...) \ MACRO(61, __VA_ARGS__) \ MU_DO_60(MACRO, __VA_ARGS__) #define MU_DO_62(MACRO, ...) \ MACRO(62, __VA_ARGS__) \ MU_DO_61(MACRO, __VA_ARGS__) #define MU_DO_63(MACRO, ...) \ MACRO(63, __VA_ARGS__) \ MU_DO_62(MACRO, __VA_ARGS__) #define MU_DO_64(MACRO, ...) \ MACRO(64, __VA_ARGS__) \ MU_DO_63(MACRO, __VA_ARGS__) #define MU_DO_65(MACRO, ...) \ MACRO(65, __VA_ARGS__) \ MU_DO_64(MACRO, __VA_ARGS__) #define MU_DO_66(MACRO, ...) \ MACRO(66, __VA_ARGS__) \ MU_DO_65(MACRO, __VA_ARGS__) #define MU_DO_67(MACRO, ...) \ MACRO(67, __VA_ARGS__) \ MU_DO_66(MACRO, __VA_ARGS__) #define MU_DO_68(MACRO, ...) \ MACRO(68, __VA_ARGS__) \ MU_DO_67(MACRO, __VA_ARGS__) #define MU_DO_69(MACRO, ...) \ MACRO(69, __VA_ARGS__) \ MU_DO_68(MACRO, __VA_ARGS__) #define MU_DO_70(MACRO, ...) \ MACRO(70, __VA_ARGS__) \ MU_DO_69(MACRO, __VA_ARGS__) #define MU_DO_71(MACRO, ...) \ MACRO(71, __VA_ARGS__) \ MU_DO_70(MACRO, __VA_ARGS__) #define MU_DO_72(MACRO, ...) \ MACRO(72, __VA_ARGS__) \ MU_DO_71(MACRO, __VA_ARGS__) #define MU_DO_73(MACRO, ...) \ MACRO(73, __VA_ARGS__) \ MU_DO_72(MACRO, __VA_ARGS__) #define MU_DO_74(MACRO, ...) \ MACRO(74, __VA_ARGS__) \ MU_DO_73(MACRO, __VA_ARGS__) #define MU_DO_75(MACRO, ...) \ MACRO(75, __VA_ARGS__) \ MU_DO_74(MACRO, __VA_ARGS__) #define MU_DO_76(MACRO, ...) \ MACRO(76, __VA_ARGS__) \ MU_DO_75(MACRO, __VA_ARGS__) #define MU_DO_77(MACRO, ...) \ MACRO(77, __VA_ARGS__) \ MU_DO_76(MACRO, __VA_ARGS__) #define MU_DO_78(MACRO, ...) \ MACRO(78, __VA_ARGS__) \ MU_DO_77(MACRO, __VA_ARGS__) #define MU_DO_79(MACRO, ...) \ MACRO(79, __VA_ARGS__) \ MU_DO_78(MACRO, __VA_ARGS__) #define MU_DO_80(MACRO, ...) \ MACRO(80, __VA_ARGS__) \ MU_DO_79(MACRO, __VA_ARGS__) #define MU_DO_81(MACRO, ...) \ MACRO(81, __VA_ARGS__) \ MU_DO_80(MACRO, __VA_ARGS__) #define MU_DO_82(MACRO, ...) \ MACRO(82, __VA_ARGS__) \ MU_DO_81(MACRO, __VA_ARGS__) #define MU_DO_83(MACRO, ...) \ MACRO(83, __VA_ARGS__) \ MU_DO_82(MACRO, __VA_ARGS__) #define MU_DO_84(MACRO, ...) \ MACRO(84, __VA_ARGS__) \ MU_DO_83(MACRO, __VA_ARGS__) #define MU_DO_85(MACRO, ...) \ MACRO(85, __VA_ARGS__) \ MU_DO_84(MACRO, __VA_ARGS__) #define MU_DO_86(MACRO, ...) \ MACRO(86, __VA_ARGS__) \ MU_DO_85(MACRO, __VA_ARGS__) #define MU_DO_87(MACRO, ...) \ MACRO(87, __VA_ARGS__) \ MU_DO_86(MACRO, __VA_ARGS__) #define MU_DO_88(MACRO, ...) \ MACRO(88, __VA_ARGS__) \ MU_DO_87(MACRO, __VA_ARGS__) #define MU_DO_89(MACRO, ...) \ MACRO(89, __VA_ARGS__) \ MU_DO_88(MACRO, __VA_ARGS__) #define MU_DO_90(MACRO, ...) \ MACRO(90, __VA_ARGS__) \ MU_DO_89(MACRO, __VA_ARGS__) #define MU_DO_91(MACRO, ...) \ MACRO(91, __VA_ARGS__) \ MU_DO_90(MACRO, __VA_ARGS__) #define MU_DO_92(MACRO, ...) \ MACRO(92, __VA_ARGS__) \ MU_DO_91(MACRO, __VA_ARGS__) #define MU_DO_93(MACRO, ...) \ MACRO(93, __VA_ARGS__) \ MU_DO_92(MACRO, __VA_ARGS__) #define MU_DO_94(MACRO, ...) \ MACRO(94, __VA_ARGS__) \ MU_DO_93(MACRO, __VA_ARGS__) #define MU_DO_95(MACRO, ...) \ MACRO(95, __VA_ARGS__) \ MU_DO_94(MACRO, __VA_ARGS__) #define MU_DO_96(MACRO, ...) \ MACRO(96, __VA_ARGS__) \ MU_DO_95(MACRO, __VA_ARGS__) #define MU_DO_97(MACRO, ...) \ MACRO(97, __VA_ARGS__) \ MU_DO_96(MACRO, __VA_ARGS__) #define MU_DO_98(MACRO, ...) \ MACRO(98, __VA_ARGS__) \ MU_DO_97(MACRO, __VA_ARGS__) #define MU_DO_99(MACRO, ...) \ MACRO(99, __VA_ARGS__) \ MU_DO_98(MACRO, __VA_ARGS__) #define MU_DO_100(MACRO, ...) \ MACRO(100, __VA_ARGS__) \ MU_DO_99(MACRO, __VA_ARGS__) #define MU_DO_101(MACRO, ...) \ MACRO(101, __VA_ARGS__) \ MU_DO_100(MACRO, __VA_ARGS__) #define MU_DO_102(MACRO, ...) \ MACRO(102, __VA_ARGS__) \ MU_DO_101(MACRO, __VA_ARGS__) #define MU_DO_103(MACRO, ...) \ MACRO(103, __VA_ARGS__) \ MU_DO_102(MACRO, __VA_ARGS__) #define MU_DO_104(MACRO, ...) \ MACRO(104, __VA_ARGS__) \ MU_DO_103(MACRO, __VA_ARGS__) #define MU_DO_105(MACRO, ...) \ MACRO(105, __VA_ARGS__) \ MU_DO_104(MACRO, __VA_ARGS__) #define MU_DO_106(MACRO, ...) \ MACRO(106, __VA_ARGS__) \ MU_DO_105(MACRO, __VA_ARGS__) #define MU_DO_107(MACRO, ...) \ MACRO(107, __VA_ARGS__) \ MU_DO_106(MACRO, __VA_ARGS__) #define MU_DO_108(MACRO, ...) \ MACRO(108, __VA_ARGS__) \ MU_DO_107(MACRO, __VA_ARGS__) #define MU_DO_109(MACRO, ...) \ MACRO(109, __VA_ARGS__) \ MU_DO_108(MACRO, __VA_ARGS__) #define MU_DO_110(MACRO, ...) \ MACRO(110, __VA_ARGS__) \ MU_DO_109(MACRO, __VA_ARGS__) #define MU_DO_111(MACRO, ...) \ MACRO(111, __VA_ARGS__) \ MU_DO_110(MACRO, __VA_ARGS__) #define MU_DO_112(MACRO, ...) \ MACRO(112, __VA_ARGS__) \ MU_DO_111(MACRO, __VA_ARGS__) #define MU_DO_113(MACRO, ...) \ MACRO(113, __VA_ARGS__) \ MU_DO_112(MACRO, __VA_ARGS__) #define MU_DO_114(MACRO, ...) \ MACRO(114, __VA_ARGS__) \ MU_DO_113(MACRO, __VA_ARGS__) #define MU_DO_115(MACRO, ...) \ MACRO(115, __VA_ARGS__) \ MU_DO_114(MACRO, __VA_ARGS__) #define MU_DO_116(MACRO, ...) \ MACRO(116, __VA_ARGS__) \ MU_DO_115(MACRO, __VA_ARGS__) #define MU_DO_117(MACRO, ...) \ MACRO(117, __VA_ARGS__) \ MU_DO_116(MACRO, __VA_ARGS__) #define MU_DO_118(MACRO, ...) \ MACRO(118, __VA_ARGS__) \ MU_DO_117(MACRO, __VA_ARGS__) #define MU_DO_119(MACRO, ...) \ MACRO(119, __VA_ARGS__) \ MU_DO_118(MACRO, __VA_ARGS__) #define MU_DO_120(MACRO, ...) \ MACRO(120, __VA_ARGS__) \ MU_DO_119(MACRO, __VA_ARGS__) #define MU_DO_121(MACRO, ...) \ MACRO(121, __VA_ARGS__) \ MU_DO_120(MACRO, __VA_ARGS__) #define MU_DO_122(MACRO, ...) \ MACRO(122, __VA_ARGS__) \ MU_DO_121(MACRO, __VA_ARGS__) #define MU_DO_123(MACRO, ...) \ MACRO(123, __VA_ARGS__) \ MU_DO_122(MACRO, __VA_ARGS__) #define MU_DO_124(MACRO, ...) \ MACRO(124, __VA_ARGS__) \ MU_DO_123(MACRO, __VA_ARGS__) #define MU_DO_125(MACRO, ...) \ MACRO(125, __VA_ARGS__) \ MU_DO_124(MACRO, __VA_ARGS__) #define MU_DO_126(MACRO, ...) \ MACRO(126, __VA_ARGS__) \ MU_DO_125(MACRO, __VA_ARGS__) #define MU_DO_127(MACRO, ...) \ MACRO(127, __VA_ARGS__) \ MU_DO_126(MACRO, __VA_ARGS__) #define MU_DO_128(MACRO, ...) \ MACRO(128, __VA_ARGS__) \ MU_DO_127(MACRO, __VA_ARGS__) #define MU_DO_129(MACRO, ...) \ MACRO(129, __VA_ARGS__) \ MU_DO_128(MACRO, __VA_ARGS__) #define MU_DO_130(MACRO, ...) \ MACRO(130, __VA_ARGS__) \ MU_DO_129(MACRO, __VA_ARGS__) #define MU_DO_131(MACRO, ...) \ MACRO(131, __VA_ARGS__) \ MU_DO_130(MACRO, __VA_ARGS__) #define MU_DO_132(MACRO, ...) \ MACRO(132, __VA_ARGS__) \ MU_DO_131(MACRO, __VA_ARGS__) #define MU_DO_133(MACRO, ...) \ MACRO(133, __VA_ARGS__) \ MU_DO_132(MACRO, __VA_ARGS__) #define MU_DO_134(MACRO, ...) \ MACRO(134, __VA_ARGS__) \ MU_DO_133(MACRO, __VA_ARGS__) #define MU_DO_135(MACRO, ...) \ MACRO(135, __VA_ARGS__) \ MU_DO_134(MACRO, __VA_ARGS__) #define MU_DO_136(MACRO, ...) \ MACRO(136, __VA_ARGS__) \ MU_DO_135(MACRO, __VA_ARGS__) #define MU_DO_137(MACRO, ...) \ MACRO(137, __VA_ARGS__) \ MU_DO_136(MACRO, __VA_ARGS__) #define MU_DO_138(MACRO, ...) \ MACRO(138, __VA_ARGS__) \ MU_DO_137(MACRO, __VA_ARGS__) #define MU_DO_139(MACRO, ...) \ MACRO(139, __VA_ARGS__) \ MU_DO_138(MACRO, __VA_ARGS__) #define MU_DO_140(MACRO, ...) \ MACRO(140, __VA_ARGS__) \ MU_DO_139(MACRO, __VA_ARGS__) #define MU_DO_141(MACRO, ...) \ MACRO(141, __VA_ARGS__) \ MU_DO_140(MACRO, __VA_ARGS__) #define MU_DO_142(MACRO, ...) \ MACRO(142, __VA_ARGS__) \ MU_DO_141(MACRO, __VA_ARGS__) #define MU_DO_143(MACRO, ...) \ MACRO(143, __VA_ARGS__) \ MU_DO_142(MACRO, __VA_ARGS__) #define MU_DO_144(MACRO, ...) \ MACRO(144, __VA_ARGS__) \ MU_DO_143(MACRO, __VA_ARGS__) #define MU_DO_145(MACRO, ...) \ MACRO(145, __VA_ARGS__) \ MU_DO_144(MACRO, __VA_ARGS__) #define MU_DO_146(MACRO, ...) \ MACRO(146, __VA_ARGS__) \ MU_DO_145(MACRO, __VA_ARGS__) #define MU_DO_147(MACRO, ...) \ MACRO(147, __VA_ARGS__) \ MU_DO_146(MACRO, __VA_ARGS__) #define MU_DO_148(MACRO, ...) \ MACRO(148, __VA_ARGS__) \ MU_DO_147(MACRO, __VA_ARGS__) #define MU_DO_149(MACRO, ...) \ MACRO(149, __VA_ARGS__) \ MU_DO_148(MACRO, __VA_ARGS__) #define MU_DO_150(MACRO, ...) \ MACRO(150, __VA_ARGS__) \ MU_DO_149(MACRO, __VA_ARGS__) #define MU_DO_151(MACRO, ...) \ MACRO(151, __VA_ARGS__) \ MU_DO_150(MACRO, __VA_ARGS__) #define MU_DO_152(MACRO, ...) \ MACRO(152, __VA_ARGS__) \ MU_DO_151(MACRO, __VA_ARGS__) #define MU_DO_153(MACRO, ...) \ MACRO(153, __VA_ARGS__) \ MU_DO_152(MACRO, __VA_ARGS__) #define MU_DO_154(MACRO, ...) \ MACRO(154, __VA_ARGS__) \ MU_DO_153(MACRO, __VA_ARGS__) #define MU_DO_155(MACRO, ...) \ MACRO(155, __VA_ARGS__) \ MU_DO_154(MACRO, __VA_ARGS__) #define MU_DO_156(MACRO, ...) \ MACRO(156, __VA_ARGS__) \ MU_DO_155(MACRO, __VA_ARGS__) #define MU_DO_157(MACRO, ...) \ MACRO(157, __VA_ARGS__) \ MU_DO_156(MACRO, __VA_ARGS__) #define MU_DO_158(MACRO, ...) \ MACRO(158, __VA_ARGS__) \ MU_DO_157(MACRO, __VA_ARGS__) #define MU_DO_159(MACRO, ...) \ MACRO(159, __VA_ARGS__) \ MU_DO_158(MACRO, __VA_ARGS__) #define MU_DO_160(MACRO, ...) \ MACRO(160, __VA_ARGS__) \ MU_DO_159(MACRO, __VA_ARGS__) #define MU_DO_161(MACRO, ...) \ MACRO(161, __VA_ARGS__) \ MU_DO_160(MACRO, __VA_ARGS__) #define MU_DO_162(MACRO, ...) \ MACRO(162, __VA_ARGS__) \ MU_DO_161(MACRO, __VA_ARGS__) #define MU_DO_163(MACRO, ...) \ MACRO(163, __VA_ARGS__) \ MU_DO_162(MACRO, __VA_ARGS__) #define MU_DO_164(MACRO, ...) \ MACRO(164, __VA_ARGS__) \ MU_DO_163(MACRO, __VA_ARGS__) #define MU_DO_165(MACRO, ...) \ MACRO(165, __VA_ARGS__) \ MU_DO_164(MACRO, __VA_ARGS__) #define MU_DO_166(MACRO, ...) \ MACRO(166, __VA_ARGS__) \ MU_DO_165(MACRO, __VA_ARGS__) #define MU_DO_167(MACRO, ...) \ MACRO(167, __VA_ARGS__) \ MU_DO_166(MACRO, __VA_ARGS__) #define MU_DO_168(MACRO, ...) \ MACRO(168, __VA_ARGS__) \ MU_DO_167(MACRO, __VA_ARGS__) #define MU_DO_169(MACRO, ...) \ MACRO(169, __VA_ARGS__) \ MU_DO_168(MACRO, __VA_ARGS__) #define MU_DO_170(MACRO, ...) \ MACRO(170, __VA_ARGS__) \ MU_DO_169(MACRO, __VA_ARGS__) #define MU_DO_171(MACRO, ...) \ MACRO(171, __VA_ARGS__) \ MU_DO_170(MACRO, __VA_ARGS__) #define MU_DO_172(MACRO, ...) \ MACRO(172, __VA_ARGS__) \ MU_DO_171(MACRO, __VA_ARGS__) #define MU_DO_173(MACRO, ...) \ MACRO(173, __VA_ARGS__) \ MU_DO_172(MACRO, __VA_ARGS__) #define MU_DO_174(MACRO, ...) \ MACRO(174, __VA_ARGS__) \ MU_DO_173(MACRO, __VA_ARGS__) #define MU_DO_175(MACRO, ...) \ MACRO(175, __VA_ARGS__) \ MU_DO_174(MACRO, __VA_ARGS__) #define MU_DO_176(MACRO, ...) \ MACRO(176, __VA_ARGS__) \ MU_DO_175(MACRO, __VA_ARGS__) #define MU_DO_177(MACRO, ...) \ MACRO(177, __VA_ARGS__) \ MU_DO_176(MACRO, __VA_ARGS__) #define MU_DO_178(MACRO, ...) \ MACRO(178, __VA_ARGS__) \ MU_DO_177(MACRO, __VA_ARGS__) #define MU_DO_179(MACRO, ...) \ MACRO(179, __VA_ARGS__) \ MU_DO_178(MACRO, __VA_ARGS__) #define MU_DO_180(MACRO, ...) \ MACRO(180, __VA_ARGS__) \ MU_DO_179(MACRO, __VA_ARGS__) #define MU_DO_181(MACRO, ...) \ MACRO(181, __VA_ARGS__) \ MU_DO_180(MACRO, __VA_ARGS__) #define MU_DO_182(MACRO, ...) \ MACRO(182, __VA_ARGS__) \ MU_DO_181(MACRO, __VA_ARGS__) #define MU_DO_183(MACRO, ...) \ MACRO(183, __VA_ARGS__) \ MU_DO_182(MACRO, __VA_ARGS__) #define MU_DO_184(MACRO, ...) \ MACRO(184, __VA_ARGS__) \ MU_DO_183(MACRO, __VA_ARGS__) #define MU_DO_185(MACRO, ...) \ MACRO(185, __VA_ARGS__) \ MU_DO_184(MACRO, __VA_ARGS__) #define MU_DO_186(MACRO, ...) \ MACRO(186, __VA_ARGS__) \ MU_DO_185(MACRO, __VA_ARGS__) #define MU_DO_187(MACRO, ...) \ MACRO(187, __VA_ARGS__) \ MU_DO_186(MACRO, __VA_ARGS__) #define MU_DO_188(MACRO, ...) \ MACRO(188, __VA_ARGS__) \ MU_DO_187(MACRO, __VA_ARGS__) #define MU_DO_189(MACRO, ...) \ MACRO(189, __VA_ARGS__) \ MU_DO_188(MACRO, __VA_ARGS__) #define MU_DO_190(MACRO, ...) \ MACRO(190, __VA_ARGS__) \ MU_DO_189(MACRO, __VA_ARGS__) #define MU_DO_191(MACRO, ...) \ MACRO(191, __VA_ARGS__) \ MU_DO_190(MACRO, __VA_ARGS__) #define MU_DO_192(MACRO, ...) \ MACRO(192, __VA_ARGS__) \ MU_DO_191(MACRO, __VA_ARGS__) #define MU_DO_193(MACRO, ...) \ MACRO(193, __VA_ARGS__) \ MU_DO_192(MACRO, __VA_ARGS__) #define MU_DO_194(MACRO, ...) \ MACRO(194, __VA_ARGS__) \ MU_DO_193(MACRO, __VA_ARGS__) #define MU_DO_195(MACRO, ...) \ MACRO(195, __VA_ARGS__) \ MU_DO_194(MACRO, __VA_ARGS__) #define MU_DO_196(MACRO, ...) \ MACRO(196, __VA_ARGS__) \ MU_DO_195(MACRO, __VA_ARGS__) #define MU_DO_197(MACRO, ...) \ MACRO(197, __VA_ARGS__) \ MU_DO_196(MACRO, __VA_ARGS__) #define MU_DO_198(MACRO, ...) \ MACRO(198, __VA_ARGS__) \ MU_DO_197(MACRO, __VA_ARGS__) #define MU_DO_199(MACRO, ...) \ MACRO(199, __VA_ARGS__) \ MU_DO_198(MACRO, __VA_ARGS__) #define MU_DO_200(MACRO, ...) \ MACRO(200, __VA_ARGS__) \ MU_DO_199(MACRO, __VA_ARGS__) #define MU_DO_201(MACRO, ...) \ MACRO(201, __VA_ARGS__) \ MU_DO_200(MACRO, __VA_ARGS__) #define MU_DO_202(MACRO, ...) \ MACRO(202, __VA_ARGS__) \ MU_DO_201(MACRO, __VA_ARGS__) #define MU_DO_203(MACRO, ...) \ MACRO(203, __VA_ARGS__) \ MU_DO_202(MACRO, __VA_ARGS__) #define MU_DO_204(MACRO, ...) \ MACRO(204, __VA_ARGS__) \ MU_DO_203(MACRO, __VA_ARGS__) #define MU_DO_205(MACRO, ...) \ MACRO(205, __VA_ARGS__) \ MU_DO_204(MACRO, __VA_ARGS__) #define MU_DO_206(MACRO, ...) \ MACRO(206, __VA_ARGS__) \ MU_DO_205(MACRO, __VA_ARGS__) #define MU_DO_207(MACRO, ...) \ MACRO(207, __VA_ARGS__) \ MU_DO_206(MACRO, __VA_ARGS__) #define MU_DO_208(MACRO, ...) \ MACRO(208, __VA_ARGS__) \ MU_DO_207(MACRO, __VA_ARGS__) #define MU_DO_209(MACRO, ...) \ MACRO(209, __VA_ARGS__) \ MU_DO_208(MACRO, __VA_ARGS__) #define MU_DO_210(MACRO, ...) \ MACRO(210, __VA_ARGS__) \ MU_DO_209(MACRO, __VA_ARGS__) #define MU_DO_211(MACRO, ...) \ MACRO(211, __VA_ARGS__) \ MU_DO_210(MACRO, __VA_ARGS__) #define MU_DO_212(MACRO, ...) \ MACRO(212, __VA_ARGS__) \ MU_DO_211(MACRO, __VA_ARGS__) #define MU_DO_213(MACRO, ...) \ MACRO(213, __VA_ARGS__) \ MU_DO_212(MACRO, __VA_ARGS__) #define MU_DO_214(MACRO, ...) \ MACRO(214, __VA_ARGS__) \ MU_DO_213(MACRO, __VA_ARGS__) #define MU_DO_215(MACRO, ...) \ MACRO(215, __VA_ARGS__) \ MU_DO_214(MACRO, __VA_ARGS__) #define MU_DO_216(MACRO, ...) \ MACRO(216, __VA_ARGS__) \ MU_DO_215(MACRO, __VA_ARGS__) #define MU_DO_217(MACRO, ...) \ MACRO(217, __VA_ARGS__) \ MU_DO_216(MACRO, __VA_ARGS__) #define MU_DO_218(MACRO, ...) \ MACRO(218, __VA_ARGS__) \ MU_DO_217(MACRO, __VA_ARGS__) #define MU_DO_219(MACRO, ...) \ MACRO(219, __VA_ARGS__) \ MU_DO_218(MACRO, __VA_ARGS__) #define MU_DO_220(MACRO, ...) \ MACRO(220, __VA_ARGS__) \ MU_DO_219(MACRO, __VA_ARGS__) #define MU_DO_221(MACRO, ...) \ MACRO(221, __VA_ARGS__) \ MU_DO_220(MACRO, __VA_ARGS__) #define MU_DO_222(MACRO, ...) \ MACRO(222, __VA_ARGS__) \ MU_DO_221(MACRO, __VA_ARGS__) #define MU_DO_223(MACRO, ...) \ MACRO(223, __VA_ARGS__) \ MU_DO_222(MACRO, __VA_ARGS__) #define MU_DO_224(MACRO, ...) \ MACRO(224, __VA_ARGS__) \ MU_DO_223(MACRO, __VA_ARGS__) #define MU_DO_225(MACRO, ...) \ MACRO(225, __VA_ARGS__) \ MU_DO_224(MACRO, __VA_ARGS__) #define MU_DO_226(MACRO, ...) \ MACRO(226, __VA_ARGS__) \ MU_DO_225(MACRO, __VA_ARGS__) #define MU_DO_227(MACRO, ...) \ MACRO(227, __VA_ARGS__) \ MU_DO_226(MACRO, __VA_ARGS__) #define MU_DO_228(MACRO, ...) \ MACRO(228, __VA_ARGS__) \ MU_DO_227(MACRO, __VA_ARGS__) #define MU_DO_229(MACRO, ...) \ MACRO(229, __VA_ARGS__) \ MU_DO_228(MACRO, __VA_ARGS__) #define MU_DO_230(MACRO, ...) \ MACRO(230, __VA_ARGS__) \ MU_DO_229(MACRO, __VA_ARGS__) #define MU_DO_231(MACRO, ...) \ MACRO(231, __VA_ARGS__) \ MU_DO_230(MACRO, __VA_ARGS__) #define MU_DO_232(MACRO, ...) \ MACRO(232, __VA_ARGS__) \ MU_DO_231(MACRO, __VA_ARGS__) #define MU_DO_233(MACRO, ...) \ MACRO(233, __VA_ARGS__) \ MU_DO_232(MACRO, __VA_ARGS__) #define MU_DO_234(MACRO, ...) \ MACRO(234, __VA_ARGS__) \ MU_DO_233(MACRO, __VA_ARGS__) #define MU_DO_235(MACRO, ...) \ MACRO(235, __VA_ARGS__) \ MU_DO_234(MACRO, __VA_ARGS__) #define MU_DO_236(MACRO, ...) \ MACRO(236, __VA_ARGS__) \ MU_DO_235(MACRO, __VA_ARGS__) #define MU_DO_237(MACRO, ...) \ MACRO(237, __VA_ARGS__) \ MU_DO_236(MACRO, __VA_ARGS__) #define MU_DO_238(MACRO, ...) \ MACRO(238, __VA_ARGS__) \ MU_DO_237(MACRO, __VA_ARGS__) #define MU_DO_239(MACRO, ...) \ MACRO(239, __VA_ARGS__) \ MU_DO_238(MACRO, __VA_ARGS__) #define MU_DO_240(MACRO, ...) \ MACRO(240, __VA_ARGS__) \ MU_DO_239(MACRO, __VA_ARGS__) #define MU_DO_241(MACRO, ...) \ MACRO(241, __VA_ARGS__) \ MU_DO_240(MACRO, __VA_ARGS__) #define MU_DO_242(MACRO, ...) \ MACRO(242, __VA_ARGS__) \ MU_DO_241(MACRO, __VA_ARGS__) #define MU_DO_243(MACRO, ...) \ MACRO(243, __VA_ARGS__) \ MU_DO_242(MACRO, __VA_ARGS__) #define MU_DO_244(MACRO, ...) \ MACRO(244, __VA_ARGS__) \ MU_DO_243(MACRO, __VA_ARGS__) #define MU_DO_245(MACRO, ...) \ MACRO(245, __VA_ARGS__) \ MU_DO_244(MACRO, __VA_ARGS__) #define MU_DO_246(MACRO, ...) \ MACRO(246, __VA_ARGS__) \ MU_DO_245(MACRO, __VA_ARGS__) #define MU_DO_247(MACRO, ...) \ MACRO(247, __VA_ARGS__) \ MU_DO_246(MACRO, __VA_ARGS__) #define MU_DO_248(MACRO, ...) \ MACRO(248, __VA_ARGS__) \ MU_DO_247(MACRO, __VA_ARGS__) #define MU_DO_249(MACRO, ...) \ MACRO(249, __VA_ARGS__) \ MU_DO_248(MACRO, __VA_ARGS__) #define MU_DO_250(MACRO, ...) \ MACRO(250, __VA_ARGS__) \ MU_DO_249(MACRO, __VA_ARGS__) #define MU_DO_251(MACRO, ...) \ MACRO(251, __VA_ARGS__) \ MU_DO_250(MACRO, __VA_ARGS__) #define MU_DO_252(MACRO, ...) \ MACRO(252, __VA_ARGS__) \ MU_DO_251(MACRO, __VA_ARGS__) #define MU_DO_253(MACRO, ...) \ MACRO(253, __VA_ARGS__) \ MU_DO_252(MACRO, __VA_ARGS__) #define MU_DO_254(MACRO, ...) \ MACRO(254, __VA_ARGS__) \ MU_DO_253(MACRO, __VA_ARGS__) #define MU_DO_255(MACRO, ...) \ MACRO(255, __VA_ARGS__) \ MU_DO_254(MACRO, __VA_ARGS__) #define MU_DO_256(MACRO, ...) \ MACRO(256, __VA_ARGS__) \ MU_DO_255(MACRO, __VA_ARGS__) #define MU_DO_257(MACRO, ...) \ MACRO(257, __VA_ARGS__) \ MU_DO_256(MACRO, __VA_ARGS__) #define MU_DO_258(MACRO, ...) \ MACRO(258, __VA_ARGS__) \ MU_DO_257(MACRO, __VA_ARGS__) #define MU_DO_259(MACRO, ...) \ MACRO(259, __VA_ARGS__) \ MU_DO_258(MACRO, __VA_ARGS__) #define MU_DO_260(MACRO, ...) \ MACRO(260, __VA_ARGS__) \ MU_DO_259(MACRO, __VA_ARGS__) #define MU_DO_261(MACRO, ...) \ MACRO(261, __VA_ARGS__) \ MU_DO_260(MACRO, __VA_ARGS__) #define MU_DO_262(MACRO, ...) \ MACRO(262, __VA_ARGS__) \ MU_DO_261(MACRO, __VA_ARGS__) #define MU_DO_263(MACRO, ...) \ MACRO(263, __VA_ARGS__) \ MU_DO_262(MACRO, __VA_ARGS__) #define MU_DO_264(MACRO, ...) \ MACRO(264, __VA_ARGS__) \ MU_DO_263(MACRO, __VA_ARGS__) #define MU_DO_265(MACRO, ...) \ MACRO(265, __VA_ARGS__) \ MU_DO_264(MACRO, __VA_ARGS__) #define MU_DO_266(MACRO, ...) \ MACRO(266, __VA_ARGS__) \ MU_DO_265(MACRO, __VA_ARGS__) #define MU_DO_267(MACRO, ...) \ MACRO(267, __VA_ARGS__) \ MU_DO_266(MACRO, __VA_ARGS__) #define MU_DO_268(MACRO, ...) \ MACRO(268, __VA_ARGS__) \ MU_DO_267(MACRO, __VA_ARGS__) #define MU_DO_269(MACRO, ...) \ MACRO(269, __VA_ARGS__) \ MU_DO_268(MACRO, __VA_ARGS__) #define MU_DO_270(MACRO, ...) \ MACRO(270, __VA_ARGS__) \ MU_DO_269(MACRO, __VA_ARGS__) #define MU_DO_271(MACRO, ...) \ MACRO(271, __VA_ARGS__) \ MU_DO_270(MACRO, __VA_ARGS__) #define MU_DO_272(MACRO, ...) \ MACRO(272, __VA_ARGS__) \ MU_DO_271(MACRO, __VA_ARGS__) #define MU_DO_273(MACRO, ...) \ MACRO(273, __VA_ARGS__) \ MU_DO_272(MACRO, __VA_ARGS__) #define MU_DO_274(MACRO, ...) \ MACRO(274, __VA_ARGS__) \ MU_DO_273(MACRO, __VA_ARGS__) #define MU_DO_275(MACRO, ...) \ MACRO(275, __VA_ARGS__) \ MU_DO_274(MACRO, __VA_ARGS__) #define MU_DO_276(MACRO, ...) \ MACRO(276, __VA_ARGS__) \ MU_DO_275(MACRO, __VA_ARGS__) #define MU_DO_277(MACRO, ...) \ MACRO(277, __VA_ARGS__) \ MU_DO_276(MACRO, __VA_ARGS__) #define MU_DO_278(MACRO, ...) \ MACRO(278, __VA_ARGS__) \ MU_DO_277(MACRO, __VA_ARGS__) #define MU_DO_279(MACRO, ...) \ MACRO(279, __VA_ARGS__) \ MU_DO_278(MACRO, __VA_ARGS__) #define MU_DO_280(MACRO, ...) \ MACRO(280, __VA_ARGS__) \ MU_DO_279(MACRO, __VA_ARGS__) #define MU_DO_281(MACRO, ...) \ MACRO(281, __VA_ARGS__) \ MU_DO_280(MACRO, __VA_ARGS__) #define MU_DO_282(MACRO, ...) \ MACRO(282, __VA_ARGS__) \ MU_DO_281(MACRO, __VA_ARGS__) #define MU_DO_283(MACRO, ...) \ MACRO(283, __VA_ARGS__) \ MU_DO_282(MACRO, __VA_ARGS__) #define MU_DO_284(MACRO, ...) \ MACRO(284, __VA_ARGS__) \ MU_DO_283(MACRO, __VA_ARGS__) #define MU_DO_285(MACRO, ...) \ MACRO(285, __VA_ARGS__) \ MU_DO_284(MACRO, __VA_ARGS__) #define MU_DO_286(MACRO, ...) \ MACRO(286, __VA_ARGS__) \ MU_DO_285(MACRO, __VA_ARGS__) #define MU_DO_287(MACRO, ...) \ MACRO(287, __VA_ARGS__) \ MU_DO_286(MACRO, __VA_ARGS__) #define MU_DO_288(MACRO, ...) \ MACRO(288, __VA_ARGS__) \ MU_DO_287(MACRO, __VA_ARGS__) #define MU_DO_289(MACRO, ...) \ MACRO(289, __VA_ARGS__) \ MU_DO_288(MACRO, __VA_ARGS__) #define MU_DO_290(MACRO, ...) \ MACRO(290, __VA_ARGS__) \ MU_DO_289(MACRO, __VA_ARGS__) #define MU_DO_291(MACRO, ...) \ MACRO(291, __VA_ARGS__) \ MU_DO_290(MACRO, __VA_ARGS__) #define MU_DO_292(MACRO, ...) \ MACRO(292, __VA_ARGS__) \ MU_DO_291(MACRO, __VA_ARGS__) #define MU_DO_293(MACRO, ...) \ MACRO(293, __VA_ARGS__) \ MU_DO_292(MACRO, __VA_ARGS__) #define MU_DO_294(MACRO, ...) \ MACRO(294, __VA_ARGS__) \ MU_DO_293(MACRO, __VA_ARGS__) #define MU_DO_295(MACRO, ...) \ MACRO(295, __VA_ARGS__) \ MU_DO_294(MACRO, __VA_ARGS__) #define MU_DO_296(MACRO, ...) \ MACRO(296, __VA_ARGS__) \ MU_DO_295(MACRO, __VA_ARGS__) #define MU_DO_297(MACRO, ...) \ MACRO(297, __VA_ARGS__) \ MU_DO_296(MACRO, __VA_ARGS__) #define MU_DO_298(MACRO, ...) \ MACRO(298, __VA_ARGS__) \ MU_DO_297(MACRO, __VA_ARGS__) #define MU_DO_299(MACRO, ...) \ MACRO(299, __VA_ARGS__) \ MU_DO_298(MACRO, __VA_ARGS__) #define MU_DO_300(MACRO, ...) \ MACRO(300, __VA_ARGS__) \ MU_DO_299(MACRO, __VA_ARGS__) #define MU_DO_301(MACRO, ...) \ MACRO(301, __VA_ARGS__) \ MU_DO_300(MACRO, __VA_ARGS__) #define MU_DO_302(MACRO, ...) \ MACRO(302, __VA_ARGS__) \ MU_DO_301(MACRO, __VA_ARGS__) #define MU_DO_303(MACRO, ...) \ MACRO(303, __VA_ARGS__) \ MU_DO_302(MACRO, __VA_ARGS__) #define MU_DO_304(MACRO, ...) \ MACRO(304, __VA_ARGS__) \ MU_DO_303(MACRO, __VA_ARGS__) #define MU_DO_305(MACRO, ...) \ MACRO(305, __VA_ARGS__) \ MU_DO_304(MACRO, __VA_ARGS__) #define MU_DO_306(MACRO, ...) \ MACRO(306, __VA_ARGS__) \ MU_DO_305(MACRO, __VA_ARGS__) #define MU_DO_307(MACRO, ...) \ MACRO(307, __VA_ARGS__) \ MU_DO_306(MACRO, __VA_ARGS__) #define MU_DO_308(MACRO, ...) \ MACRO(308, __VA_ARGS__) \ MU_DO_307(MACRO, __VA_ARGS__) #define MU_DO_309(MACRO, ...) \ MACRO(309, __VA_ARGS__) \ MU_DO_308(MACRO, __VA_ARGS__) #define MU_DO_310(MACRO, ...) \ MACRO(310, __VA_ARGS__) \ MU_DO_309(MACRO, __VA_ARGS__) #define MU_DO_311(MACRO, ...) \ MACRO(311, __VA_ARGS__) \ MU_DO_310(MACRO, __VA_ARGS__) #define MU_DO_312(MACRO, ...) \ MACRO(312, __VA_ARGS__) \ MU_DO_311(MACRO, __VA_ARGS__) #define MU_DO_313(MACRO, ...) \ MACRO(313, __VA_ARGS__) \ MU_DO_312(MACRO, __VA_ARGS__) #define MU_DO_314(MACRO, ...) \ MACRO(314, __VA_ARGS__) \ MU_DO_313(MACRO, __VA_ARGS__) #define MU_DO_315(MACRO, ...) \ MACRO(315, __VA_ARGS__) \ MU_DO_314(MACRO, __VA_ARGS__) #define MU_DO_316(MACRO, ...) \ MACRO(316, __VA_ARGS__) \ MU_DO_315(MACRO, __VA_ARGS__) #define MU_DO_317(MACRO, ...) \ MACRO(317, __VA_ARGS__) \ MU_DO_316(MACRO, __VA_ARGS__) #define MU_DO_318(MACRO, ...) \ MACRO(318, __VA_ARGS__) \ MU_DO_317(MACRO, __VA_ARGS__) #define MU_DO_319(MACRO, ...) \ MACRO(319, __VA_ARGS__) \ MU_DO_318(MACRO, __VA_ARGS__) #define MU_DO_320(MACRO, ...) \ MACRO(320, __VA_ARGS__) \ MU_DO_319(MACRO, __VA_ARGS__) #define MU_DO_321(MACRO, ...) \ MACRO(321, __VA_ARGS__) \ MU_DO_320(MACRO, __VA_ARGS__) #define MU_DO_322(MACRO, ...) \ MACRO(322, __VA_ARGS__) \ MU_DO_321(MACRO, __VA_ARGS__) #define MU_DO_323(MACRO, ...) \ MACRO(323, __VA_ARGS__) \ MU_DO_322(MACRO, __VA_ARGS__) #define MU_DO_324(MACRO, ...) \ MACRO(324, __VA_ARGS__) \ MU_DO_323(MACRO, __VA_ARGS__) #define MU_DO_325(MACRO, ...) \ MACRO(325, __VA_ARGS__) \ MU_DO_324(MACRO, __VA_ARGS__) #define MU_DO_326(MACRO, ...) \ MACRO(326, __VA_ARGS__) \ MU_DO_325(MACRO, __VA_ARGS__) #define MU_DO_327(MACRO, ...) \ MACRO(327, __VA_ARGS__) \ MU_DO_326(MACRO, __VA_ARGS__) #define MU_DO_328(MACRO, ...) \ MACRO(328, __VA_ARGS__) \ MU_DO_327(MACRO, __VA_ARGS__) #define MU_DO_329(MACRO, ...) \ MACRO(329, __VA_ARGS__) \ MU_DO_328(MACRO, __VA_ARGS__) #define MU_DO_330(MACRO, ...) \ MACRO(330, __VA_ARGS__) \ MU_DO_329(MACRO, __VA_ARGS__) #define MU_DO_331(MACRO, ...) \ MACRO(331, __VA_ARGS__) \ MU_DO_330(MACRO, __VA_ARGS__) #define MU_DO_332(MACRO, ...) \ MACRO(332, __VA_ARGS__) \ MU_DO_331(MACRO, __VA_ARGS__) #define MU_DO_333(MACRO, ...) \ MACRO(333, __VA_ARGS__) \ MU_DO_332(MACRO, __VA_ARGS__) #define MU_DO_334(MACRO, ...) \ MACRO(334, __VA_ARGS__) \ MU_DO_333(MACRO, __VA_ARGS__) #define MU_DO_335(MACRO, ...) \ MACRO(335, __VA_ARGS__) \ MU_DO_334(MACRO, __VA_ARGS__) #define MU_DO_336(MACRO, ...) \ MACRO(336, __VA_ARGS__) \ MU_DO_335(MACRO, __VA_ARGS__) #define MU_DO_337(MACRO, ...) \ MACRO(337, __VA_ARGS__) \ MU_DO_336(MACRO, __VA_ARGS__) #define MU_DO_338(MACRO, ...) \ MACRO(338, __VA_ARGS__) \ MU_DO_337(MACRO, __VA_ARGS__) #define MU_DO_339(MACRO, ...) \ MACRO(339, __VA_ARGS__) \ MU_DO_338(MACRO, __VA_ARGS__) #define MU_DO_340(MACRO, ...) \ MACRO(340, __VA_ARGS__) \ MU_DO_339(MACRO, __VA_ARGS__) #define MU_DO_341(MACRO, ...) \ MACRO(341, __VA_ARGS__) \ MU_DO_340(MACRO, __VA_ARGS__) #define MU_DO_342(MACRO, ...) \ MACRO(342, __VA_ARGS__) \ MU_DO_341(MACRO, __VA_ARGS__) #define MU_DO_343(MACRO, ...) \ MACRO(343, __VA_ARGS__) \ MU_DO_342(MACRO, __VA_ARGS__) #define MU_DO_344(MACRO, ...) \ MACRO(344, __VA_ARGS__) \ MU_DO_343(MACRO, __VA_ARGS__) #define MU_DO_345(MACRO, ...) \ MACRO(345, __VA_ARGS__) \ MU_DO_344(MACRO, __VA_ARGS__) #define MU_DO_346(MACRO, ...) \ MACRO(346, __VA_ARGS__) \ MU_DO_345(MACRO, __VA_ARGS__) #define MU_DO_347(MACRO, ...) \ MACRO(347, __VA_ARGS__) \ MU_DO_346(MACRO, __VA_ARGS__) #define MU_DO_348(MACRO, ...) \ MACRO(348, __VA_ARGS__) \ MU_DO_347(MACRO, __VA_ARGS__) #define MU_DO_349(MACRO, ...) \ MACRO(349, __VA_ARGS__) \ MU_DO_348(MACRO, __VA_ARGS__) #define MU_DO_350(MACRO, ...) \ MACRO(350, __VA_ARGS__) \ MU_DO_349(MACRO, __VA_ARGS__) #define MU_DO_351(MACRO, ...) \ MACRO(351, __VA_ARGS__) \ MU_DO_350(MACRO, __VA_ARGS__) #define MU_DO_352(MACRO, ...) \ MACRO(352, __VA_ARGS__) \ MU_DO_351(MACRO, __VA_ARGS__) #define MU_DO_353(MACRO, ...) \ MACRO(353, __VA_ARGS__) \ MU_DO_352(MACRO, __VA_ARGS__) #define MU_DO_354(MACRO, ...) \ MACRO(354, __VA_ARGS__) \ MU_DO_353(MACRO, __VA_ARGS__) #define MU_DO_355(MACRO, ...) \ MACRO(355, __VA_ARGS__) \ MU_DO_354(MACRO, __VA_ARGS__) #define MU_DO_356(MACRO, ...) \ MACRO(356, __VA_ARGS__) \ MU_DO_355(MACRO, __VA_ARGS__) #define MU_DO_357(MACRO, ...) \ MACRO(357, __VA_ARGS__) \ MU_DO_356(MACRO, __VA_ARGS__) #define MU_DO_358(MACRO, ...) \ MACRO(358, __VA_ARGS__) \ MU_DO_357(MACRO, __VA_ARGS__) #define MU_DO_359(MACRO, ...) \ MACRO(359, __VA_ARGS__) \ MU_DO_358(MACRO, __VA_ARGS__) #define MU_DO_360(MACRO, ...) \ MACRO(360, __VA_ARGS__) \ MU_DO_359(MACRO, __VA_ARGS__) #define MU_DO_361(MACRO, ...) \ MACRO(361, __VA_ARGS__) \ MU_DO_360(MACRO, __VA_ARGS__) #define MU_DO_362(MACRO, ...) \ MACRO(362, __VA_ARGS__) \ MU_DO_361(MACRO, __VA_ARGS__) #define MU_DO_363(MACRO, ...) \ MACRO(363, __VA_ARGS__) \ MU_DO_362(MACRO, __VA_ARGS__) #define MU_DO_364(MACRO, ...) \ MACRO(364, __VA_ARGS__) \ MU_DO_363(MACRO, __VA_ARGS__) #define MU_DO_365(MACRO, ...) \ MACRO(365, __VA_ARGS__) \ MU_DO_364(MACRO, __VA_ARGS__) #define MU_DO_366(MACRO, ...) \ MACRO(366, __VA_ARGS__) \ MU_DO_365(MACRO, __VA_ARGS__) #define MU_DO_367(MACRO, ...) \ MACRO(367, __VA_ARGS__) \ MU_DO_366(MACRO, __VA_ARGS__) #define MU_DO_368(MACRO, ...) \ MACRO(368, __VA_ARGS__) \ MU_DO_367(MACRO, __VA_ARGS__) #define MU_DO_369(MACRO, ...) \ MACRO(369, __VA_ARGS__) \ MU_DO_368(MACRO, __VA_ARGS__) #define MU_DO_370(MACRO, ...) \ MACRO(370, __VA_ARGS__) \ MU_DO_369(MACRO, __VA_ARGS__) #define MU_DO_371(MACRO, ...) \ MACRO(371, __VA_ARGS__) \ MU_DO_370(MACRO, __VA_ARGS__) #define MU_DO_372(MACRO, ...) \ MACRO(372, __VA_ARGS__) \ MU_DO_371(MACRO, __VA_ARGS__) #define MU_DO_373(MACRO, ...) \ MACRO(373, __VA_ARGS__) \ MU_DO_372(MACRO, __VA_ARGS__) #define MU_DO_374(MACRO, ...) \ MACRO(374, __VA_ARGS__) \ MU_DO_373(MACRO, __VA_ARGS__) #define MU_DO_375(MACRO, ...) \ MACRO(375, __VA_ARGS__) \ MU_DO_374(MACRO, __VA_ARGS__) #define MU_DO_376(MACRO, ...) \ MACRO(376, __VA_ARGS__) \ MU_DO_375(MACRO, __VA_ARGS__) #define MU_DO_377(MACRO, ...) \ MACRO(377, __VA_ARGS__) \ MU_DO_376(MACRO, __VA_ARGS__) #define MU_DO_378(MACRO, ...) \ MACRO(378, __VA_ARGS__) \ MU_DO_377(MACRO, __VA_ARGS__) #define MU_DO_379(MACRO, ...) \ MACRO(379, __VA_ARGS__) \ MU_DO_378(MACRO, __VA_ARGS__) #define MU_DO_380(MACRO, ...) \ MACRO(380, __VA_ARGS__) \ MU_DO_379(MACRO, __VA_ARGS__) #define MU_DO_381(MACRO, ...) \ MACRO(381, __VA_ARGS__) \ MU_DO_380(MACRO, __VA_ARGS__) #define MU_DO_382(MACRO, ...) \ MACRO(382, __VA_ARGS__) \ MU_DO_381(MACRO, __VA_ARGS__) #define MU_DO_383(MACRO, ...) \ MACRO(383, __VA_ARGS__) \ MU_DO_382(MACRO, __VA_ARGS__) #define MU_DO_384(MACRO, ...) \ MACRO(384, __VA_ARGS__) \ MU_DO_383(MACRO, __VA_ARGS__) #define MU_DO_385(MACRO, ...) \ MACRO(385, __VA_ARGS__) \ MU_DO_384(MACRO, __VA_ARGS__) #define MU_DO_386(MACRO, ...) \ MACRO(386, __VA_ARGS__) \ MU_DO_385(MACRO, __VA_ARGS__) #define MU_DO_387(MACRO, ...) \ MACRO(387, __VA_ARGS__) \ MU_DO_386(MACRO, __VA_ARGS__) #define MU_DO_388(MACRO, ...) \ MACRO(388, __VA_ARGS__) \ MU_DO_387(MACRO, __VA_ARGS__) #define MU_DO_389(MACRO, ...) \ MACRO(389, __VA_ARGS__) \ MU_DO_388(MACRO, __VA_ARGS__) #define MU_DO_390(MACRO, ...) \ MACRO(390, __VA_ARGS__) \ MU_DO_389(MACRO, __VA_ARGS__) #define MU_DO_391(MACRO, ...) \ MACRO(391, __VA_ARGS__) \ MU_DO_390(MACRO, __VA_ARGS__) #define MU_DO_392(MACRO, ...) \ MACRO(392, __VA_ARGS__) \ MU_DO_391(MACRO, __VA_ARGS__) #define MU_DO_393(MACRO, ...) \ MACRO(393, __VA_ARGS__) \ MU_DO_392(MACRO, __VA_ARGS__) #define MU_DO_394(MACRO, ...) \ MACRO(394, __VA_ARGS__) \ MU_DO_393(MACRO, __VA_ARGS__) #define MU_DO_395(MACRO, ...) \ MACRO(395, __VA_ARGS__) \ MU_DO_394(MACRO, __VA_ARGS__) #define MU_DO_396(MACRO, ...) \ MACRO(396, __VA_ARGS__) \ MU_DO_395(MACRO, __VA_ARGS__) #define MU_DO_397(MACRO, ...) \ MACRO(397, __VA_ARGS__) \ MU_DO_396(MACRO, __VA_ARGS__) #define MU_DO_398(MACRO, ...) \ MACRO(398, __VA_ARGS__) \ MU_DO_397(MACRO, __VA_ARGS__) #define MU_DO_399(MACRO, ...) \ MACRO(399, __VA_ARGS__) \ MU_DO_398(MACRO, __VA_ARGS__) #define MU_DO_400(MACRO, ...) \ MACRO(400, __VA_ARGS__) \ MU_DO_399(MACRO, __VA_ARGS__) #define MU_DO_401(MACRO, ...) \ MACRO(401, __VA_ARGS__) \ MU_DO_400(MACRO, __VA_ARGS__) #define MU_DO_402(MACRO, ...) \ MACRO(402, __VA_ARGS__) \ MU_DO_401(MACRO, __VA_ARGS__) #define MU_DO_403(MACRO, ...) \ MACRO(403, __VA_ARGS__) \ MU_DO_402(MACRO, __VA_ARGS__) #define MU_DO_404(MACRO, ...) \ MACRO(404, __VA_ARGS__) \ MU_DO_403(MACRO, __VA_ARGS__) #define MU_DO_405(MACRO, ...) \ MACRO(405, __VA_ARGS__) \ MU_DO_404(MACRO, __VA_ARGS__) #define MU_DO_406(MACRO, ...) \ MACRO(406, __VA_ARGS__) \ MU_DO_405(MACRO, __VA_ARGS__) #define MU_DO_407(MACRO, ...) \ MACRO(407, __VA_ARGS__) \ MU_DO_406(MACRO, __VA_ARGS__) #define MU_DO_408(MACRO, ...) \ MACRO(408, __VA_ARGS__) \ MU_DO_407(MACRO, __VA_ARGS__) #define MU_DO_409(MACRO, ...) \ MACRO(409, __VA_ARGS__) \ MU_DO_408(MACRO, __VA_ARGS__) #define MU_DO_410(MACRO, ...) \ MACRO(410, __VA_ARGS__) \ MU_DO_409(MACRO, __VA_ARGS__) #define MU_DO_411(MACRO, ...) \ MACRO(411, __VA_ARGS__) \ MU_DO_410(MACRO, __VA_ARGS__) #define MU_DO_412(MACRO, ...) \ MACRO(412, __VA_ARGS__) \ MU_DO_411(MACRO, __VA_ARGS__) #define MU_DO_413(MACRO, ...) \ MACRO(413, __VA_ARGS__) \ MU_DO_412(MACRO, __VA_ARGS__) #define MU_DO_414(MACRO, ...) \ MACRO(414, __VA_ARGS__) \ MU_DO_413(MACRO, __VA_ARGS__) #define MU_DO_415(MACRO, ...) \ MACRO(415, __VA_ARGS__) \ MU_DO_414(MACRO, __VA_ARGS__) #define MU_DO_416(MACRO, ...) \ MACRO(416, __VA_ARGS__) \ MU_DO_415(MACRO, __VA_ARGS__) #define MU_DO_417(MACRO, ...) \ MACRO(417, __VA_ARGS__) \ MU_DO_416(MACRO, __VA_ARGS__) #define MU_DO_418(MACRO, ...) \ MACRO(418, __VA_ARGS__) \ MU_DO_417(MACRO, __VA_ARGS__) #define MU_DO_419(MACRO, ...) \ MACRO(419, __VA_ARGS__) \ MU_DO_418(MACRO, __VA_ARGS__) #define MU_DO_420(MACRO, ...) \ MACRO(420, __VA_ARGS__) \ MU_DO_419(MACRO, __VA_ARGS__) #define MU_DO_421(MACRO, ...) \ MACRO(421, __VA_ARGS__) \ MU_DO_420(MACRO, __VA_ARGS__) #define MU_DO_422(MACRO, ...) \ MACRO(422, __VA_ARGS__) \ MU_DO_421(MACRO, __VA_ARGS__) #define MU_DO_423(MACRO, ...) \ MACRO(423, __VA_ARGS__) \ MU_DO_422(MACRO, __VA_ARGS__) #define MU_DO_424(MACRO, ...) \ MACRO(424, __VA_ARGS__) \ MU_DO_423(MACRO, __VA_ARGS__) #define MU_DO_425(MACRO, ...) \ MACRO(425, __VA_ARGS__) \ MU_DO_424(MACRO, __VA_ARGS__) #define MU_DO_426(MACRO, ...) \ MACRO(426, __VA_ARGS__) \ MU_DO_425(MACRO, __VA_ARGS__) #define MU_DO_427(MACRO, ...) \ MACRO(427, __VA_ARGS__) \ MU_DO_426(MACRO, __VA_ARGS__) #define MU_DO_428(MACRO, ...) \ MACRO(428, __VA_ARGS__) \ MU_DO_427(MACRO, __VA_ARGS__) #define MU_DO_429(MACRO, ...) \ MACRO(429, __VA_ARGS__) \ MU_DO_428(MACRO, __VA_ARGS__) #define MU_DO_430(MACRO, ...) \ MACRO(430, __VA_ARGS__) \ MU_DO_429(MACRO, __VA_ARGS__) #define MU_DO_431(MACRO, ...) \ MACRO(431, __VA_ARGS__) \ MU_DO_430(MACRO, __VA_ARGS__) #define MU_DO_432(MACRO, ...) \ MACRO(432, __VA_ARGS__) \ MU_DO_431(MACRO, __VA_ARGS__) #define MU_DO_433(MACRO, ...) \ MACRO(433, __VA_ARGS__) \ MU_DO_432(MACRO, __VA_ARGS__) #define MU_DO_434(MACRO, ...) \ MACRO(434, __VA_ARGS__) \ MU_DO_433(MACRO, __VA_ARGS__) #define MU_DO_435(MACRO, ...) \ MACRO(435, __VA_ARGS__) \ MU_DO_434(MACRO, __VA_ARGS__) #define MU_DO_436(MACRO, ...) \ MACRO(436, __VA_ARGS__) \ MU_DO_435(MACRO, __VA_ARGS__) #define MU_DO_437(MACRO, ...) \ MACRO(437, __VA_ARGS__) \ MU_DO_436(MACRO, __VA_ARGS__) #define MU_DO_438(MACRO, ...) \ MACRO(438, __VA_ARGS__) \ MU_DO_437(MACRO, __VA_ARGS__) #define MU_DO_439(MACRO, ...) \ MACRO(439, __VA_ARGS__) \ MU_DO_438(MACRO, __VA_ARGS__) #define MU_DO_440(MACRO, ...) \ MACRO(440, __VA_ARGS__) \ MU_DO_439(MACRO, __VA_ARGS__) #define MU_DO_441(MACRO, ...) \ MACRO(441, __VA_ARGS__) \ MU_DO_440(MACRO, __VA_ARGS__) #define MU_DO_442(MACRO, ...) \ MACRO(442, __VA_ARGS__) \ MU_DO_441(MACRO, __VA_ARGS__) #define MU_DO_443(MACRO, ...) \ MACRO(443, __VA_ARGS__) \ MU_DO_442(MACRO, __VA_ARGS__) #define MU_DO_444(MACRO, ...) \ MACRO(444, __VA_ARGS__) \ MU_DO_443(MACRO, __VA_ARGS__) #define MU_DO_445(MACRO, ...) \ MACRO(445, __VA_ARGS__) \ MU_DO_444(MACRO, __VA_ARGS__) #define MU_DO_446(MACRO, ...) \ MACRO(446, __VA_ARGS__) \ MU_DO_445(MACRO, __VA_ARGS__) #define MU_DO_447(MACRO, ...) \ MACRO(447, __VA_ARGS__) \ MU_DO_446(MACRO, __VA_ARGS__) #define MU_DO_448(MACRO, ...) \ MACRO(448, __VA_ARGS__) \ MU_DO_447(MACRO, __VA_ARGS__) #define MU_DO_449(MACRO, ...) \ MACRO(449, __VA_ARGS__) \ MU_DO_448(MACRO, __VA_ARGS__) #define MU_DO_450(MACRO, ...) \ MACRO(450, __VA_ARGS__) \ MU_DO_449(MACRO, __VA_ARGS__) #define MU_DO_451(MACRO, ...) \ MACRO(451, __VA_ARGS__) \ MU_DO_450(MACRO, __VA_ARGS__) #define MU_DO_452(MACRO, ...) \ MACRO(452, __VA_ARGS__) \ MU_DO_451(MACRO, __VA_ARGS__) #define MU_DO_453(MACRO, ...) \ MACRO(453, __VA_ARGS__) \ MU_DO_452(MACRO, __VA_ARGS__) #define MU_DO_454(MACRO, ...) \ MACRO(454, __VA_ARGS__) \ MU_DO_453(MACRO, __VA_ARGS__) #define MU_DO_455(MACRO, ...) \ MACRO(455, __VA_ARGS__) \ MU_DO_454(MACRO, __VA_ARGS__) #define MU_DO_456(MACRO, ...) \ MACRO(456, __VA_ARGS__) \ MU_DO_455(MACRO, __VA_ARGS__) #define MU_DO_457(MACRO, ...) \ MACRO(457, __VA_ARGS__) \ MU_DO_456(MACRO, __VA_ARGS__) #define MU_DO_458(MACRO, ...) \ MACRO(458, __VA_ARGS__) \ MU_DO_457(MACRO, __VA_ARGS__) #define MU_DO_459(MACRO, ...) \ MACRO(459, __VA_ARGS__) \ MU_DO_458(MACRO, __VA_ARGS__) #define MU_DO_460(MACRO, ...) \ MACRO(460, __VA_ARGS__) \ MU_DO_459(MACRO, __VA_ARGS__) #define MU_DO_461(MACRO, ...) \ MACRO(461, __VA_ARGS__) \ MU_DO_460(MACRO, __VA_ARGS__) #define MU_DO_462(MACRO, ...) \ MACRO(462, __VA_ARGS__) \ MU_DO_461(MACRO, __VA_ARGS__) #define MU_DO_463(MACRO, ...) \ MACRO(463, __VA_ARGS__) \ MU_DO_462(MACRO, __VA_ARGS__) #define MU_DO_464(MACRO, ...) \ MACRO(464, __VA_ARGS__) \ MU_DO_463(MACRO, __VA_ARGS__) #define MU_DO_465(MACRO, ...) \ MACRO(465, __VA_ARGS__) \ MU_DO_464(MACRO, __VA_ARGS__) #define MU_DO_466(MACRO, ...) \ MACRO(466, __VA_ARGS__) \ MU_DO_465(MACRO, __VA_ARGS__) #define MU_DO_467(MACRO, ...) \ MACRO(467, __VA_ARGS__) \ MU_DO_466(MACRO, __VA_ARGS__) #define MU_DO_468(MACRO, ...) \ MACRO(468, __VA_ARGS__) \ MU_DO_467(MACRO, __VA_ARGS__) #define MU_DO_469(MACRO, ...) \ MACRO(469, __VA_ARGS__) \ MU_DO_468(MACRO, __VA_ARGS__) #define MU_DO_470(MACRO, ...) \ MACRO(470, __VA_ARGS__) \ MU_DO_469(MACRO, __VA_ARGS__) #define MU_DO_471(MACRO, ...) \ MACRO(471, __VA_ARGS__) \ MU_DO_470(MACRO, __VA_ARGS__) #define MU_DO_472(MACRO, ...) \ MACRO(472, __VA_ARGS__) \ MU_DO_471(MACRO, __VA_ARGS__) #define MU_DO_473(MACRO, ...) \ MACRO(473, __VA_ARGS__) \ MU_DO_472(MACRO, __VA_ARGS__) #define MU_DO_474(MACRO, ...) \ MACRO(474, __VA_ARGS__) \ MU_DO_473(MACRO, __VA_ARGS__) #define MU_DO_475(MACRO, ...) \ MACRO(475, __VA_ARGS__) \ MU_DO_474(MACRO, __VA_ARGS__) #define MU_DO_476(MACRO, ...) \ MACRO(476, __VA_ARGS__) \ MU_DO_475(MACRO, __VA_ARGS__) #define MU_DO_477(MACRO, ...) \ MACRO(477, __VA_ARGS__) \ MU_DO_476(MACRO, __VA_ARGS__) #define MU_DO_478(MACRO, ...) \ MACRO(478, __VA_ARGS__) \ MU_DO_477(MACRO, __VA_ARGS__) #define MU_DO_479(MACRO, ...) \ MACRO(479, __VA_ARGS__) \ MU_DO_478(MACRO, __VA_ARGS__) #define MU_DO_480(MACRO, ...) \ MACRO(480, __VA_ARGS__) \ MU_DO_479(MACRO, __VA_ARGS__) #define MU_DO_481(MACRO, ...) \ MACRO(481, __VA_ARGS__) \ MU_DO_480(MACRO, __VA_ARGS__) #define MU_DO_482(MACRO, ...) \ MACRO(482, __VA_ARGS__) \ MU_DO_481(MACRO, __VA_ARGS__) #define MU_DO_483(MACRO, ...) \ MACRO(483, __VA_ARGS__) \ MU_DO_482(MACRO, __VA_ARGS__) #define MU_DO_484(MACRO, ...) \ MACRO(484, __VA_ARGS__) \ MU_DO_483(MACRO, __VA_ARGS__) #define MU_DO_485(MACRO, ...) \ MACRO(485, __VA_ARGS__) \ MU_DO_484(MACRO, __VA_ARGS__) #define MU_DO_486(MACRO, ...) \ MACRO(486, __VA_ARGS__) \ MU_DO_485(MACRO, __VA_ARGS__) #define MU_DO_487(MACRO, ...) \ MACRO(487, __VA_ARGS__) \ MU_DO_486(MACRO, __VA_ARGS__) #define MU_DO_488(MACRO, ...) \ MACRO(488, __VA_ARGS__) \ MU_DO_487(MACRO, __VA_ARGS__) #define MU_DO_489(MACRO, ...) \ MACRO(489, __VA_ARGS__) \ MU_DO_488(MACRO, __VA_ARGS__) #define MU_DO_490(MACRO, ...) \ MACRO(490, __VA_ARGS__) \ MU_DO_489(MACRO, __VA_ARGS__) #define MU_DO_491(MACRO, ...) \ MACRO(491, __VA_ARGS__) \ MU_DO_490(MACRO, __VA_ARGS__) #define MU_DO_492(MACRO, ...) \ MACRO(492, __VA_ARGS__) \ MU_DO_491(MACRO, __VA_ARGS__) #define MU_DO_493(MACRO, ...) \ MACRO(493, __VA_ARGS__) \ MU_DO_492(MACRO, __VA_ARGS__) #define MU_DO_494(MACRO, ...) \ MACRO(494, __VA_ARGS__) \ MU_DO_493(MACRO, __VA_ARGS__) #define MU_DO_495(MACRO, ...) \ MACRO(495, __VA_ARGS__) \ MU_DO_494(MACRO, __VA_ARGS__) #define MU_DO_496(MACRO, ...) \ MACRO(496, __VA_ARGS__) \ MU_DO_495(MACRO, __VA_ARGS__) #define MU_DO_497(MACRO, ...) \ MACRO(497, __VA_ARGS__) \ MU_DO_496(MACRO, __VA_ARGS__) #define MU_DO_498(MACRO, ...) \ MACRO(498, __VA_ARGS__) \ MU_DO_497(MACRO, __VA_ARGS__) #define MU_DO_499(MACRO, ...) \ MACRO(499, __VA_ARGS__) \ MU_DO_498(MACRO, __VA_ARGS__) #define MU_DO_500(MACRO, ...) \ MACRO(500, __VA_ARGS__) \ MU_DO_499(MACRO, __VA_ARGS__) #define MU_DO_501(MACRO, ...) \ MACRO(501, __VA_ARGS__) \ MU_DO_500(MACRO, __VA_ARGS__) #define MU_DO_502(MACRO, ...) \ MACRO(502, __VA_ARGS__) \ MU_DO_501(MACRO, __VA_ARGS__) #define MU_DO_503(MACRO, ...) \ MACRO(503, __VA_ARGS__) \ MU_DO_502(MACRO, __VA_ARGS__) #define MU_DO_504(MACRO, ...) \ MACRO(504, __VA_ARGS__) \ MU_DO_503(MACRO, __VA_ARGS__) #define MU_DO_505(MACRO, ...) \ MACRO(505, __VA_ARGS__) \ MU_DO_504(MACRO, __VA_ARGS__) #define MU_DO_506(MACRO, ...) \ MACRO(506, __VA_ARGS__) \ MU_DO_505(MACRO, __VA_ARGS__) #define MU_DO_507(MACRO, ...) \ MACRO(507, __VA_ARGS__) \ MU_DO_506(MACRO, __VA_ARGS__) #define MU_DO_508(MACRO, ...) \ MACRO(508, __VA_ARGS__) \ MU_DO_507(MACRO, __VA_ARGS__) #define MU_DO_509(MACRO, ...) \ MACRO(509, __VA_ARGS__) \ MU_DO_508(MACRO, __VA_ARGS__) #define MU_DO_510(MACRO, ...) \ MACRO(510, __VA_ARGS__) \ MU_DO_509(MACRO, __VA_ARGS__) #define MU_DO_511(MACRO, ...) \ MACRO(511, __VA_ARGS__) \ MU_DO_510(MACRO, __VA_ARGS__) #define MU_DO_512(MACRO, ...) \ MACRO(512, __VA_ARGS__) \ MU_DO_511(MACRO, __VA_ARGS__) #define MU_DO_513(MACRO, ...) \ MACRO(513, __VA_ARGS__) \ MU_DO_512(MACRO, __VA_ARGS__) #define MU_DO_514(MACRO, ...) \ MACRO(514, __VA_ARGS__) \ MU_DO_513(MACRO, __VA_ARGS__) #define MU_DO_515(MACRO, ...) \ MACRO(515, __VA_ARGS__) \ MU_DO_514(MACRO, __VA_ARGS__) #define MU_DO_516(MACRO, ...) \ MACRO(516, __VA_ARGS__) \ MU_DO_515(MACRO, __VA_ARGS__) #define MU_DO_517(MACRO, ...) \ MACRO(517, __VA_ARGS__) \ MU_DO_516(MACRO, __VA_ARGS__) #define MU_DO_518(MACRO, ...) \ MACRO(518, __VA_ARGS__) \ MU_DO_517(MACRO, __VA_ARGS__) #define MU_DO_519(MACRO, ...) \ MACRO(519, __VA_ARGS__) \ MU_DO_518(MACRO, __VA_ARGS__) #define MU_DO_520(MACRO, ...) \ MACRO(520, __VA_ARGS__) \ MU_DO_519(MACRO, __VA_ARGS__) #define MU_DO_521(MACRO, ...) \ MACRO(521, __VA_ARGS__) \ MU_DO_520(MACRO, __VA_ARGS__) #define MU_DO_522(MACRO, ...) \ MACRO(522, __VA_ARGS__) \ MU_DO_521(MACRO, __VA_ARGS__) #define MU_DO_523(MACRO, ...) \ MACRO(523, __VA_ARGS__) \ MU_DO_522(MACRO, __VA_ARGS__) #define MU_DO_524(MACRO, ...) \ MACRO(524, __VA_ARGS__) \ MU_DO_523(MACRO, __VA_ARGS__) #define MU_DO_525(MACRO, ...) \ MACRO(525, __VA_ARGS__) \ MU_DO_524(MACRO, __VA_ARGS__) #define MU_DO_526(MACRO, ...) \ MACRO(526, __VA_ARGS__) \ MU_DO_525(MACRO, __VA_ARGS__) #define MU_DO_527(MACRO, ...) \ MACRO(527, __VA_ARGS__) \ MU_DO_526(MACRO, __VA_ARGS__) #define MU_DO_528(MACRO, ...) \ MACRO(528, __VA_ARGS__) \ MU_DO_527(MACRO, __VA_ARGS__) #define MU_DO_529(MACRO, ...) \ MACRO(529, __VA_ARGS__) \ MU_DO_528(MACRO, __VA_ARGS__) #define MU_DO_530(MACRO, ...) \ MACRO(530, __VA_ARGS__) \ MU_DO_529(MACRO, __VA_ARGS__) #define MU_DO_531(MACRO, ...) \ MACRO(531, __VA_ARGS__) \ MU_DO_530(MACRO, __VA_ARGS__) #define MU_DO_532(MACRO, ...) \ MACRO(532, __VA_ARGS__) \ MU_DO_531(MACRO, __VA_ARGS__) #define MU_DO_533(MACRO, ...) \ MACRO(533, __VA_ARGS__) \ MU_DO_532(MACRO, __VA_ARGS__) #define MU_DO_534(MACRO, ...) \ MACRO(534, __VA_ARGS__) \ MU_DO_533(MACRO, __VA_ARGS__) #define MU_DO_535(MACRO, ...) \ MACRO(535, __VA_ARGS__) \ MU_DO_534(MACRO, __VA_ARGS__) #define MU_DO_536(MACRO, ...) \ MACRO(536, __VA_ARGS__) \ MU_DO_535(MACRO, __VA_ARGS__) #define MU_DO_537(MACRO, ...) \ MACRO(537, __VA_ARGS__) \ MU_DO_536(MACRO, __VA_ARGS__) #define MU_DO_538(MACRO, ...) \ MACRO(538, __VA_ARGS__) \ MU_DO_537(MACRO, __VA_ARGS__) #define MU_DO_539(MACRO, ...) \ MACRO(539, __VA_ARGS__) \ MU_DO_538(MACRO, __VA_ARGS__) #define MU_DO_540(MACRO, ...) \ MACRO(540, __VA_ARGS__) \ MU_DO_539(MACRO, __VA_ARGS__) #define MU_DO_541(MACRO, ...) \ MACRO(541, __VA_ARGS__) \ MU_DO_540(MACRO, __VA_ARGS__) #define MU_DO_542(MACRO, ...) \ MACRO(542, __VA_ARGS__) \ MU_DO_541(MACRO, __VA_ARGS__) #define MU_DO_543(MACRO, ...) \ MACRO(543, __VA_ARGS__) \ MU_DO_542(MACRO, __VA_ARGS__) #define MU_DO_544(MACRO, ...) \ MACRO(544, __VA_ARGS__) \ MU_DO_543(MACRO, __VA_ARGS__) #define MU_DO_545(MACRO, ...) \ MACRO(545, __VA_ARGS__) \ MU_DO_544(MACRO, __VA_ARGS__) #define MU_DO_546(MACRO, ...) \ MACRO(546, __VA_ARGS__) \ MU_DO_545(MACRO, __VA_ARGS__) #define MU_DO_547(MACRO, ...) \ MACRO(547, __VA_ARGS__) \ MU_DO_546(MACRO, __VA_ARGS__) #define MU_DO_548(MACRO, ...) \ MACRO(548, __VA_ARGS__) \ MU_DO_547(MACRO, __VA_ARGS__) #define MU_DO_549(MACRO, ...) \ MACRO(549, __VA_ARGS__) \ MU_DO_548(MACRO, __VA_ARGS__) #define MU_DO_550(MACRO, ...) \ MACRO(550, __VA_ARGS__) \ MU_DO_549(MACRO, __VA_ARGS__) #define MU_DO_551(MACRO, ...) \ MACRO(551, __VA_ARGS__) \ MU_DO_550(MACRO, __VA_ARGS__) #define MU_DO_552(MACRO, ...) \ MACRO(552, __VA_ARGS__) \ MU_DO_551(MACRO, __VA_ARGS__) #define MU_DO_553(MACRO, ...) \ MACRO(553, __VA_ARGS__) \ MU_DO_552(MACRO, __VA_ARGS__) #define MU_DO_554(MACRO, ...) \ MACRO(554, __VA_ARGS__) \ MU_DO_553(MACRO, __VA_ARGS__) #define MU_DO_555(MACRO, ...) \ MACRO(555, __VA_ARGS__) \ MU_DO_554(MACRO, __VA_ARGS__) #define MU_DO_556(MACRO, ...) \ MACRO(556, __VA_ARGS__) \ MU_DO_555(MACRO, __VA_ARGS__) #define MU_DO_557(MACRO, ...) \ MACRO(557, __VA_ARGS__) \ MU_DO_556(MACRO, __VA_ARGS__) #define MU_DO_558(MACRO, ...) \ MACRO(558, __VA_ARGS__) \ MU_DO_557(MACRO, __VA_ARGS__) #define MU_DO_559(MACRO, ...) \ MACRO(559, __VA_ARGS__) \ MU_DO_558(MACRO, __VA_ARGS__) #define MU_DO_560(MACRO, ...) \ MACRO(560, __VA_ARGS__) \ MU_DO_559(MACRO, __VA_ARGS__) #define MU_DO_561(MACRO, ...) \ MACRO(561, __VA_ARGS__) \ MU_DO_560(MACRO, __VA_ARGS__) #define MU_DO_562(MACRO, ...) \ MACRO(562, __VA_ARGS__) \ MU_DO_561(MACRO, __VA_ARGS__) #define MU_DO_563(MACRO, ...) \ MACRO(563, __VA_ARGS__) \ MU_DO_562(MACRO, __VA_ARGS__) #define MU_DO_564(MACRO, ...) \ MACRO(564, __VA_ARGS__) \ MU_DO_563(MACRO, __VA_ARGS__) #define MU_DO_565(MACRO, ...) \ MACRO(565, __VA_ARGS__) \ MU_DO_564(MACRO, __VA_ARGS__) #define MU_DO_566(MACRO, ...) \ MACRO(566, __VA_ARGS__) \ MU_DO_565(MACRO, __VA_ARGS__) #define MU_DO_567(MACRO, ...) \ MACRO(567, __VA_ARGS__) \ MU_DO_566(MACRO, __VA_ARGS__) #define MU_DO_568(MACRO, ...) \ MACRO(568, __VA_ARGS__) \ MU_DO_567(MACRO, __VA_ARGS__) #define MU_DO_569(MACRO, ...) \ MACRO(569, __VA_ARGS__) \ MU_DO_568(MACRO, __VA_ARGS__) #define MU_DO_570(MACRO, ...) \ MACRO(570, __VA_ARGS__) \ MU_DO_569(MACRO, __VA_ARGS__) #define MU_DO_571(MACRO, ...) \ MACRO(571, __VA_ARGS__) \ MU_DO_570(MACRO, __VA_ARGS__) #define MU_DO_572(MACRO, ...) \ MACRO(572, __VA_ARGS__) \ MU_DO_571(MACRO, __VA_ARGS__) #define MU_DO_573(MACRO, ...) \ MACRO(573, __VA_ARGS__) \ MU_DO_572(MACRO, __VA_ARGS__) #define MU_DO_574(MACRO, ...) \ MACRO(574, __VA_ARGS__) \ MU_DO_573(MACRO, __VA_ARGS__) #define MU_DO_575(MACRO, ...) \ MACRO(575, __VA_ARGS__) \ MU_DO_574(MACRO, __VA_ARGS__) #define MU_DO_576(MACRO, ...) \ MACRO(576, __VA_ARGS__) \ MU_DO_575(MACRO, __VA_ARGS__) #define MU_DO_577(MACRO, ...) \ MACRO(577, __VA_ARGS__) \ MU_DO_576(MACRO, __VA_ARGS__) #define MU_DO_578(MACRO, ...) \ MACRO(578, __VA_ARGS__) \ MU_DO_577(MACRO, __VA_ARGS__) #define MU_DO_579(MACRO, ...) \ MACRO(579, __VA_ARGS__) \ MU_DO_578(MACRO, __VA_ARGS__) #define MU_DO_580(MACRO, ...) \ MACRO(580, __VA_ARGS__) \ MU_DO_579(MACRO, __VA_ARGS__) #define MU_DO_581(MACRO, ...) \ MACRO(581, __VA_ARGS__) \ MU_DO_580(MACRO, __VA_ARGS__) #define MU_DO_582(MACRO, ...) \ MACRO(582, __VA_ARGS__) \ MU_DO_581(MACRO, __VA_ARGS__) #define MU_DO_583(MACRO, ...) \ MACRO(583, __VA_ARGS__) \ MU_DO_582(MACRO, __VA_ARGS__) #define MU_DO_584(MACRO, ...) \ MACRO(584, __VA_ARGS__) \ MU_DO_583(MACRO, __VA_ARGS__) #define MU_DO_585(MACRO, ...) \ MACRO(585, __VA_ARGS__) \ MU_DO_584(MACRO, __VA_ARGS__) #define MU_DO_586(MACRO, ...) \ MACRO(586, __VA_ARGS__) \ MU_DO_585(MACRO, __VA_ARGS__) #define MU_DO_587(MACRO, ...) \ MACRO(587, __VA_ARGS__) \ MU_DO_586(MACRO, __VA_ARGS__) #define MU_DO_588(MACRO, ...) \ MACRO(588, __VA_ARGS__) \ MU_DO_587(MACRO, __VA_ARGS__) #define MU_DO_589(MACRO, ...) \ MACRO(589, __VA_ARGS__) \ MU_DO_588(MACRO, __VA_ARGS__) #define MU_DO_590(MACRO, ...) \ MACRO(590, __VA_ARGS__) \ MU_DO_589(MACRO, __VA_ARGS__) #define MU_DO_591(MACRO, ...) \ MACRO(591, __VA_ARGS__) \ MU_DO_590(MACRO, __VA_ARGS__) #define MU_DO_592(MACRO, ...) \ MACRO(592, __VA_ARGS__) \ MU_DO_591(MACRO, __VA_ARGS__) #define MU_DO_593(MACRO, ...) \ MACRO(593, __VA_ARGS__) \ MU_DO_592(MACRO, __VA_ARGS__) #define MU_DO_594(MACRO, ...) \ MACRO(594, __VA_ARGS__) \ MU_DO_593(MACRO, __VA_ARGS__) #define MU_DO_595(MACRO, ...) \ MACRO(595, __VA_ARGS__) \ MU_DO_594(MACRO, __VA_ARGS__) #define MU_DO_596(MACRO, ...) \ MACRO(596, __VA_ARGS__) \ MU_DO_595(MACRO, __VA_ARGS__) #define MU_DO_597(MACRO, ...) \ MACRO(597, __VA_ARGS__) \ MU_DO_596(MACRO, __VA_ARGS__) #define MU_DO_598(MACRO, ...) \ MACRO(598, __VA_ARGS__) \ MU_DO_597(MACRO, __VA_ARGS__) #define MU_DO_599(MACRO, ...) \ MACRO(599, __VA_ARGS__) \ MU_DO_598(MACRO, __VA_ARGS__) #define MU_DO_600(MACRO, ...) \ MACRO(600, __VA_ARGS__) \ MU_DO_599(MACRO, __VA_ARGS__) #define MU_DO_601(MACRO, ...) \ MACRO(601, __VA_ARGS__) \ MU_DO_600(MACRO, __VA_ARGS__) #define MU_DO_602(MACRO, ...) \ MACRO(602, __VA_ARGS__) \ MU_DO_601(MACRO, __VA_ARGS__) #define MU_DO_603(MACRO, ...) \ MACRO(603, __VA_ARGS__) \ MU_DO_602(MACRO, __VA_ARGS__) #define MU_DO_604(MACRO, ...) \ MACRO(604, __VA_ARGS__) \ MU_DO_603(MACRO, __VA_ARGS__) #define MU_DO_605(MACRO, ...) \ MACRO(605, __VA_ARGS__) \ MU_DO_604(MACRO, __VA_ARGS__) #define MU_DO_606(MACRO, ...) \ MACRO(606, __VA_ARGS__) \ MU_DO_605(MACRO, __VA_ARGS__) #define MU_DO_607(MACRO, ...) \ MACRO(607, __VA_ARGS__) \ MU_DO_606(MACRO, __VA_ARGS__) #define MU_DO_608(MACRO, ...) \ MACRO(608, __VA_ARGS__) \ MU_DO_607(MACRO, __VA_ARGS__) #define MU_DO_609(MACRO, ...) \ MACRO(609, __VA_ARGS__) \ MU_DO_608(MACRO, __VA_ARGS__) #define MU_DO_610(MACRO, ...) \ MACRO(610, __VA_ARGS__) \ MU_DO_609(MACRO, __VA_ARGS__) #define MU_DO_611(MACRO, ...) \ MACRO(611, __VA_ARGS__) \ MU_DO_610(MACRO, __VA_ARGS__) #define MU_DO_612(MACRO, ...) \ MACRO(612, __VA_ARGS__) \ MU_DO_611(MACRO, __VA_ARGS__) #define MU_DO_613(MACRO, ...) \ MACRO(613, __VA_ARGS__) \ MU_DO_612(MACRO, __VA_ARGS__) #define MU_DO_614(MACRO, ...) \ MACRO(614, __VA_ARGS__) \ MU_DO_613(MACRO, __VA_ARGS__) #define MU_DO_615(MACRO, ...) \ MACRO(615, __VA_ARGS__) \ MU_DO_614(MACRO, __VA_ARGS__) #define MU_DO_616(MACRO, ...) \ MACRO(616, __VA_ARGS__) \ MU_DO_615(MACRO, __VA_ARGS__) #define MU_DO_617(MACRO, ...) \ MACRO(617, __VA_ARGS__) \ MU_DO_616(MACRO, __VA_ARGS__) #define MU_DO_618(MACRO, ...) \ MACRO(618, __VA_ARGS__) \ MU_DO_617(MACRO, __VA_ARGS__) #define MU_DO_619(MACRO, ...) \ MACRO(619, __VA_ARGS__) \ MU_DO_618(MACRO, __VA_ARGS__) #define MU_DO_620(MACRO, ...) \ MACRO(620, __VA_ARGS__) \ MU_DO_619(MACRO, __VA_ARGS__) #define MU_DO_621(MACRO, ...) \ MACRO(621, __VA_ARGS__) \ MU_DO_620(MACRO, __VA_ARGS__) #define MU_DO_622(MACRO, ...) \ MACRO(622, __VA_ARGS__) \ MU_DO_621(MACRO, __VA_ARGS__) #define MU_DO_623(MACRO, ...) \ MACRO(623, __VA_ARGS__) \ MU_DO_622(MACRO, __VA_ARGS__) #define MU_DO_624(MACRO, ...) \ MACRO(624, __VA_ARGS__) \ MU_DO_623(MACRO, __VA_ARGS__) #define MU_DO_625(MACRO, ...) \ MACRO(625, __VA_ARGS__) \ MU_DO_624(MACRO, __VA_ARGS__) #define MU_DO_626(MACRO, ...) \ MACRO(626, __VA_ARGS__) \ MU_DO_625(MACRO, __VA_ARGS__) #define MU_DO_627(MACRO, ...) \ MACRO(627, __VA_ARGS__) \ MU_DO_626(MACRO, __VA_ARGS__) #define MU_DO_628(MACRO, ...) \ MACRO(628, __VA_ARGS__) \ MU_DO_627(MACRO, __VA_ARGS__) #define MU_DO_629(MACRO, ...) \ MACRO(629, __VA_ARGS__) \ MU_DO_628(MACRO, __VA_ARGS__) #define MU_DO_630(MACRO, ...) \ MACRO(630, __VA_ARGS__) \ MU_DO_629(MACRO, __VA_ARGS__) #define MU_DO_631(MACRO, ...) \ MACRO(631, __VA_ARGS__) \ MU_DO_630(MACRO, __VA_ARGS__) #define MU_DO_632(MACRO, ...) \ MACRO(632, __VA_ARGS__) \ MU_DO_631(MACRO, __VA_ARGS__) #define MU_DO_633(MACRO, ...) \ MACRO(633, __VA_ARGS__) \ MU_DO_632(MACRO, __VA_ARGS__) #define MU_DO_634(MACRO, ...) \ MACRO(634, __VA_ARGS__) \ MU_DO_633(MACRO, __VA_ARGS__) #define MU_DO_635(MACRO, ...) \ MACRO(635, __VA_ARGS__) \ MU_DO_634(MACRO, __VA_ARGS__) #define MU_DO_636(MACRO, ...) \ MACRO(636, __VA_ARGS__) \ MU_DO_635(MACRO, __VA_ARGS__) #define MU_DO_637(MACRO, ...) \ MACRO(637, __VA_ARGS__) \ MU_DO_636(MACRO, __VA_ARGS__) #define MU_DO_638(MACRO, ...) \ MACRO(638, __VA_ARGS__) \ MU_DO_637(MACRO, __VA_ARGS__) #define MU_DO_639(MACRO, ...) \ MACRO(639, __VA_ARGS__) \ MU_DO_638(MACRO, __VA_ARGS__) #define MU_DO_640(MACRO, ...) \ MACRO(640, __VA_ARGS__) \ MU_DO_639(MACRO, __VA_ARGS__) #define MU_DO_641(MACRO, ...) \ MACRO(641, __VA_ARGS__) \ MU_DO_640(MACRO, __VA_ARGS__) #define MU_DO_642(MACRO, ...) \ MACRO(642, __VA_ARGS__) \ MU_DO_641(MACRO, __VA_ARGS__) #define MU_DO_643(MACRO, ...) \ MACRO(643, __VA_ARGS__) \ MU_DO_642(MACRO, __VA_ARGS__) #define MU_DO_644(MACRO, ...) \ MACRO(644, __VA_ARGS__) \ MU_DO_643(MACRO, __VA_ARGS__) #define MU_DO_645(MACRO, ...) \ MACRO(645, __VA_ARGS__) \ MU_DO_644(MACRO, __VA_ARGS__) #define MU_DO_646(MACRO, ...) \ MACRO(646, __VA_ARGS__) \ MU_DO_645(MACRO, __VA_ARGS__) #define MU_DO_647(MACRO, ...) \ MACRO(647, __VA_ARGS__) \ MU_DO_646(MACRO, __VA_ARGS__) #define MU_DO_648(MACRO, ...) \ MACRO(648, __VA_ARGS__) \ MU_DO_647(MACRO, __VA_ARGS__) #define MU_DO_649(MACRO, ...) \ MACRO(649, __VA_ARGS__) \ MU_DO_648(MACRO, __VA_ARGS__) #define MU_DO_650(MACRO, ...) \ MACRO(650, __VA_ARGS__) \ MU_DO_649(MACRO, __VA_ARGS__) #define MU_DO_651(MACRO, ...) \ MACRO(651, __VA_ARGS__) \ MU_DO_650(MACRO, __VA_ARGS__) #define MU_DO_652(MACRO, ...) \ MACRO(652, __VA_ARGS__) \ MU_DO_651(MACRO, __VA_ARGS__) #define MU_DO_653(MACRO, ...) \ MACRO(653, __VA_ARGS__) \ MU_DO_652(MACRO, __VA_ARGS__) #define MU_DO_654(MACRO, ...) \ MACRO(654, __VA_ARGS__) \ MU_DO_653(MACRO, __VA_ARGS__) #define MU_DO_655(MACRO, ...) \ MACRO(655, __VA_ARGS__) \ MU_DO_654(MACRO, __VA_ARGS__) #define MU_DO_656(MACRO, ...) \ MACRO(656, __VA_ARGS__) \ MU_DO_655(MACRO, __VA_ARGS__) #define MU_DO_657(MACRO, ...) \ MACRO(657, __VA_ARGS__) \ MU_DO_656(MACRO, __VA_ARGS__) #define MU_DO_658(MACRO, ...) \ MACRO(658, __VA_ARGS__) \ MU_DO_657(MACRO, __VA_ARGS__) #define MU_DO_659(MACRO, ...) \ MACRO(659, __VA_ARGS__) \ MU_DO_658(MACRO, __VA_ARGS__) #define MU_DO_660(MACRO, ...) \ MACRO(660, __VA_ARGS__) \ MU_DO_659(MACRO, __VA_ARGS__) #define MU_DO_661(MACRO, ...) \ MACRO(661, __VA_ARGS__) \ MU_DO_660(MACRO, __VA_ARGS__) #define MU_DO_662(MACRO, ...) \ MACRO(662, __VA_ARGS__) \ MU_DO_661(MACRO, __VA_ARGS__) #define MU_DO_663(MACRO, ...) \ MACRO(663, __VA_ARGS__) \ MU_DO_662(MACRO, __VA_ARGS__) #define MU_DO_664(MACRO, ...) \ MACRO(664, __VA_ARGS__) \ MU_DO_663(MACRO, __VA_ARGS__) #define MU_DO_665(MACRO, ...) \ MACRO(665, __VA_ARGS__) \ MU_DO_664(MACRO, __VA_ARGS__) #define MU_DO_666(MACRO, ...) \ MACRO(666, __VA_ARGS__) \ MU_DO_665(MACRO, __VA_ARGS__) #define MU_DO_667(MACRO, ...) \ MACRO(667, __VA_ARGS__) \ MU_DO_666(MACRO, __VA_ARGS__) #define MU_DO_668(MACRO, ...) \ MACRO(668, __VA_ARGS__) \ MU_DO_667(MACRO, __VA_ARGS__) #define MU_DO_669(MACRO, ...) \ MACRO(669, __VA_ARGS__) \ MU_DO_668(MACRO, __VA_ARGS__) #define MU_DO_670(MACRO, ...) \ MACRO(670, __VA_ARGS__) \ MU_DO_669(MACRO, __VA_ARGS__) #define MU_DO_671(MACRO, ...) \ MACRO(671, __VA_ARGS__) \ MU_DO_670(MACRO, __VA_ARGS__) #define MU_DO_672(MACRO, ...) \ MACRO(672, __VA_ARGS__) \ MU_DO_671(MACRO, __VA_ARGS__) #define MU_DO_673(MACRO, ...) \ MACRO(673, __VA_ARGS__) \ MU_DO_672(MACRO, __VA_ARGS__) #define MU_DO_674(MACRO, ...) \ MACRO(674, __VA_ARGS__) \ MU_DO_673(MACRO, __VA_ARGS__) #define MU_DO_675(MACRO, ...) \ MACRO(675, __VA_ARGS__) \ MU_DO_674(MACRO, __VA_ARGS__) #define MU_DO_676(MACRO, ...) \ MACRO(676, __VA_ARGS__) \ MU_DO_675(MACRO, __VA_ARGS__) #define MU_DO_677(MACRO, ...) \ MACRO(677, __VA_ARGS__) \ MU_DO_676(MACRO, __VA_ARGS__) #define MU_DO_678(MACRO, ...) \ MACRO(678, __VA_ARGS__) \ MU_DO_677(MACRO, __VA_ARGS__) #define MU_DO_679(MACRO, ...) \ MACRO(679, __VA_ARGS__) \ MU_DO_678(MACRO, __VA_ARGS__) #define MU_DO_680(MACRO, ...) \ MACRO(680, __VA_ARGS__) \ MU_DO_679(MACRO, __VA_ARGS__) #define MU_DO_681(MACRO, ...) \ MACRO(681, __VA_ARGS__) \ MU_DO_680(MACRO, __VA_ARGS__) #define MU_DO_682(MACRO, ...) \ MACRO(682, __VA_ARGS__) \ MU_DO_681(MACRO, __VA_ARGS__) #define MU_DO_683(MACRO, ...) \ MACRO(683, __VA_ARGS__) \ MU_DO_682(MACRO, __VA_ARGS__) #define MU_DO_684(MACRO, ...) \ MACRO(684, __VA_ARGS__) \ MU_DO_683(MACRO, __VA_ARGS__) #define MU_DO_685(MACRO, ...) \ MACRO(685, __VA_ARGS__) \ MU_DO_684(MACRO, __VA_ARGS__) #define MU_DO_686(MACRO, ...) \ MACRO(686, __VA_ARGS__) \ MU_DO_685(MACRO, __VA_ARGS__) #define MU_DO_687(MACRO, ...) \ MACRO(687, __VA_ARGS__) \ MU_DO_686(MACRO, __VA_ARGS__) #define MU_DO_688(MACRO, ...) \ MACRO(688, __VA_ARGS__) \ MU_DO_687(MACRO, __VA_ARGS__) #define MU_DO_689(MACRO, ...) \ MACRO(689, __VA_ARGS__) \ MU_DO_688(MACRO, __VA_ARGS__) #define MU_DO_690(MACRO, ...) \ MACRO(690, __VA_ARGS__) \ MU_DO_689(MACRO, __VA_ARGS__) #define MU_DO_691(MACRO, ...) \ MACRO(691, __VA_ARGS__) \ MU_DO_690(MACRO, __VA_ARGS__) #define MU_DO_692(MACRO, ...) \ MACRO(692, __VA_ARGS__) \ MU_DO_691(MACRO, __VA_ARGS__) #define MU_DO_693(MACRO, ...) \ MACRO(693, __VA_ARGS__) \ MU_DO_692(MACRO, __VA_ARGS__) #define MU_DO_694(MACRO, ...) \ MACRO(694, __VA_ARGS__) \ MU_DO_693(MACRO, __VA_ARGS__) #define MU_DO_695(MACRO, ...) \ MACRO(695, __VA_ARGS__) \ MU_DO_694(MACRO, __VA_ARGS__) #define MU_DO_696(MACRO, ...) \ MACRO(696, __VA_ARGS__) \ MU_DO_695(MACRO, __VA_ARGS__) #define MU_DO_697(MACRO, ...) \ MACRO(697, __VA_ARGS__) \ MU_DO_696(MACRO, __VA_ARGS__) #define MU_DO_698(MACRO, ...) \ MACRO(698, __VA_ARGS__) \ MU_DO_697(MACRO, __VA_ARGS__) #define MU_DO_699(MACRO, ...) \ MACRO(699, __VA_ARGS__) \ MU_DO_698(MACRO, __VA_ARGS__) #define MU_DO_700(MACRO, ...) \ MACRO(700, __VA_ARGS__) \ MU_DO_699(MACRO, __VA_ARGS__) #define MU_DO_701(MACRO, ...) \ MACRO(701, __VA_ARGS__) \ MU_DO_700(MACRO, __VA_ARGS__) #define MU_DO_702(MACRO, ...) \ MACRO(702, __VA_ARGS__) \ MU_DO_701(MACRO, __VA_ARGS__) #define MU_DO_703(MACRO, ...) \ MACRO(703, __VA_ARGS__) \ MU_DO_702(MACRO, __VA_ARGS__) #define MU_DO_704(MACRO, ...) \ MACRO(704, __VA_ARGS__) \ MU_DO_703(MACRO, __VA_ARGS__) #define MU_DO_705(MACRO, ...) \ MACRO(705, __VA_ARGS__) \ MU_DO_704(MACRO, __VA_ARGS__) #define MU_DO_706(MACRO, ...) \ MACRO(706, __VA_ARGS__) \ MU_DO_705(MACRO, __VA_ARGS__) #define MU_DO_707(MACRO, ...) \ MACRO(707, __VA_ARGS__) \ MU_DO_706(MACRO, __VA_ARGS__) #define MU_DO_708(MACRO, ...) \ MACRO(708, __VA_ARGS__) \ MU_DO_707(MACRO, __VA_ARGS__) #define MU_DO_709(MACRO, ...) \ MACRO(709, __VA_ARGS__) \ MU_DO_708(MACRO, __VA_ARGS__) #define MU_DO_710(MACRO, ...) \ MACRO(710, __VA_ARGS__) \ MU_DO_709(MACRO, __VA_ARGS__) #define MU_DO_711(MACRO, ...) \ MACRO(711, __VA_ARGS__) \ MU_DO_710(MACRO, __VA_ARGS__) #define MU_DO_712(MACRO, ...) \ MACRO(712, __VA_ARGS__) \ MU_DO_711(MACRO, __VA_ARGS__) #define MU_DO_713(MACRO, ...) \ MACRO(713, __VA_ARGS__) \ MU_DO_712(MACRO, __VA_ARGS__) #define MU_DO_714(MACRO, ...) \ MACRO(714, __VA_ARGS__) \ MU_DO_713(MACRO, __VA_ARGS__) #define MU_DO_715(MACRO, ...) \ MACRO(715, __VA_ARGS__) \ MU_DO_714(MACRO, __VA_ARGS__) #define MU_DO_716(MACRO, ...) \ MACRO(716, __VA_ARGS__) \ MU_DO_715(MACRO, __VA_ARGS__) #define MU_DO_717(MACRO, ...) \ MACRO(717, __VA_ARGS__) \ MU_DO_716(MACRO, __VA_ARGS__) #define MU_DO_718(MACRO, ...) \ MACRO(718, __VA_ARGS__) \ MU_DO_717(MACRO, __VA_ARGS__) #define MU_DO_719(MACRO, ...) \ MACRO(719, __VA_ARGS__) \ MU_DO_718(MACRO, __VA_ARGS__) #define MU_DO_720(MACRO, ...) \ MACRO(720, __VA_ARGS__) \ MU_DO_719(MACRO, __VA_ARGS__) #define MU_DO_721(MACRO, ...) \ MACRO(721, __VA_ARGS__) \ MU_DO_720(MACRO, __VA_ARGS__) #define MU_DO_722(MACRO, ...) \ MACRO(722, __VA_ARGS__) \ MU_DO_721(MACRO, __VA_ARGS__) #define MU_DO_723(MACRO, ...) \ MACRO(723, __VA_ARGS__) \ MU_DO_722(MACRO, __VA_ARGS__) #define MU_DO_724(MACRO, ...) \ MACRO(724, __VA_ARGS__) \ MU_DO_723(MACRO, __VA_ARGS__) #define MU_DO_725(MACRO, ...) \ MACRO(725, __VA_ARGS__) \ MU_DO_724(MACRO, __VA_ARGS__) #define MU_DO_726(MACRO, ...) \ MACRO(726, __VA_ARGS__) \ MU_DO_725(MACRO, __VA_ARGS__) #define MU_DO_727(MACRO, ...) \ MACRO(727, __VA_ARGS__) \ MU_DO_726(MACRO, __VA_ARGS__) #define MU_DO_728(MACRO, ...) \ MACRO(728, __VA_ARGS__) \ MU_DO_727(MACRO, __VA_ARGS__) #define MU_DO_729(MACRO, ...) \ MACRO(729, __VA_ARGS__) \ MU_DO_728(MACRO, __VA_ARGS__) #define MU_DO_730(MACRO, ...) \ MACRO(730, __VA_ARGS__) \ MU_DO_729(MACRO, __VA_ARGS__) #define MU_DO_731(MACRO, ...) \ MACRO(731, __VA_ARGS__) \ MU_DO_730(MACRO, __VA_ARGS__) #define MU_DO_732(MACRO, ...) \ MACRO(732, __VA_ARGS__) \ MU_DO_731(MACRO, __VA_ARGS__) #define MU_DO_733(MACRO, ...) \ MACRO(733, __VA_ARGS__) \ MU_DO_732(MACRO, __VA_ARGS__) #define MU_DO_734(MACRO, ...) \ MACRO(734, __VA_ARGS__) \ MU_DO_733(MACRO, __VA_ARGS__) #define MU_DO_735(MACRO, ...) \ MACRO(735, __VA_ARGS__) \ MU_DO_734(MACRO, __VA_ARGS__) #define MU_DO_736(MACRO, ...) \ MACRO(736, __VA_ARGS__) \ MU_DO_735(MACRO, __VA_ARGS__) #define MU_DO_737(MACRO, ...) \ MACRO(737, __VA_ARGS__) \ MU_DO_736(MACRO, __VA_ARGS__) #define MU_DO_738(MACRO, ...) \ MACRO(738, __VA_ARGS__) \ MU_DO_737(MACRO, __VA_ARGS__) #define MU_DO_739(MACRO, ...) \ MACRO(739, __VA_ARGS__) \ MU_DO_738(MACRO, __VA_ARGS__) #define MU_DO_740(MACRO, ...) \ MACRO(740, __VA_ARGS__) \ MU_DO_739(MACRO, __VA_ARGS__) #define MU_DO_741(MACRO, ...) \ MACRO(741, __VA_ARGS__) \ MU_DO_740(MACRO, __VA_ARGS__) #define MU_DO_742(MACRO, ...) \ MACRO(742, __VA_ARGS__) \ MU_DO_741(MACRO, __VA_ARGS__) #define MU_DO_743(MACRO, ...) \ MACRO(743, __VA_ARGS__) \ MU_DO_742(MACRO, __VA_ARGS__) #define MU_DO_744(MACRO, ...) \ MACRO(744, __VA_ARGS__) \ MU_DO_743(MACRO, __VA_ARGS__) #define MU_DO_745(MACRO, ...) \ MACRO(745, __VA_ARGS__) \ MU_DO_744(MACRO, __VA_ARGS__) #define MU_DO_746(MACRO, ...) \ MACRO(746, __VA_ARGS__) \ MU_DO_745(MACRO, __VA_ARGS__) #define MU_DO_747(MACRO, ...) \ MACRO(747, __VA_ARGS__) \ MU_DO_746(MACRO, __VA_ARGS__) #define MU_DO_748(MACRO, ...) \ MACRO(748, __VA_ARGS__) \ MU_DO_747(MACRO, __VA_ARGS__) #define MU_DO_749(MACRO, ...) \ MACRO(749, __VA_ARGS__) \ MU_DO_748(MACRO, __VA_ARGS__) #define MU_DO_750(MACRO, ...) \ MACRO(750, __VA_ARGS__) \ MU_DO_749(MACRO, __VA_ARGS__) #define MU_DO_751(MACRO, ...) \ MACRO(751, __VA_ARGS__) \ MU_DO_750(MACRO, __VA_ARGS__) #define MU_DO_752(MACRO, ...) \ MACRO(752, __VA_ARGS__) \ MU_DO_751(MACRO, __VA_ARGS__) #define MU_DO_753(MACRO, ...) \ MACRO(753, __VA_ARGS__) \ MU_DO_752(MACRO, __VA_ARGS__) #define MU_DO_754(MACRO, ...) \ MACRO(754, __VA_ARGS__) \ MU_DO_753(MACRO, __VA_ARGS__) #define MU_DO_755(MACRO, ...) \ MACRO(755, __VA_ARGS__) \ MU_DO_754(MACRO, __VA_ARGS__) #define MU_DO_756(MACRO, ...) \ MACRO(756, __VA_ARGS__) \ MU_DO_755(MACRO, __VA_ARGS__) #define MU_DO_757(MACRO, ...) \ MACRO(757, __VA_ARGS__) \ MU_DO_756(MACRO, __VA_ARGS__) #define MU_DO_758(MACRO, ...) \ MACRO(758, __VA_ARGS__) \ MU_DO_757(MACRO, __VA_ARGS__) #define MU_DO_759(MACRO, ...) \ MACRO(759, __VA_ARGS__) \ MU_DO_758(MACRO, __VA_ARGS__) #define MU_DO_760(MACRO, ...) \ MACRO(760, __VA_ARGS__) \ MU_DO_759(MACRO, __VA_ARGS__) #define MU_DO_761(MACRO, ...) \ MACRO(761, __VA_ARGS__) \ MU_DO_760(MACRO, __VA_ARGS__) #define MU_DO_762(MACRO, ...) \ MACRO(762, __VA_ARGS__) \ MU_DO_761(MACRO, __VA_ARGS__) #define MU_DO_763(MACRO, ...) \ MACRO(763, __VA_ARGS__) \ MU_DO_762(MACRO, __VA_ARGS__) #define MU_DO_764(MACRO, ...) \ MACRO(764, __VA_ARGS__) \ MU_DO_763(MACRO, __VA_ARGS__) #define MU_DO_765(MACRO, ...) \ MACRO(765, __VA_ARGS__) \ MU_DO_764(MACRO, __VA_ARGS__) #define MU_DO_766(MACRO, ...) \ MACRO(766, __VA_ARGS__) \ MU_DO_765(MACRO, __VA_ARGS__) #define MU_DO_767(MACRO, ...) \ MACRO(767, __VA_ARGS__) \ MU_DO_766(MACRO, __VA_ARGS__) #define MU_DO_768(MACRO, ...) \ MACRO(768, __VA_ARGS__) \ MU_DO_767(MACRO, __VA_ARGS__) #define MU_DO_769(MACRO, ...) \ MACRO(769, __VA_ARGS__) \ MU_DO_768(MACRO, __VA_ARGS__) #define MU_DO_770(MACRO, ...) \ MACRO(770, __VA_ARGS__) \ MU_DO_769(MACRO, __VA_ARGS__) #define MU_DO_771(MACRO, ...) \ MACRO(771, __VA_ARGS__) \ MU_DO_770(MACRO, __VA_ARGS__) #define MU_DO_772(MACRO, ...) \ MACRO(772, __VA_ARGS__) \ MU_DO_771(MACRO, __VA_ARGS__) #define MU_DO_773(MACRO, ...) \ MACRO(773, __VA_ARGS__) \ MU_DO_772(MACRO, __VA_ARGS__) #define MU_DO_774(MACRO, ...) \ MACRO(774, __VA_ARGS__) \ MU_DO_773(MACRO, __VA_ARGS__) #define MU_DO_775(MACRO, ...) \ MACRO(775, __VA_ARGS__) \ MU_DO_774(MACRO, __VA_ARGS__) #define MU_DO_776(MACRO, ...) \ MACRO(776, __VA_ARGS__) \ MU_DO_775(MACRO, __VA_ARGS__) #define MU_DO_777(MACRO, ...) \ MACRO(777, __VA_ARGS__) \ MU_DO_776(MACRO, __VA_ARGS__) #define MU_DO_778(MACRO, ...) \ MACRO(778, __VA_ARGS__) \ MU_DO_777(MACRO, __VA_ARGS__) #define MU_DO_779(MACRO, ...) \ MACRO(779, __VA_ARGS__) \ MU_DO_778(MACRO, __VA_ARGS__) #define MU_DO_780(MACRO, ...) \ MACRO(780, __VA_ARGS__) \ MU_DO_779(MACRO, __VA_ARGS__) #define MU_DO_781(MACRO, ...) \ MACRO(781, __VA_ARGS__) \ MU_DO_780(MACRO, __VA_ARGS__) #define MU_DO_782(MACRO, ...) \ MACRO(782, __VA_ARGS__) \ MU_DO_781(MACRO, __VA_ARGS__) #define MU_DO_783(MACRO, ...) \ MACRO(783, __VA_ARGS__) \ MU_DO_782(MACRO, __VA_ARGS__) #define MU_DO_784(MACRO, ...) \ MACRO(784, __VA_ARGS__) \ MU_DO_783(MACRO, __VA_ARGS__) #define MU_DO_785(MACRO, ...) \ MACRO(785, __VA_ARGS__) \ MU_DO_784(MACRO, __VA_ARGS__) #define MU_DO_786(MACRO, ...) \ MACRO(786, __VA_ARGS__) \ MU_DO_785(MACRO, __VA_ARGS__) #define MU_DO_787(MACRO, ...) \ MACRO(787, __VA_ARGS__) \ MU_DO_786(MACRO, __VA_ARGS__) #define MU_DO_788(MACRO, ...) \ MACRO(788, __VA_ARGS__) \ MU_DO_787(MACRO, __VA_ARGS__) #define MU_DO_789(MACRO, ...) \ MACRO(789, __VA_ARGS__) \ MU_DO_788(MACRO, __VA_ARGS__) #define MU_DO_790(MACRO, ...) \ MACRO(790, __VA_ARGS__) \ MU_DO_789(MACRO, __VA_ARGS__) #define MU_DO_791(MACRO, ...) \ MACRO(791, __VA_ARGS__) \ MU_DO_790(MACRO, __VA_ARGS__) #define MU_DO_792(MACRO, ...) \ MACRO(792, __VA_ARGS__) \ MU_DO_791(MACRO, __VA_ARGS__) #define MU_DO_793(MACRO, ...) \ MACRO(793, __VA_ARGS__) \ MU_DO_792(MACRO, __VA_ARGS__) #define MU_DO_794(MACRO, ...) \ MACRO(794, __VA_ARGS__) \ MU_DO_793(MACRO, __VA_ARGS__) #define MU_DO_795(MACRO, ...) \ MACRO(795, __VA_ARGS__) \ MU_DO_794(MACRO, __VA_ARGS__) #define MU_DO_796(MACRO, ...) \ MACRO(796, __VA_ARGS__) \ MU_DO_795(MACRO, __VA_ARGS__) #define MU_DO_797(MACRO, ...) \ MACRO(797, __VA_ARGS__) \ MU_DO_796(MACRO, __VA_ARGS__) #define MU_DO_798(MACRO, ...) \ MACRO(798, __VA_ARGS__) \ MU_DO_797(MACRO, __VA_ARGS__) #define MU_DO_799(MACRO, ...) \ MACRO(799, __VA_ARGS__) \ MU_DO_798(MACRO, __VA_ARGS__) #define MU_DO_800(MACRO, ...) \ MACRO(800, __VA_ARGS__) \ MU_DO_799(MACRO, __VA_ARGS__) #define MU_DO_801(MACRO, ...) \ MACRO(801, __VA_ARGS__) \ MU_DO_800(MACRO, __VA_ARGS__) #define MU_DO_802(MACRO, ...) \ MACRO(802, __VA_ARGS__) \ MU_DO_801(MACRO, __VA_ARGS__) #define MU_DO_803(MACRO, ...) \ MACRO(803, __VA_ARGS__) \ MU_DO_802(MACRO, __VA_ARGS__) #define MU_DO_804(MACRO, ...) \ MACRO(804, __VA_ARGS__) \ MU_DO_803(MACRO, __VA_ARGS__) #define MU_DO_805(MACRO, ...) \ MACRO(805, __VA_ARGS__) \ MU_DO_804(MACRO, __VA_ARGS__) #define MU_DO_806(MACRO, ...) \ MACRO(806, __VA_ARGS__) \ MU_DO_805(MACRO, __VA_ARGS__) #define MU_DO_807(MACRO, ...) \ MACRO(807, __VA_ARGS__) \ MU_DO_806(MACRO, __VA_ARGS__) #define MU_DO_808(MACRO, ...) \ MACRO(808, __VA_ARGS__) \ MU_DO_807(MACRO, __VA_ARGS__) #define MU_DO_809(MACRO, ...) \ MACRO(809, __VA_ARGS__) \ MU_DO_808(MACRO, __VA_ARGS__) #define MU_DO_810(MACRO, ...) \ MACRO(810, __VA_ARGS__) \ MU_DO_809(MACRO, __VA_ARGS__) #define MU_DO_811(MACRO, ...) \ MACRO(811, __VA_ARGS__) \ MU_DO_810(MACRO, __VA_ARGS__) #define MU_DO_812(MACRO, ...) \ MACRO(812, __VA_ARGS__) \ MU_DO_811(MACRO, __VA_ARGS__) #define MU_DO_813(MACRO, ...) \ MACRO(813, __VA_ARGS__) \ MU_DO_812(MACRO, __VA_ARGS__) #define MU_DO_814(MACRO, ...) \ MACRO(814, __VA_ARGS__) \ MU_DO_813(MACRO, __VA_ARGS__) #define MU_DO_815(MACRO, ...) \ MACRO(815, __VA_ARGS__) \ MU_DO_814(MACRO, __VA_ARGS__) #define MU_DO_816(MACRO, ...) \ MACRO(816, __VA_ARGS__) \ MU_DO_815(MACRO, __VA_ARGS__) #define MU_DO_817(MACRO, ...) \ MACRO(817, __VA_ARGS__) \ MU_DO_816(MACRO, __VA_ARGS__) #define MU_DO_818(MACRO, ...) \ MACRO(818, __VA_ARGS__) \ MU_DO_817(MACRO, __VA_ARGS__) #define MU_DO_819(MACRO, ...) \ MACRO(819, __VA_ARGS__) \ MU_DO_818(MACRO, __VA_ARGS__) #define MU_DO_820(MACRO, ...) \ MACRO(820, __VA_ARGS__) \ MU_DO_819(MACRO, __VA_ARGS__) #define MU_DO_821(MACRO, ...) \ MACRO(821, __VA_ARGS__) \ MU_DO_820(MACRO, __VA_ARGS__) #define MU_DO_822(MACRO, ...) \ MACRO(822, __VA_ARGS__) \ MU_DO_821(MACRO, __VA_ARGS__) #define MU_DO_823(MACRO, ...) \ MACRO(823, __VA_ARGS__) \ MU_DO_822(MACRO, __VA_ARGS__) #define MU_DO_824(MACRO, ...) \ MACRO(824, __VA_ARGS__) \ MU_DO_823(MACRO, __VA_ARGS__) #define MU_DO_825(MACRO, ...) \ MACRO(825, __VA_ARGS__) \ MU_DO_824(MACRO, __VA_ARGS__) #define MU_DO_826(MACRO, ...) \ MACRO(826, __VA_ARGS__) \ MU_DO_825(MACRO, __VA_ARGS__) #define MU_DO_827(MACRO, ...) \ MACRO(827, __VA_ARGS__) \ MU_DO_826(MACRO, __VA_ARGS__) #define MU_DO_828(MACRO, ...) \ MACRO(828, __VA_ARGS__) \ MU_DO_827(MACRO, __VA_ARGS__) #define MU_DO_829(MACRO, ...) \ MACRO(829, __VA_ARGS__) \ MU_DO_828(MACRO, __VA_ARGS__) #define MU_DO_830(MACRO, ...) \ MACRO(830, __VA_ARGS__) \ MU_DO_829(MACRO, __VA_ARGS__) #define MU_DO_831(MACRO, ...) \ MACRO(831, __VA_ARGS__) \ MU_DO_830(MACRO, __VA_ARGS__) #define MU_DO_832(MACRO, ...) \ MACRO(832, __VA_ARGS__) \ MU_DO_831(MACRO, __VA_ARGS__) #define MU_DO_833(MACRO, ...) \ MACRO(833, __VA_ARGS__) \ MU_DO_832(MACRO, __VA_ARGS__) #define MU_DO_834(MACRO, ...) \ MACRO(834, __VA_ARGS__) \ MU_DO_833(MACRO, __VA_ARGS__) #define MU_DO_835(MACRO, ...) \ MACRO(835, __VA_ARGS__) \ MU_DO_834(MACRO, __VA_ARGS__) #define MU_DO_836(MACRO, ...) \ MACRO(836, __VA_ARGS__) \ MU_DO_835(MACRO, __VA_ARGS__) #define MU_DO_837(MACRO, ...) \ MACRO(837, __VA_ARGS__) \ MU_DO_836(MACRO, __VA_ARGS__) #define MU_DO_838(MACRO, ...) \ MACRO(838, __VA_ARGS__) \ MU_DO_837(MACRO, __VA_ARGS__) #define MU_DO_839(MACRO, ...) \ MACRO(839, __VA_ARGS__) \ MU_DO_838(MACRO, __VA_ARGS__) #define MU_DO_840(MACRO, ...) \ MACRO(840, __VA_ARGS__) \ MU_DO_839(MACRO, __VA_ARGS__) #define MU_DO_841(MACRO, ...) \ MACRO(841, __VA_ARGS__) \ MU_DO_840(MACRO, __VA_ARGS__) #define MU_DO_842(MACRO, ...) \ MACRO(842, __VA_ARGS__) \ MU_DO_841(MACRO, __VA_ARGS__) #define MU_DO_843(MACRO, ...) \ MACRO(843, __VA_ARGS__) \ MU_DO_842(MACRO, __VA_ARGS__) #define MU_DO_844(MACRO, ...) \ MACRO(844, __VA_ARGS__) \ MU_DO_843(MACRO, __VA_ARGS__) #define MU_DO_845(MACRO, ...) \ MACRO(845, __VA_ARGS__) \ MU_DO_844(MACRO, __VA_ARGS__) #define MU_DO_846(MACRO, ...) \ MACRO(846, __VA_ARGS__) \ MU_DO_845(MACRO, __VA_ARGS__) #define MU_DO_847(MACRO, ...) \ MACRO(847, __VA_ARGS__) \ MU_DO_846(MACRO, __VA_ARGS__) #define MU_DO_848(MACRO, ...) \ MACRO(848, __VA_ARGS__) \ MU_DO_847(MACRO, __VA_ARGS__) #define MU_DO_849(MACRO, ...) \ MACRO(849, __VA_ARGS__) \ MU_DO_848(MACRO, __VA_ARGS__) #define MU_DO_850(MACRO, ...) \ MACRO(850, __VA_ARGS__) \ MU_DO_849(MACRO, __VA_ARGS__) #define MU_DO_851(MACRO, ...) \ MACRO(851, __VA_ARGS__) \ MU_DO_850(MACRO, __VA_ARGS__) #define MU_DO_852(MACRO, ...) \ MACRO(852, __VA_ARGS__) \ MU_DO_851(MACRO, __VA_ARGS__) #define MU_DO_853(MACRO, ...) \ MACRO(853, __VA_ARGS__) \ MU_DO_852(MACRO, __VA_ARGS__) #define MU_DO_854(MACRO, ...) \ MACRO(854, __VA_ARGS__) \ MU_DO_853(MACRO, __VA_ARGS__) #define MU_DO_855(MACRO, ...) \ MACRO(855, __VA_ARGS__) \ MU_DO_854(MACRO, __VA_ARGS__) #define MU_DO_856(MACRO, ...) \ MACRO(856, __VA_ARGS__) \ MU_DO_855(MACRO, __VA_ARGS__) #define MU_DO_857(MACRO, ...) \ MACRO(857, __VA_ARGS__) \ MU_DO_856(MACRO, __VA_ARGS__) #define MU_DO_858(MACRO, ...) \ MACRO(858, __VA_ARGS__) \ MU_DO_857(MACRO, __VA_ARGS__) #define MU_DO_859(MACRO, ...) \ MACRO(859, __VA_ARGS__) \ MU_DO_858(MACRO, __VA_ARGS__) #define MU_DO_860(MACRO, ...) \ MACRO(860, __VA_ARGS__) \ MU_DO_859(MACRO, __VA_ARGS__) #define MU_DO_861(MACRO, ...) \ MACRO(861, __VA_ARGS__) \ MU_DO_860(MACRO, __VA_ARGS__) #define MU_DO_862(MACRO, ...) \ MACRO(862, __VA_ARGS__) \ MU_DO_861(MACRO, __VA_ARGS__) #define MU_DO_863(MACRO, ...) \ MACRO(863, __VA_ARGS__) \ MU_DO_862(MACRO, __VA_ARGS__) #define MU_DO_864(MACRO, ...) \ MACRO(864, __VA_ARGS__) \ MU_DO_863(MACRO, __VA_ARGS__) #define MU_DO_865(MACRO, ...) \ MACRO(865, __VA_ARGS__) \ MU_DO_864(MACRO, __VA_ARGS__) #define MU_DO_866(MACRO, ...) \ MACRO(866, __VA_ARGS__) \ MU_DO_865(MACRO, __VA_ARGS__) #define MU_DO_867(MACRO, ...) \ MACRO(867, __VA_ARGS__) \ MU_DO_866(MACRO, __VA_ARGS__) #define MU_DO_868(MACRO, ...) \ MACRO(868, __VA_ARGS__) \ MU_DO_867(MACRO, __VA_ARGS__) #define MU_DO_869(MACRO, ...) \ MACRO(869, __VA_ARGS__) \ MU_DO_868(MACRO, __VA_ARGS__) #define MU_DO_870(MACRO, ...) \ MACRO(870, __VA_ARGS__) \ MU_DO_869(MACRO, __VA_ARGS__) #define MU_DO_871(MACRO, ...) \ MACRO(871, __VA_ARGS__) \ MU_DO_870(MACRO, __VA_ARGS__) #define MU_DO_872(MACRO, ...) \ MACRO(872, __VA_ARGS__) \ MU_DO_871(MACRO, __VA_ARGS__) #define MU_DO_873(MACRO, ...) \ MACRO(873, __VA_ARGS__) \ MU_DO_872(MACRO, __VA_ARGS__) #define MU_DO_874(MACRO, ...) \ MACRO(874, __VA_ARGS__) \ MU_DO_873(MACRO, __VA_ARGS__) #define MU_DO_875(MACRO, ...) \ MACRO(875, __VA_ARGS__) \ MU_DO_874(MACRO, __VA_ARGS__) #define MU_DO_876(MACRO, ...) \ MACRO(876, __VA_ARGS__) \ MU_DO_875(MACRO, __VA_ARGS__) #define MU_DO_877(MACRO, ...) \ MACRO(877, __VA_ARGS__) \ MU_DO_876(MACRO, __VA_ARGS__) #define MU_DO_878(MACRO, ...) \ MACRO(878, __VA_ARGS__) \ MU_DO_877(MACRO, __VA_ARGS__) #define MU_DO_879(MACRO, ...) \ MACRO(879, __VA_ARGS__) \ MU_DO_878(MACRO, __VA_ARGS__) #define MU_DO_880(MACRO, ...) \ MACRO(880, __VA_ARGS__) \ MU_DO_879(MACRO, __VA_ARGS__) #define MU_DO_881(MACRO, ...) \ MACRO(881, __VA_ARGS__) \ MU_DO_880(MACRO, __VA_ARGS__) #define MU_DO_882(MACRO, ...) \ MACRO(882, __VA_ARGS__) \ MU_DO_881(MACRO, __VA_ARGS__) #define MU_DO_883(MACRO, ...) \ MACRO(883, __VA_ARGS__) \ MU_DO_882(MACRO, __VA_ARGS__) #define MU_DO_884(MACRO, ...) \ MACRO(884, __VA_ARGS__) \ MU_DO_883(MACRO, __VA_ARGS__) #define MU_DO_885(MACRO, ...) \ MACRO(885, __VA_ARGS__) \ MU_DO_884(MACRO, __VA_ARGS__) #define MU_DO_886(MACRO, ...) \ MACRO(886, __VA_ARGS__) \ MU_DO_885(MACRO, __VA_ARGS__) #define MU_DO_887(MACRO, ...) \ MACRO(887, __VA_ARGS__) \ MU_DO_886(MACRO, __VA_ARGS__) #define MU_DO_888(MACRO, ...) \ MACRO(888, __VA_ARGS__) \ MU_DO_887(MACRO, __VA_ARGS__) #define MU_DO_889(MACRO, ...) \ MACRO(889, __VA_ARGS__) \ MU_DO_888(MACRO, __VA_ARGS__) #define MU_DO_890(MACRO, ...) \ MACRO(890, __VA_ARGS__) \ MU_DO_889(MACRO, __VA_ARGS__) #define MU_DO_891(MACRO, ...) \ MACRO(891, __VA_ARGS__) \ MU_DO_890(MACRO, __VA_ARGS__) #define MU_DO_892(MACRO, ...) \ MACRO(892, __VA_ARGS__) \ MU_DO_891(MACRO, __VA_ARGS__) #define MU_DO_893(MACRO, ...) \ MACRO(893, __VA_ARGS__) \ MU_DO_892(MACRO, __VA_ARGS__) #define MU_DO_894(MACRO, ...) \ MACRO(894, __VA_ARGS__) \ MU_DO_893(MACRO, __VA_ARGS__) #define MU_DO_895(MACRO, ...) \ MACRO(895, __VA_ARGS__) \ MU_DO_894(MACRO, __VA_ARGS__) #define MU_DO_896(MACRO, ...) \ MACRO(896, __VA_ARGS__) \ MU_DO_895(MACRO, __VA_ARGS__) #define MU_DO_897(MACRO, ...) \ MACRO(897, __VA_ARGS__) \ MU_DO_896(MACRO, __VA_ARGS__) #define MU_DO_898(MACRO, ...) \ MACRO(898, __VA_ARGS__) \ MU_DO_897(MACRO, __VA_ARGS__) #define MU_DO_899(MACRO, ...) \ MACRO(899, __VA_ARGS__) \ MU_DO_898(MACRO, __VA_ARGS__) #define MU_DO_900(MACRO, ...) \ MACRO(900, __VA_ARGS__) \ MU_DO_899(MACRO, __VA_ARGS__) #define MU_DO_901(MACRO, ...) \ MACRO(901, __VA_ARGS__) \ MU_DO_900(MACRO, __VA_ARGS__) #define MU_DO_902(MACRO, ...) \ MACRO(902, __VA_ARGS__) \ MU_DO_901(MACRO, __VA_ARGS__) #define MU_DO_903(MACRO, ...) \ MACRO(903, __VA_ARGS__) \ MU_DO_902(MACRO, __VA_ARGS__) #define MU_DO_904(MACRO, ...) \ MACRO(904, __VA_ARGS__) \ MU_DO_903(MACRO, __VA_ARGS__) #define MU_DO_905(MACRO, ...) \ MACRO(905, __VA_ARGS__) \ MU_DO_904(MACRO, __VA_ARGS__) #define MU_DO_906(MACRO, ...) \ MACRO(906, __VA_ARGS__) \ MU_DO_905(MACRO, __VA_ARGS__) #define MU_DO_907(MACRO, ...) \ MACRO(907, __VA_ARGS__) \ MU_DO_906(MACRO, __VA_ARGS__) #define MU_DO_908(MACRO, ...) \ MACRO(908, __VA_ARGS__) \ MU_DO_907(MACRO, __VA_ARGS__) #define MU_DO_909(MACRO, ...) \ MACRO(909, __VA_ARGS__) \ MU_DO_908(MACRO, __VA_ARGS__) #define MU_DO_910(MACRO, ...) \ MACRO(910, __VA_ARGS__) \ MU_DO_909(MACRO, __VA_ARGS__) #define MU_DO_911(MACRO, ...) \ MACRO(911, __VA_ARGS__) \ MU_DO_910(MACRO, __VA_ARGS__) #define MU_DO_912(MACRO, ...) \ MACRO(912, __VA_ARGS__) \ MU_DO_911(MACRO, __VA_ARGS__) #define MU_DO_913(MACRO, ...) \ MACRO(913, __VA_ARGS__) \ MU_DO_912(MACRO, __VA_ARGS__) #define MU_DO_914(MACRO, ...) \ MACRO(914, __VA_ARGS__) \ MU_DO_913(MACRO, __VA_ARGS__) #define MU_DO_915(MACRO, ...) \ MACRO(915, __VA_ARGS__) \ MU_DO_914(MACRO, __VA_ARGS__) #define MU_DO_916(MACRO, ...) \ MACRO(916, __VA_ARGS__) \ MU_DO_915(MACRO, __VA_ARGS__) #define MU_DO_917(MACRO, ...) \ MACRO(917, __VA_ARGS__) \ MU_DO_916(MACRO, __VA_ARGS__) #define MU_DO_918(MACRO, ...) \ MACRO(918, __VA_ARGS__) \ MU_DO_917(MACRO, __VA_ARGS__) #define MU_DO_919(MACRO, ...) \ MACRO(919, __VA_ARGS__) \ MU_DO_918(MACRO, __VA_ARGS__) #define MU_DO_920(MACRO, ...) \ MACRO(920, __VA_ARGS__) \ MU_DO_919(MACRO, __VA_ARGS__) #define MU_DO_921(MACRO, ...) \ MACRO(921, __VA_ARGS__) \ MU_DO_920(MACRO, __VA_ARGS__) #define MU_DO_922(MACRO, ...) \ MACRO(922, __VA_ARGS__) \ MU_DO_921(MACRO, __VA_ARGS__) #define MU_DO_923(MACRO, ...) \ MACRO(923, __VA_ARGS__) \ MU_DO_922(MACRO, __VA_ARGS__) #define MU_DO_924(MACRO, ...) \ MACRO(924, __VA_ARGS__) \ MU_DO_923(MACRO, __VA_ARGS__) #define MU_DO_925(MACRO, ...) \ MACRO(925, __VA_ARGS__) \ MU_DO_924(MACRO, __VA_ARGS__) #define MU_DO_926(MACRO, ...) \ MACRO(926, __VA_ARGS__) \ MU_DO_925(MACRO, __VA_ARGS__) #define MU_DO_927(MACRO, ...) \ MACRO(927, __VA_ARGS__) \ MU_DO_926(MACRO, __VA_ARGS__) #define MU_DO_928(MACRO, ...) \ MACRO(928, __VA_ARGS__) \ MU_DO_927(MACRO, __VA_ARGS__) #define MU_DO_929(MACRO, ...) \ MACRO(929, __VA_ARGS__) \ MU_DO_928(MACRO, __VA_ARGS__) #define MU_DO_930(MACRO, ...) \ MACRO(930, __VA_ARGS__) \ MU_DO_929(MACRO, __VA_ARGS__) #define MU_DO_931(MACRO, ...) \ MACRO(931, __VA_ARGS__) \ MU_DO_930(MACRO, __VA_ARGS__) #define MU_DO_932(MACRO, ...) \ MACRO(932, __VA_ARGS__) \ MU_DO_931(MACRO, __VA_ARGS__) #define MU_DO_933(MACRO, ...) \ MACRO(933, __VA_ARGS__) \ MU_DO_932(MACRO, __VA_ARGS__) #define MU_DO_934(MACRO, ...) \ MACRO(934, __VA_ARGS__) \ MU_DO_933(MACRO, __VA_ARGS__) #define MU_DO_935(MACRO, ...) \ MACRO(935, __VA_ARGS__) \ MU_DO_934(MACRO, __VA_ARGS__) #define MU_DO_936(MACRO, ...) \ MACRO(936, __VA_ARGS__) \ MU_DO_935(MACRO, __VA_ARGS__) #define MU_DO_937(MACRO, ...) \ MACRO(937, __VA_ARGS__) \ MU_DO_936(MACRO, __VA_ARGS__) #define MU_DO_938(MACRO, ...) \ MACRO(938, __VA_ARGS__) \ MU_DO_937(MACRO, __VA_ARGS__) #define MU_DO_939(MACRO, ...) \ MACRO(939, __VA_ARGS__) \ MU_DO_938(MACRO, __VA_ARGS__) #define MU_DO_940(MACRO, ...) \ MACRO(940, __VA_ARGS__) \ MU_DO_939(MACRO, __VA_ARGS__) #define MU_DO_941(MACRO, ...) \ MACRO(941, __VA_ARGS__) \ MU_DO_940(MACRO, __VA_ARGS__) #define MU_DO_942(MACRO, ...) \ MACRO(942, __VA_ARGS__) \ MU_DO_941(MACRO, __VA_ARGS__) #define MU_DO_943(MACRO, ...) \ MACRO(943, __VA_ARGS__) \ MU_DO_942(MACRO, __VA_ARGS__) #define MU_DO_944(MACRO, ...) \ MACRO(944, __VA_ARGS__) \ MU_DO_943(MACRO, __VA_ARGS__) #define MU_DO_945(MACRO, ...) \ MACRO(945, __VA_ARGS__) \ MU_DO_944(MACRO, __VA_ARGS__) #define MU_DO_946(MACRO, ...) \ MACRO(946, __VA_ARGS__) \ MU_DO_945(MACRO, __VA_ARGS__) #define MU_DO_947(MACRO, ...) \ MACRO(947, __VA_ARGS__) \ MU_DO_946(MACRO, __VA_ARGS__) #define MU_DO_948(MACRO, ...) \ MACRO(948, __VA_ARGS__) \ MU_DO_947(MACRO, __VA_ARGS__) #define MU_DO_949(MACRO, ...) \ MACRO(949, __VA_ARGS__) \ MU_DO_948(MACRO, __VA_ARGS__) #define MU_DO_950(MACRO, ...) \ MACRO(950, __VA_ARGS__) \ MU_DO_949(MACRO, __VA_ARGS__) #define MU_DO_951(MACRO, ...) \ MACRO(951, __VA_ARGS__) \ MU_DO_950(MACRO, __VA_ARGS__) #define MU_DO_952(MACRO, ...) \ MACRO(952, __VA_ARGS__) \ MU_DO_951(MACRO, __VA_ARGS__) #define MU_DO_953(MACRO, ...) \ MACRO(953, __VA_ARGS__) \ MU_DO_952(MACRO, __VA_ARGS__) #define MU_DO_954(MACRO, ...) \ MACRO(954, __VA_ARGS__) \ MU_DO_953(MACRO, __VA_ARGS__) #define MU_DO_955(MACRO, ...) \ MACRO(955, __VA_ARGS__) \ MU_DO_954(MACRO, __VA_ARGS__) #define MU_DO_956(MACRO, ...) \ MACRO(956, __VA_ARGS__) \ MU_DO_955(MACRO, __VA_ARGS__) #define MU_DO_957(MACRO, ...) \ MACRO(957, __VA_ARGS__) \ MU_DO_956(MACRO, __VA_ARGS__) #define MU_DO_958(MACRO, ...) \ MACRO(958, __VA_ARGS__) \ MU_DO_957(MACRO, __VA_ARGS__) #define MU_DO_959(MACRO, ...) \ MACRO(959, __VA_ARGS__) \ MU_DO_958(MACRO, __VA_ARGS__) #define MU_DO_960(MACRO, ...) \ MACRO(960, __VA_ARGS__) \ MU_DO_959(MACRO, __VA_ARGS__) #define MU_DO_961(MACRO, ...) \ MACRO(961, __VA_ARGS__) \ MU_DO_960(MACRO, __VA_ARGS__) #define MU_DO_962(MACRO, ...) \ MACRO(962, __VA_ARGS__) \ MU_DO_961(MACRO, __VA_ARGS__) #define MU_DO_963(MACRO, ...) \ MACRO(963, __VA_ARGS__) \ MU_DO_962(MACRO, __VA_ARGS__) #define MU_DO_964(MACRO, ...) \ MACRO(964, __VA_ARGS__) \ MU_DO_963(MACRO, __VA_ARGS__) #define MU_DO_965(MACRO, ...) \ MACRO(965, __VA_ARGS__) \ MU_DO_964(MACRO, __VA_ARGS__) #define MU_DO_966(MACRO, ...) \ MACRO(966, __VA_ARGS__) \ MU_DO_965(MACRO, __VA_ARGS__) #define MU_DO_967(MACRO, ...) \ MACRO(967, __VA_ARGS__) \ MU_DO_966(MACRO, __VA_ARGS__) #define MU_DO_968(MACRO, ...) \ MACRO(968, __VA_ARGS__) \ MU_DO_967(MACRO, __VA_ARGS__) #define MU_DO_969(MACRO, ...) \ MACRO(969, __VA_ARGS__) \ MU_DO_968(MACRO, __VA_ARGS__) #define MU_DO_970(MACRO, ...) \ MACRO(970, __VA_ARGS__) \ MU_DO_969(MACRO, __VA_ARGS__) #define MU_DO_971(MACRO, ...) \ MACRO(971, __VA_ARGS__) \ MU_DO_970(MACRO, __VA_ARGS__) #define MU_DO_972(MACRO, ...) \ MACRO(972, __VA_ARGS__) \ MU_DO_971(MACRO, __VA_ARGS__) #define MU_DO_973(MACRO, ...) \ MACRO(973, __VA_ARGS__) \ MU_DO_972(MACRO, __VA_ARGS__) #define MU_DO_974(MACRO, ...) \ MACRO(974, __VA_ARGS__) \ MU_DO_973(MACRO, __VA_ARGS__) #define MU_DO_975(MACRO, ...) \ MACRO(975, __VA_ARGS__) \ MU_DO_974(MACRO, __VA_ARGS__) #define MU_DO_976(MACRO, ...) \ MACRO(976, __VA_ARGS__) \ MU_DO_975(MACRO, __VA_ARGS__) #define MU_DO_977(MACRO, ...) \ MACRO(977, __VA_ARGS__) \ MU_DO_976(MACRO, __VA_ARGS__) #define MU_DO_978(MACRO, ...) \ MACRO(978, __VA_ARGS__) \ MU_DO_977(MACRO, __VA_ARGS__) #define MU_DO_979(MACRO, ...) \ MACRO(979, __VA_ARGS__) \ MU_DO_978(MACRO, __VA_ARGS__) #define MU_DO_980(MACRO, ...) \ MACRO(980, __VA_ARGS__) \ MU_DO_979(MACRO, __VA_ARGS__) #define MU_DO_981(MACRO, ...) \ MACRO(981, __VA_ARGS__) \ MU_DO_980(MACRO, __VA_ARGS__) #define MU_DO_982(MACRO, ...) \ MACRO(982, __VA_ARGS__) \ MU_DO_981(MACRO, __VA_ARGS__) #define MU_DO_983(MACRO, ...) \ MACRO(983, __VA_ARGS__) \ MU_DO_982(MACRO, __VA_ARGS__) #define MU_DO_984(MACRO, ...) \ MACRO(984, __VA_ARGS__) \ MU_DO_983(MACRO, __VA_ARGS__) #define MU_DO_985(MACRO, ...) \ MACRO(985, __VA_ARGS__) \ MU_DO_984(MACRO, __VA_ARGS__) #define MU_DO_986(MACRO, ...) \ MACRO(986, __VA_ARGS__) \ MU_DO_985(MACRO, __VA_ARGS__) #define MU_DO_987(MACRO, ...) \ MACRO(987, __VA_ARGS__) \ MU_DO_986(MACRO, __VA_ARGS__) #define MU_DO_988(MACRO, ...) \ MACRO(988, __VA_ARGS__) \ MU_DO_987(MACRO, __VA_ARGS__) #define MU_DO_989(MACRO, ...) \ MACRO(989, __VA_ARGS__) \ MU_DO_988(MACRO, __VA_ARGS__) #define MU_DO_990(MACRO, ...) \ MACRO(990, __VA_ARGS__) \ MU_DO_989(MACRO, __VA_ARGS__) #define MU_DO_991(MACRO, ...) \ MACRO(991, __VA_ARGS__) \ MU_DO_990(MACRO, __VA_ARGS__) #define MU_DO_992(MACRO, ...) \ MACRO(992, __VA_ARGS__) \ MU_DO_991(MACRO, __VA_ARGS__) #define MU_DO_993(MACRO, ...) \ MACRO(993, __VA_ARGS__) \ MU_DO_992(MACRO, __VA_ARGS__) #define MU_DO_994(MACRO, ...) \ MACRO(994, __VA_ARGS__) \ MU_DO_993(MACRO, __VA_ARGS__) #define MU_DO_995(MACRO, ...) \ MACRO(995, __VA_ARGS__) \ MU_DO_994(MACRO, __VA_ARGS__) #define MU_DO_996(MACRO, ...) \ MACRO(996, __VA_ARGS__) \ MU_DO_995(MACRO, __VA_ARGS__) #define MU_DO_997(MACRO, ...) \ MACRO(997, __VA_ARGS__) \ MU_DO_996(MACRO, __VA_ARGS__) #define MU_DO_998(MACRO, ...) \ MACRO(998, __VA_ARGS__) \ MU_DO_997(MACRO, __VA_ARGS__) #define MU_DO_999(MACRO, ...) \ MACRO(999, __VA_ARGS__) \ MU_DO_998(MACRO, __VA_ARGS__) #define MU_DO_1000(MACRO, ...) \ MACRO(1000, __VA_ARGS__) \ MU_DO_999(MACRO, __VA_ARGS__) #define MU_DO_1001(MACRO, ...) \ MACRO(1001, __VA_ARGS__) \ MU_DO_1000(MACRO, __VA_ARGS__) #define MU_DO_1002(MACRO, ...) \ MACRO(1002, __VA_ARGS__) \ MU_DO_1001(MACRO, __VA_ARGS__) #define MU_DO_1003(MACRO, ...) \ MACRO(1003, __VA_ARGS__) \ MU_DO_1002(MACRO, __VA_ARGS__) #define MU_DO_1004(MACRO, ...) \ MACRO(1004, __VA_ARGS__) \ MU_DO_1003(MACRO, __VA_ARGS__) #define MU_DO_1005(MACRO, ...) \ MACRO(1005, __VA_ARGS__) \ MU_DO_1004(MACRO, __VA_ARGS__) #define MU_DO_1006(MACRO, ...) \ MACRO(1006, __VA_ARGS__) \ MU_DO_1005(MACRO, __VA_ARGS__) #define MU_DO_1007(MACRO, ...) \ MACRO(1007, __VA_ARGS__) \ MU_DO_1006(MACRO, __VA_ARGS__) #define MU_DO_1008(MACRO, ...) \ MACRO(1008, __VA_ARGS__) \ MU_DO_1007(MACRO, __VA_ARGS__) #define MU_DO_1009(MACRO, ...) \ MACRO(1009, __VA_ARGS__) \ MU_DO_1008(MACRO, __VA_ARGS__) #define MU_DO_1010(MACRO, ...) \ MACRO(1010, __VA_ARGS__) \ MU_DO_1009(MACRO, __VA_ARGS__) #define MU_DO_1011(MACRO, ...) \ MACRO(1011, __VA_ARGS__) \ MU_DO_1010(MACRO, __VA_ARGS__) #define MU_DO_1012(MACRO, ...) \ MACRO(1012, __VA_ARGS__) \ MU_DO_1011(MACRO, __VA_ARGS__) #define MU_DO_1013(MACRO, ...) \ MACRO(1013, __VA_ARGS__) \ MU_DO_1012(MACRO, __VA_ARGS__) #define MU_DO_1014(MACRO, ...) \ MACRO(1014, __VA_ARGS__) \ MU_DO_1013(MACRO, __VA_ARGS__) #define MU_DO_1015(MACRO, ...) \ MACRO(1015, __VA_ARGS__) \ MU_DO_1014(MACRO, __VA_ARGS__) #define MU_DO_1016(MACRO, ...) \ MACRO(1016, __VA_ARGS__) \ MU_DO_1015(MACRO, __VA_ARGS__) #define MU_DO_1017(MACRO, ...) \ MACRO(1017, __VA_ARGS__) \ MU_DO_1016(MACRO, __VA_ARGS__) #define MU_DO_1018(MACRO, ...) \ MACRO(1018, __VA_ARGS__) \ MU_DO_1017(MACRO, __VA_ARGS__) #define MU_DO_1019(MACRO, ...) \ MACRO(1019, __VA_ARGS__) \ MU_DO_1018(MACRO, __VA_ARGS__) #define MU_DO_1020(MACRO, ...) \ MACRO(1020, __VA_ARGS__) \ MU_DO_1019(MACRO, __VA_ARGS__) #define MU_DO_1021(MACRO, ...) \ MACRO(1021, __VA_ARGS__) \ MU_DO_1020(MACRO, __VA_ARGS__) #define MU_DO_1022(MACRO, ...) \ MACRO(1022, __VA_ARGS__) \ MU_DO_1021(MACRO, __VA_ARGS__) #define MU_DO_1023(MACRO, ...) \ MACRO(1023, __VA_ARGS__) \ MU_DO_1022(MACRO, __VA_ARGS__) #define MU_DO_1024(MACRO, ...) \ MACRO(1024, __VA_ARGS__) \ MU_DO_1023(MACRO, __VA_ARGS__) #define MU_DO_1025(MACRO, ...) \ MACRO(1025, __VA_ARGS__) \ MU_DO_1024(MACRO, __VA_ARGS__) #define MU_DO_1026(MACRO, ...) \ MACRO(1026, __VA_ARGS__) \ MU_DO_1025(MACRO, __VA_ARGS__) #define MU_DO_1027(MACRO, ...) \ MACRO(1027, __VA_ARGS__) \ MU_DO_1026(MACRO, __VA_ARGS__) #define MU_DO_1028(MACRO, ...) \ MACRO(1028, __VA_ARGS__) \ MU_DO_1027(MACRO, __VA_ARGS__) #define MU_DO_1029(MACRO, ...) \ MACRO(1029, __VA_ARGS__) \ MU_DO_1028(MACRO, __VA_ARGS__) #define MU_DO_1030(MACRO, ...) \ MACRO(1030, __VA_ARGS__) \ MU_DO_1029(MACRO, __VA_ARGS__) #define MU_DO_1031(MACRO, ...) \ MACRO(1031, __VA_ARGS__) \ MU_DO_1030(MACRO, __VA_ARGS__) #define MU_DO_1032(MACRO, ...) \ MACRO(1032, __VA_ARGS__) \ MU_DO_1031(MACRO, __VA_ARGS__) #define MU_DO_1033(MACRO, ...) \ MACRO(1033, __VA_ARGS__) \ MU_DO_1032(MACRO, __VA_ARGS__) #define MU_DO_1034(MACRO, ...) \ MACRO(1034, __VA_ARGS__) \ MU_DO_1033(MACRO, __VA_ARGS__) #define MU_DO_1035(MACRO, ...) \ MACRO(1035, __VA_ARGS__) \ MU_DO_1034(MACRO, __VA_ARGS__) #define MU_DO_1036(MACRO, ...) \ MACRO(1036, __VA_ARGS__) \ MU_DO_1035(MACRO, __VA_ARGS__) #define MU_DO_1037(MACRO, ...) \ MACRO(1037, __VA_ARGS__) \ MU_DO_1036(MACRO, __VA_ARGS__) #define MU_DO_1038(MACRO, ...) \ MACRO(1038, __VA_ARGS__) \ MU_DO_1037(MACRO, __VA_ARGS__) #define MU_DO_1039(MACRO, ...) \ MACRO(1039, __VA_ARGS__) \ MU_DO_1038(MACRO, __VA_ARGS__) #define MU_DO_1040(MACRO, ...) \ MACRO(1040, __VA_ARGS__) \ MU_DO_1039(MACRO, __VA_ARGS__) #define MU_DO_1041(MACRO, ...) \ MACRO(1041, __VA_ARGS__) \ MU_DO_1040(MACRO, __VA_ARGS__) #define MU_DO_1042(MACRO, ...) \ MACRO(1042, __VA_ARGS__) \ MU_DO_1041(MACRO, __VA_ARGS__) #define MU_DO_1043(MACRO, ...) \ MACRO(1043, __VA_ARGS__) \ MU_DO_1042(MACRO, __VA_ARGS__) #define MU_DO_1044(MACRO, ...) \ MACRO(1044, __VA_ARGS__) \ MU_DO_1043(MACRO, __VA_ARGS__) #define MU_DO_1045(MACRO, ...) \ MACRO(1045, __VA_ARGS__) \ MU_DO_1044(MACRO, __VA_ARGS__) #define MU_DO_1046(MACRO, ...) \ MACRO(1046, __VA_ARGS__) \ MU_DO_1045(MACRO, __VA_ARGS__) #define MU_DO_1047(MACRO, ...) \ MACRO(1047, __VA_ARGS__) \ MU_DO_1046(MACRO, __VA_ARGS__) #define MU_DO_1048(MACRO, ...) \ MACRO(1048, __VA_ARGS__) \ MU_DO_1047(MACRO, __VA_ARGS__) #define MU_DO_1049(MACRO, ...) \ MACRO(1049, __VA_ARGS__) \ MU_DO_1048(MACRO, __VA_ARGS__) #define MU_DO_1050(MACRO, ...) \ MACRO(1050, __VA_ARGS__) \ MU_DO_1049(MACRO, __VA_ARGS__) #define MU_DO_1051(MACRO, ...) \ MACRO(1051, __VA_ARGS__) \ MU_DO_1050(MACRO, __VA_ARGS__) #define MU_DO_1052(MACRO, ...) \ MACRO(1052, __VA_ARGS__) \ MU_DO_1051(MACRO, __VA_ARGS__) #define MU_DO_1053(MACRO, ...) \ MACRO(1053, __VA_ARGS__) \ MU_DO_1052(MACRO, __VA_ARGS__) #define MU_DO_1054(MACRO, ...) \ MACRO(1054, __VA_ARGS__) \ MU_DO_1053(MACRO, __VA_ARGS__) #define MU_DO_1055(MACRO, ...) \ MACRO(1055, __VA_ARGS__) \ MU_DO_1054(MACRO, __VA_ARGS__) #define MU_DO_1056(MACRO, ...) \ MACRO(1056, __VA_ARGS__) \ MU_DO_1055(MACRO, __VA_ARGS__) #define MU_DO_1057(MACRO, ...) \ MACRO(1057, __VA_ARGS__) \ MU_DO_1056(MACRO, __VA_ARGS__) #define MU_DO_1058(MACRO, ...) \ MACRO(1058, __VA_ARGS__) \ MU_DO_1057(MACRO, __VA_ARGS__) #define MU_DO_1059(MACRO, ...) \ MACRO(1059, __VA_ARGS__) \ MU_DO_1058(MACRO, __VA_ARGS__) #define MU_DO_1060(MACRO, ...) \ MACRO(1060, __VA_ARGS__) \ MU_DO_1059(MACRO, __VA_ARGS__) #define MU_DO_1061(MACRO, ...) \ MACRO(1061, __VA_ARGS__) \ MU_DO_1060(MACRO, __VA_ARGS__) #define MU_DO_1062(MACRO, ...) \ MACRO(1062, __VA_ARGS__) \ MU_DO_1061(MACRO, __VA_ARGS__) #define MU_DO_1063(MACRO, ...) \ MACRO(1063, __VA_ARGS__) \ MU_DO_1062(MACRO, __VA_ARGS__) #define MU_DO_1064(MACRO, ...) \ MACRO(1064, __VA_ARGS__) \ MU_DO_1063(MACRO, __VA_ARGS__) #define MU_DO_1065(MACRO, ...) \ MACRO(1065, __VA_ARGS__) \ MU_DO_1064(MACRO, __VA_ARGS__) #define MU_DO_1066(MACRO, ...) \ MACRO(1066, __VA_ARGS__) \ MU_DO_1065(MACRO, __VA_ARGS__) #define MU_DO_1067(MACRO, ...) \ MACRO(1067, __VA_ARGS__) \ MU_DO_1066(MACRO, __VA_ARGS__) #define MU_DO_1068(MACRO, ...) \ MACRO(1068, __VA_ARGS__) \ MU_DO_1067(MACRO, __VA_ARGS__) #define MU_DO_1069(MACRO, ...) \ MACRO(1069, __VA_ARGS__) \ MU_DO_1068(MACRO, __VA_ARGS__) #define MU_DO_1070(MACRO, ...) \ MACRO(1070, __VA_ARGS__) \ MU_DO_1069(MACRO, __VA_ARGS__) #define MU_DO_1071(MACRO, ...) \ MACRO(1071, __VA_ARGS__) \ MU_DO_1070(MACRO, __VA_ARGS__) #define MU_DO_1072(MACRO, ...) \ MACRO(1072, __VA_ARGS__) \ MU_DO_1071(MACRO, __VA_ARGS__) #define MU_DO_1073(MACRO, ...) \ MACRO(1073, __VA_ARGS__) \ MU_DO_1072(MACRO, __VA_ARGS__) #define MU_DO_1074(MACRO, ...) \ MACRO(1074, __VA_ARGS__) \ MU_DO_1073(MACRO, __VA_ARGS__) #define MU_DO_1075(MACRO, ...) \ MACRO(1075, __VA_ARGS__) \ MU_DO_1074(MACRO, __VA_ARGS__) #define MU_DO_1076(MACRO, ...) \ MACRO(1076, __VA_ARGS__) \ MU_DO_1075(MACRO, __VA_ARGS__) #define MU_DO_1077(MACRO, ...) \ MACRO(1077, __VA_ARGS__) \ MU_DO_1076(MACRO, __VA_ARGS__) #define MU_DO_1078(MACRO, ...) \ MACRO(1078, __VA_ARGS__) \ MU_DO_1077(MACRO, __VA_ARGS__) #define MU_DO_1079(MACRO, ...) \ MACRO(1079, __VA_ARGS__) \ MU_DO_1078(MACRO, __VA_ARGS__) #define MU_DO_1080(MACRO, ...) \ MACRO(1080, __VA_ARGS__) \ MU_DO_1079(MACRO, __VA_ARGS__) #define MU_DO_1081(MACRO, ...) \ MACRO(1081, __VA_ARGS__) \ MU_DO_1080(MACRO, __VA_ARGS__) #define MU_DO_1082(MACRO, ...) \ MACRO(1082, __VA_ARGS__) \ MU_DO_1081(MACRO, __VA_ARGS__) #define MU_DO_1083(MACRO, ...) \ MACRO(1083, __VA_ARGS__) \ MU_DO_1082(MACRO, __VA_ARGS__) #define MU_DO_1084(MACRO, ...) \ MACRO(1084, __VA_ARGS__) \ MU_DO_1083(MACRO, __VA_ARGS__) #define MU_DO_1085(MACRO, ...) \ MACRO(1085, __VA_ARGS__) \ MU_DO_1084(MACRO, __VA_ARGS__) #define MU_DO_1086(MACRO, ...) \ MACRO(1086, __VA_ARGS__) \ MU_DO_1085(MACRO, __VA_ARGS__) #define MU_DO_1087(MACRO, ...) \ MACRO(1087, __VA_ARGS__) \ MU_DO_1086(MACRO, __VA_ARGS__) #define MU_DO_1088(MACRO, ...) \ MACRO(1088, __VA_ARGS__) \ MU_DO_1087(MACRO, __VA_ARGS__) #define MU_DO_1089(MACRO, ...) \ MACRO(1089, __VA_ARGS__) \ MU_DO_1088(MACRO, __VA_ARGS__) #define MU_DO_1090(MACRO, ...) \ MACRO(1090, __VA_ARGS__) \ MU_DO_1089(MACRO, __VA_ARGS__) #define MU_DO_1091(MACRO, ...) \ MACRO(1091, __VA_ARGS__) \ MU_DO_1090(MACRO, __VA_ARGS__) #define MU_DO_1092(MACRO, ...) \ MACRO(1092, __VA_ARGS__) \ MU_DO_1091(MACRO, __VA_ARGS__) #define MU_DO_1093(MACRO, ...) \ MACRO(1093, __VA_ARGS__) \ MU_DO_1092(MACRO, __VA_ARGS__) #define MU_DO_1094(MACRO, ...) \ MACRO(1094, __VA_ARGS__) \ MU_DO_1093(MACRO, __VA_ARGS__) #define MU_DO_1095(MACRO, ...) \ MACRO(1095, __VA_ARGS__) \ MU_DO_1094(MACRO, __VA_ARGS__) #define MU_DO_1096(MACRO, ...) \ MACRO(1096, __VA_ARGS__) \ MU_DO_1095(MACRO, __VA_ARGS__) #define MU_DO_1097(MACRO, ...) \ MACRO(1097, __VA_ARGS__) \ MU_DO_1096(MACRO, __VA_ARGS__) #define MU_DO_1098(MACRO, ...) \ MACRO(1098, __VA_ARGS__) \ MU_DO_1097(MACRO, __VA_ARGS__) #define MU_DO_1099(MACRO, ...) \ MACRO(1099, __VA_ARGS__) \ MU_DO_1098(MACRO, __VA_ARGS__) #define MU_DO_1100(MACRO, ...) \ MACRO(1100, __VA_ARGS__) \ MU_DO_1099(MACRO, __VA_ARGS__) #define MU_DO_1101(MACRO, ...) \ MACRO(1101, __VA_ARGS__) \ MU_DO_1100(MACRO, __VA_ARGS__) #define MU_DO_1102(MACRO, ...) \ MACRO(1102, __VA_ARGS__) \ MU_DO_1101(MACRO, __VA_ARGS__) #define MU_DO_1103(MACRO, ...) \ MACRO(1103, __VA_ARGS__) \ MU_DO_1102(MACRO, __VA_ARGS__) #define MU_DO_1104(MACRO, ...) \ MACRO(1104, __VA_ARGS__) \ MU_DO_1103(MACRO, __VA_ARGS__) #define MU_DO_1105(MACRO, ...) \ MACRO(1105, __VA_ARGS__) \ MU_DO_1104(MACRO, __VA_ARGS__) #define MU_DO_1106(MACRO, ...) \ MACRO(1106, __VA_ARGS__) \ MU_DO_1105(MACRO, __VA_ARGS__) #define MU_DO_1107(MACRO, ...) \ MACRO(1107, __VA_ARGS__) \ MU_DO_1106(MACRO, __VA_ARGS__) #define MU_DO_1108(MACRO, ...) \ MACRO(1108, __VA_ARGS__) \ MU_DO_1107(MACRO, __VA_ARGS__) #define MU_DO_1109(MACRO, ...) \ MACRO(1109, __VA_ARGS__) \ MU_DO_1108(MACRO, __VA_ARGS__) #define MU_DO_1110(MACRO, ...) \ MACRO(1110, __VA_ARGS__) \ MU_DO_1109(MACRO, __VA_ARGS__) #define MU_DO_1111(MACRO, ...) \ MACRO(1111, __VA_ARGS__) \ MU_DO_1110(MACRO, __VA_ARGS__) #define MU_DO_1112(MACRO, ...) \ MACRO(1112, __VA_ARGS__) \ MU_DO_1111(MACRO, __VA_ARGS__) #define MU_DO_1113(MACRO, ...) \ MACRO(1113, __VA_ARGS__) \ MU_DO_1112(MACRO, __VA_ARGS__) #define MU_DO_1114(MACRO, ...) \ MACRO(1114, __VA_ARGS__) \ MU_DO_1113(MACRO, __VA_ARGS__) #define MU_DO_1115(MACRO, ...) \ MACRO(1115, __VA_ARGS__) \ MU_DO_1114(MACRO, __VA_ARGS__) #define MU_DO_1116(MACRO, ...) \ MACRO(1116, __VA_ARGS__) \ MU_DO_1115(MACRO, __VA_ARGS__) #define MU_DO_1117(MACRO, ...) \ MACRO(1117, __VA_ARGS__) \ MU_DO_1116(MACRO, __VA_ARGS__) #define MU_DO_1118(MACRO, ...) \ MACRO(1118, __VA_ARGS__) \ MU_DO_1117(MACRO, __VA_ARGS__) #define MU_DO_1119(MACRO, ...) \ MACRO(1119, __VA_ARGS__) \ MU_DO_1118(MACRO, __VA_ARGS__) #define MU_DO_1120(MACRO, ...) \ MACRO(1120, __VA_ARGS__) \ MU_DO_1119(MACRO, __VA_ARGS__) #define MU_DO_1121(MACRO, ...) \ MACRO(1121, __VA_ARGS__) \ MU_DO_1120(MACRO, __VA_ARGS__) #define MU_DO_1122(MACRO, ...) \ MACRO(1122, __VA_ARGS__) \ MU_DO_1121(MACRO, __VA_ARGS__) #define MU_DO_1123(MACRO, ...) \ MACRO(1123, __VA_ARGS__) \ MU_DO_1122(MACRO, __VA_ARGS__) #define MU_DO_1124(MACRO, ...) \ MACRO(1124, __VA_ARGS__) \ MU_DO_1123(MACRO, __VA_ARGS__) #define MU_DO_1125(MACRO, ...) \ MACRO(1125, __VA_ARGS__) \ MU_DO_1124(MACRO, __VA_ARGS__) #define MU_DO_1126(MACRO, ...) \ MACRO(1126, __VA_ARGS__) \ MU_DO_1125(MACRO, __VA_ARGS__) #define MU_DO_1127(MACRO, ...) \ MACRO(1127, __VA_ARGS__) \ MU_DO_1126(MACRO, __VA_ARGS__) #define MU_DO_1128(MACRO, ...) \ MACRO(1128, __VA_ARGS__) \ MU_DO_1127(MACRO, __VA_ARGS__) #define MU_DO_1129(MACRO, ...) \ MACRO(1129, __VA_ARGS__) \ MU_DO_1128(MACRO, __VA_ARGS__) #define MU_DO_1130(MACRO, ...) \ MACRO(1130, __VA_ARGS__) \ MU_DO_1129(MACRO, __VA_ARGS__) #define MU_DO_1131(MACRO, ...) \ MACRO(1131, __VA_ARGS__) \ MU_DO_1130(MACRO, __VA_ARGS__) #define MU_DO_1132(MACRO, ...) \ MACRO(1132, __VA_ARGS__) \ MU_DO_1131(MACRO, __VA_ARGS__) #define MU_DO_1133(MACRO, ...) \ MACRO(1133, __VA_ARGS__) \ MU_DO_1132(MACRO, __VA_ARGS__) #define MU_DO_1134(MACRO, ...) \ MACRO(1134, __VA_ARGS__) \ MU_DO_1133(MACRO, __VA_ARGS__) #define MU_DO_1135(MACRO, ...) \ MACRO(1135, __VA_ARGS__) \ MU_DO_1134(MACRO, __VA_ARGS__) #define MU_DO_1136(MACRO, ...) \ MACRO(1136, __VA_ARGS__) \ MU_DO_1135(MACRO, __VA_ARGS__) #define MU_DO_1137(MACRO, ...) \ MACRO(1137, __VA_ARGS__) \ MU_DO_1136(MACRO, __VA_ARGS__) #define MU_DO_1138(MACRO, ...) \ MACRO(1138, __VA_ARGS__) \ MU_DO_1137(MACRO, __VA_ARGS__) #define MU_DO_1139(MACRO, ...) \ MACRO(1139, __VA_ARGS__) \ MU_DO_1138(MACRO, __VA_ARGS__) #define MU_DO_1140(MACRO, ...) \ MACRO(1140, __VA_ARGS__) \ MU_DO_1139(MACRO, __VA_ARGS__) #define MU_DO_1141(MACRO, ...) \ MACRO(1141, __VA_ARGS__) \ MU_DO_1140(MACRO, __VA_ARGS__) #define MU_DO_1142(MACRO, ...) \ MACRO(1142, __VA_ARGS__) \ MU_DO_1141(MACRO, __VA_ARGS__) #define MU_DO_1143(MACRO, ...) \ MACRO(1143, __VA_ARGS__) \ MU_DO_1142(MACRO, __VA_ARGS__) #define MU_DO_1144(MACRO, ...) \ MACRO(1144, __VA_ARGS__) \ MU_DO_1143(MACRO, __VA_ARGS__) #define MU_DO_1145(MACRO, ...) \ MACRO(1145, __VA_ARGS__) \ MU_DO_1144(MACRO, __VA_ARGS__) #define MU_DO_1146(MACRO, ...) \ MACRO(1146, __VA_ARGS__) \ MU_DO_1145(MACRO, __VA_ARGS__) #define MU_DO_1147(MACRO, ...) \ MACRO(1147, __VA_ARGS__) \ MU_DO_1146(MACRO, __VA_ARGS__) #define MU_DO_1148(MACRO, ...) \ MACRO(1148, __VA_ARGS__) \ MU_DO_1147(MACRO, __VA_ARGS__) #define MU_DO_1149(MACRO, ...) \ MACRO(1149, __VA_ARGS__) \ MU_DO_1148(MACRO, __VA_ARGS__) #define MU_DO_1150(MACRO, ...) \ MACRO(1150, __VA_ARGS__) \ MU_DO_1149(MACRO, __VA_ARGS__) #define MU_DO_1151(MACRO, ...) \ MACRO(1151, __VA_ARGS__) \ MU_DO_1150(MACRO, __VA_ARGS__) #define MU_DO_1152(MACRO, ...) \ MACRO(1152, __VA_ARGS__) \ MU_DO_1151(MACRO, __VA_ARGS__) #define MU_DO_1153(MACRO, ...) \ MACRO(1153, __VA_ARGS__) \ MU_DO_1152(MACRO, __VA_ARGS__) #define MU_DO_1154(MACRO, ...) \ MACRO(1154, __VA_ARGS__) \ MU_DO_1153(MACRO, __VA_ARGS__) #define MU_DO_1155(MACRO, ...) \ MACRO(1155, __VA_ARGS__) \ MU_DO_1154(MACRO, __VA_ARGS__) #define MU_DO_1156(MACRO, ...) \ MACRO(1156, __VA_ARGS__) \ MU_DO_1155(MACRO, __VA_ARGS__) #define MU_DO_1157(MACRO, ...) \ MACRO(1157, __VA_ARGS__) \ MU_DO_1156(MACRO, __VA_ARGS__) #define MU_DO_1158(MACRO, ...) \ MACRO(1158, __VA_ARGS__) \ MU_DO_1157(MACRO, __VA_ARGS__) #define MU_DO_1159(MACRO, ...) \ MACRO(1159, __VA_ARGS__) \ MU_DO_1158(MACRO, __VA_ARGS__) #define MU_DO_1160(MACRO, ...) \ MACRO(1160, __VA_ARGS__) \ MU_DO_1159(MACRO, __VA_ARGS__) #define MU_DO_1161(MACRO, ...) \ MACRO(1161, __VA_ARGS__) \ MU_DO_1160(MACRO, __VA_ARGS__) #define MU_DO_1162(MACRO, ...) \ MACRO(1162, __VA_ARGS__) \ MU_DO_1161(MACRO, __VA_ARGS__) #define MU_DO_1163(MACRO, ...) \ MACRO(1163, __VA_ARGS__) \ MU_DO_1162(MACRO, __VA_ARGS__) #define MU_DO_1164(MACRO, ...) \ MACRO(1164, __VA_ARGS__) \ MU_DO_1163(MACRO, __VA_ARGS__) #define MU_DO_1165(MACRO, ...) \ MACRO(1165, __VA_ARGS__) \ MU_DO_1164(MACRO, __VA_ARGS__) #define MU_DO_1166(MACRO, ...) \ MACRO(1166, __VA_ARGS__) \ MU_DO_1165(MACRO, __VA_ARGS__) #define MU_DO_1167(MACRO, ...) \ MACRO(1167, __VA_ARGS__) \ MU_DO_1166(MACRO, __VA_ARGS__) #define MU_DO_1168(MACRO, ...) \ MACRO(1168, __VA_ARGS__) \ MU_DO_1167(MACRO, __VA_ARGS__) #define MU_DO_1169(MACRO, ...) \ MACRO(1169, __VA_ARGS__) \ MU_DO_1168(MACRO, __VA_ARGS__) #define MU_DO_1170(MACRO, ...) \ MACRO(1170, __VA_ARGS__) \ MU_DO_1169(MACRO, __VA_ARGS__) #define MU_DO_1171(MACRO, ...) \ MACRO(1171, __VA_ARGS__) \ MU_DO_1170(MACRO, __VA_ARGS__) #define MU_DO_1172(MACRO, ...) \ MACRO(1172, __VA_ARGS__) \ MU_DO_1171(MACRO, __VA_ARGS__) #define MU_DO_1173(MACRO, ...) \ MACRO(1173, __VA_ARGS__) \ MU_DO_1172(MACRO, __VA_ARGS__) #define MU_DO_1174(MACRO, ...) \ MACRO(1174, __VA_ARGS__) \ MU_DO_1173(MACRO, __VA_ARGS__) #define MU_DO_1175(MACRO, ...) \ MACRO(1175, __VA_ARGS__) \ MU_DO_1174(MACRO, __VA_ARGS__) #define MU_DO_1176(MACRO, ...) \ MACRO(1176, __VA_ARGS__) \ MU_DO_1175(MACRO, __VA_ARGS__) #define MU_DO_1177(MACRO, ...) \ MACRO(1177, __VA_ARGS__) \ MU_DO_1176(MACRO, __VA_ARGS__) #define MU_DO_1178(MACRO, ...) \ MACRO(1178, __VA_ARGS__) \ MU_DO_1177(MACRO, __VA_ARGS__) #define MU_DO_1179(MACRO, ...) \ MACRO(1179, __VA_ARGS__) \ MU_DO_1178(MACRO, __VA_ARGS__) #define MU_DO_1180(MACRO, ...) \ MACRO(1180, __VA_ARGS__) \ MU_DO_1179(MACRO, __VA_ARGS__) #define MU_DO_1181(MACRO, ...) \ MACRO(1181, __VA_ARGS__) \ MU_DO_1180(MACRO, __VA_ARGS__) #define MU_DO_1182(MACRO, ...) \ MACRO(1182, __VA_ARGS__) \ MU_DO_1181(MACRO, __VA_ARGS__) #define MU_DO_1183(MACRO, ...) \ MACRO(1183, __VA_ARGS__) \ MU_DO_1182(MACRO, __VA_ARGS__) #define MU_DO_1184(MACRO, ...) \ MACRO(1184, __VA_ARGS__) \ MU_DO_1183(MACRO, __VA_ARGS__) #define MU_DO_1185(MACRO, ...) \ MACRO(1185, __VA_ARGS__) \ MU_DO_1184(MACRO, __VA_ARGS__) #define MU_DO_1186(MACRO, ...) \ MACRO(1186, __VA_ARGS__) \ MU_DO_1185(MACRO, __VA_ARGS__) #define MU_DO_1187(MACRO, ...) \ MACRO(1187, __VA_ARGS__) \ MU_DO_1186(MACRO, __VA_ARGS__) #define MU_DO_1188(MACRO, ...) \ MACRO(1188, __VA_ARGS__) \ MU_DO_1187(MACRO, __VA_ARGS__) #define MU_DO_1189(MACRO, ...) \ MACRO(1189, __VA_ARGS__) \ MU_DO_1188(MACRO, __VA_ARGS__) #define MU_DO_1190(MACRO, ...) \ MACRO(1190, __VA_ARGS__) \ MU_DO_1189(MACRO, __VA_ARGS__) #define MU_DO_1191(MACRO, ...) \ MACRO(1191, __VA_ARGS__) \ MU_DO_1190(MACRO, __VA_ARGS__) #define MU_DO_1192(MACRO, ...) \ MACRO(1192, __VA_ARGS__) \ MU_DO_1191(MACRO, __VA_ARGS__) #define MU_DO_1193(MACRO, ...) \ MACRO(1193, __VA_ARGS__) \ MU_DO_1192(MACRO, __VA_ARGS__) #define MU_DO_1194(MACRO, ...) \ MACRO(1194, __VA_ARGS__) \ MU_DO_1193(MACRO, __VA_ARGS__) #define MU_DO_1195(MACRO, ...) \ MACRO(1195, __VA_ARGS__) \ MU_DO_1194(MACRO, __VA_ARGS__) #define MU_DO_1196(MACRO, ...) \ MACRO(1196, __VA_ARGS__) \ MU_DO_1195(MACRO, __VA_ARGS__) #define MU_DO_1197(MACRO, ...) \ MACRO(1197, __VA_ARGS__) \ MU_DO_1196(MACRO, __VA_ARGS__) #define MU_DO_1198(MACRO, ...) \ MACRO(1198, __VA_ARGS__) \ MU_DO_1197(MACRO, __VA_ARGS__) #define MU_DO_1199(MACRO, ...) \ MACRO(1199, __VA_ARGS__) \ MU_DO_1198(MACRO, __VA_ARGS__) #define MU_DO_1200(MACRO, ...) \ MACRO(1200, __VA_ARGS__) \ MU_DO_1199(MACRO, __VA_ARGS__) #define MU_DO_1201(MACRO, ...) \ MACRO(1201, __VA_ARGS__) \ MU_DO_1200(MACRO, __VA_ARGS__) #define MU_DO_1202(MACRO, ...) \ MACRO(1202, __VA_ARGS__) \ MU_DO_1201(MACRO, __VA_ARGS__) #define MU_DO_1203(MACRO, ...) \ MACRO(1203, __VA_ARGS__) \ MU_DO_1202(MACRO, __VA_ARGS__) #define MU_DO_1204(MACRO, ...) \ MACRO(1204, __VA_ARGS__) \ MU_DO_1203(MACRO, __VA_ARGS__) #define MU_DO_1205(MACRO, ...) \ MACRO(1205, __VA_ARGS__) \ MU_DO_1204(MACRO, __VA_ARGS__) #define MU_DO_1206(MACRO, ...) \ MACRO(1206, __VA_ARGS__) \ MU_DO_1205(MACRO, __VA_ARGS__) #define MU_DO_1207(MACRO, ...) \ MACRO(1207, __VA_ARGS__) \ MU_DO_1206(MACRO, __VA_ARGS__) #define MU_DO_1208(MACRO, ...) \ MACRO(1208, __VA_ARGS__) \ MU_DO_1207(MACRO, __VA_ARGS__) #define MU_DO_1209(MACRO, ...) \ MACRO(1209, __VA_ARGS__) \ MU_DO_1208(MACRO, __VA_ARGS__) #define MU_DO_1210(MACRO, ...) \ MACRO(1210, __VA_ARGS__) \ MU_DO_1209(MACRO, __VA_ARGS__) #define MU_DO_1211(MACRO, ...) \ MACRO(1211, __VA_ARGS__) \ MU_DO_1210(MACRO, __VA_ARGS__) #define MU_DO_1212(MACRO, ...) \ MACRO(1212, __VA_ARGS__) \ MU_DO_1211(MACRO, __VA_ARGS__) #define MU_DO_1213(MACRO, ...) \ MACRO(1213, __VA_ARGS__) \ MU_DO_1212(MACRO, __VA_ARGS__) #define MU_DO_1214(MACRO, ...) \ MACRO(1214, __VA_ARGS__) \ MU_DO_1213(MACRO, __VA_ARGS__) #define MU_DO_1215(MACRO, ...) \ MACRO(1215, __VA_ARGS__) \ MU_DO_1214(MACRO, __VA_ARGS__) #define MU_DO_1216(MACRO, ...) \ MACRO(1216, __VA_ARGS__) \ MU_DO_1215(MACRO, __VA_ARGS__) #define MU_DO_1217(MACRO, ...) \ MACRO(1217, __VA_ARGS__) \ MU_DO_1216(MACRO, __VA_ARGS__) #define MU_DO_1218(MACRO, ...) \ MACRO(1218, __VA_ARGS__) \ MU_DO_1217(MACRO, __VA_ARGS__) #define MU_DO_1219(MACRO, ...) \ MACRO(1219, __VA_ARGS__) \ MU_DO_1218(MACRO, __VA_ARGS__) #define MU_DO_1220(MACRO, ...) \ MACRO(1220, __VA_ARGS__) \ MU_DO_1219(MACRO, __VA_ARGS__) #define MU_DO_1221(MACRO, ...) \ MACRO(1221, __VA_ARGS__) \ MU_DO_1220(MACRO, __VA_ARGS__) #define MU_DO_1222(MACRO, ...) \ MACRO(1222, __VA_ARGS__) \ MU_DO_1221(MACRO, __VA_ARGS__) #define MU_DO_1223(MACRO, ...) \ MACRO(1223, __VA_ARGS__) \ MU_DO_1222(MACRO, __VA_ARGS__) #define MU_DO_1224(MACRO, ...) \ MACRO(1224, __VA_ARGS__) \ MU_DO_1223(MACRO, __VA_ARGS__) #define MU_DO_1225(MACRO, ...) \ MACRO(1225, __VA_ARGS__) \ MU_DO_1224(MACRO, __VA_ARGS__) #define MU_DO_1226(MACRO, ...) \ MACRO(1226, __VA_ARGS__) \ MU_DO_1225(MACRO, __VA_ARGS__) #define MU_DO_1227(MACRO, ...) \ MACRO(1227, __VA_ARGS__) \ MU_DO_1226(MACRO, __VA_ARGS__) #define MU_DO_1228(MACRO, ...) \ MACRO(1228, __VA_ARGS__) \ MU_DO_1227(MACRO, __VA_ARGS__) #define MU_DO_1229(MACRO, ...) \ MACRO(1229, __VA_ARGS__) \ MU_DO_1228(MACRO, __VA_ARGS__) #define MU_DO_1230(MACRO, ...) \ MACRO(1230, __VA_ARGS__) \ MU_DO_1229(MACRO, __VA_ARGS__) #define MU_DO_1231(MACRO, ...) \ MACRO(1231, __VA_ARGS__) \ MU_DO_1230(MACRO, __VA_ARGS__) #define MU_DO_1232(MACRO, ...) \ MACRO(1232, __VA_ARGS__) \ MU_DO_1231(MACRO, __VA_ARGS__) #define MU_DO_1233(MACRO, ...) \ MACRO(1233, __VA_ARGS__) \ MU_DO_1232(MACRO, __VA_ARGS__) #define MU_DO_1234(MACRO, ...) \ MACRO(1234, __VA_ARGS__) \ MU_DO_1233(MACRO, __VA_ARGS__) #define MU_DO_1235(MACRO, ...) \ MACRO(1235, __VA_ARGS__) \ MU_DO_1234(MACRO, __VA_ARGS__) #define MU_DO_1236(MACRO, ...) \ MACRO(1236, __VA_ARGS__) \ MU_DO_1235(MACRO, __VA_ARGS__) #define MU_DO_1237(MACRO, ...) \ MACRO(1237, __VA_ARGS__) \ MU_DO_1236(MACRO, __VA_ARGS__) #define MU_DO_1238(MACRO, ...) \ MACRO(1238, __VA_ARGS__) \ MU_DO_1237(MACRO, __VA_ARGS__) #define MU_DO_1239(MACRO, ...) \ MACRO(1239, __VA_ARGS__) \ MU_DO_1238(MACRO, __VA_ARGS__) #define MU_DO_1240(MACRO, ...) \ MACRO(1240, __VA_ARGS__) \ MU_DO_1239(MACRO, __VA_ARGS__) #define MU_DO_1241(MACRO, ...) \ MACRO(1241, __VA_ARGS__) \ MU_DO_1240(MACRO, __VA_ARGS__) #define MU_DO_1242(MACRO, ...) \ MACRO(1242, __VA_ARGS__) \ MU_DO_1241(MACRO, __VA_ARGS__) #define MU_DO_1243(MACRO, ...) \ MACRO(1243, __VA_ARGS__) \ MU_DO_1242(MACRO, __VA_ARGS__) #define MU_DO_1244(MACRO, ...) \ MACRO(1244, __VA_ARGS__) \ MU_DO_1243(MACRO, __VA_ARGS__) #define MU_DO_1245(MACRO, ...) \ MACRO(1245, __VA_ARGS__) \ MU_DO_1244(MACRO, __VA_ARGS__) #define MU_DO_1246(MACRO, ...) \ MACRO(1246, __VA_ARGS__) \ MU_DO_1245(MACRO, __VA_ARGS__) #define MU_DO_1247(MACRO, ...) \ MACRO(1247, __VA_ARGS__) \ MU_DO_1246(MACRO, __VA_ARGS__) #define MU_DO_1248(MACRO, ...) \ MACRO(1248, __VA_ARGS__) \ MU_DO_1247(MACRO, __VA_ARGS__) #define MU_DO_1249(MACRO, ...) \ MACRO(1249, __VA_ARGS__) \ MU_DO_1248(MACRO, __VA_ARGS__) #define MU_DO_1250(MACRO, ...) \ MACRO(1250, __VA_ARGS__) \ MU_DO_1249(MACRO, __VA_ARGS__) #define MU_DO_1251(MACRO, ...) \ MACRO(1251, __VA_ARGS__) \ MU_DO_1250(MACRO, __VA_ARGS__) #define MU_DO_1252(MACRO, ...) \ MACRO(1252, __VA_ARGS__) \ MU_DO_1251(MACRO, __VA_ARGS__) #define MU_DO_1253(MACRO, ...) \ MACRO(1253, __VA_ARGS__) \ MU_DO_1252(MACRO, __VA_ARGS__) #define MU_DO_1254(MACRO, ...) \ MACRO(1254, __VA_ARGS__) \ MU_DO_1253(MACRO, __VA_ARGS__) #define MU_DO_1255(MACRO, ...) \ MACRO(1255, __VA_ARGS__) \ MU_DO_1254(MACRO, __VA_ARGS__) #define MU_DO_1256(MACRO, ...) \ MACRO(1256, __VA_ARGS__) \ MU_DO_1255(MACRO, __VA_ARGS__) #define MU_DO_1257(MACRO, ...) \ MACRO(1257, __VA_ARGS__) \ MU_DO_1256(MACRO, __VA_ARGS__) #define MU_DO_1258(MACRO, ...) \ MACRO(1258, __VA_ARGS__) \ MU_DO_1257(MACRO, __VA_ARGS__) #define MU_DO_1259(MACRO, ...) \ MACRO(1259, __VA_ARGS__) \ MU_DO_1258(MACRO, __VA_ARGS__) #define MU_DO_1260(MACRO, ...) \ MACRO(1260, __VA_ARGS__) \ MU_DO_1259(MACRO, __VA_ARGS__) #define MU_DO_1261(MACRO, ...) \ MACRO(1261, __VA_ARGS__) \ MU_DO_1260(MACRO, __VA_ARGS__) #define MU_DO_1262(MACRO, ...) \ MACRO(1262, __VA_ARGS__) \ MU_DO_1261(MACRO, __VA_ARGS__) #define MU_DO_1263(MACRO, ...) \ MACRO(1263, __VA_ARGS__) \ MU_DO_1262(MACRO, __VA_ARGS__) #define MU_DO_1264(MACRO, ...) \ MACRO(1264, __VA_ARGS__) \ MU_DO_1263(MACRO, __VA_ARGS__) #define MU_DO_1265(MACRO, ...) \ MACRO(1265, __VA_ARGS__) \ MU_DO_1264(MACRO, __VA_ARGS__) #define MU_DO_1266(MACRO, ...) \ MACRO(1266, __VA_ARGS__) \ MU_DO_1265(MACRO, __VA_ARGS__) #define MU_DO_1267(MACRO, ...) \ MACRO(1267, __VA_ARGS__) \ MU_DO_1266(MACRO, __VA_ARGS__) #define MU_DO_1268(MACRO, ...) \ MACRO(1268, __VA_ARGS__) \ MU_DO_1267(MACRO, __VA_ARGS__) #define MU_DO_1269(MACRO, ...) \ MACRO(1269, __VA_ARGS__) \ MU_DO_1268(MACRO, __VA_ARGS__) #define MU_DO_1270(MACRO, ...) \ MACRO(1270, __VA_ARGS__) \ MU_DO_1269(MACRO, __VA_ARGS__) #define MU_DO_1271(MACRO, ...) \ MACRO(1271, __VA_ARGS__) \ MU_DO_1270(MACRO, __VA_ARGS__) #define MU_DO_1272(MACRO, ...) \ MACRO(1272, __VA_ARGS__) \ MU_DO_1271(MACRO, __VA_ARGS__) #define MU_DO_1273(MACRO, ...) \ MACRO(1273, __VA_ARGS__) \ MU_DO_1272(MACRO, __VA_ARGS__) #define MU_DO_1274(MACRO, ...) \ MACRO(1274, __VA_ARGS__) \ MU_DO_1273(MACRO, __VA_ARGS__) #define MU_DO_1275(MACRO, ...) \ MACRO(1275, __VA_ARGS__) \ MU_DO_1274(MACRO, __VA_ARGS__) #define MU_DO_1276(MACRO, ...) \ MACRO(1276, __VA_ARGS__) \ MU_DO_1275(MACRO, __VA_ARGS__) #define MU_DO_1277(MACRO, ...) \ MACRO(1277, __VA_ARGS__) \ MU_DO_1276(MACRO, __VA_ARGS__) #define MU_DO_1278(MACRO, ...) \ MACRO(1278, __VA_ARGS__) \ MU_DO_1277(MACRO, __VA_ARGS__) #define MU_DO_1279(MACRO, ...) \ MACRO(1279, __VA_ARGS__) \ MU_DO_1278(MACRO, __VA_ARGS__) #define MU_DO_1280(MACRO, ...) \ MACRO(1280, __VA_ARGS__) \ MU_DO_1279(MACRO, __VA_ARGS__) #define MU_DO_1281(MACRO, ...) \ MACRO(1281, __VA_ARGS__) \ MU_DO_1280(MACRO, __VA_ARGS__) #define MU_DO_1282(MACRO, ...) \ MACRO(1282, __VA_ARGS__) \ MU_DO_1281(MACRO, __VA_ARGS__) #define MU_DO_1283(MACRO, ...) \ MACRO(1283, __VA_ARGS__) \ MU_DO_1282(MACRO, __VA_ARGS__) #define MU_DO_1284(MACRO, ...) \ MACRO(1284, __VA_ARGS__) \ MU_DO_1283(MACRO, __VA_ARGS__) #define MU_DO_1285(MACRO, ...) \ MACRO(1285, __VA_ARGS__) \ MU_DO_1284(MACRO, __VA_ARGS__) #define MU_DO_1286(MACRO, ...) \ MACRO(1286, __VA_ARGS__) \ MU_DO_1285(MACRO, __VA_ARGS__) #define MU_DO_1287(MACRO, ...) \ MACRO(1287, __VA_ARGS__) \ MU_DO_1286(MACRO, __VA_ARGS__) #define MU_DO_1288(MACRO, ...) \ MACRO(1288, __VA_ARGS__) \ MU_DO_1287(MACRO, __VA_ARGS__) #define MU_DO_1289(MACRO, ...) \ MACRO(1289, __VA_ARGS__) \ MU_DO_1288(MACRO, __VA_ARGS__) #define MU_DO_1290(MACRO, ...) \ MACRO(1290, __VA_ARGS__) \ MU_DO_1289(MACRO, __VA_ARGS__) #define MU_DO_1291(MACRO, ...) \ MACRO(1291, __VA_ARGS__) \ MU_DO_1290(MACRO, __VA_ARGS__) #define MU_DO_1292(MACRO, ...) \ MACRO(1292, __VA_ARGS__) \ MU_DO_1291(MACRO, __VA_ARGS__) #define MU_DO_1293(MACRO, ...) \ MACRO(1293, __VA_ARGS__) \ MU_DO_1292(MACRO, __VA_ARGS__) #define MU_DO_1294(MACRO, ...) \ MACRO(1294, __VA_ARGS__) \ MU_DO_1293(MACRO, __VA_ARGS__) #define MU_DO_1295(MACRO, ...) \ MACRO(1295, __VA_ARGS__) \ MU_DO_1294(MACRO, __VA_ARGS__) #define MU_DO_1296(MACRO, ...) \ MACRO(1296, __VA_ARGS__) \ MU_DO_1295(MACRO, __VA_ARGS__) #define MU_DO_1297(MACRO, ...) \ MACRO(1297, __VA_ARGS__) \ MU_DO_1296(MACRO, __VA_ARGS__) #define MU_DO_1298(MACRO, ...) \ MACRO(1298, __VA_ARGS__) \ MU_DO_1297(MACRO, __VA_ARGS__) #define MU_DO_1299(MACRO, ...) \ MACRO(1299, __VA_ARGS__) \ MU_DO_1298(MACRO, __VA_ARGS__) #define MU_DO_1300(MACRO, ...) \ MACRO(1300, __VA_ARGS__) \ MU_DO_1299(MACRO, __VA_ARGS__) #define MU_DO_1301(MACRO, ...) \ MACRO(1301, __VA_ARGS__) \ MU_DO_1300(MACRO, __VA_ARGS__) #define MU_DO_1302(MACRO, ...) \ MACRO(1302, __VA_ARGS__) \ MU_DO_1301(MACRO, __VA_ARGS__) #define MU_DO_1303(MACRO, ...) \ MACRO(1303, __VA_ARGS__) \ MU_DO_1302(MACRO, __VA_ARGS__) #define MU_DO_1304(MACRO, ...) \ MACRO(1304, __VA_ARGS__) \ MU_DO_1303(MACRO, __VA_ARGS__) #define MU_DO_1305(MACRO, ...) \ MACRO(1305, __VA_ARGS__) \ MU_DO_1304(MACRO, __VA_ARGS__) #define MU_DO_1306(MACRO, ...) \ MACRO(1306, __VA_ARGS__) \ MU_DO_1305(MACRO, __VA_ARGS__) #define MU_DO_1307(MACRO, ...) \ MACRO(1307, __VA_ARGS__) \ MU_DO_1306(MACRO, __VA_ARGS__) #define MU_DO_1308(MACRO, ...) \ MACRO(1308, __VA_ARGS__) \ MU_DO_1307(MACRO, __VA_ARGS__) #define MU_DO_1309(MACRO, ...) \ MACRO(1309, __VA_ARGS__) \ MU_DO_1308(MACRO, __VA_ARGS__) #define MU_DO_1310(MACRO, ...) \ MACRO(1310, __VA_ARGS__) \ MU_DO_1309(MACRO, __VA_ARGS__) #define MU_DO_1311(MACRO, ...) \ MACRO(1311, __VA_ARGS__) \ MU_DO_1310(MACRO, __VA_ARGS__) #define MU_DO_1312(MACRO, ...) \ MACRO(1312, __VA_ARGS__) \ MU_DO_1311(MACRO, __VA_ARGS__) #define MU_DO_1313(MACRO, ...) \ MACRO(1313, __VA_ARGS__) \ MU_DO_1312(MACRO, __VA_ARGS__) #define MU_DO_1314(MACRO, ...) \ MACRO(1314, __VA_ARGS__) \ MU_DO_1313(MACRO, __VA_ARGS__) #define MU_DO_1315(MACRO, ...) \ MACRO(1315, __VA_ARGS__) \ MU_DO_1314(MACRO, __VA_ARGS__) #define MU_DO_1316(MACRO, ...) \ MACRO(1316, __VA_ARGS__) \ MU_DO_1315(MACRO, __VA_ARGS__) #define MU_DO_1317(MACRO, ...) \ MACRO(1317, __VA_ARGS__) \ MU_DO_1316(MACRO, __VA_ARGS__) #define MU_DO_1318(MACRO, ...) \ MACRO(1318, __VA_ARGS__) \ MU_DO_1317(MACRO, __VA_ARGS__) #define MU_DO_1319(MACRO, ...) \ MACRO(1319, __VA_ARGS__) \ MU_DO_1318(MACRO, __VA_ARGS__) #define MU_DO_1320(MACRO, ...) \ MACRO(1320, __VA_ARGS__) \ MU_DO_1319(MACRO, __VA_ARGS__) #define MU_DO_1321(MACRO, ...) \ MACRO(1321, __VA_ARGS__) \ MU_DO_1320(MACRO, __VA_ARGS__) #define MU_DO_1322(MACRO, ...) \ MACRO(1322, __VA_ARGS__) \ MU_DO_1321(MACRO, __VA_ARGS__) #define MU_DO_1323(MACRO, ...) \ MACRO(1323, __VA_ARGS__) \ MU_DO_1322(MACRO, __VA_ARGS__) #define MU_DO_1324(MACRO, ...) \ MACRO(1324, __VA_ARGS__) \ MU_DO_1323(MACRO, __VA_ARGS__) #define MU_DO_1325(MACRO, ...) \ MACRO(1325, __VA_ARGS__) \ MU_DO_1324(MACRO, __VA_ARGS__) #define MU_DO_1326(MACRO, ...) \ MACRO(1326, __VA_ARGS__) \ MU_DO_1325(MACRO, __VA_ARGS__) #define MU_DO_1327(MACRO, ...) \ MACRO(1327, __VA_ARGS__) \ MU_DO_1326(MACRO, __VA_ARGS__) #define MU_DO_1328(MACRO, ...) \ MACRO(1328, __VA_ARGS__) \ MU_DO_1327(MACRO, __VA_ARGS__) #define MU_DO_1329(MACRO, ...) \ MACRO(1329, __VA_ARGS__) \ MU_DO_1328(MACRO, __VA_ARGS__) #define MU_DO_1330(MACRO, ...) \ MACRO(1330, __VA_ARGS__) \ MU_DO_1329(MACRO, __VA_ARGS__) #define MU_DO_1331(MACRO, ...) \ MACRO(1331, __VA_ARGS__) \ MU_DO_1330(MACRO, __VA_ARGS__) #define MU_DO_1332(MACRO, ...) \ MACRO(1332, __VA_ARGS__) \ MU_DO_1331(MACRO, __VA_ARGS__) #define MU_DO_1333(MACRO, ...) \ MACRO(1333, __VA_ARGS__) \ MU_DO_1332(MACRO, __VA_ARGS__) #define MU_DO_1334(MACRO, ...) \ MACRO(1334, __VA_ARGS__) \ MU_DO_1333(MACRO, __VA_ARGS__) #define MU_DO_1335(MACRO, ...) \ MACRO(1335, __VA_ARGS__) \ MU_DO_1334(MACRO, __VA_ARGS__) #define MU_DO_1336(MACRO, ...) \ MACRO(1336, __VA_ARGS__) \ MU_DO_1335(MACRO, __VA_ARGS__) #define MU_DO_1337(MACRO, ...) \ MACRO(1337, __VA_ARGS__) \ MU_DO_1336(MACRO, __VA_ARGS__) #define MU_DO_1338(MACRO, ...) \ MACRO(1338, __VA_ARGS__) \ MU_DO_1337(MACRO, __VA_ARGS__) #define MU_DO_1339(MACRO, ...) \ MACRO(1339, __VA_ARGS__) \ MU_DO_1338(MACRO, __VA_ARGS__) #define MU_DO_1340(MACRO, ...) \ MACRO(1340, __VA_ARGS__) \ MU_DO_1339(MACRO, __VA_ARGS__) #define MU_DO_1341(MACRO, ...) \ MACRO(1341, __VA_ARGS__) \ MU_DO_1340(MACRO, __VA_ARGS__) #define MU_DO_1342(MACRO, ...) \ MACRO(1342, __VA_ARGS__) \ MU_DO_1341(MACRO, __VA_ARGS__) #define MU_DO_1343(MACRO, ...) \ MACRO(1343, __VA_ARGS__) \ MU_DO_1342(MACRO, __VA_ARGS__) #define MU_DO_1344(MACRO, ...) \ MACRO(1344, __VA_ARGS__) \ MU_DO_1343(MACRO, __VA_ARGS__) #define MU_DO_1345(MACRO, ...) \ MACRO(1345, __VA_ARGS__) \ MU_DO_1344(MACRO, __VA_ARGS__) #define MU_DO_1346(MACRO, ...) \ MACRO(1346, __VA_ARGS__) \ MU_DO_1345(MACRO, __VA_ARGS__) #define MU_DO_1347(MACRO, ...) \ MACRO(1347, __VA_ARGS__) \ MU_DO_1346(MACRO, __VA_ARGS__) #define MU_DO_1348(MACRO, ...) \ MACRO(1348, __VA_ARGS__) \ MU_DO_1347(MACRO, __VA_ARGS__) #define MU_DO_1349(MACRO, ...) \ MACRO(1349, __VA_ARGS__) \ MU_DO_1348(MACRO, __VA_ARGS__) #define MU_DO_1350(MACRO, ...) \ MACRO(1350, __VA_ARGS__) \ MU_DO_1349(MACRO, __VA_ARGS__) #define MU_DO_1351(MACRO, ...) \ MACRO(1351, __VA_ARGS__) \ MU_DO_1350(MACRO, __VA_ARGS__) #define MU_DO_1352(MACRO, ...) \ MACRO(1352, __VA_ARGS__) \ MU_DO_1351(MACRO, __VA_ARGS__) #define MU_DO_1353(MACRO, ...) \ MACRO(1353, __VA_ARGS__) \ MU_DO_1352(MACRO, __VA_ARGS__) #define MU_DO_1354(MACRO, ...) \ MACRO(1354, __VA_ARGS__) \ MU_DO_1353(MACRO, __VA_ARGS__) #define MU_DO_1355(MACRO, ...) \ MACRO(1355, __VA_ARGS__) \ MU_DO_1354(MACRO, __VA_ARGS__) #define MU_DO_1356(MACRO, ...) \ MACRO(1356, __VA_ARGS__) \ MU_DO_1355(MACRO, __VA_ARGS__) #define MU_DO_1357(MACRO, ...) \ MACRO(1357, __VA_ARGS__) \ MU_DO_1356(MACRO, __VA_ARGS__) #define MU_DO_1358(MACRO, ...) \ MACRO(1358, __VA_ARGS__) \ MU_DO_1357(MACRO, __VA_ARGS__) #define MU_DO_1359(MACRO, ...) \ MACRO(1359, __VA_ARGS__) \ MU_DO_1358(MACRO, __VA_ARGS__) #define MU_DO_1360(MACRO, ...) \ MACRO(1360, __VA_ARGS__) \ MU_DO_1359(MACRO, __VA_ARGS__) #define MU_DO_1361(MACRO, ...) \ MACRO(1361, __VA_ARGS__) \ MU_DO_1360(MACRO, __VA_ARGS__) #define MU_DO_1362(MACRO, ...) \ MACRO(1362, __VA_ARGS__) \ MU_DO_1361(MACRO, __VA_ARGS__) #define MU_DO_1363(MACRO, ...) \ MACRO(1363, __VA_ARGS__) \ MU_DO_1362(MACRO, __VA_ARGS__) #define MU_DO_1364(MACRO, ...) \ MACRO(1364, __VA_ARGS__) \ MU_DO_1363(MACRO, __VA_ARGS__) #define MU_DO_1365(MACRO, ...) \ MACRO(1365, __VA_ARGS__) \ MU_DO_1364(MACRO, __VA_ARGS__) #define MU_DO_1366(MACRO, ...) \ MACRO(1366, __VA_ARGS__) \ MU_DO_1365(MACRO, __VA_ARGS__) #define MU_DO_1367(MACRO, ...) \ MACRO(1367, __VA_ARGS__) \ MU_DO_1366(MACRO, __VA_ARGS__) #define MU_DO_1368(MACRO, ...) \ MACRO(1368, __VA_ARGS__) \ MU_DO_1367(MACRO, __VA_ARGS__) #define MU_DO_1369(MACRO, ...) \ MACRO(1369, __VA_ARGS__) \ MU_DO_1368(MACRO, __VA_ARGS__) #define MU_DO_1370(MACRO, ...) \ MACRO(1370, __VA_ARGS__) \ MU_DO_1369(MACRO, __VA_ARGS__) #define MU_DO_1371(MACRO, ...) \ MACRO(1371, __VA_ARGS__) \ MU_DO_1370(MACRO, __VA_ARGS__) #define MU_DO_1372(MACRO, ...) \ MACRO(1372, __VA_ARGS__) \ MU_DO_1371(MACRO, __VA_ARGS__) #define MU_DO_1373(MACRO, ...) \ MACRO(1373, __VA_ARGS__) \ MU_DO_1372(MACRO, __VA_ARGS__) #define MU_DO_1374(MACRO, ...) \ MACRO(1374, __VA_ARGS__) \ MU_DO_1373(MACRO, __VA_ARGS__) #define MU_DO_1375(MACRO, ...) \ MACRO(1375, __VA_ARGS__) \ MU_DO_1374(MACRO, __VA_ARGS__) #define MU_DO_1376(MACRO, ...) \ MACRO(1376, __VA_ARGS__) \ MU_DO_1375(MACRO, __VA_ARGS__) #define MU_DO_1377(MACRO, ...) \ MACRO(1377, __VA_ARGS__) \ MU_DO_1376(MACRO, __VA_ARGS__) #define MU_DO_1378(MACRO, ...) \ MACRO(1378, __VA_ARGS__) \ MU_DO_1377(MACRO, __VA_ARGS__) #define MU_DO_1379(MACRO, ...) \ MACRO(1379, __VA_ARGS__) \ MU_DO_1378(MACRO, __VA_ARGS__) #define MU_DO_1380(MACRO, ...) \ MACRO(1380, __VA_ARGS__) \ MU_DO_1379(MACRO, __VA_ARGS__) #define MU_DO_1381(MACRO, ...) \ MACRO(1381, __VA_ARGS__) \ MU_DO_1380(MACRO, __VA_ARGS__) #define MU_DO_1382(MACRO, ...) \ MACRO(1382, __VA_ARGS__) \ MU_DO_1381(MACRO, __VA_ARGS__) #define MU_DO_1383(MACRO, ...) \ MACRO(1383, __VA_ARGS__) \ MU_DO_1382(MACRO, __VA_ARGS__) #define MU_DO_1384(MACRO, ...) \ MACRO(1384, __VA_ARGS__) \ MU_DO_1383(MACRO, __VA_ARGS__) #define MU_DO_1385(MACRO, ...) \ MACRO(1385, __VA_ARGS__) \ MU_DO_1384(MACRO, __VA_ARGS__) #define MU_DO_1386(MACRO, ...) \ MACRO(1386, __VA_ARGS__) \ MU_DO_1385(MACRO, __VA_ARGS__) #define MU_DO_1387(MACRO, ...) \ MACRO(1387, __VA_ARGS__) \ MU_DO_1386(MACRO, __VA_ARGS__) #define MU_DO_1388(MACRO, ...) \ MACRO(1388, __VA_ARGS__) \ MU_DO_1387(MACRO, __VA_ARGS__) #define MU_DO_1389(MACRO, ...) \ MACRO(1389, __VA_ARGS__) \ MU_DO_1388(MACRO, __VA_ARGS__) #define MU_DO_1390(MACRO, ...) \ MACRO(1390, __VA_ARGS__) \ MU_DO_1389(MACRO, __VA_ARGS__) #define MU_DO_1391(MACRO, ...) \ MACRO(1391, __VA_ARGS__) \ MU_DO_1390(MACRO, __VA_ARGS__) #define MU_DO_1392(MACRO, ...) \ MACRO(1392, __VA_ARGS__) \ MU_DO_1391(MACRO, __VA_ARGS__) #define MU_DO_1393(MACRO, ...) \ MACRO(1393, __VA_ARGS__) \ MU_DO_1392(MACRO, __VA_ARGS__) #define MU_DO_1394(MACRO, ...) \ MACRO(1394, __VA_ARGS__) \ MU_DO_1393(MACRO, __VA_ARGS__) #define MU_DO_1395(MACRO, ...) \ MACRO(1395, __VA_ARGS__) \ MU_DO_1394(MACRO, __VA_ARGS__) #define MU_DO_1396(MACRO, ...) \ MACRO(1396, __VA_ARGS__) \ MU_DO_1395(MACRO, __VA_ARGS__) #define MU_DO_1397(MACRO, ...) \ MACRO(1397, __VA_ARGS__) \ MU_DO_1396(MACRO, __VA_ARGS__) #define MU_DO_1398(MACRO, ...) \ MACRO(1398, __VA_ARGS__) \ MU_DO_1397(MACRO, __VA_ARGS__) #define MU_DO_1399(MACRO, ...) \ MACRO(1399, __VA_ARGS__) \ MU_DO_1398(MACRO, __VA_ARGS__) #define MU_DO_1400(MACRO, ...) \ MACRO(1400, __VA_ARGS__) \ MU_DO_1399(MACRO, __VA_ARGS__) #define MU_DO_1401(MACRO, ...) \ MACRO(1401, __VA_ARGS__) \ MU_DO_1400(MACRO, __VA_ARGS__) #define MU_DO_1402(MACRO, ...) \ MACRO(1402, __VA_ARGS__) \ MU_DO_1401(MACRO, __VA_ARGS__) #define MU_DO_1403(MACRO, ...) \ MACRO(1403, __VA_ARGS__) \ MU_DO_1402(MACRO, __VA_ARGS__) #define MU_DO_1404(MACRO, ...) \ MACRO(1404, __VA_ARGS__) \ MU_DO_1403(MACRO, __VA_ARGS__) #define MU_DO_1405(MACRO, ...) \ MACRO(1405, __VA_ARGS__) \ MU_DO_1404(MACRO, __VA_ARGS__) #define MU_DO_1406(MACRO, ...) \ MACRO(1406, __VA_ARGS__) \ MU_DO_1405(MACRO, __VA_ARGS__) #define MU_DO_1407(MACRO, ...) \ MACRO(1407, __VA_ARGS__) \ MU_DO_1406(MACRO, __VA_ARGS__) #define MU_DO_1408(MACRO, ...) \ MACRO(1408, __VA_ARGS__) \ MU_DO_1407(MACRO, __VA_ARGS__) #define MU_DO_1409(MACRO, ...) \ MACRO(1409, __VA_ARGS__) \ MU_DO_1408(MACRO, __VA_ARGS__) #define MU_DO_1410(MACRO, ...) \ MACRO(1410, __VA_ARGS__) \ MU_DO_1409(MACRO, __VA_ARGS__) #define MU_DO_1411(MACRO, ...) \ MACRO(1411, __VA_ARGS__) \ MU_DO_1410(MACRO, __VA_ARGS__) #define MU_DO_1412(MACRO, ...) \ MACRO(1412, __VA_ARGS__) \ MU_DO_1411(MACRO, __VA_ARGS__) #define MU_DO_1413(MACRO, ...) \ MACRO(1413, __VA_ARGS__) \ MU_DO_1412(MACRO, __VA_ARGS__) #define MU_DO_1414(MACRO, ...) \ MACRO(1414, __VA_ARGS__) \ MU_DO_1413(MACRO, __VA_ARGS__) #define MU_DO_1415(MACRO, ...) \ MACRO(1415, __VA_ARGS__) \ MU_DO_1414(MACRO, __VA_ARGS__) #define MU_DO_1416(MACRO, ...) \ MACRO(1416, __VA_ARGS__) \ MU_DO_1415(MACRO, __VA_ARGS__) #define MU_DO_1417(MACRO, ...) \ MACRO(1417, __VA_ARGS__) \ MU_DO_1416(MACRO, __VA_ARGS__) #define MU_DO_1418(MACRO, ...) \ MACRO(1418, __VA_ARGS__) \ MU_DO_1417(MACRO, __VA_ARGS__) #define MU_DO_1419(MACRO, ...) \ MACRO(1419, __VA_ARGS__) \ MU_DO_1418(MACRO, __VA_ARGS__) #define MU_DO_1420(MACRO, ...) \ MACRO(1420, __VA_ARGS__) \ MU_DO_1419(MACRO, __VA_ARGS__) #define MU_DO_1421(MACRO, ...) \ MACRO(1421, __VA_ARGS__) \ MU_DO_1420(MACRO, __VA_ARGS__) #define MU_DO_1422(MACRO, ...) \ MACRO(1422, __VA_ARGS__) \ MU_DO_1421(MACRO, __VA_ARGS__) #define MU_DO_1423(MACRO, ...) \ MACRO(1423, __VA_ARGS__) \ MU_DO_1422(MACRO, __VA_ARGS__) #define MU_DO_1424(MACRO, ...) \ MACRO(1424, __VA_ARGS__) \ MU_DO_1423(MACRO, __VA_ARGS__) #define MU_DO_1425(MACRO, ...) \ MACRO(1425, __VA_ARGS__) \ MU_DO_1424(MACRO, __VA_ARGS__) #define MU_DO_1426(MACRO, ...) \ MACRO(1426, __VA_ARGS__) \ MU_DO_1425(MACRO, __VA_ARGS__) #define MU_DO_1427(MACRO, ...) \ MACRO(1427, __VA_ARGS__) \ MU_DO_1426(MACRO, __VA_ARGS__) #define MU_DO_1428(MACRO, ...) \ MACRO(1428, __VA_ARGS__) \ MU_DO_1427(MACRO, __VA_ARGS__) #define MU_DO_1429(MACRO, ...) \ MACRO(1429, __VA_ARGS__) \ MU_DO_1428(MACRO, __VA_ARGS__) #define MU_DO_1430(MACRO, ...) \ MACRO(1430, __VA_ARGS__) \ MU_DO_1429(MACRO, __VA_ARGS__) #define MU_DO_1431(MACRO, ...) \ MACRO(1431, __VA_ARGS__) \ MU_DO_1430(MACRO, __VA_ARGS__) #define MU_DO_1432(MACRO, ...) \ MACRO(1432, __VA_ARGS__) \ MU_DO_1431(MACRO, __VA_ARGS__) #define MU_DO_1433(MACRO, ...) \ MACRO(1433, __VA_ARGS__) \ MU_DO_1432(MACRO, __VA_ARGS__) #define MU_DO_1434(MACRO, ...) \ MACRO(1434, __VA_ARGS__) \ MU_DO_1433(MACRO, __VA_ARGS__) #define MU_DO_1435(MACRO, ...) \ MACRO(1435, __VA_ARGS__) \ MU_DO_1434(MACRO, __VA_ARGS__) #define MU_DO_1436(MACRO, ...) \ MACRO(1436, __VA_ARGS__) \ MU_DO_1435(MACRO, __VA_ARGS__) #define MU_DO_1437(MACRO, ...) \ MACRO(1437, __VA_ARGS__) \ MU_DO_1436(MACRO, __VA_ARGS__) #define MU_DO_1438(MACRO, ...) \ MACRO(1438, __VA_ARGS__) \ MU_DO_1437(MACRO, __VA_ARGS__) #define MU_DO_1439(MACRO, ...) \ MACRO(1439, __VA_ARGS__) \ MU_DO_1438(MACRO, __VA_ARGS__) #define MU_DO_1440(MACRO, ...) \ MACRO(1440, __VA_ARGS__) \ MU_DO_1439(MACRO, __VA_ARGS__) #define MU_DO_1441(MACRO, ...) \ MACRO(1441, __VA_ARGS__) \ MU_DO_1440(MACRO, __VA_ARGS__) #define MU_DO_1442(MACRO, ...) \ MACRO(1442, __VA_ARGS__) \ MU_DO_1441(MACRO, __VA_ARGS__) #define MU_DO_1443(MACRO, ...) \ MACRO(1443, __VA_ARGS__) \ MU_DO_1442(MACRO, __VA_ARGS__) #define MU_DO_1444(MACRO, ...) \ MACRO(1444, __VA_ARGS__) \ MU_DO_1443(MACRO, __VA_ARGS__) #define MU_DO_1445(MACRO, ...) \ MACRO(1445, __VA_ARGS__) \ MU_DO_1444(MACRO, __VA_ARGS__) #define MU_DO_1446(MACRO, ...) \ MACRO(1446, __VA_ARGS__) \ MU_DO_1445(MACRO, __VA_ARGS__) #define MU_DO_1447(MACRO, ...) \ MACRO(1447, __VA_ARGS__) \ MU_DO_1446(MACRO, __VA_ARGS__) #define MU_DO_1448(MACRO, ...) \ MACRO(1448, __VA_ARGS__) \ MU_DO_1447(MACRO, __VA_ARGS__) #define MU_DO_1449(MACRO, ...) \ MACRO(1449, __VA_ARGS__) \ MU_DO_1448(MACRO, __VA_ARGS__) #define MU_DO_1450(MACRO, ...) \ MACRO(1450, __VA_ARGS__) \ MU_DO_1449(MACRO, __VA_ARGS__) #define MU_DO_1451(MACRO, ...) \ MACRO(1451, __VA_ARGS__) \ MU_DO_1450(MACRO, __VA_ARGS__) #define MU_DO_1452(MACRO, ...) \ MACRO(1452, __VA_ARGS__) \ MU_DO_1451(MACRO, __VA_ARGS__) #define MU_DO_1453(MACRO, ...) \ MACRO(1453, __VA_ARGS__) \ MU_DO_1452(MACRO, __VA_ARGS__) #define MU_DO_1454(MACRO, ...) \ MACRO(1454, __VA_ARGS__) \ MU_DO_1453(MACRO, __VA_ARGS__) #define MU_DO_1455(MACRO, ...) \ MACRO(1455, __VA_ARGS__) \ MU_DO_1454(MACRO, __VA_ARGS__) #define MU_DO_1456(MACRO, ...) \ MACRO(1456, __VA_ARGS__) \ MU_DO_1455(MACRO, __VA_ARGS__) #define MU_DO_1457(MACRO, ...) \ MACRO(1457, __VA_ARGS__) \ MU_DO_1456(MACRO, __VA_ARGS__) #define MU_DO_1458(MACRO, ...) \ MACRO(1458, __VA_ARGS__) \ MU_DO_1457(MACRO, __VA_ARGS__) #define MU_DO_1459(MACRO, ...) \ MACRO(1459, __VA_ARGS__) \ MU_DO_1458(MACRO, __VA_ARGS__) #define MU_DO_1460(MACRO, ...) \ MACRO(1460, __VA_ARGS__) \ MU_DO_1459(MACRO, __VA_ARGS__) #define MU_DO_1461(MACRO, ...) \ MACRO(1461, __VA_ARGS__) \ MU_DO_1460(MACRO, __VA_ARGS__) #define MU_DO_1462(MACRO, ...) \ MACRO(1462, __VA_ARGS__) \ MU_DO_1461(MACRO, __VA_ARGS__) #define MU_DO_1463(MACRO, ...) \ MACRO(1463, __VA_ARGS__) \ MU_DO_1462(MACRO, __VA_ARGS__) #define MU_DO_1464(MACRO, ...) \ MACRO(1464, __VA_ARGS__) \ MU_DO_1463(MACRO, __VA_ARGS__) #define MU_DO_1465(MACRO, ...) \ MACRO(1465, __VA_ARGS__) \ MU_DO_1464(MACRO, __VA_ARGS__) #define MU_DO_1466(MACRO, ...) \ MACRO(1466, __VA_ARGS__) \ MU_DO_1465(MACRO, __VA_ARGS__) #define MU_DO_1467(MACRO, ...) \ MACRO(1467, __VA_ARGS__) \ MU_DO_1466(MACRO, __VA_ARGS__) #define MU_DO_1468(MACRO, ...) \ MACRO(1468, __VA_ARGS__) \ MU_DO_1467(MACRO, __VA_ARGS__) #define MU_DO_1469(MACRO, ...) \ MACRO(1469, __VA_ARGS__) \ MU_DO_1468(MACRO, __VA_ARGS__) #define MU_DO_1470(MACRO, ...) \ MACRO(1470, __VA_ARGS__) \ MU_DO_1469(MACRO, __VA_ARGS__) #define MU_DO_1471(MACRO, ...) \ MACRO(1471, __VA_ARGS__) \ MU_DO_1470(MACRO, __VA_ARGS__) #define MU_DO_1472(MACRO, ...) \ MACRO(1472, __VA_ARGS__) \ MU_DO_1471(MACRO, __VA_ARGS__) #define MU_DO_1473(MACRO, ...) \ MACRO(1473, __VA_ARGS__) \ MU_DO_1472(MACRO, __VA_ARGS__) #define MU_DO_1474(MACRO, ...) \ MACRO(1474, __VA_ARGS__) \ MU_DO_1473(MACRO, __VA_ARGS__) #define MU_DO_1475(MACRO, ...) \ MACRO(1475, __VA_ARGS__) \ MU_DO_1474(MACRO, __VA_ARGS__) #define MU_DO_1476(MACRO, ...) \ MACRO(1476, __VA_ARGS__) \ MU_DO_1475(MACRO, __VA_ARGS__) #define MU_DO_1477(MACRO, ...) \ MACRO(1477, __VA_ARGS__) \ MU_DO_1476(MACRO, __VA_ARGS__) #define MU_DO_1478(MACRO, ...) \ MACRO(1478, __VA_ARGS__) \ MU_DO_1477(MACRO, __VA_ARGS__) #define MU_DO_1479(MACRO, ...) \ MACRO(1479, __VA_ARGS__) \ MU_DO_1478(MACRO, __VA_ARGS__) #define MU_DO_1480(MACRO, ...) \ MACRO(1480, __VA_ARGS__) \ MU_DO_1479(MACRO, __VA_ARGS__) #define MU_DO_1481(MACRO, ...) \ MACRO(1481, __VA_ARGS__) \ MU_DO_1480(MACRO, __VA_ARGS__) #define MU_DO_1482(MACRO, ...) \ MACRO(1482, __VA_ARGS__) \ MU_DO_1481(MACRO, __VA_ARGS__) #define MU_DO_1483(MACRO, ...) \ MACRO(1483, __VA_ARGS__) \ MU_DO_1482(MACRO, __VA_ARGS__) #define MU_DO_1484(MACRO, ...) \ MACRO(1484, __VA_ARGS__) \ MU_DO_1483(MACRO, __VA_ARGS__) #define MU_DO_1485(MACRO, ...) \ MACRO(1485, __VA_ARGS__) \ MU_DO_1484(MACRO, __VA_ARGS__) #define MU_DO_1486(MACRO, ...) \ MACRO(1486, __VA_ARGS__) \ MU_DO_1485(MACRO, __VA_ARGS__) #define MU_DO_1487(MACRO, ...) \ MACRO(1487, __VA_ARGS__) \ MU_DO_1486(MACRO, __VA_ARGS__) #define MU_DO_1488(MACRO, ...) \ MACRO(1488, __VA_ARGS__) \ MU_DO_1487(MACRO, __VA_ARGS__) #define MU_DO_1489(MACRO, ...) \ MACRO(1489, __VA_ARGS__) \ MU_DO_1488(MACRO, __VA_ARGS__) #define MU_DO_1490(MACRO, ...) \ MACRO(1490, __VA_ARGS__) \ MU_DO_1489(MACRO, __VA_ARGS__) #define MU_DO_1491(MACRO, ...) \ MACRO(1491, __VA_ARGS__) \ MU_DO_1490(MACRO, __VA_ARGS__) #define MU_DO_1492(MACRO, ...) \ MACRO(1492, __VA_ARGS__) \ MU_DO_1491(MACRO, __VA_ARGS__) #define MU_DO_1493(MACRO, ...) \ MACRO(1493, __VA_ARGS__) \ MU_DO_1492(MACRO, __VA_ARGS__) #define MU_DO_1494(MACRO, ...) \ MACRO(1494, __VA_ARGS__) \ MU_DO_1493(MACRO, __VA_ARGS__) #define MU_DO_1495(MACRO, ...) \ MACRO(1495, __VA_ARGS__) \ MU_DO_1494(MACRO, __VA_ARGS__) #define MU_DO_1496(MACRO, ...) \ MACRO(1496, __VA_ARGS__) \ MU_DO_1495(MACRO, __VA_ARGS__) #define MU_DO_1497(MACRO, ...) \ MACRO(1497, __VA_ARGS__) \ MU_DO_1496(MACRO, __VA_ARGS__) #define MU_DO_1498(MACRO, ...) \ MACRO(1498, __VA_ARGS__) \ MU_DO_1497(MACRO, __VA_ARGS__) #define MU_DO_1499(MACRO, ...) \ MACRO(1499, __VA_ARGS__) \ MU_DO_1498(MACRO, __VA_ARGS__) #define MU_DO_1500(MACRO, ...) \ MACRO(1500, __VA_ARGS__) \ MU_DO_1499(MACRO, __VA_ARGS__) #define MU_DO_1501(MACRO, ...) \ MACRO(1501, __VA_ARGS__) \ MU_DO_1500(MACRO, __VA_ARGS__) #define MU_DO_1502(MACRO, ...) \ MACRO(1502, __VA_ARGS__) \ MU_DO_1501(MACRO, __VA_ARGS__) #define MU_DO_1503(MACRO, ...) \ MACRO(1503, __VA_ARGS__) \ MU_DO_1502(MACRO, __VA_ARGS__) #define MU_DO_1504(MACRO, ...) \ MACRO(1504, __VA_ARGS__) \ MU_DO_1503(MACRO, __VA_ARGS__) #define MU_DO_1505(MACRO, ...) \ MACRO(1505, __VA_ARGS__) \ MU_DO_1504(MACRO, __VA_ARGS__) #define MU_DO_1506(MACRO, ...) \ MACRO(1506, __VA_ARGS__) \ MU_DO_1505(MACRO, __VA_ARGS__) #define MU_DO_1507(MACRO, ...) \ MACRO(1507, __VA_ARGS__) \ MU_DO_1506(MACRO, __VA_ARGS__) #define MU_DO_1508(MACRO, ...) \ MACRO(1508, __VA_ARGS__) \ MU_DO_1507(MACRO, __VA_ARGS__) #define MU_DO_1509(MACRO, ...) \ MACRO(1509, __VA_ARGS__) \ MU_DO_1508(MACRO, __VA_ARGS__) #define MU_DO_1510(MACRO, ...) \ MACRO(1510, __VA_ARGS__) \ MU_DO_1509(MACRO, __VA_ARGS__) #define MU_DO_1511(MACRO, ...) \ MACRO(1511, __VA_ARGS__) \ MU_DO_1510(MACRO, __VA_ARGS__) #define MU_DO_1512(MACRO, ...) \ MACRO(1512, __VA_ARGS__) \ MU_DO_1511(MACRO, __VA_ARGS__) #define MU_DO_1513(MACRO, ...) \ MACRO(1513, __VA_ARGS__) \ MU_DO_1512(MACRO, __VA_ARGS__) #define MU_DO_1514(MACRO, ...) \ MACRO(1514, __VA_ARGS__) \ MU_DO_1513(MACRO, __VA_ARGS__) #define MU_DO_1515(MACRO, ...) \ MACRO(1515, __VA_ARGS__) \ MU_DO_1514(MACRO, __VA_ARGS__) #define MU_DO_1516(MACRO, ...) \ MACRO(1516, __VA_ARGS__) \ MU_DO_1515(MACRO, __VA_ARGS__) #define MU_DO_1517(MACRO, ...) \ MACRO(1517, __VA_ARGS__) \ MU_DO_1516(MACRO, __VA_ARGS__) #define MU_DO_1518(MACRO, ...) \ MACRO(1518, __VA_ARGS__) \ MU_DO_1517(MACRO, __VA_ARGS__) #define MU_DO_1519(MACRO, ...) \ MACRO(1519, __VA_ARGS__) \ MU_DO_1518(MACRO, __VA_ARGS__) #define MU_DO_1520(MACRO, ...) \ MACRO(1520, __VA_ARGS__) \ MU_DO_1519(MACRO, __VA_ARGS__) #define MU_DO_1521(MACRO, ...) \ MACRO(1521, __VA_ARGS__) \ MU_DO_1520(MACRO, __VA_ARGS__) #define MU_DO_1522(MACRO, ...) \ MACRO(1522, __VA_ARGS__) \ MU_DO_1521(MACRO, __VA_ARGS__) #define MU_DO_1523(MACRO, ...) \ MACRO(1523, __VA_ARGS__) \ MU_DO_1522(MACRO, __VA_ARGS__) #define MU_DO_1524(MACRO, ...) \ MACRO(1524, __VA_ARGS__) \ MU_DO_1523(MACRO, __VA_ARGS__) #define MU_DO_1525(MACRO, ...) \ MACRO(1525, __VA_ARGS__) \ MU_DO_1524(MACRO, __VA_ARGS__) #define MU_DO_1526(MACRO, ...) \ MACRO(1526, __VA_ARGS__) \ MU_DO_1525(MACRO, __VA_ARGS__) #define MU_DO_1527(MACRO, ...) \ MACRO(1527, __VA_ARGS__) \ MU_DO_1526(MACRO, __VA_ARGS__) #define MU_DO_1528(MACRO, ...) \ MACRO(1528, __VA_ARGS__) \ MU_DO_1527(MACRO, __VA_ARGS__) #define MU_DO_1529(MACRO, ...) \ MACRO(1529, __VA_ARGS__) \ MU_DO_1528(MACRO, __VA_ARGS__) #define MU_DO_1530(MACRO, ...) \ MACRO(1530, __VA_ARGS__) \ MU_DO_1529(MACRO, __VA_ARGS__) #define MU_DO_1531(MACRO, ...) \ MACRO(1531, __VA_ARGS__) \ MU_DO_1530(MACRO, __VA_ARGS__) #define MU_DO_1532(MACRO, ...) \ MACRO(1532, __VA_ARGS__) \ MU_DO_1531(MACRO, __VA_ARGS__) #define MU_DO_1533(MACRO, ...) \ MACRO(1533, __VA_ARGS__) \ MU_DO_1532(MACRO, __VA_ARGS__) #define MU_DO_1534(MACRO, ...) \ MACRO(1534, __VA_ARGS__) \ MU_DO_1533(MACRO, __VA_ARGS__) #define MU_DO_1535(MACRO, ...) \ MACRO(1535, __VA_ARGS__) \ MU_DO_1534(MACRO, __VA_ARGS__) #define MU_DO_1536(MACRO, ...) \ MACRO(1536, __VA_ARGS__) \ MU_DO_1535(MACRO, __VA_ARGS__) #define MU_DO_1537(MACRO, ...) \ MACRO(1537, __VA_ARGS__) \ MU_DO_1536(MACRO, __VA_ARGS__) #define MU_DO_1538(MACRO, ...) \ MACRO(1538, __VA_ARGS__) \ MU_DO_1537(MACRO, __VA_ARGS__) #define MU_DO_1539(MACRO, ...) \ MACRO(1539, __VA_ARGS__) \ MU_DO_1538(MACRO, __VA_ARGS__) #define MU_DO_1540(MACRO, ...) \ MACRO(1540, __VA_ARGS__) \ MU_DO_1539(MACRO, __VA_ARGS__) #define MU_DO_1541(MACRO, ...) \ MACRO(1541, __VA_ARGS__) \ MU_DO_1540(MACRO, __VA_ARGS__) #define MU_DO_1542(MACRO, ...) \ MACRO(1542, __VA_ARGS__) \ MU_DO_1541(MACRO, __VA_ARGS__) #define MU_DO_1543(MACRO, ...) \ MACRO(1543, __VA_ARGS__) \ MU_DO_1542(MACRO, __VA_ARGS__) #define MU_DO_1544(MACRO, ...) \ MACRO(1544, __VA_ARGS__) \ MU_DO_1543(MACRO, __VA_ARGS__) #define MU_DO_1545(MACRO, ...) \ MACRO(1545, __VA_ARGS__) \ MU_DO_1544(MACRO, __VA_ARGS__) #define MU_DO_1546(MACRO, ...) \ MACRO(1546, __VA_ARGS__) \ MU_DO_1545(MACRO, __VA_ARGS__) #define MU_DO_1547(MACRO, ...) \ MACRO(1547, __VA_ARGS__) \ MU_DO_1546(MACRO, __VA_ARGS__) #define MU_DO_1548(MACRO, ...) \ MACRO(1548, __VA_ARGS__) \ MU_DO_1547(MACRO, __VA_ARGS__) #define MU_DO_1549(MACRO, ...) \ MACRO(1549, __VA_ARGS__) \ MU_DO_1548(MACRO, __VA_ARGS__) #define MU_DO_1550(MACRO, ...) \ MACRO(1550, __VA_ARGS__) \ MU_DO_1549(MACRO, __VA_ARGS__) #define MU_DO_1551(MACRO, ...) \ MACRO(1551, __VA_ARGS__) \ MU_DO_1550(MACRO, __VA_ARGS__) #define MU_DO_1552(MACRO, ...) \ MACRO(1552, __VA_ARGS__) \ MU_DO_1551(MACRO, __VA_ARGS__) #define MU_DO_1553(MACRO, ...) \ MACRO(1553, __VA_ARGS__) \ MU_DO_1552(MACRO, __VA_ARGS__) #define MU_DO_1554(MACRO, ...) \ MACRO(1554, __VA_ARGS__) \ MU_DO_1553(MACRO, __VA_ARGS__) #define MU_DO_1555(MACRO, ...) \ MACRO(1555, __VA_ARGS__) \ MU_DO_1554(MACRO, __VA_ARGS__) #define MU_DO_1556(MACRO, ...) \ MACRO(1556, __VA_ARGS__) \ MU_DO_1555(MACRO, __VA_ARGS__) #define MU_DO_1557(MACRO, ...) \ MACRO(1557, __VA_ARGS__) \ MU_DO_1556(MACRO, __VA_ARGS__) #define MU_DO_1558(MACRO, ...) \ MACRO(1558, __VA_ARGS__) \ MU_DO_1557(MACRO, __VA_ARGS__) #define MU_DO_1559(MACRO, ...) \ MACRO(1559, __VA_ARGS__) \ MU_DO_1558(MACRO, __VA_ARGS__) #define MU_DO_1560(MACRO, ...) \ MACRO(1560, __VA_ARGS__) \ MU_DO_1559(MACRO, __VA_ARGS__) #define MU_DO_1561(MACRO, ...) \ MACRO(1561, __VA_ARGS__) \ MU_DO_1560(MACRO, __VA_ARGS__) #define MU_DO_1562(MACRO, ...) \ MACRO(1562, __VA_ARGS__) \ MU_DO_1561(MACRO, __VA_ARGS__) #define MU_DO_1563(MACRO, ...) \ MACRO(1563, __VA_ARGS__) \ MU_DO_1562(MACRO, __VA_ARGS__) #define MU_DO_1564(MACRO, ...) \ MACRO(1564, __VA_ARGS__) \ MU_DO_1563(MACRO, __VA_ARGS__) #define MU_DO_1565(MACRO, ...) \ MACRO(1565, __VA_ARGS__) \ MU_DO_1564(MACRO, __VA_ARGS__) #define MU_DO_1566(MACRO, ...) \ MACRO(1566, __VA_ARGS__) \ MU_DO_1565(MACRO, __VA_ARGS__) #define MU_DO_1567(MACRO, ...) \ MACRO(1567, __VA_ARGS__) \ MU_DO_1566(MACRO, __VA_ARGS__) #define MU_DO_1568(MACRO, ...) \ MACRO(1568, __VA_ARGS__) \ MU_DO_1567(MACRO, __VA_ARGS__) #define MU_DO_1569(MACRO, ...) \ MACRO(1569, __VA_ARGS__) \ MU_DO_1568(MACRO, __VA_ARGS__) #define MU_DO_1570(MACRO, ...) \ MACRO(1570, __VA_ARGS__) \ MU_DO_1569(MACRO, __VA_ARGS__) #define MU_DO_1571(MACRO, ...) \ MACRO(1571, __VA_ARGS__) \ MU_DO_1570(MACRO, __VA_ARGS__) #define MU_DO_1572(MACRO, ...) \ MACRO(1572, __VA_ARGS__) \ MU_DO_1571(MACRO, __VA_ARGS__) #define MU_DO_1573(MACRO, ...) \ MACRO(1573, __VA_ARGS__) \ MU_DO_1572(MACRO, __VA_ARGS__) #define MU_DO_1574(MACRO, ...) \ MACRO(1574, __VA_ARGS__) \ MU_DO_1573(MACRO, __VA_ARGS__) #define MU_DO_1575(MACRO, ...) \ MACRO(1575, __VA_ARGS__) \ MU_DO_1574(MACRO, __VA_ARGS__) #define MU_DO_1576(MACRO, ...) \ MACRO(1576, __VA_ARGS__) \ MU_DO_1575(MACRO, __VA_ARGS__) #define MU_DO_1577(MACRO, ...) \ MACRO(1577, __VA_ARGS__) \ MU_DO_1576(MACRO, __VA_ARGS__) #define MU_DO_1578(MACRO, ...) \ MACRO(1578, __VA_ARGS__) \ MU_DO_1577(MACRO, __VA_ARGS__) #define MU_DO_1579(MACRO, ...) \ MACRO(1579, __VA_ARGS__) \ MU_DO_1578(MACRO, __VA_ARGS__) #define MU_DO_1580(MACRO, ...) \ MACRO(1580, __VA_ARGS__) \ MU_DO_1579(MACRO, __VA_ARGS__) #define MU_DO_1581(MACRO, ...) \ MACRO(1581, __VA_ARGS__) \ MU_DO_1580(MACRO, __VA_ARGS__) #define MU_DO_1582(MACRO, ...) \ MACRO(1582, __VA_ARGS__) \ MU_DO_1581(MACRO, __VA_ARGS__) #define MU_DO_1583(MACRO, ...) \ MACRO(1583, __VA_ARGS__) \ MU_DO_1582(MACRO, __VA_ARGS__) #define MU_DO_1584(MACRO, ...) \ MACRO(1584, __VA_ARGS__) \ MU_DO_1583(MACRO, __VA_ARGS__) #define MU_DO_1585(MACRO, ...) \ MACRO(1585, __VA_ARGS__) \ MU_DO_1584(MACRO, __VA_ARGS__) #define MU_DO_1586(MACRO, ...) \ MACRO(1586, __VA_ARGS__) \ MU_DO_1585(MACRO, __VA_ARGS__) #define MU_DO_1587(MACRO, ...) \ MACRO(1587, __VA_ARGS__) \ MU_DO_1586(MACRO, __VA_ARGS__) #define MU_DO_1588(MACRO, ...) \ MACRO(1588, __VA_ARGS__) \ MU_DO_1587(MACRO, __VA_ARGS__) #define MU_DO_1589(MACRO, ...) \ MACRO(1589, __VA_ARGS__) \ MU_DO_1588(MACRO, __VA_ARGS__) #define MU_DO_1590(MACRO, ...) \ MACRO(1590, __VA_ARGS__) \ MU_DO_1589(MACRO, __VA_ARGS__) #define MU_DO_1591(MACRO, ...) \ MACRO(1591, __VA_ARGS__) \ MU_DO_1590(MACRO, __VA_ARGS__) #define MU_DO_1592(MACRO, ...) \ MACRO(1592, __VA_ARGS__) \ MU_DO_1591(MACRO, __VA_ARGS__) #define MU_DO_1593(MACRO, ...) \ MACRO(1593, __VA_ARGS__) \ MU_DO_1592(MACRO, __VA_ARGS__) #define MU_DO_1594(MACRO, ...) \ MACRO(1594, __VA_ARGS__) \ MU_DO_1593(MACRO, __VA_ARGS__) #define MU_DO_1595(MACRO, ...) \ MACRO(1595, __VA_ARGS__) \ MU_DO_1594(MACRO, __VA_ARGS__) #define MU_DO_1596(MACRO, ...) \ MACRO(1596, __VA_ARGS__) \ MU_DO_1595(MACRO, __VA_ARGS__) #define MU_DO_1597(MACRO, ...) \ MACRO(1597, __VA_ARGS__) \ MU_DO_1596(MACRO, __VA_ARGS__) #define MU_DO_1598(MACRO, ...) \ MACRO(1598, __VA_ARGS__) \ MU_DO_1597(MACRO, __VA_ARGS__) #define MU_DO_1599(MACRO, ...) \ MACRO(1599, __VA_ARGS__) \ MU_DO_1598(MACRO, __VA_ARGS__) #define MU_DO_1600(MACRO, ...) \ MACRO(1600, __VA_ARGS__) \ MU_DO_1599(MACRO, __VA_ARGS__) #define MU_DO_1601(MACRO, ...) \ MACRO(1601, __VA_ARGS__) \ MU_DO_1600(MACRO, __VA_ARGS__) #define MU_DO_1602(MACRO, ...) \ MACRO(1602, __VA_ARGS__) \ MU_DO_1601(MACRO, __VA_ARGS__) #define MU_DO_1603(MACRO, ...) \ MACRO(1603, __VA_ARGS__) \ MU_DO_1602(MACRO, __VA_ARGS__) #define MU_DO_1604(MACRO, ...) \ MACRO(1604, __VA_ARGS__) \ MU_DO_1603(MACRO, __VA_ARGS__) #define MU_DO_1605(MACRO, ...) \ MACRO(1605, __VA_ARGS__) \ MU_DO_1604(MACRO, __VA_ARGS__) #define MU_DO_1606(MACRO, ...) \ MACRO(1606, __VA_ARGS__) \ MU_DO_1605(MACRO, __VA_ARGS__) #define MU_DO_1607(MACRO, ...) \ MACRO(1607, __VA_ARGS__) \ MU_DO_1606(MACRO, __VA_ARGS__) #define MU_DO_1608(MACRO, ...) \ MACRO(1608, __VA_ARGS__) \ MU_DO_1607(MACRO, __VA_ARGS__) #define MU_DO_1609(MACRO, ...) \ MACRO(1609, __VA_ARGS__) \ MU_DO_1608(MACRO, __VA_ARGS__) #define MU_DO_1610(MACRO, ...) \ MACRO(1610, __VA_ARGS__) \ MU_DO_1609(MACRO, __VA_ARGS__) #define MU_DO_1611(MACRO, ...) \ MACRO(1611, __VA_ARGS__) \ MU_DO_1610(MACRO, __VA_ARGS__) #define MU_DO_1612(MACRO, ...) \ MACRO(1612, __VA_ARGS__) \ MU_DO_1611(MACRO, __VA_ARGS__) #define MU_DO_1613(MACRO, ...) \ MACRO(1613, __VA_ARGS__) \ MU_DO_1612(MACRO, __VA_ARGS__) #define MU_DO_1614(MACRO, ...) \ MACRO(1614, __VA_ARGS__) \ MU_DO_1613(MACRO, __VA_ARGS__) #define MU_DO_1615(MACRO, ...) \ MACRO(1615, __VA_ARGS__) \ MU_DO_1614(MACRO, __VA_ARGS__) #define MU_DO_1616(MACRO, ...) \ MACRO(1616, __VA_ARGS__) \ MU_DO_1615(MACRO, __VA_ARGS__) #define MU_DO_1617(MACRO, ...) \ MACRO(1617, __VA_ARGS__) \ MU_DO_1616(MACRO, __VA_ARGS__) #define MU_DO_1618(MACRO, ...) \ MACRO(1618, __VA_ARGS__) \ MU_DO_1617(MACRO, __VA_ARGS__) #define MU_DO_1619(MACRO, ...) \ MACRO(1619, __VA_ARGS__) \ MU_DO_1618(MACRO, __VA_ARGS__) #define MU_DO_1620(MACRO, ...) \ MACRO(1620, __VA_ARGS__) \ MU_DO_1619(MACRO, __VA_ARGS__) #define MU_DO_1621(MACRO, ...) \ MACRO(1621, __VA_ARGS__) \ MU_DO_1620(MACRO, __VA_ARGS__) #define MU_DO_1622(MACRO, ...) \ MACRO(1622, __VA_ARGS__) \ MU_DO_1621(MACRO, __VA_ARGS__) #define MU_DO_1623(MACRO, ...) \ MACRO(1623, __VA_ARGS__) \ MU_DO_1622(MACRO, __VA_ARGS__) #define MU_DO_1624(MACRO, ...) \ MACRO(1624, __VA_ARGS__) \ MU_DO_1623(MACRO, __VA_ARGS__) #define MU_DO_1625(MACRO, ...) \ MACRO(1625, __VA_ARGS__) \ MU_DO_1624(MACRO, __VA_ARGS__) #define MU_DO_1626(MACRO, ...) \ MACRO(1626, __VA_ARGS__) \ MU_DO_1625(MACRO, __VA_ARGS__) #define MU_DO_1627(MACRO, ...) \ MACRO(1627, __VA_ARGS__) \ MU_DO_1626(MACRO, __VA_ARGS__) #define MU_DO_1628(MACRO, ...) \ MACRO(1628, __VA_ARGS__) \ MU_DO_1627(MACRO, __VA_ARGS__) #define MU_DO_1629(MACRO, ...) \ MACRO(1629, __VA_ARGS__) \ MU_DO_1628(MACRO, __VA_ARGS__) #define MU_DO_1630(MACRO, ...) \ MACRO(1630, __VA_ARGS__) \ MU_DO_1629(MACRO, __VA_ARGS__) #define MU_DO_1631(MACRO, ...) \ MACRO(1631, __VA_ARGS__) \ MU_DO_1630(MACRO, __VA_ARGS__) #define MU_DO_1632(MACRO, ...) \ MACRO(1632, __VA_ARGS__) \ MU_DO_1631(MACRO, __VA_ARGS__) #define MU_DO_1633(MACRO, ...) \ MACRO(1633, __VA_ARGS__) \ MU_DO_1632(MACRO, __VA_ARGS__) #define MU_DO_1634(MACRO, ...) \ MACRO(1634, __VA_ARGS__) \ MU_DO_1633(MACRO, __VA_ARGS__) #define MU_DO_1635(MACRO, ...) \ MACRO(1635, __VA_ARGS__) \ MU_DO_1634(MACRO, __VA_ARGS__) #define MU_DO_1636(MACRO, ...) \ MACRO(1636, __VA_ARGS__) \ MU_DO_1635(MACRO, __VA_ARGS__) #define MU_DO_1637(MACRO, ...) \ MACRO(1637, __VA_ARGS__) \ MU_DO_1636(MACRO, __VA_ARGS__) #define MU_DO_1638(MACRO, ...) \ MACRO(1638, __VA_ARGS__) \ MU_DO_1637(MACRO, __VA_ARGS__) #define MU_DO_1639(MACRO, ...) \ MACRO(1639, __VA_ARGS__) \ MU_DO_1638(MACRO, __VA_ARGS__) #define MU_DO_1640(MACRO, ...) \ MACRO(1640, __VA_ARGS__) \ MU_DO_1639(MACRO, __VA_ARGS__) #define MU_DO_1641(MACRO, ...) \ MACRO(1641, __VA_ARGS__) \ MU_DO_1640(MACRO, __VA_ARGS__) #define MU_DO_1642(MACRO, ...) \ MACRO(1642, __VA_ARGS__) \ MU_DO_1641(MACRO, __VA_ARGS__) #define MU_DO_1643(MACRO, ...) \ MACRO(1643, __VA_ARGS__) \ MU_DO_1642(MACRO, __VA_ARGS__) #define MU_DO_1644(MACRO, ...) \ MACRO(1644, __VA_ARGS__) \ MU_DO_1643(MACRO, __VA_ARGS__) #define MU_DO_1645(MACRO, ...) \ MACRO(1645, __VA_ARGS__) \ MU_DO_1644(MACRO, __VA_ARGS__) #define MU_DO_1646(MACRO, ...) \ MACRO(1646, __VA_ARGS__) \ MU_DO_1645(MACRO, __VA_ARGS__) #define MU_DO_1647(MACRO, ...) \ MACRO(1647, __VA_ARGS__) \ MU_DO_1646(MACRO, __VA_ARGS__) #define MU_DO_1648(MACRO, ...) \ MACRO(1648, __VA_ARGS__) \ MU_DO_1647(MACRO, __VA_ARGS__) #define MU_DO_1649(MACRO, ...) \ MACRO(1649, __VA_ARGS__) \ MU_DO_1648(MACRO, __VA_ARGS__) #define MU_DO_1650(MACRO, ...) \ MACRO(1650, __VA_ARGS__) \ MU_DO_1649(MACRO, __VA_ARGS__) #define MU_DO_1651(MACRO, ...) \ MACRO(1651, __VA_ARGS__) \ MU_DO_1650(MACRO, __VA_ARGS__) #define MU_DO_1652(MACRO, ...) \ MACRO(1652, __VA_ARGS__) \ MU_DO_1651(MACRO, __VA_ARGS__) #define MU_DO_1653(MACRO, ...) \ MACRO(1653, __VA_ARGS__) \ MU_DO_1652(MACRO, __VA_ARGS__) #define MU_DO_1654(MACRO, ...) \ MACRO(1654, __VA_ARGS__) \ MU_DO_1653(MACRO, __VA_ARGS__) #define MU_DO_1655(MACRO, ...) \ MACRO(1655, __VA_ARGS__) \ MU_DO_1654(MACRO, __VA_ARGS__) #define MU_DO_1656(MACRO, ...) \ MACRO(1656, __VA_ARGS__) \ MU_DO_1655(MACRO, __VA_ARGS__) #define MU_DO_1657(MACRO, ...) \ MACRO(1657, __VA_ARGS__) \ MU_DO_1656(MACRO, __VA_ARGS__) #define MU_DO_1658(MACRO, ...) \ MACRO(1658, __VA_ARGS__) \ MU_DO_1657(MACRO, __VA_ARGS__) #define MU_DO_1659(MACRO, ...) \ MACRO(1659, __VA_ARGS__) \ MU_DO_1658(MACRO, __VA_ARGS__) #define MU_DO_1660(MACRO, ...) \ MACRO(1660, __VA_ARGS__) \ MU_DO_1659(MACRO, __VA_ARGS__) #define MU_DO_1661(MACRO, ...) \ MACRO(1661, __VA_ARGS__) \ MU_DO_1660(MACRO, __VA_ARGS__) #define MU_DO_1662(MACRO, ...) \ MACRO(1662, __VA_ARGS__) \ MU_DO_1661(MACRO, __VA_ARGS__) #define MU_DO_1663(MACRO, ...) \ MACRO(1663, __VA_ARGS__) \ MU_DO_1662(MACRO, __VA_ARGS__) #define MU_DO_1664(MACRO, ...) \ MACRO(1664, __VA_ARGS__) \ MU_DO_1663(MACRO, __VA_ARGS__) #define MU_DO_1665(MACRO, ...) \ MACRO(1665, __VA_ARGS__) \ MU_DO_1664(MACRO, __VA_ARGS__) #define MU_DO_1666(MACRO, ...) \ MACRO(1666, __VA_ARGS__) \ MU_DO_1665(MACRO, __VA_ARGS__) #define MU_DO_1667(MACRO, ...) \ MACRO(1667, __VA_ARGS__) \ MU_DO_1666(MACRO, __VA_ARGS__) #define MU_DO_1668(MACRO, ...) \ MACRO(1668, __VA_ARGS__) \ MU_DO_1667(MACRO, __VA_ARGS__) #define MU_DO_1669(MACRO, ...) \ MACRO(1669, __VA_ARGS__) \ MU_DO_1668(MACRO, __VA_ARGS__) #define MU_DO_1670(MACRO, ...) \ MACRO(1670, __VA_ARGS__) \ MU_DO_1669(MACRO, __VA_ARGS__) #define MU_DO_1671(MACRO, ...) \ MACRO(1671, __VA_ARGS__) \ MU_DO_1670(MACRO, __VA_ARGS__) #define MU_DO_1672(MACRO, ...) \ MACRO(1672, __VA_ARGS__) \ MU_DO_1671(MACRO, __VA_ARGS__) #define MU_DO_1673(MACRO, ...) \ MACRO(1673, __VA_ARGS__) \ MU_DO_1672(MACRO, __VA_ARGS__) #define MU_DO_1674(MACRO, ...) \ MACRO(1674, __VA_ARGS__) \ MU_DO_1673(MACRO, __VA_ARGS__) #define MU_DO_1675(MACRO, ...) \ MACRO(1675, __VA_ARGS__) \ MU_DO_1674(MACRO, __VA_ARGS__) #define MU_DO_1676(MACRO, ...) \ MACRO(1676, __VA_ARGS__) \ MU_DO_1675(MACRO, __VA_ARGS__) #define MU_DO_1677(MACRO, ...) \ MACRO(1677, __VA_ARGS__) \ MU_DO_1676(MACRO, __VA_ARGS__) #define MU_DO_1678(MACRO, ...) \ MACRO(1678, __VA_ARGS__) \ MU_DO_1677(MACRO, __VA_ARGS__) #define MU_DO_1679(MACRO, ...) \ MACRO(1679, __VA_ARGS__) \ MU_DO_1678(MACRO, __VA_ARGS__) #define MU_DO_1680(MACRO, ...) \ MACRO(1680, __VA_ARGS__) \ MU_DO_1679(MACRO, __VA_ARGS__) #define MU_DO_1681(MACRO, ...) \ MACRO(1681, __VA_ARGS__) \ MU_DO_1680(MACRO, __VA_ARGS__) #define MU_DO_1682(MACRO, ...) \ MACRO(1682, __VA_ARGS__) \ MU_DO_1681(MACRO, __VA_ARGS__) #define MU_DO_1683(MACRO, ...) \ MACRO(1683, __VA_ARGS__) \ MU_DO_1682(MACRO, __VA_ARGS__) #define MU_DO_1684(MACRO, ...) \ MACRO(1684, __VA_ARGS__) \ MU_DO_1683(MACRO, __VA_ARGS__) #define MU_DO_1685(MACRO, ...) \ MACRO(1685, __VA_ARGS__) \ MU_DO_1684(MACRO, __VA_ARGS__) #define MU_DO_1686(MACRO, ...) \ MACRO(1686, __VA_ARGS__) \ MU_DO_1685(MACRO, __VA_ARGS__) #define MU_DO_1687(MACRO, ...) \ MACRO(1687, __VA_ARGS__) \ MU_DO_1686(MACRO, __VA_ARGS__) #define MU_DO_1688(MACRO, ...) \ MACRO(1688, __VA_ARGS__) \ MU_DO_1687(MACRO, __VA_ARGS__) #define MU_DO_1689(MACRO, ...) \ MACRO(1689, __VA_ARGS__) \ MU_DO_1688(MACRO, __VA_ARGS__) #define MU_DO_1690(MACRO, ...) \ MACRO(1690, __VA_ARGS__) \ MU_DO_1689(MACRO, __VA_ARGS__) #define MU_DO_1691(MACRO, ...) \ MACRO(1691, __VA_ARGS__) \ MU_DO_1690(MACRO, __VA_ARGS__) #define MU_DO_1692(MACRO, ...) \ MACRO(1692, __VA_ARGS__) \ MU_DO_1691(MACRO, __VA_ARGS__) #define MU_DO_1693(MACRO, ...) \ MACRO(1693, __VA_ARGS__) \ MU_DO_1692(MACRO, __VA_ARGS__) #define MU_DO_1694(MACRO, ...) \ MACRO(1694, __VA_ARGS__) \ MU_DO_1693(MACRO, __VA_ARGS__) #define MU_DO_1695(MACRO, ...) \ MACRO(1695, __VA_ARGS__) \ MU_DO_1694(MACRO, __VA_ARGS__) #define MU_DO_1696(MACRO, ...) \ MACRO(1696, __VA_ARGS__) \ MU_DO_1695(MACRO, __VA_ARGS__) #define MU_DO_1697(MACRO, ...) \ MACRO(1697, __VA_ARGS__) \ MU_DO_1696(MACRO, __VA_ARGS__) #define MU_DO_1698(MACRO, ...) \ MACRO(1698, __VA_ARGS__) \ MU_DO_1697(MACRO, __VA_ARGS__) #define MU_DO_1699(MACRO, ...) \ MACRO(1699, __VA_ARGS__) \ MU_DO_1698(MACRO, __VA_ARGS__) #define MU_DO_1700(MACRO, ...) \ MACRO(1700, __VA_ARGS__) \ MU_DO_1699(MACRO, __VA_ARGS__) #define MU_DO_1701(MACRO, ...) \ MACRO(1701, __VA_ARGS__) \ MU_DO_1700(MACRO, __VA_ARGS__) #define MU_DO_1702(MACRO, ...) \ MACRO(1702, __VA_ARGS__) \ MU_DO_1701(MACRO, __VA_ARGS__) #define MU_DO_1703(MACRO, ...) \ MACRO(1703, __VA_ARGS__) \ MU_DO_1702(MACRO, __VA_ARGS__) #define MU_DO_1704(MACRO, ...) \ MACRO(1704, __VA_ARGS__) \ MU_DO_1703(MACRO, __VA_ARGS__) #define MU_DO_1705(MACRO, ...) \ MACRO(1705, __VA_ARGS__) \ MU_DO_1704(MACRO, __VA_ARGS__) #define MU_DO_1706(MACRO, ...) \ MACRO(1706, __VA_ARGS__) \ MU_DO_1705(MACRO, __VA_ARGS__) #define MU_DO_1707(MACRO, ...) \ MACRO(1707, __VA_ARGS__) \ MU_DO_1706(MACRO, __VA_ARGS__) #define MU_DO_1708(MACRO, ...) \ MACRO(1708, __VA_ARGS__) \ MU_DO_1707(MACRO, __VA_ARGS__) #define MU_DO_1709(MACRO, ...) \ MACRO(1709, __VA_ARGS__) \ MU_DO_1708(MACRO, __VA_ARGS__) #define MU_DO_1710(MACRO, ...) \ MACRO(1710, __VA_ARGS__) \ MU_DO_1709(MACRO, __VA_ARGS__) #define MU_DO_1711(MACRO, ...) \ MACRO(1711, __VA_ARGS__) \ MU_DO_1710(MACRO, __VA_ARGS__) #define MU_DO_1712(MACRO, ...) \ MACRO(1712, __VA_ARGS__) \ MU_DO_1711(MACRO, __VA_ARGS__) #define MU_DO_1713(MACRO, ...) \ MACRO(1713, __VA_ARGS__) \ MU_DO_1712(MACRO, __VA_ARGS__) #define MU_DO_1714(MACRO, ...) \ MACRO(1714, __VA_ARGS__) \ MU_DO_1713(MACRO, __VA_ARGS__) #define MU_DO_1715(MACRO, ...) \ MACRO(1715, __VA_ARGS__) \ MU_DO_1714(MACRO, __VA_ARGS__) #define MU_DO_1716(MACRO, ...) \ MACRO(1716, __VA_ARGS__) \ MU_DO_1715(MACRO, __VA_ARGS__) #define MU_DO_1717(MACRO, ...) \ MACRO(1717, __VA_ARGS__) \ MU_DO_1716(MACRO, __VA_ARGS__) #define MU_DO_1718(MACRO, ...) \ MACRO(1718, __VA_ARGS__) \ MU_DO_1717(MACRO, __VA_ARGS__) #define MU_DO_1719(MACRO, ...) \ MACRO(1719, __VA_ARGS__) \ MU_DO_1718(MACRO, __VA_ARGS__) #define MU_DO_1720(MACRO, ...) \ MACRO(1720, __VA_ARGS__) \ MU_DO_1719(MACRO, __VA_ARGS__) #define MU_DO_1721(MACRO, ...) \ MACRO(1721, __VA_ARGS__) \ MU_DO_1720(MACRO, __VA_ARGS__) #define MU_DO_1722(MACRO, ...) \ MACRO(1722, __VA_ARGS__) \ MU_DO_1721(MACRO, __VA_ARGS__) #define MU_DO_1723(MACRO, ...) \ MACRO(1723, __VA_ARGS__) \ MU_DO_1722(MACRO, __VA_ARGS__) #define MU_DO_1724(MACRO, ...) \ MACRO(1724, __VA_ARGS__) \ MU_DO_1723(MACRO, __VA_ARGS__) #define MU_DO_1725(MACRO, ...) \ MACRO(1725, __VA_ARGS__) \ MU_DO_1724(MACRO, __VA_ARGS__) #define MU_DO_1726(MACRO, ...) \ MACRO(1726, __VA_ARGS__) \ MU_DO_1725(MACRO, __VA_ARGS__) #define MU_DO_1727(MACRO, ...) \ MACRO(1727, __VA_ARGS__) \ MU_DO_1726(MACRO, __VA_ARGS__) #define MU_DO_1728(MACRO, ...) \ MACRO(1728, __VA_ARGS__) \ MU_DO_1727(MACRO, __VA_ARGS__) #define MU_DO_1729(MACRO, ...) \ MACRO(1729, __VA_ARGS__) \ MU_DO_1728(MACRO, __VA_ARGS__) #define MU_DO_1730(MACRO, ...) \ MACRO(1730, __VA_ARGS__) \ MU_DO_1729(MACRO, __VA_ARGS__) #define MU_DO_1731(MACRO, ...) \ MACRO(1731, __VA_ARGS__) \ MU_DO_1730(MACRO, __VA_ARGS__) #define MU_DO_1732(MACRO, ...) \ MACRO(1732, __VA_ARGS__) \ MU_DO_1731(MACRO, __VA_ARGS__) #define MU_DO_1733(MACRO, ...) \ MACRO(1733, __VA_ARGS__) \ MU_DO_1732(MACRO, __VA_ARGS__) #define MU_DO_1734(MACRO, ...) \ MACRO(1734, __VA_ARGS__) \ MU_DO_1733(MACRO, __VA_ARGS__) #define MU_DO_1735(MACRO, ...) \ MACRO(1735, __VA_ARGS__) \ MU_DO_1734(MACRO, __VA_ARGS__) #define MU_DO_1736(MACRO, ...) \ MACRO(1736, __VA_ARGS__) \ MU_DO_1735(MACRO, __VA_ARGS__) #define MU_DO_1737(MACRO, ...) \ MACRO(1737, __VA_ARGS__) \ MU_DO_1736(MACRO, __VA_ARGS__) #define MU_DO_1738(MACRO, ...) \ MACRO(1738, __VA_ARGS__) \ MU_DO_1737(MACRO, __VA_ARGS__) #define MU_DO_1739(MACRO, ...) \ MACRO(1739, __VA_ARGS__) \ MU_DO_1738(MACRO, __VA_ARGS__) #define MU_DO_1740(MACRO, ...) \ MACRO(1740, __VA_ARGS__) \ MU_DO_1739(MACRO, __VA_ARGS__) #define MU_DO_1741(MACRO, ...) \ MACRO(1741, __VA_ARGS__) \ MU_DO_1740(MACRO, __VA_ARGS__) #define MU_DO_1742(MACRO, ...) \ MACRO(1742, __VA_ARGS__) \ MU_DO_1741(MACRO, __VA_ARGS__) #define MU_DO_1743(MACRO, ...) \ MACRO(1743, __VA_ARGS__) \ MU_DO_1742(MACRO, __VA_ARGS__) #define MU_DO_1744(MACRO, ...) \ MACRO(1744, __VA_ARGS__) \ MU_DO_1743(MACRO, __VA_ARGS__) #define MU_DO_1745(MACRO, ...) \ MACRO(1745, __VA_ARGS__) \ MU_DO_1744(MACRO, __VA_ARGS__) #define MU_DO_1746(MACRO, ...) \ MACRO(1746, __VA_ARGS__) \ MU_DO_1745(MACRO, __VA_ARGS__) #define MU_DO_1747(MACRO, ...) \ MACRO(1747, __VA_ARGS__) \ MU_DO_1746(MACRO, __VA_ARGS__) #define MU_DO_1748(MACRO, ...) \ MACRO(1748, __VA_ARGS__) \ MU_DO_1747(MACRO, __VA_ARGS__) #define MU_DO_1749(MACRO, ...) \ MACRO(1749, __VA_ARGS__) \ MU_DO_1748(MACRO, __VA_ARGS__) #define MU_DO_1750(MACRO, ...) \ MACRO(1750, __VA_ARGS__) \ MU_DO_1749(MACRO, __VA_ARGS__) #define MU_DO_1751(MACRO, ...) \ MACRO(1751, __VA_ARGS__) \ MU_DO_1750(MACRO, __VA_ARGS__) #define MU_DO_1752(MACRO, ...) \ MACRO(1752, __VA_ARGS__) \ MU_DO_1751(MACRO, __VA_ARGS__) #define MU_DO_1753(MACRO, ...) \ MACRO(1753, __VA_ARGS__) \ MU_DO_1752(MACRO, __VA_ARGS__) #define MU_DO_1754(MACRO, ...) \ MACRO(1754, __VA_ARGS__) \ MU_DO_1753(MACRO, __VA_ARGS__) #define MU_DO_1755(MACRO, ...) \ MACRO(1755, __VA_ARGS__) \ MU_DO_1754(MACRO, __VA_ARGS__) #define MU_DO_1756(MACRO, ...) \ MACRO(1756, __VA_ARGS__) \ MU_DO_1755(MACRO, __VA_ARGS__) #define MU_DO_1757(MACRO, ...) \ MACRO(1757, __VA_ARGS__) \ MU_DO_1756(MACRO, __VA_ARGS__) #define MU_DO_1758(MACRO, ...) \ MACRO(1758, __VA_ARGS__) \ MU_DO_1757(MACRO, __VA_ARGS__) #define MU_DO_1759(MACRO, ...) \ MACRO(1759, __VA_ARGS__) \ MU_DO_1758(MACRO, __VA_ARGS__) #define MU_DO_1760(MACRO, ...) \ MACRO(1760, __VA_ARGS__) \ MU_DO_1759(MACRO, __VA_ARGS__) #define MU_DO_1761(MACRO, ...) \ MACRO(1761, __VA_ARGS__) \ MU_DO_1760(MACRO, __VA_ARGS__) #define MU_DO_1762(MACRO, ...) \ MACRO(1762, __VA_ARGS__) \ MU_DO_1761(MACRO, __VA_ARGS__) #define MU_DO_1763(MACRO, ...) \ MACRO(1763, __VA_ARGS__) \ MU_DO_1762(MACRO, __VA_ARGS__) #define MU_DO_1764(MACRO, ...) \ MACRO(1764, __VA_ARGS__) \ MU_DO_1763(MACRO, __VA_ARGS__) #define MU_DO_1765(MACRO, ...) \ MACRO(1765, __VA_ARGS__) \ MU_DO_1764(MACRO, __VA_ARGS__) #define MU_DO_1766(MACRO, ...) \ MACRO(1766, __VA_ARGS__) \ MU_DO_1765(MACRO, __VA_ARGS__) #define MU_DO_1767(MACRO, ...) \ MACRO(1767, __VA_ARGS__) \ MU_DO_1766(MACRO, __VA_ARGS__) #define MU_DO_1768(MACRO, ...) \ MACRO(1768, __VA_ARGS__) \ MU_DO_1767(MACRO, __VA_ARGS__) #define MU_DO_1769(MACRO, ...) \ MACRO(1769, __VA_ARGS__) \ MU_DO_1768(MACRO, __VA_ARGS__) #define MU_DO_1770(MACRO, ...) \ MACRO(1770, __VA_ARGS__) \ MU_DO_1769(MACRO, __VA_ARGS__) #define MU_DO_1771(MACRO, ...) \ MACRO(1771, __VA_ARGS__) \ MU_DO_1770(MACRO, __VA_ARGS__) #define MU_DO_1772(MACRO, ...) \ MACRO(1772, __VA_ARGS__) \ MU_DO_1771(MACRO, __VA_ARGS__) #define MU_DO_1773(MACRO, ...) \ MACRO(1773, __VA_ARGS__) \ MU_DO_1772(MACRO, __VA_ARGS__) #define MU_DO_1774(MACRO, ...) \ MACRO(1774, __VA_ARGS__) \ MU_DO_1773(MACRO, __VA_ARGS__) #define MU_DO_1775(MACRO, ...) \ MACRO(1775, __VA_ARGS__) \ MU_DO_1774(MACRO, __VA_ARGS__) #define MU_DO_1776(MACRO, ...) \ MACRO(1776, __VA_ARGS__) \ MU_DO_1775(MACRO, __VA_ARGS__) #define MU_DO_1777(MACRO, ...) \ MACRO(1777, __VA_ARGS__) \ MU_DO_1776(MACRO, __VA_ARGS__) #define MU_DO_1778(MACRO, ...) \ MACRO(1778, __VA_ARGS__) \ MU_DO_1777(MACRO, __VA_ARGS__) #define MU_DO_1779(MACRO, ...) \ MACRO(1779, __VA_ARGS__) \ MU_DO_1778(MACRO, __VA_ARGS__) #define MU_DO_1780(MACRO, ...) \ MACRO(1780, __VA_ARGS__) \ MU_DO_1779(MACRO, __VA_ARGS__) #define MU_DO_1781(MACRO, ...) \ MACRO(1781, __VA_ARGS__) \ MU_DO_1780(MACRO, __VA_ARGS__) #define MU_DO_1782(MACRO, ...) \ MACRO(1782, __VA_ARGS__) \ MU_DO_1781(MACRO, __VA_ARGS__) #define MU_DO_1783(MACRO, ...) \ MACRO(1783, __VA_ARGS__) \ MU_DO_1782(MACRO, __VA_ARGS__) #define MU_DO_1784(MACRO, ...) \ MACRO(1784, __VA_ARGS__) \ MU_DO_1783(MACRO, __VA_ARGS__) #define MU_DO_1785(MACRO, ...) \ MACRO(1785, __VA_ARGS__) \ MU_DO_1784(MACRO, __VA_ARGS__) #define MU_DO_1786(MACRO, ...) \ MACRO(1786, __VA_ARGS__) \ MU_DO_1785(MACRO, __VA_ARGS__) #define MU_DO_1787(MACRO, ...) \ MACRO(1787, __VA_ARGS__) \ MU_DO_1786(MACRO, __VA_ARGS__) #define MU_DO_1788(MACRO, ...) \ MACRO(1788, __VA_ARGS__) \ MU_DO_1787(MACRO, __VA_ARGS__) #define MU_DO_1789(MACRO, ...) \ MACRO(1789, __VA_ARGS__) \ MU_DO_1788(MACRO, __VA_ARGS__) #define MU_DO_1790(MACRO, ...) \ MACRO(1790, __VA_ARGS__) \ MU_DO_1789(MACRO, __VA_ARGS__) #define MU_DO_1791(MACRO, ...) \ MACRO(1791, __VA_ARGS__) \ MU_DO_1790(MACRO, __VA_ARGS__) #define MU_DO_1792(MACRO, ...) \ MACRO(1792, __VA_ARGS__) \ MU_DO_1791(MACRO, __VA_ARGS__) #define MU_DO_1793(MACRO, ...) \ MACRO(1793, __VA_ARGS__) \ MU_DO_1792(MACRO, __VA_ARGS__) #define MU_DO_1794(MACRO, ...) \ MACRO(1794, __VA_ARGS__) \ MU_DO_1793(MACRO, __VA_ARGS__) #define MU_DO_1795(MACRO, ...) \ MACRO(1795, __VA_ARGS__) \ MU_DO_1794(MACRO, __VA_ARGS__) #define MU_DO_1796(MACRO, ...) \ MACRO(1796, __VA_ARGS__) \ MU_DO_1795(MACRO, __VA_ARGS__) #define MU_DO_1797(MACRO, ...) \ MACRO(1797, __VA_ARGS__) \ MU_DO_1796(MACRO, __VA_ARGS__) #define MU_DO_1798(MACRO, ...) \ MACRO(1798, __VA_ARGS__) \ MU_DO_1797(MACRO, __VA_ARGS__) #define MU_DO_1799(MACRO, ...) \ MACRO(1799, __VA_ARGS__) \ MU_DO_1798(MACRO, __VA_ARGS__) #define MU_DO_1800(MACRO, ...) \ MACRO(1800, __VA_ARGS__) \ MU_DO_1799(MACRO, __VA_ARGS__) #define MU_DO_1801(MACRO, ...) \ MACRO(1801, __VA_ARGS__) \ MU_DO_1800(MACRO, __VA_ARGS__) #define MU_DO_1802(MACRO, ...) \ MACRO(1802, __VA_ARGS__) \ MU_DO_1801(MACRO, __VA_ARGS__) #define MU_DO_1803(MACRO, ...) \ MACRO(1803, __VA_ARGS__) \ MU_DO_1802(MACRO, __VA_ARGS__) #define MU_DO_1804(MACRO, ...) \ MACRO(1804, __VA_ARGS__) \ MU_DO_1803(MACRO, __VA_ARGS__) #define MU_DO_1805(MACRO, ...) \ MACRO(1805, __VA_ARGS__) \ MU_DO_1804(MACRO, __VA_ARGS__) #define MU_DO_1806(MACRO, ...) \ MACRO(1806, __VA_ARGS__) \ MU_DO_1805(MACRO, __VA_ARGS__) #define MU_DO_1807(MACRO, ...) \ MACRO(1807, __VA_ARGS__) \ MU_DO_1806(MACRO, __VA_ARGS__) #define MU_DO_1808(MACRO, ...) \ MACRO(1808, __VA_ARGS__) \ MU_DO_1807(MACRO, __VA_ARGS__) #define MU_DO_1809(MACRO, ...) \ MACRO(1809, __VA_ARGS__) \ MU_DO_1808(MACRO, __VA_ARGS__) #define MU_DO_1810(MACRO, ...) \ MACRO(1810, __VA_ARGS__) \ MU_DO_1809(MACRO, __VA_ARGS__) #define MU_DO_1811(MACRO, ...) \ MACRO(1811, __VA_ARGS__) \ MU_DO_1810(MACRO, __VA_ARGS__) #define MU_DO_1812(MACRO, ...) \ MACRO(1812, __VA_ARGS__) \ MU_DO_1811(MACRO, __VA_ARGS__) #define MU_DO_1813(MACRO, ...) \ MACRO(1813, __VA_ARGS__) \ MU_DO_1812(MACRO, __VA_ARGS__) #define MU_DO_1814(MACRO, ...) \ MACRO(1814, __VA_ARGS__) \ MU_DO_1813(MACRO, __VA_ARGS__) #define MU_DO_1815(MACRO, ...) \ MACRO(1815, __VA_ARGS__) \ MU_DO_1814(MACRO, __VA_ARGS__) #define MU_DO_1816(MACRO, ...) \ MACRO(1816, __VA_ARGS__) \ MU_DO_1815(MACRO, __VA_ARGS__) #define MU_DO_1817(MACRO, ...) \ MACRO(1817, __VA_ARGS__) \ MU_DO_1816(MACRO, __VA_ARGS__) #define MU_DO_1818(MACRO, ...) \ MACRO(1818, __VA_ARGS__) \ MU_DO_1817(MACRO, __VA_ARGS__) #define MU_DO_1819(MACRO, ...) \ MACRO(1819, __VA_ARGS__) \ MU_DO_1818(MACRO, __VA_ARGS__) #define MU_DO_1820(MACRO, ...) \ MACRO(1820, __VA_ARGS__) \ MU_DO_1819(MACRO, __VA_ARGS__) #define MU_DO_1821(MACRO, ...) \ MACRO(1821, __VA_ARGS__) \ MU_DO_1820(MACRO, __VA_ARGS__) #define MU_DO_1822(MACRO, ...) \ MACRO(1822, __VA_ARGS__) \ MU_DO_1821(MACRO, __VA_ARGS__) #define MU_DO_1823(MACRO, ...) \ MACRO(1823, __VA_ARGS__) \ MU_DO_1822(MACRO, __VA_ARGS__) #define MU_DO_1824(MACRO, ...) \ MACRO(1824, __VA_ARGS__) \ MU_DO_1823(MACRO, __VA_ARGS__) #define MU_DO_1825(MACRO, ...) \ MACRO(1825, __VA_ARGS__) \ MU_DO_1824(MACRO, __VA_ARGS__) #define MU_DO_1826(MACRO, ...) \ MACRO(1826, __VA_ARGS__) \ MU_DO_1825(MACRO, __VA_ARGS__) #define MU_DO_1827(MACRO, ...) \ MACRO(1827, __VA_ARGS__) \ MU_DO_1826(MACRO, __VA_ARGS__) #define MU_DO_1828(MACRO, ...) \ MACRO(1828, __VA_ARGS__) \ MU_DO_1827(MACRO, __VA_ARGS__) #define MU_DO_1829(MACRO, ...) \ MACRO(1829, __VA_ARGS__) \ MU_DO_1828(MACRO, __VA_ARGS__) #define MU_DO_1830(MACRO, ...) \ MACRO(1830, __VA_ARGS__) \ MU_DO_1829(MACRO, __VA_ARGS__) #define MU_DO_1831(MACRO, ...) \ MACRO(1831, __VA_ARGS__) \ MU_DO_1830(MACRO, __VA_ARGS__) #define MU_DO_1832(MACRO, ...) \ MACRO(1832, __VA_ARGS__) \ MU_DO_1831(MACRO, __VA_ARGS__) #define MU_DO_1833(MACRO, ...) \ MACRO(1833, __VA_ARGS__) \ MU_DO_1832(MACRO, __VA_ARGS__) #define MU_DO_1834(MACRO, ...) \ MACRO(1834, __VA_ARGS__) \ MU_DO_1833(MACRO, __VA_ARGS__) #define MU_DO_1835(MACRO, ...) \ MACRO(1835, __VA_ARGS__) \ MU_DO_1834(MACRO, __VA_ARGS__) #define MU_DO_1836(MACRO, ...) \ MACRO(1836, __VA_ARGS__) \ MU_DO_1835(MACRO, __VA_ARGS__) #define MU_DO_1837(MACRO, ...) \ MACRO(1837, __VA_ARGS__) \ MU_DO_1836(MACRO, __VA_ARGS__) #define MU_DO_1838(MACRO, ...) \ MACRO(1838, __VA_ARGS__) \ MU_DO_1837(MACRO, __VA_ARGS__) #define MU_DO_1839(MACRO, ...) \ MACRO(1839, __VA_ARGS__) \ MU_DO_1838(MACRO, __VA_ARGS__) #define MU_DO_1840(MACRO, ...) \ MACRO(1840, __VA_ARGS__) \ MU_DO_1839(MACRO, __VA_ARGS__) #define MU_DO_1841(MACRO, ...) \ MACRO(1841, __VA_ARGS__) \ MU_DO_1840(MACRO, __VA_ARGS__) #define MU_DO_1842(MACRO, ...) \ MACRO(1842, __VA_ARGS__) \ MU_DO_1841(MACRO, __VA_ARGS__) #define MU_DO_1843(MACRO, ...) \ MACRO(1843, __VA_ARGS__) \ MU_DO_1842(MACRO, __VA_ARGS__) #define MU_DO_1844(MACRO, ...) \ MACRO(1844, __VA_ARGS__) \ MU_DO_1843(MACRO, __VA_ARGS__) #define MU_DO_1845(MACRO, ...) \ MACRO(1845, __VA_ARGS__) \ MU_DO_1844(MACRO, __VA_ARGS__) #define MU_DO_1846(MACRO, ...) \ MACRO(1846, __VA_ARGS__) \ MU_DO_1845(MACRO, __VA_ARGS__) #define MU_DO_1847(MACRO, ...) \ MACRO(1847, __VA_ARGS__) \ MU_DO_1846(MACRO, __VA_ARGS__) #define MU_DO_1848(MACRO, ...) \ MACRO(1848, __VA_ARGS__) \ MU_DO_1847(MACRO, __VA_ARGS__) #define MU_DO_1849(MACRO, ...) \ MACRO(1849, __VA_ARGS__) \ MU_DO_1848(MACRO, __VA_ARGS__) #define MU_DO_1850(MACRO, ...) \ MACRO(1850, __VA_ARGS__) \ MU_DO_1849(MACRO, __VA_ARGS__) #define MU_DO_1851(MACRO, ...) \ MACRO(1851, __VA_ARGS__) \ MU_DO_1850(MACRO, __VA_ARGS__) #define MU_DO_1852(MACRO, ...) \ MACRO(1852, __VA_ARGS__) \ MU_DO_1851(MACRO, __VA_ARGS__) #define MU_DO_1853(MACRO, ...) \ MACRO(1853, __VA_ARGS__) \ MU_DO_1852(MACRO, __VA_ARGS__) #define MU_DO_1854(MACRO, ...) \ MACRO(1854, __VA_ARGS__) \ MU_DO_1853(MACRO, __VA_ARGS__) #define MU_DO_1855(MACRO, ...) \ MACRO(1855, __VA_ARGS__) \ MU_DO_1854(MACRO, __VA_ARGS__) #define MU_DO_1856(MACRO, ...) \ MACRO(1856, __VA_ARGS__) \ MU_DO_1855(MACRO, __VA_ARGS__) #define MU_DO_1857(MACRO, ...) \ MACRO(1857, __VA_ARGS__) \ MU_DO_1856(MACRO, __VA_ARGS__) #define MU_DO_1858(MACRO, ...) \ MACRO(1858, __VA_ARGS__) \ MU_DO_1857(MACRO, __VA_ARGS__) #define MU_DO_1859(MACRO, ...) \ MACRO(1859, __VA_ARGS__) \ MU_DO_1858(MACRO, __VA_ARGS__) #define MU_DO_1860(MACRO, ...) \ MACRO(1860, __VA_ARGS__) \ MU_DO_1859(MACRO, __VA_ARGS__) #define MU_DO_1861(MACRO, ...) \ MACRO(1861, __VA_ARGS__) \ MU_DO_1860(MACRO, __VA_ARGS__) #define MU_DO_1862(MACRO, ...) \ MACRO(1862, __VA_ARGS__) \ MU_DO_1861(MACRO, __VA_ARGS__) #define MU_DO_1863(MACRO, ...) \ MACRO(1863, __VA_ARGS__) \ MU_DO_1862(MACRO, __VA_ARGS__) #define MU_DO_1864(MACRO, ...) \ MACRO(1864, __VA_ARGS__) \ MU_DO_1863(MACRO, __VA_ARGS__) #define MU_DO_1865(MACRO, ...) \ MACRO(1865, __VA_ARGS__) \ MU_DO_1864(MACRO, __VA_ARGS__) #define MU_DO_1866(MACRO, ...) \ MACRO(1866, __VA_ARGS__) \ MU_DO_1865(MACRO, __VA_ARGS__) #define MU_DO_1867(MACRO, ...) \ MACRO(1867, __VA_ARGS__) \ MU_DO_1866(MACRO, __VA_ARGS__) #define MU_DO_1868(MACRO, ...) \ MACRO(1868, __VA_ARGS__) \ MU_DO_1867(MACRO, __VA_ARGS__) #define MU_DO_1869(MACRO, ...) \ MACRO(1869, __VA_ARGS__) \ MU_DO_1868(MACRO, __VA_ARGS__) #define MU_DO_1870(MACRO, ...) \ MACRO(1870, __VA_ARGS__) \ MU_DO_1869(MACRO, __VA_ARGS__) #define MU_DO_1871(MACRO, ...) \ MACRO(1871, __VA_ARGS__) \ MU_DO_1870(MACRO, __VA_ARGS__) #define MU_DO_1872(MACRO, ...) \ MACRO(1872, __VA_ARGS__) \ MU_DO_1871(MACRO, __VA_ARGS__) #define MU_DO_1873(MACRO, ...) \ MACRO(1873, __VA_ARGS__) \ MU_DO_1872(MACRO, __VA_ARGS__) #define MU_DO_1874(MACRO, ...) \ MACRO(1874, __VA_ARGS__) \ MU_DO_1873(MACRO, __VA_ARGS__) #define MU_DO_1875(MACRO, ...) \ MACRO(1875, __VA_ARGS__) \ MU_DO_1874(MACRO, __VA_ARGS__) #define MU_DO_1876(MACRO, ...) \ MACRO(1876, __VA_ARGS__) \ MU_DO_1875(MACRO, __VA_ARGS__) #define MU_DO_1877(MACRO, ...) \ MACRO(1877, __VA_ARGS__) \ MU_DO_1876(MACRO, __VA_ARGS__) #define MU_DO_1878(MACRO, ...) \ MACRO(1878, __VA_ARGS__) \ MU_DO_1877(MACRO, __VA_ARGS__) #define MU_DO_1879(MACRO, ...) \ MACRO(1879, __VA_ARGS__) \ MU_DO_1878(MACRO, __VA_ARGS__) #define MU_DO_1880(MACRO, ...) \ MACRO(1880, __VA_ARGS__) \ MU_DO_1879(MACRO, __VA_ARGS__) #define MU_DO_1881(MACRO, ...) \ MACRO(1881, __VA_ARGS__) \ MU_DO_1880(MACRO, __VA_ARGS__) #define MU_DO_1882(MACRO, ...) \ MACRO(1882, __VA_ARGS__) \ MU_DO_1881(MACRO, __VA_ARGS__) #define MU_DO_1883(MACRO, ...) \ MACRO(1883, __VA_ARGS__) \ MU_DO_1882(MACRO, __VA_ARGS__) #define MU_DO_1884(MACRO, ...) \ MACRO(1884, __VA_ARGS__) \ MU_DO_1883(MACRO, __VA_ARGS__) #define MU_DO_1885(MACRO, ...) \ MACRO(1885, __VA_ARGS__) \ MU_DO_1884(MACRO, __VA_ARGS__) #define MU_DO_1886(MACRO, ...) \ MACRO(1886, __VA_ARGS__) \ MU_DO_1885(MACRO, __VA_ARGS__) #define MU_DO_1887(MACRO, ...) \ MACRO(1887, __VA_ARGS__) \ MU_DO_1886(MACRO, __VA_ARGS__) #define MU_DO_1888(MACRO, ...) \ MACRO(1888, __VA_ARGS__) \ MU_DO_1887(MACRO, __VA_ARGS__) #define MU_DO_1889(MACRO, ...) \ MACRO(1889, __VA_ARGS__) \ MU_DO_1888(MACRO, __VA_ARGS__) #define MU_DO_1890(MACRO, ...) \ MACRO(1890, __VA_ARGS__) \ MU_DO_1889(MACRO, __VA_ARGS__) #define MU_DO_1891(MACRO, ...) \ MACRO(1891, __VA_ARGS__) \ MU_DO_1890(MACRO, __VA_ARGS__) #define MU_DO_1892(MACRO, ...) \ MACRO(1892, __VA_ARGS__) \ MU_DO_1891(MACRO, __VA_ARGS__) #define MU_DO_1893(MACRO, ...) \ MACRO(1893, __VA_ARGS__) \ MU_DO_1892(MACRO, __VA_ARGS__) #define MU_DO_1894(MACRO, ...) \ MACRO(1894, __VA_ARGS__) \ MU_DO_1893(MACRO, __VA_ARGS__) #define MU_DO_1895(MACRO, ...) \ MACRO(1895, __VA_ARGS__) \ MU_DO_1894(MACRO, __VA_ARGS__) #define MU_DO_1896(MACRO, ...) \ MACRO(1896, __VA_ARGS__) \ MU_DO_1895(MACRO, __VA_ARGS__) #define MU_DO_1897(MACRO, ...) \ MACRO(1897, __VA_ARGS__) \ MU_DO_1896(MACRO, __VA_ARGS__) #define MU_DO_1898(MACRO, ...) \ MACRO(1898, __VA_ARGS__) \ MU_DO_1897(MACRO, __VA_ARGS__) #define MU_DO_1899(MACRO, ...) \ MACRO(1899, __VA_ARGS__) \ MU_DO_1898(MACRO, __VA_ARGS__) #define MU_DO_1900(MACRO, ...) \ MACRO(1900, __VA_ARGS__) \ MU_DO_1899(MACRO, __VA_ARGS__) #define MU_DO_1901(MACRO, ...) \ MACRO(1901, __VA_ARGS__) \ MU_DO_1900(MACRO, __VA_ARGS__) #define MU_DO_1902(MACRO, ...) \ MACRO(1902, __VA_ARGS__) \ MU_DO_1901(MACRO, __VA_ARGS__) #define MU_DO_1903(MACRO, ...) \ MACRO(1903, __VA_ARGS__) \ MU_DO_1902(MACRO, __VA_ARGS__) #define MU_DO_1904(MACRO, ...) \ MACRO(1904, __VA_ARGS__) \ MU_DO_1903(MACRO, __VA_ARGS__) #define MU_DO_1905(MACRO, ...) \ MACRO(1905, __VA_ARGS__) \ MU_DO_1904(MACRO, __VA_ARGS__) #define MU_DO_1906(MACRO, ...) \ MACRO(1906, __VA_ARGS__) \ MU_DO_1905(MACRO, __VA_ARGS__) #define MU_DO_1907(MACRO, ...) \ MACRO(1907, __VA_ARGS__) \ MU_DO_1906(MACRO, __VA_ARGS__) #define MU_DO_1908(MACRO, ...) \ MACRO(1908, __VA_ARGS__) \ MU_DO_1907(MACRO, __VA_ARGS__) #define MU_DO_1909(MACRO, ...) \ MACRO(1909, __VA_ARGS__) \ MU_DO_1908(MACRO, __VA_ARGS__) #define MU_DO_1910(MACRO, ...) \ MACRO(1910, __VA_ARGS__) \ MU_DO_1909(MACRO, __VA_ARGS__) #define MU_DO_1911(MACRO, ...) \ MACRO(1911, __VA_ARGS__) \ MU_DO_1910(MACRO, __VA_ARGS__) #define MU_DO_1912(MACRO, ...) \ MACRO(1912, __VA_ARGS__) \ MU_DO_1911(MACRO, __VA_ARGS__) #define MU_DO_1913(MACRO, ...) \ MACRO(1913, __VA_ARGS__) \ MU_DO_1912(MACRO, __VA_ARGS__) #define MU_DO_1914(MACRO, ...) \ MACRO(1914, __VA_ARGS__) \ MU_DO_1913(MACRO, __VA_ARGS__) #define MU_DO_1915(MACRO, ...) \ MACRO(1915, __VA_ARGS__) \ MU_DO_1914(MACRO, __VA_ARGS__) #define MU_DO_1916(MACRO, ...) \ MACRO(1916, __VA_ARGS__) \ MU_DO_1915(MACRO, __VA_ARGS__) #define MU_DO_1917(MACRO, ...) \ MACRO(1917, __VA_ARGS__) \ MU_DO_1916(MACRO, __VA_ARGS__) #define MU_DO_1918(MACRO, ...) \ MACRO(1918, __VA_ARGS__) \ MU_DO_1917(MACRO, __VA_ARGS__) #define MU_DO_1919(MACRO, ...) \ MACRO(1919, __VA_ARGS__) \ MU_DO_1918(MACRO, __VA_ARGS__) #define MU_DO_1920(MACRO, ...) \ MACRO(1920, __VA_ARGS__) \ MU_DO_1919(MACRO, __VA_ARGS__) #define MU_DO_1921(MACRO, ...) \ MACRO(1921, __VA_ARGS__) \ MU_DO_1920(MACRO, __VA_ARGS__) #define MU_DO_1922(MACRO, ...) \ MACRO(1922, __VA_ARGS__) \ MU_DO_1921(MACRO, __VA_ARGS__) #define MU_DO_1923(MACRO, ...) \ MACRO(1923, __VA_ARGS__) \ MU_DO_1922(MACRO, __VA_ARGS__) #define MU_DO_1924(MACRO, ...) \ MACRO(1924, __VA_ARGS__) \ MU_DO_1923(MACRO, __VA_ARGS__) #define MU_DO_1925(MACRO, ...) \ MACRO(1925, __VA_ARGS__) \ MU_DO_1924(MACRO, __VA_ARGS__) #define MU_DO_1926(MACRO, ...) \ MACRO(1926, __VA_ARGS__) \ MU_DO_1925(MACRO, __VA_ARGS__) #define MU_DO_1927(MACRO, ...) \ MACRO(1927, __VA_ARGS__) \ MU_DO_1926(MACRO, __VA_ARGS__) #define MU_DO_1928(MACRO, ...) \ MACRO(1928, __VA_ARGS__) \ MU_DO_1927(MACRO, __VA_ARGS__) #define MU_DO_1929(MACRO, ...) \ MACRO(1929, __VA_ARGS__) \ MU_DO_1928(MACRO, __VA_ARGS__) #define MU_DO_1930(MACRO, ...) \ MACRO(1930, __VA_ARGS__) \ MU_DO_1929(MACRO, __VA_ARGS__) #define MU_DO_1931(MACRO, ...) \ MACRO(1931, __VA_ARGS__) \ MU_DO_1930(MACRO, __VA_ARGS__) #define MU_DO_1932(MACRO, ...) \ MACRO(1932, __VA_ARGS__) \ MU_DO_1931(MACRO, __VA_ARGS__) #define MU_DO_1933(MACRO, ...) \ MACRO(1933, __VA_ARGS__) \ MU_DO_1932(MACRO, __VA_ARGS__) #define MU_DO_1934(MACRO, ...) \ MACRO(1934, __VA_ARGS__) \ MU_DO_1933(MACRO, __VA_ARGS__) #define MU_DO_1935(MACRO, ...) \ MACRO(1935, __VA_ARGS__) \ MU_DO_1934(MACRO, __VA_ARGS__) #define MU_DO_1936(MACRO, ...) \ MACRO(1936, __VA_ARGS__) \ MU_DO_1935(MACRO, __VA_ARGS__) #define MU_DO_1937(MACRO, ...) \ MACRO(1937, __VA_ARGS__) \ MU_DO_1936(MACRO, __VA_ARGS__) #define MU_DO_1938(MACRO, ...) \ MACRO(1938, __VA_ARGS__) \ MU_DO_1937(MACRO, __VA_ARGS__) #define MU_DO_1939(MACRO, ...) \ MACRO(1939, __VA_ARGS__) \ MU_DO_1938(MACRO, __VA_ARGS__) #define MU_DO_1940(MACRO, ...) \ MACRO(1940, __VA_ARGS__) \ MU_DO_1939(MACRO, __VA_ARGS__) #define MU_DO_1941(MACRO, ...) \ MACRO(1941, __VA_ARGS__) \ MU_DO_1940(MACRO, __VA_ARGS__) #define MU_DO_1942(MACRO, ...) \ MACRO(1942, __VA_ARGS__) \ MU_DO_1941(MACRO, __VA_ARGS__) #define MU_DO_1943(MACRO, ...) \ MACRO(1943, __VA_ARGS__) \ MU_DO_1942(MACRO, __VA_ARGS__) #define MU_DO_1944(MACRO, ...) \ MACRO(1944, __VA_ARGS__) \ MU_DO_1943(MACRO, __VA_ARGS__) #define MU_DO_1945(MACRO, ...) \ MACRO(1945, __VA_ARGS__) \ MU_DO_1944(MACRO, __VA_ARGS__) #define MU_DO_1946(MACRO, ...) \ MACRO(1946, __VA_ARGS__) \ MU_DO_1945(MACRO, __VA_ARGS__) #define MU_DO_1947(MACRO, ...) \ MACRO(1947, __VA_ARGS__) \ MU_DO_1946(MACRO, __VA_ARGS__) #define MU_DO_1948(MACRO, ...) \ MACRO(1948, __VA_ARGS__) \ MU_DO_1947(MACRO, __VA_ARGS__) #define MU_DO_1949(MACRO, ...) \ MACRO(1949, __VA_ARGS__) \ MU_DO_1948(MACRO, __VA_ARGS__) #define MU_DO_1950(MACRO, ...) \ MACRO(1950, __VA_ARGS__) \ MU_DO_1949(MACRO, __VA_ARGS__) #define MU_DO_1951(MACRO, ...) \ MACRO(1951, __VA_ARGS__) \ MU_DO_1950(MACRO, __VA_ARGS__) #define MU_DO_1952(MACRO, ...) \ MACRO(1952, __VA_ARGS__) \ MU_DO_1951(MACRO, __VA_ARGS__) #define MU_DO_1953(MACRO, ...) \ MACRO(1953, __VA_ARGS__) \ MU_DO_1952(MACRO, __VA_ARGS__) #define MU_DO_1954(MACRO, ...) \ MACRO(1954, __VA_ARGS__) \ MU_DO_1953(MACRO, __VA_ARGS__) #define MU_DO_1955(MACRO, ...) \ MACRO(1955, __VA_ARGS__) \ MU_DO_1954(MACRO, __VA_ARGS__) #define MU_DO_1956(MACRO, ...) \ MACRO(1956, __VA_ARGS__) \ MU_DO_1955(MACRO, __VA_ARGS__) #define MU_DO_1957(MACRO, ...) \ MACRO(1957, __VA_ARGS__) \ MU_DO_1956(MACRO, __VA_ARGS__) #define MU_DO_1958(MACRO, ...) \ MACRO(1958, __VA_ARGS__) \ MU_DO_1957(MACRO, __VA_ARGS__) #define MU_DO_1959(MACRO, ...) \ MACRO(1959, __VA_ARGS__) \ MU_DO_1958(MACRO, __VA_ARGS__) #define MU_DO_1960(MACRO, ...) \ MACRO(1960, __VA_ARGS__) \ MU_DO_1959(MACRO, __VA_ARGS__) #define MU_DO_1961(MACRO, ...) \ MACRO(1961, __VA_ARGS__) \ MU_DO_1960(MACRO, __VA_ARGS__) #define MU_DO_1962(MACRO, ...) \ MACRO(1962, __VA_ARGS__) \ MU_DO_1961(MACRO, __VA_ARGS__) #define MU_DO_1963(MACRO, ...) \ MACRO(1963, __VA_ARGS__) \ MU_DO_1962(MACRO, __VA_ARGS__) #define MU_DO_1964(MACRO, ...) \ MACRO(1964, __VA_ARGS__) \ MU_DO_1963(MACRO, __VA_ARGS__) #define MU_DO_1965(MACRO, ...) \ MACRO(1965, __VA_ARGS__) \ MU_DO_1964(MACRO, __VA_ARGS__) #define MU_DO_1966(MACRO, ...) \ MACRO(1966, __VA_ARGS__) \ MU_DO_1965(MACRO, __VA_ARGS__) #define MU_DO_1967(MACRO, ...) \ MACRO(1967, __VA_ARGS__) \ MU_DO_1966(MACRO, __VA_ARGS__) #define MU_DO_1968(MACRO, ...) \ MACRO(1968, __VA_ARGS__) \ MU_DO_1967(MACRO, __VA_ARGS__) #define MU_DO_1969(MACRO, ...) \ MACRO(1969, __VA_ARGS__) \ MU_DO_1968(MACRO, __VA_ARGS__) #define MU_DO_1970(MACRO, ...) \ MACRO(1970, __VA_ARGS__) \ MU_DO_1969(MACRO, __VA_ARGS__) #define MU_DO_1971(MACRO, ...) \ MACRO(1971, __VA_ARGS__) \ MU_DO_1970(MACRO, __VA_ARGS__) #define MU_DO_1972(MACRO, ...) \ MACRO(1972, __VA_ARGS__) \ MU_DO_1971(MACRO, __VA_ARGS__) #define MU_DO_1973(MACRO, ...) \ MACRO(1973, __VA_ARGS__) \ MU_DO_1972(MACRO, __VA_ARGS__) #define MU_DO_1974(MACRO, ...) \ MACRO(1974, __VA_ARGS__) \ MU_DO_1973(MACRO, __VA_ARGS__) #define MU_DO_1975(MACRO, ...) \ MACRO(1975, __VA_ARGS__) \ MU_DO_1974(MACRO, __VA_ARGS__) #define MU_DO_1976(MACRO, ...) \ MACRO(1976, __VA_ARGS__) \ MU_DO_1975(MACRO, __VA_ARGS__) #define MU_DO_1977(MACRO, ...) \ MACRO(1977, __VA_ARGS__) \ MU_DO_1976(MACRO, __VA_ARGS__) #define MU_DO_1978(MACRO, ...) \ MACRO(1978, __VA_ARGS__) \ MU_DO_1977(MACRO, __VA_ARGS__) #define MU_DO_1979(MACRO, ...) \ MACRO(1979, __VA_ARGS__) \ MU_DO_1978(MACRO, __VA_ARGS__) #define MU_DO_1980(MACRO, ...) \ MACRO(1980, __VA_ARGS__) \ MU_DO_1979(MACRO, __VA_ARGS__) #define MU_DO_1981(MACRO, ...) \ MACRO(1981, __VA_ARGS__) \ MU_DO_1980(MACRO, __VA_ARGS__) #define MU_DO_1982(MACRO, ...) \ MACRO(1982, __VA_ARGS__) \ MU_DO_1981(MACRO, __VA_ARGS__) #define MU_DO_1983(MACRO, ...) \ MACRO(1983, __VA_ARGS__) \ MU_DO_1982(MACRO, __VA_ARGS__) #define MU_DO_1984(MACRO, ...) \ MACRO(1984, __VA_ARGS__) \ MU_DO_1983(MACRO, __VA_ARGS__) #define MU_DO_1985(MACRO, ...) \ MACRO(1985, __VA_ARGS__) \ MU_DO_1984(MACRO, __VA_ARGS__) #define MU_DO_1986(MACRO, ...) \ MACRO(1986, __VA_ARGS__) \ MU_DO_1985(MACRO, __VA_ARGS__) #define MU_DO_1987(MACRO, ...) \ MACRO(1987, __VA_ARGS__) \ MU_DO_1986(MACRO, __VA_ARGS__) #define MU_DO_1988(MACRO, ...) \ MACRO(1988, __VA_ARGS__) \ MU_DO_1987(MACRO, __VA_ARGS__) #define MU_DO_1989(MACRO, ...) \ MACRO(1989, __VA_ARGS__) \ MU_DO_1988(MACRO, __VA_ARGS__) #define MU_DO_1990(MACRO, ...) \ MACRO(1990, __VA_ARGS__) \ MU_DO_1989(MACRO, __VA_ARGS__) #define MU_DO_1991(MACRO, ...) \ MACRO(1991, __VA_ARGS__) \ MU_DO_1990(MACRO, __VA_ARGS__) #define MU_DO_1992(MACRO, ...) \ MACRO(1992, __VA_ARGS__) \ MU_DO_1991(MACRO, __VA_ARGS__) #define MU_DO_1993(MACRO, ...) \ MACRO(1993, __VA_ARGS__) \ MU_DO_1992(MACRO, __VA_ARGS__) #define MU_DO_1994(MACRO, ...) \ MACRO(1994, __VA_ARGS__) \ MU_DO_1993(MACRO, __VA_ARGS__) #define MU_DO_1995(MACRO, ...) \ MACRO(1995, __VA_ARGS__) \ MU_DO_1994(MACRO, __VA_ARGS__) #define MU_DO_1996(MACRO, ...) \ MACRO(1996, __VA_ARGS__) \ MU_DO_1995(MACRO, __VA_ARGS__) #define MU_DO_1997(MACRO, ...) \ MACRO(1997, __VA_ARGS__) \ MU_DO_1996(MACRO, __VA_ARGS__) #define MU_DO_1998(MACRO, ...) \ MACRO(1998, __VA_ARGS__) \ MU_DO_1997(MACRO, __VA_ARGS__) #define MU_DO_1999(MACRO, ...) \ MACRO(1999, __VA_ARGS__) \ MU_DO_1998(MACRO, __VA_ARGS__) #define MU_DO_2000(MACRO, ...) \ MACRO(2000, __VA_ARGS__) \ MU_DO_1999(MACRO, __VA_ARGS__) #define MU_DO_2001(MACRO, ...) \ MACRO(2001, __VA_ARGS__) \ MU_DO_2000(MACRO, __VA_ARGS__) #define MU_DO_2002(MACRO, ...) \ MACRO(2002, __VA_ARGS__) \ MU_DO_2001(MACRO, __VA_ARGS__) #define MU_DO_2003(MACRO, ...) \ MACRO(2003, __VA_ARGS__) \ MU_DO_2002(MACRO, __VA_ARGS__) #define MU_DO_2004(MACRO, ...) \ MACRO(2004, __VA_ARGS__) \ MU_DO_2003(MACRO, __VA_ARGS__) #define MU_DO_2005(MACRO, ...) \ MACRO(2005, __VA_ARGS__) \ MU_DO_2004(MACRO, __VA_ARGS__) #define MU_DO_2006(MACRO, ...) \ MACRO(2006, __VA_ARGS__) \ MU_DO_2005(MACRO, __VA_ARGS__) #define MU_DO_2007(MACRO, ...) \ MACRO(2007, __VA_ARGS__) \ MU_DO_2006(MACRO, __VA_ARGS__) #define MU_DO_2008(MACRO, ...) \ MACRO(2008, __VA_ARGS__) \ MU_DO_2007(MACRO, __VA_ARGS__) #define MU_DO_2009(MACRO, ...) \ MACRO(2009, __VA_ARGS__) \ MU_DO_2008(MACRO, __VA_ARGS__) #define MU_DO_2010(MACRO, ...) \ MACRO(2010, __VA_ARGS__) \ MU_DO_2009(MACRO, __VA_ARGS__) #define MU_DO_2011(MACRO, ...) \ MACRO(2011, __VA_ARGS__) \ MU_DO_2010(MACRO, __VA_ARGS__) #define MU_DO_2012(MACRO, ...) \ MACRO(2012, __VA_ARGS__) \ MU_DO_2011(MACRO, __VA_ARGS__) #define MU_DO_2013(MACRO, ...) \ MACRO(2013, __VA_ARGS__) \ MU_DO_2012(MACRO, __VA_ARGS__) #define MU_DO_2014(MACRO, ...) \ MACRO(2014, __VA_ARGS__) \ MU_DO_2013(MACRO, __VA_ARGS__) #define MU_DO_2015(MACRO, ...) \ MACRO(2015, __VA_ARGS__) \ MU_DO_2014(MACRO, __VA_ARGS__) #define MU_DO_2016(MACRO, ...) \ MACRO(2016, __VA_ARGS__) \ MU_DO_2015(MACRO, __VA_ARGS__) #define MU_DO_2017(MACRO, ...) \ MACRO(2017, __VA_ARGS__) \ MU_DO_2016(MACRO, __VA_ARGS__) #define MU_DO_2018(MACRO, ...) \ MACRO(2018, __VA_ARGS__) \ MU_DO_2017(MACRO, __VA_ARGS__) #define MU_DO_2019(MACRO, ...) \ MACRO(2019, __VA_ARGS__) \ MU_DO_2018(MACRO, __VA_ARGS__) #define MU_DO_2020(MACRO, ...) \ MACRO(2020, __VA_ARGS__) \ MU_DO_2019(MACRO, __VA_ARGS__) #define MU_DO_2021(MACRO, ...) \ MACRO(2021, __VA_ARGS__) \ MU_DO_2020(MACRO, __VA_ARGS__) #define MU_DO_2022(MACRO, ...) \ MACRO(2022, __VA_ARGS__) \ MU_DO_2021(MACRO, __VA_ARGS__) #define MU_DO_2023(MACRO, ...) \ MACRO(2023, __VA_ARGS__) \ MU_DO_2022(MACRO, __VA_ARGS__) #define MU_DO_2024(MACRO, ...) \ MACRO(2024, __VA_ARGS__) \ MU_DO_2023(MACRO, __VA_ARGS__) #define MU_DO_2025(MACRO, ...) \ MACRO(2025, __VA_ARGS__) \ MU_DO_2024(MACRO, __VA_ARGS__) #define MU_DO_2026(MACRO, ...) \ MACRO(2026, __VA_ARGS__) \ MU_DO_2025(MACRO, __VA_ARGS__) #define MU_DO_2027(MACRO, ...) \ MACRO(2027, __VA_ARGS__) \ MU_DO_2026(MACRO, __VA_ARGS__) #define MU_DO_2028(MACRO, ...) \ MACRO(2028, __VA_ARGS__) \ MU_DO_2027(MACRO, __VA_ARGS__) #define MU_DO_2029(MACRO, ...) \ MACRO(2029, __VA_ARGS__) \ MU_DO_2028(MACRO, __VA_ARGS__) #define MU_DO_2030(MACRO, ...) \ MACRO(2030, __VA_ARGS__) \ MU_DO_2029(MACRO, __VA_ARGS__) #define MU_DO_2031(MACRO, ...) \ MACRO(2031, __VA_ARGS__) \ MU_DO_2030(MACRO, __VA_ARGS__) #define MU_DO_2032(MACRO, ...) \ MACRO(2032, __VA_ARGS__) \ MU_DO_2031(MACRO, __VA_ARGS__) #define MU_DO_2033(MACRO, ...) \ MACRO(2033, __VA_ARGS__) \ MU_DO_2032(MACRO, __VA_ARGS__) #define MU_DO_2034(MACRO, ...) \ MACRO(2034, __VA_ARGS__) \ MU_DO_2033(MACRO, __VA_ARGS__) #define MU_DO_2035(MACRO, ...) \ MACRO(2035, __VA_ARGS__) \ MU_DO_2034(MACRO, __VA_ARGS__) #define MU_DO_2036(MACRO, ...) \ MACRO(2036, __VA_ARGS__) \ MU_DO_2035(MACRO, __VA_ARGS__) #define MU_DO_2037(MACRO, ...) \ MACRO(2037, __VA_ARGS__) \ MU_DO_2036(MACRO, __VA_ARGS__) #define MU_DO_2038(MACRO, ...) \ MACRO(2038, __VA_ARGS__) \ MU_DO_2037(MACRO, __VA_ARGS__) #define MU_DO_2039(MACRO, ...) \ MACRO(2039, __VA_ARGS__) \ MU_DO_2038(MACRO, __VA_ARGS__) #define MU_DO_2040(MACRO, ...) \ MACRO(2040, __VA_ARGS__) \ MU_DO_2039(MACRO, __VA_ARGS__) #define MU_DO_2041(MACRO, ...) \ MACRO(2041, __VA_ARGS__) \ MU_DO_2040(MACRO, __VA_ARGS__) #define MU_DO_2042(MACRO, ...) \ MACRO(2042, __VA_ARGS__) \ MU_DO_2041(MACRO, __VA_ARGS__) #define MU_DO_2043(MACRO, ...) \ MACRO(2043, __VA_ARGS__) \ MU_DO_2042(MACRO, __VA_ARGS__) #define MU_DO_2044(MACRO, ...) \ MACRO(2044, __VA_ARGS__) \ MU_DO_2043(MACRO, __VA_ARGS__) #define MU_DO_2045(MACRO, ...) \ MACRO(2045, __VA_ARGS__) \ MU_DO_2044(MACRO, __VA_ARGS__) #define MU_DO_2046(MACRO, ...) \ MACRO(2046, __VA_ARGS__) \ MU_DO_2045(MACRO, __VA_ARGS__) #define MU_DO_2047(MACRO, ...) \ MACRO(2047, __VA_ARGS__) \ MU_DO_2046(MACRO, __VA_ARGS__) #define MU_DO_2048(MACRO, ...) \ MACRO(2048, __VA_ARGS__) \ MU_DO_2047(MACRO, __VA_ARGS__) #define MU_DO(TIMES, MACRO, ...) MU_C2(MU_DO_, TIMES)(MACRO, __VA_ARGS__) #endif /*MACRO_UTILS_GENERATED_H*/ macro_utils_h_generator/000077500000000000000000000000001455573770000407275ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-capp.config000066400000000000000000000002661455573770000427020ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c/macro_utils_h_generator macro_utils_generated.cs000066400000000000000000001702061455573770000456230ustar00rootroot00000000000000azure-uamqp-python-1.6.8/src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/deps/azure-macro-utils-c/macro_utils_h_generator// ------------------------------------------------------------------------------ // // This code was generated by a tool. // Runtime Version: 16.0.0.0 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // // ------------------------------------------------------------------------------ namespace macro_utils_h_generator { using System.Linq; using System.Text; using System.Collections.Generic; using System; /// /// Class to produce the template output /// #line 1 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.TextTemplating", "16.0.0.0")] public partial class macro_utils_generated : macro_utils_generatedBase { #line hidden /// /// Create the template output /// public virtual string TransformText() { this.Write(@"// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. /*THIS FILE IS GENERATED*/ /*DO NOT EDIT BY HAND!!!*/ /*instead edit macro_utils_generated.tt here: http://www.github.com/azure/azure-macro-utils-c.git */ "); #line 14 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" /*CHANGE BELOW 2 VARIABLES TO GET MORE / LESS */ #line default #line hidden #line 15 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" int nArithmetic=2048; #line default #line hidden #line 16 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" int nMacroParameters=124;/*127 parameters in one macro definition in C99 in chapter 5.2.4.1 Translation limits*/ #line default #line hidden this.Write("\r\n#ifndef MACRO_UTILS_GENERATED_H\r\n#define MACRO_UTILS_GENERATED_H\r\n\r\n#define MU_" + "IFCOMMA(N) MU_C2(MU_IFCOMMA_, N)\r\n#define MU_IFCOMMA_0\r\n#define MU_IFCOMMA_2\r\n"); #line 24 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=4;i<=nMacroParameters;i+=2) #line default #line hidden #line 25 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_IFCOMMA_"); #line 26 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" ,\r\n"); #line 27 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n#define MU_IFCOMMALOGIC(N) MU_C2(MU_IFCOMMALOGIC_, N)\r\n#define MU_IFCOMMALOGIC_" + "0 \r\n"); #line 31 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=1;i<=nMacroParameters;i+=1) #line default #line hidden #line 32 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_IFCOMMALOGIC_"); #line 33 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" ,\r\n"); #line 34 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n#define MU_IFCOMMA_NOFIRST(N) MU_C2(MU_IFCOMMA_NOFIRST, N)\r\n#define MU_IFCOMMA_" + "NOFIRST1 \r\n"); #line 38 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=2;i<=nMacroParameters;i++) #line default #line hidden #line 39 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_IFCOMMA_NOFIRST"); #line 40 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" ,\r\n"); #line 41 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n#define MU_DEC(x) MU_C2(MU_DEC,x)\r\n"); #line 44 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nArithmetic;i>=1;i--) #line default #line hidden #line 45 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_DEC"); #line 46 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" "); #line 46 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i-1)); #line default #line hidden this.Write("\r\n"); #line 47 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n#define MU_INC(x) MU_C2(MU_INC,x)\r\n"); #line 50 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nArithmetic;i>=0;i--) #line default #line hidden #line 51 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_INC"); #line 52 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" "); #line 52 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i+1)); #line default #line hidden this.Write("\r\n"); #line 53 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n#define MU_DIV2(x) MU_C2(MU_DIV2_,x)\r\n\r\n"); #line 57 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nArithmetic;i>=0;i--) #line default #line hidden #line 58 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_DIV2_"); #line 59 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" "); #line 59 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i/2)); #line default #line hidden this.Write("\r\n"); #line 60 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n"); #line 62 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" /*the below produces MOD2 for numbers*/ #line default #line hidden this.Write("#define MU_MOD2(x) MU_C2(MU_MOD2_,x)\r\n"); #line 64 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nArithmetic;i>=0;i--) #line default #line hidden #line 65 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_MOD2_"); #line 66 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(" "); #line 66 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i%2)); #line default #line hidden this.Write("\r\n"); #line 67 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("\r\n#define MU_THE_NTH_ARG("); #line 69 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=1;i<=nMacroParameters;i++) #line default #line hidden #line 70 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("P"); #line 70 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write(", "); #line 70 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write(" ... ) P"); #line 70 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(nMacroParameters)); #line default #line hidden this.Write("\r\n\r\n#ifdef _MSC_VER\r\n#define MU_COUNT_1_OR_MORE_ARG(...) MU_THE_NTH_ARG MU_LPAREN" + " __VA_ARGS__, \\\r\n"); #line 74 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nMacroParameters-1;i>=1;i--){ #line default #line hidden #line 74 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i.ToString()+((i>1)?", ":""))); #line default #line hidden #line 74 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write(")\r\n#define MU_MORE_THAN_1_ARG(...) MU_THE_NTH_ARG MU_LPAREN __VA_ARGS__, "); #line 75 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nMacroParameters-2;i>=1;i--){ #line default #line hidden #line 75 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(1)); #line default #line hidden this.Write(","); #line 75 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write("0)\r\n#else\r\n#define MU_COUNT_1_OR_MORE_ARG(...) MU_THE_NTH_ARG (__VA_ARGS__, \\\r\n"); #line 78 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nMacroParameters-1;i>=1;i--){ #line default #line hidden #line 78 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i.ToString()+((i>1)?", ":""))); #line default #line hidden #line 78 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write(")\r\n#define MU_MORE_THAN_1_ARG(...) MU_THE_NTH_ARG(__VA_ARGS__, "); #line 79 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nMacroParameters-2;i>=1;i--){ #line default #line hidden #line 79 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(1)); #line default #line hidden this.Write(","); #line 79 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" } #line default #line hidden this.Write(@" 0) #endif #define MU_COUNT_ARG(...) MU_C2(MU_COUNT_ARG_, MU_ISEMPTY(__VA_ARGS__))(__VA_ARGS__) #define MU_COUNT_ARG_1(...) 0 #define MU_COUNT_ARG_0(...) MU_C1(MU_COUNT_1_OR_MORE_ARG(__VA_ARGS__)) #define MU_ISEMPTY(...) MU_C5(MU_DISPATCH_EMPTY_, MU_MORE_THAN_1_ARG(MU_TRIGGER_PARENTHESIS __VA_ARGS__ ()), MU_MORE_THAN_1_ARG(__VA_ARGS__), MU_MORE_THAN_1_ARG(__VA_ARGS__ ()), MU_MORE_THAN_1_ARG(MU_TRIGGER_PARENTHESIS __VA_ARGS__)) #define MU_DISPATCH_EMPTY_1000 1 #define MU_DISPATCH_EMPTY_0000 0 #define MU_DISPATCH_EMPTY_1100 0 #define MU_DISPATCH_EMPTY_1111 0 #define MU_DISPATCH_EMPTY_1001 0 #define MU_DISPATCH_EMPTY_1010 0 "); #line 95 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var i=nMacroParameters;i>=2;i--) #line default #line hidden #line 96 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" { #line default #line hidden this.Write("#define MU_FOR_EACH_1_"); #line 97 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(i)); #line default #line hidden this.Write("(X, "); #line 97 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" for(var j=1;j<=i;j++){ #line default #line hidden this.Write("P"); #line 97 "G:\w\Azure-MessagingStore\deps\azure-macro-utils-c\macro_utils_h_generator\macro_utils_generated.tt" this.Write(this.ToStringHelper.ToStringWithCulture(j.ToString()+((j