Use the first subkey for encryption instead of the primary key

.circleci/config.yml

@@ -0,0 +1,218 @@
+version: 2.1
+executors:
+  default:
+    docker:
+      - image: filecoin/rust:latest
+    working_directory: /mnt/crate
+  doxygen:
+    docker:
+      - image: hrektts/doxygen
+
+restore-workspace: &restore-workspace
+  attach_workspace:
+    at: /mnt
+
+restore-cache: &restore-cache
+  restore_cache:
+    keys:
+      - cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+      - repo-source-{{ .Branch }}-{{ .Revision }}
+
+commands:
+  test_target:
+    parameters:
+      target:
+        type: string
+    steps:
+      - *restore-workspace
+      - *restore-cache
+      - run:
+          name: Test (<< parameters.target >>)
+          command: TARGET=<< parameters.target >> ci_scripts/run-rust-test.sh
+          no_output_timeout: 15m
+
+jobs:
+  cargo_fetch:
+    executor: default
+    steps:
+      - checkout
+      - run:
+          name: Update submodules
+          command: git submodule update --init --recursive
+      - run:
+          name: Calculate dependencies
+          command: cargo generate-lockfile
+      - restore_cache:
+          keys:
+            - cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+      - run: rustup install $(cat rust-toolchain)
+      - run: rustup default $(cat rust-toolchain)
+      - run: rustup component add --toolchain $(cat rust-toolchain) rustfmt
+      - run: rustup component add --toolchain $(cat rust-toolchain) clippy-preview
+      - run: cargo update
+      - run: cargo fetch
+      - run: rustc +stable --version
+      - run: rustc +$(cat rust-toolchain) --version
+      # make sure this git repo doesn't grow too big
+      - run: git gc
+      - persist_to_workspace:
+          root: /mnt
+          paths:
+            - crate
+      - save_cache:
+          key: cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+          paths:
+            - "~/.cargo"
+            - "~/.rustup"
+
+  rustfmt:
+    executor: default
+    steps:
+      - *restore-workspace
+      - *restore-cache
+      - run:
+          name: Run cargo fmt
+          command: cargo fmt --all -- --check
+
+  test_macos:
+    macos:
+      xcode: "10.0.0"
+    working_directory: ~/crate
+    steps:
+      - run:
+          name: Configure environment variables
+          command: |
+            echo 'export PATH="${HOME}/.cargo/bin:${HOME}/.bin:${PATH}"' >> $BASH_ENV
+            echo 'export CIRCLE_ARTIFACTS="/tmp"' >> $BASH_ENV
+      - checkout
+      - run:
+          name: Install Rust
+          command: |
+            curl https://sh.rustup.rs -sSf | sh -s -- -y
+      - run: rustup install $(cat rust-toolchain)
+      - run: rustup default $(cat rust-toolchain)
+      - run: cargo update
+      - run: cargo fetch
+      - run:
+          name: Test
+          command: TARGET=x86_64-apple-darwin ci_scripts/run-rust-test.sh
+
+  test_x86_64-unknown-linux-gnu:
+    executor: default
+    steps:
+      - test_target:
+          target: "x86_64-unknown-linux-gnu"
+
+  test_i686-unknown-linux-gnu:
+    executor: default
+    steps:
+      - test_target:
+          target: "i686-unknown-linux-gnu"
+
+  test_aarch64-linux-android:
+    executor: default
+    steps:
+      - test_target:
+          target: "aarch64-linux-android"
+
+
+  build_doxygen:
+    executor: doxygen
+    steps:
+      - checkout
+      - run: bash ci_scripts/run-doxygen.sh
+      - run: mkdir -p workspace/c-docs 
+      - run: cp -av deltachat-ffi/{html,xml} workspace/c-docs/
+      - persist_to_workspace:
+          root: workspace
+          paths:
+            - c-docs
+
+  build_test_docs_wheel:
+    docker:
+      - image: deltachat/coredeps
+        environment:
+            TESTS: 1
+            DOCS: 1
+    working_directory: /mnt/crate
+    steps:
+      - *restore-workspace
+      - *restore-cache
+      - run:
+          name: build docs, run tests and build wheels
+          command: ci_scripts/run-python.sh
+      - run:
+           name: copying docs and wheels to workspace
+           command: |
+             mkdir -p workspace/python
+             # cp -av docs workspace/c-docs
+             cp -av python/.docker-tox/wheelhouse workspace/
+             cp -av python/doc/_build/ workspace/py-docs
+      - persist_to_workspace:
+          root: workspace
+          paths:
+            # - c-docs
+            - py-docs
+            - wheelhouse
+
+  upload_docs_wheels:
+    machine: true
+    steps:
+      - checkout
+      - attach_workspace:
+          at: workspace
+      - run: pyenv global 3.5.2
+      - run: ls -laR workspace
+      - run: ci_scripts/ci_upload.sh workspace/py-docs workspace/wheelhouse workspace/c-docs
+
+  clippy:
+    executor: default
+    steps:
+      - *restore-workspace
+      - *restore-cache
+      - run:
+          name: Run cargo clippy
+          command: cargo clippy --all
+
+
+workflows:
+  version: 2.1
+
+  test:
+    jobs:
+      - cargo_fetch
+      - build_doxygen
+
+      - build_test_docs_wheel:
+          requires:
+            - cargo_fetch
+      - upload_docs_wheels:
+          requires:
+            - build_test_docs_wheel
+            - build_doxygen 
+      - rustfmt:
+          requires:
+            - cargo_fetch
+      - clippy:
+          requires:
+           - cargo_fetch
+
+      # Linux Desktop 64bit
+      - test_x86_64-unknown-linux-gnu:
+          requires:
+            - cargo_fetch
+
+      # Linux Desktop 32bit
+      # - test_i686-unknown-linux-gnu:
+      #     requires:
+      #       - cargo_fetch
+
+      # Android 64bit
+      # - test_aarch64-linux-android:
+      #     requires:
+      #       - cargo_fetch
+
+      # Desktop Apple
+      # - test_macos:
+      #     requires:
+      #       - cargo_fetch

.gitattributes

@@ -12,6 +12,3 @@ test-data/* text=false
 *.gif  binary
 *.ico  binary
 
-*.py diff=python
-*.rs diff=rust
-*.md diff=markdown

.github/dependabot.yml

@@ -1,9 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    commit-message:
-      prefix: "cargo"
-    open-pull-requests-limit: 50

.github/mergeable.yml

@@ -1,26 +0,0 @@
-version: 2
-mergeable:
-  - when: pull_request.*
-    name: "Changelog check"
-    validate:
-      - do: or
-        validate:
-        - do: description
-          must_include:
-            regex: '#skip-changelog'
-        - do: and
-          validate:
-            - do: dependent
-              changed:
-                file: 'src/**'
-                required: ['CHANGELOG.md']
-            - do: dependent
-              changed:
-                file: 'deltachat-ffi/**'
-                required: ['CHANGELOG.md']
-    fail:
-      - do: checks
-        status: 'action_required' 
-        payload:
-          title: Changlog might need an update
-          summary: "Check if CHANGELOG.md needs an update or add #skip-changelog to the PR description."

.github/workflows/ci.yml

@@ -1,143 +0,0 @@
-name: Rust CI
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - staging
-      - trying
-
-env:
-  RUSTFLAGS: -Dwarnings
-
-jobs:
-
-  fmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-  run_clippy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-            toolchain: stable
-            components: clippy
-            override: true
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v1
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --tests --examples --benches
-
-  docs:
-    name: Rust doc comments
-    runs-on: ubuntu-latest
-    env:
-      RUSTDOCFLAGS: -Dwarnings
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v2
-      - name: Install rust stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          components: rust-docs
-          override: true
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v1
-      - name: Rustdoc
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --document-private-items --no-deps
-
-  build_and_test:
-    name: Build and test
-    strategy:
-      matrix:
-        include:
-          # Currently used Rust version, same as in `rust-toolchain` file.
-          - os: ubuntu-latest
-            rust: 1.60.0
-            python: 3.9
-          - os: windows-latest
-            rust: 1.60.0
-            python: false # Python bindings compilation on Windows is not supported.
-
-          # Minimum Supported Rust Version = 1.56.0
-          #
-          # Minimum Supported Python Version = 3.7
-          # This is the minimum version for which manylinux Python wheels are
-          # built.
-          - os: ubuntu-latest
-            rust: 1.56.0
-            python: 3.7
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@master
-
-    - name: Install ${{ matrix.rust }}
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        override: true
-
-    - name: Cache rust cargo artifacts
-      uses: swatinem/rust-cache@v1
-
-    - name: check
-      uses: actions-rs/cargo@v1
-      with:
-        command: check
-        args: --all --bins --examples --tests --features repl --benches
-
-    - name: tests
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --all
-
-    - name: install python
-      if: ${{ matrix.python }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python }}
-
-    - name: install tox
-      if: ${{ matrix.python }}
-      run: pip install tox
-
-    - name: build C library
-      if: ${{ matrix.python }}
-      uses: actions-rs/cargo@v1
-      with:
-        command: build
-        args: -p deltachat_ffi
-
-    - name: run python tests
-      if: ${{ matrix.python }}
-      env:
-        DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
-        DCC_RS_TARGET: debug
-        DCC_RS_DEV: ${{ github.workspace }}
-      working-directory: python
-      run: tox -e lint,mypy,doc,py3

.github/workflows/dependabot.yml

@@ -1,21 +0,0 @@
-name: Dependabot auto-approve
-on: pull_request
-
-permissions:
-  pull-requests: write
-
-jobs:
-  dependabot:
-    runs-on: ubuntu-latest
-    if: ${{ github.actor == 'dependabot[bot]' }}
-    steps:
-      - name: Dependabot metadata
-        id: metadata
-        uses: dependabot/fetch-metadata@v1.1.1
-        with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
-      - name: Approve a PR
-        run: gh pr review --approve "$PR_URL"
-        env:
-          PR_URL: ${{github.event.pull_request.html_url}}
-          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

.github/workflows/node-delete-preview.yml

@@ -1,32 +0,0 @@
-# documentation: https://github.com/deltachat/sysadmin/tree/master/download.delta.chat
-name: Delete node PR previews
-
-on:
-  pull_request:
-    types: [closed]
-
-jobs:
-  delete:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Get Pullrequest ID
-      id: getid
-      run: |
-        export PULLREQUEST_ID=$(jq .number < $GITHUB_EVENT_PATH)
-        echo ::set-output name=prid::$PULLREQUEST_ID
-    - name: Renaming
-      run: |
-        # create empty file to copy it over the outdated deliverable on download.delta.chat
-        echo "This preview build is outdated and has been removed." > empty
-        cp empty deltachat-node-${{ steps.getid.outputs.prid }}.tar.gz
-    - name: Replace builds with dummy files
-      uses: horochx/deploy-via-scp@v1.0.1
-      with:
-        user: ${{ secrets.USERNAME }}
-        key: ${{ secrets.SSH_KEY }}
-        host: "download.delta.chat"
-        port: 22
-        local: "deltachat-node-${{ steps.getid.outputs.prid }}.tar.gz"
-        remote: "/var/www/html/download/node/"

.github/workflows/node-docs.yml

@@ -1,34 +0,0 @@
-name: Generate & upload node.js documentation
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  generate:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-
-    - name: Use Node.js 16.x
-      uses: actions/setup-node@v1
-      with:
-        node-version: 16.x
-
-    - name: npm install and generate documentation
-      run: |
-        cd node
-        npm i --ignore-scripts
-        npx typedoc
-        mv docs js
-
-    - name: Upload
-      uses: horochx/deploy-via-scp@v1.0.1
-      with:
-        user: ${{ secrets.USERNAME }}
-        key: ${{ secrets.KEY }}
-        host: "delta.chat"
-        port: 22
-        local: "node/js"
-        remote: "/var/www/html/"

.github/workflows/node-package.yml

@@ -1,140 +0,0 @@
-name: 'node.js'
-on:
-  pull_request:
-  push:
-    tags:
-    - '*'
-
-
-jobs:
-  prebuild:
-    name: 'Prebuild'
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16'
-      - name: System info
-        run: |
-          rustc -vV
-          rustup -vV
-          cargo -vV
-          npm --version
-          node --version
-
-      - name: Cache node modules
-        uses: actions/cache@v2
-        with:
-          path: |
-            ${{ env.APPDATA }}/npm-cache
-            ~/.npm
-          key: ${{ matrix.os }}-node-${{ hashFiles('**/package.json') }}
-
-      - name: Cache cargo index
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry/
-            ~/.cargo/git
-            target
-          key: ${{ matrix.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}-2
-
-      - name: Install dependencies & build
-        if: steps.cache.outputs.cache-hit != 'true'
-        run: |
-          cd node
-          npm install --verbose
-
-      - name: Build Prebuild
-        run: |
-          cd node
-          npm run prebuildify
-          tar -zcvf "${{ matrix.os }}.tar.gz" -C prebuilds .
-
-      - name: Upload Prebuild
-        uses: actions/upload-artifact@v1
-        with:
-          name: ${{ matrix.os }}
-          path: node/${{ matrix.os }}.tar.gz
-
-  pack-module:
-    needs: prebuild
-    name: 'Package deltachat-node and upload to download.delta.chat'
-    runs-on: ubuntu-18.04
-    steps:
-      - name: install tree
-        run: sudo apt install tree
-      - name: Checkout
-        uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16'
-      - name: System info
-        run: |
-          rustc -vV
-          rustup -vV
-          cargo -vV
-          npm --version
-          node --version
-      - name: Download ubuntu prebuild
-        uses: actions/download-artifact@v1
-        with:
-          name: ubuntu-18.04
-      - name: Download macos prebuild
-        uses: actions/download-artifact@v1
-        with:
-          name: macos-latest
-      - name: Download windows prebuild
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-latest
-      - shell: bash
-        run: |
-          mkdir node/prebuilds
-          tar -xvzf ubuntu-18.04/ubuntu-18.04.tar.gz -C node/prebuilds
-          tar -xvzf macos-latest/macos-latest.tar.gz -C node/prebuilds
-          tar -xvzf windows-latest/windows-latest.tar.gz -C node/prebuilds
-          tree node/prebuilds
-      - name: install dependencies without running scripts
-        run: |
-          npm install --ignore-scripts
-      - name: build typescript part
-        run: |
-          npm run build:bindings:ts
-      - name: Set DELTACHAT_NODE_TAR_GZ env variable
-        run: |
-          echo "DELTACHAT_NODE_TAR_GZ=deltachat-node-${{ github.ref_name }}" >> $GITHUB_ENV
-      - name: package
-        shell: bash
-        run: |
-          npm pack .
-          ls -lah
-          mv $(find deltachat-node-*) $DELTACHAT_NODE_TAR_GZ
-      - name: Upload Prebuild
-        uses: actions/upload-artifact@v1
-        with:
-          name: deltachat-node.tgz
-          path: $DELTACHAT_NODE_TAR_GZ
-      # Upload to download.delta.chat/node/preview/
-      - name: Upload deltachat-node preview to download.delta.chat/node/preview/
-        id: upload-preview
-        shell: bash
-        run: |
-          echo -e "${{ secrets.SSH_KEY }}" >__TEMP_INPUT_KEY_FILE
-          chmod 600 __TEMP_INPUT_KEY_FILE
-          scp -o StrictHostKeyChecking=no -v -i __TEMP_INPUT_KEY_FILE -P "22" -r $DELTACHAT_NODE_TAR_GZ "${{ secrets.USERNAME }}"@"download.delta.chat":"/var/www/html/download/node/preview/"
-        continue-on-error: true
-      # Upload to download.delta.chat/node/
-      - name: Upload deltachat-node build to download.delta.chat/node/
-        if: ${{ steps.tag.outputs.tag }}
-        id: upload
-        shell: bash
-        run: |
-          echo -e "${{ secrets.SSH_KEY }}" >__TEMP_INPUT_KEY_FILE
-          chmod 600 __TEMP_INPUT_KEY_FILE
-          scp -o StrictHostKeyChecking=no -v -i __TEMP_INPUT_KEY_FILE -P "22" -r $DELTACHAT_NODE_TAR_GZ "${{ secrets.USERNAME }}"@"download.delta.chat":"/var/www/html/download/node/"

.github/workflows/repl.yml

@@ -1,32 +0,0 @@
-# Manually triggered action to build a Windows repl.exe which users can
-# download to debug complex bugs.
-
-name: Build Windows REPL .exe
-
-on:
-  workflow_dispatch:
-
-jobs:
-  build_repl:
-    name: Build REPL example
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@master
-
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: 1.50.0
-        override: true
-
-    - name: build
-      uses: actions-rs/cargo@v1
-      with:
-        command: build
-        args: --example repl --features repl,vendored
-
-    - name: Upload binary
-      uses: actions/upload-artifact@v2
-      with:
-        name: repl.exe
-        path: 'target/debug/examples/repl.exe'

.github/workflows/upload-docs.yml

@@ -1,28 +0,0 @@
-name: Build & Deploy Documentation on rs.delta.chat
-
-on:
-  push:
-    branches:
-      - master
-      - docs-gh-action
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions-rs/toolchain@v1
-    - name: Build the documentation with cargo
-      run: |
-        cargo doc --package deltachat --no-deps
-    - name: Upload to rs.delta.chat
-      uses: up9cloud/action-rsync@v1.3
-      env:
-        USER: ${{ secrets.USERNAME }}
-        KEY: ${{ secrets.KEY }}
-        HOST: "delta.chat"
-        SOURCE: "target/doc"
-        TARGET: "/var/www/html/rs/"
-

.github/workflows/upload-ffi-docs.yml

@@ -1,28 +0,0 @@
-name: Build & Deploy Documentation on cffi.delta.chat
-
-on:
-  push:
-    branches:
-      - master
-      - docs-gh-action
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions-rs/toolchain@v1
-    - name: Build the documentation with cargo
-      run: |
-        cargo doc --package deltachat_ffi --no-deps
-    - name: Upload to cffi.delta.chat
-      uses: up9cloud/action-rsync@v1.3
-      env:
-        USER: ${{ secrets.USERNAME }}
-        KEY: ${{ secrets.KEY }}
-        HOST: "delta.chat"
-        SOURCE: "target/doc"
-        TARGET: "/var/www/html/cffi/"
-

.gitignore

@@ -1,6 +1,5 @@
 /target
 **/*.rs.bk
-/build
 
 # ignore vi temporaries
 *~
@@ -24,19 +23,3 @@ python/liveconfig*
 # ignore doxgen generated files
 deltachat-ffi/html
 deltachat-ffi/xml
-
-.rsynclist
-
-coverage/
-.DS_Store
-.vscode/launch.json
-python/accounts.txt
-python/all-testaccounts.txt
-tmp/
-
-# from deltachat-node
-node_modules/
-node/build/
-node/dist/
-node/prebuilds/
-node/.nyc_output/

.npmignore

@@ -1,42 +0,0 @@
-.circleci/
-.gitmodules
-node/.nyc_output/
-.travis.yml
-appveyor.yml
-node/build/
-node/README.md
-rustfmt.toml
-spec.md
-test-data/
-build2/
-node_modules
-.git
-.idea/
-.pytest_cache
-CMakeLists.txt
-README.md
-contrib/
-node/ci_scripts/
-coverage/
-node/.circleci
-node/appveyor.yml
-ci/
-ci_scripts/
-python/
-target
-proptest-regressions
-deltachat-ffi/Doxyfile
-scripts
-webxdc.md
-standards.md
-draft/
-node/examples/
-# deltachat-core-rust/assets # don't exclude assets, otherwise it won't build
-node/images/
-node/test/
-node/windows.md
-node/*.tar.gz
-node/old_docs.md
-.vscode/
-.github/
-node/.prettierrc.yml

.npmrc

@@ -1 +0,0 @@
-package-lock=false

CMakeLists.txt

@@ -1,50 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-project(deltachat LANGUAGES C)
-include(GNUInstallDirs)
-
-find_program(CARGO cargo)
-
-if(APPLE)
-       set(DYNAMIC_EXT "dylib")
-elseif(UNIX)
-       set(DYNAMIC_EXT "so")
-else()
-       set(DYNAMIC_EXT "dll")
-endif()
-
-add_custom_command(
-	OUTPUT
-	"target/release/libdeltachat.a"
-	"target/release/libdeltachat.${DYNAMIC_EXT}"
-	"target/release/pkgconfig/deltachat.pc"
-        COMMAND
-        PREFIX=${CMAKE_INSTALL_PREFIX}
-        LIBDIR=${CMAKE_INSTALL_FULL_LIBDIR}
-        INCLUDEDIR=${CMAKE_INSTALL_FULL_INCLUDEDIR}
-        ${CARGO} build --release --no-default-features
-
-	# Build in `deltachat-ffi` directory instead of using
-	# `--package deltachat_ffi` to avoid feature resolver version
-	# "1" bug which makes `--no-default-features` affect only
-	# `deltachat`, but not `deltachat-ffi` package.
-	#
-	# We can't enable version "2" resolver [1] because it is not
-	# stable yet on rust 1.50.0.
-	#
-	# [1] https://doc.rust-lang.org/nightly/cargo/reference/features.html#resolver-version-2-command-line-flags
-	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/deltachat-ffi
-)
-
-add_custom_target(
-	lib_deltachat
-	ALL
-	DEPENDS
-	"target/release/libdeltachat.a"
-	"target/release/libdeltachat.${DYNAMIC_EXT}"
-	"target/release/pkgconfig/deltachat.pc"
-)
-
-install(FILES "deltachat-ffi/deltachat.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES "target/release/libdeltachat.a" DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES "target/release/libdeltachat.${DYNAMIC_EXT}" DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES "target/release/pkgconfig/deltachat.pc" DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

Cargo.toml

@@ -1,137 +1,79 @@
 [package]
 name = "deltachat"
-version = "1.81.0"
+version = "1.0.0-beta.7"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
-edition = "2021"
-license = "MPL-2.0"
-rust-version = "1.56"
-
-[profile.dev]
-debug = 0
-panic = 'abort'
-
-[profile.release]
-lto = true
-panic = 'abort'
+edition = "2018"
+license = "MPL"
 
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
+mmime = { version = "0.1.2", path = "./mmime" }
 
-ansi_term = { version = "0.12.1", optional = true }
-anyhow = "1"
-async-imap = { git = "https://github.com/async-email/async-imap" }
-async-native-tls = { version = "0.3" }
-async-smtp = { git = "https://github.com/async-email/async-smtp", branch="master", default-features=false, features = ["smtp-transport", "socks5"] }
-async-std-resolver = "0.21"
-async-std = { version = "1" }
-async-tar = { version = "0.4", default-features=false }
-async-trait = "0.1"
-backtrace = "0.3"
-base64 = "0.13"
-bitflags = "1.3"
-chrono = "0.4"
-dirs = { version = "4", optional=true }
-email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
-encoded-words = { git = "https://github.com/async-email/encoded-words", branch="master" }
-escaper = "0.1"
-futures = "0.3"
-hex = "0.4.0"
-image = { version = "0.24.1", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-kamadak-exif = "0.5"
-lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
-libc = "0.2"
-log = {version = "0.4.16", optional = true }
-mailparse = "0.13"
-native-tls = "0.2"
-num_cpus = "1.13"
-num-derive = "0.3"
-num-traits = "0.2"
-once_cell = "1.10.0"
+libc = "0.2.51"
+pgp = { version = "0.2.3", default-features = false }
+hex = "0.3.2"
+sha2 = "0.8.0"
+rand = "0.6.5"
+smallvec = "0.6.9"
+reqwest = "0.9.15"
+num-derive = "0.2.5"
+num-traits = "0.2.6"
+native-tls = "0.2.3"
+lettre = { git = "https://github.com/deltachat/lettre", branch = "master" }
+imap = { git = "https://github.com/deltachat/rust-imap", branch = "master" }
+base64 = "0.10"
+charset = "0.1"
 percent-encoding = "2.0"
-pgp = { version = "0.7", default-features = false }
-pretty_env_logger = { version = "0.4", optional = true }
-quick-xml = "0.22"
-r2d2 = "0.8"
-r2d2_sqlite = "0.20"
-rand = "0.7"
-regex = "1.5"
-rusqlite = { version = "0.27", features = ["sqlcipher"] }
-rust-hsluv = "0.1"
-rustyline = { version = "9", optional = true }
-sanitize-filename = "0.3"
-serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-sha-1 = "0.10"
-sha2 = "0.10"
-smallvec = "1"
-strum = "0.24"
-strum_macros = "0.24"
-surf = { version = "2.3", default-features = false, features = ["h1-client"] }
-thiserror = "1"
-toml = "0.5"
-url = "2"
-uuid = { version = "0.8", features = ["serde", "v4"] }
-fast-socks5 = "0.4"
-humansize = "1"
-qrcodegen = "1.7.0"
-tagger = "4.3.3"
-textwrap = "0.15.0"
-zip = { version = "0.6.2", default-features = false, features = ["deflate"] }
+serde_json = "1.0"
+chrono = "0.4.6"
+failure = "0.1.5"
+failure_derive = "0.1.5"
+# TODO: make optional
+rustyline = "4.1.0"
+lazy_static = "1.4.0"
+regex = "1.1.6"
+rusqlite = { version = "0.20", features = ["bundled"] }
+r2d2_sqlite = "0.12.0"
+r2d2 = "0.8.5"
+strum = "0.16.0"
+strum_macros = "0.16.0"
+thread-local-object = "0.1.0"
+backtrace = "0.3.33"
+byteorder = "1.3.1"
+itertools = "0.8.0"
+image-meta = "0.1.0"
+quick-xml = "0.15.0"
+escaper = "0.1.0"
+bitflags = "1.1.0"
+jetscii = "0.4.4"
+debug_stub_derive = "0.3.0"
+sanitize-filename = "0.2.1"
 
 [dev-dependencies]
-ansi_term = "0.12.0"
-async-std = { version = "1", features = ["unstable", "attributes"] }
-criterion = { version = "0.3.4", features = ["async_std"] }
-futures-lite = "1.12"
-log = "0.4"
-pretty_env_logger = "0.4"
-proptest = { version = "1", default-features = false, features = ["std"] }
-tempfile = "3"
+tempfile = "3.0"
+pretty_assertions = "0.6.1"
+pretty_env_logger = "0.3.0"
+proptest = "0.9.4"
 
 [workspace]
 members = [
   "deltachat-ffi",
   "deltachat_derive",
+  "mmime",
 ]
 
 [[example]]
 name = "simple"
 path = "examples/simple.rs"
-required-features = ["repl"]
 
 [[example]]
 name = "repl"
 path = "examples/repl/main.rs"
-required-features = ["repl"]
 
 
-[[bench]]
-name = "create_account"
-harness = false
-
-[[bench]]
-name = "contacts"
-harness = false
-
-[[bench]]
-name = "search_msgs"
-harness = false
-
-[[bench]]
-name = "receive_emails"
-harness = false
-
-[[bench]]
-name = "get_chat_msgs"
-harness = false
-
-[[bench]]
-name = "get_chatlist"
-harness = false
-
 [features]
-default = ["vendored"]
-internals = []
-repl = ["internals", "rustyline", "log", "pretty_env_logger", "ansi_term", "dirs"]
-vendored = ["async-native-tls/vendored", "async-smtp/native-tls-vendored", "rusqlite/bundled-sqlcipher-vendored-openssl"]
+default = ["nightly", "ringbuf"]
+vendored = ["native-tls/vendored", "reqwest/default-tls-vendored"]
 nightly = ["pgp/nightly"]
+ringbuf = ["pgp/ringbuf"]

LICENSE

@@ -2,6 +2,9 @@ The files in this directory and under its subdirectories
 are (c) 2019 by Bjoern Petersen and contributors and released under the
 Mozilla Public License Version 2.0, see below for a copy.
 
+NOTE that the files in the "libs" directory are copyrighted by third parties
+and come with their own respective licenses.
+
 Mozilla Public License Version 2.0
 ==================================
 

README.md

@@ -1,27 +1,26 @@
 # Delta Chat Rust
 
-> Deltachat-core written in Rust 
+> Project porting deltachat-core to rust
 
-[![Rust CI](https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml)
+[![CircleCI build status][circle-shield]][circle] [![Appveyor build status][appveyor-shield]][appveyor]
+
+Current commit on deltachat/deltachat-core: `12ef73c8e76185f9b78e844ea673025f56a959ab`.
 
 ## Installing Rust and Cargo
 
 To download and install the official compiler for the Rust programming language, and the Cargo package manager, run the command in your user environment:
 
 ```
-$ curl https://sh.rustup.rs -sSf | sh
+curl https://sh.rustup.rs -sSf | sh
 ```
 
-> On Windows, you may need to also install **Perl** to be able to compile deltachat-core.
-
 ## Using the CLI client
 
-Compile and run Delta Chat Core command line utility, using `cargo`:
+Compile and run Delta Chat Core using `cargo`:
 
 ```
-$ RUST_LOG=repl=info cargo run --example repl --features repl -- ~/deltachat-db
+cargo run --example repl -- /path/to/db
 ```
-where ~/deltachat-db is the database file. Delta Chat will create it if it does not exist.
 
 Configure your account (if not already configured):
 
@@ -81,16 +80,6 @@ For more commands type:
 > help
 ```
 
-## Installing libdeltachat system wide
-
-```
-$ git clone https://github.com/deltachat/deltachat-core-rust.git
-$ cd deltachat-core-rust
-$ cmake -B build . -DCMAKE_INSTALL_PREFIX=/usr
-$ cmake --build build
-$ sudo cmake --install build
-```
-
 ## Development
 
 ```sh
@@ -100,16 +89,6 @@ $ cargo test --all
 $ cargo build -p deltachat_ffi --release
 ```
 
-## Debugging environment variables 
-
-- `DCC_IMAP_DEBUG`: if set IMAP protocol commands and responses will be
-  printed
-
-- `DCC_MIME_DEBUG`: if set outgoing and incoming message will be printed 
-
-- `RUST_LOG=repl=info,async_imap=trace,async_smtp=trace`: enable IMAP and
-SMTP tracing in addition to info messages.
-
 ### Expensive tests
 
 Some tests are expensive and marked with `#[ignore]`, to run these
@@ -122,24 +101,9 @@ $ cargo test -- --ignored
 
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.
 - `nightly`: Enable nightly only performance and security related features.
+- `ringbuf`: Enable the use of [`slice_deque`](https://github.com/gnzlbg/slice_deque) in pgp.
 
-## Language bindings and frontend projects
-
-Language bindings are available for:
-
-- **C** \[[📂 source](./deltachat-ffi) | [📚 docs](https://c.delta.chat)\]
-- **Node.js** \[[📂 source](./node) | [📦 npm](https://www.npmjs.com/package/deltachat-node) | [📚 docs](https://js.delta.chat)\]
-- **Python** \[[📂 source](./python) | [📦 pypi](https://pypi.org/project/deltachat) | [📚 docs](https://py.delta.chat)\]
-- **Go** \[[📂 source](https://github.com/deltachat/go-deltachat/)\]
-- **Free Pascal** \[[📂 source](https://github.com/deltachat/deltachat-fp/)\]
-- **Java** and **Swift** (contained in the Android/iOS repos)
-
-The following "frontend" projects make use of the Rust-library
-or its language bindings:
-
-- [Android](https://github.com/deltachat/deltachat-android)
-- [iOS](https://github.com/deltachat/deltachat-ios)
-- [Desktop](https://github.com/deltachat/deltachat-desktop)
-- [Pidgin](https://code.ur.gs/lupine/purple-plugin-delta/)
-- [Telepathy](https://code.ur.gs/lupine/telepathy-padfoot/)
-- several **Bots**
+[circle-shield]: https://img.shields.io/circleci/project/github/deltachat/deltachat-core-rust/master.svg?style=flat-square
+[circle]: https://circleci.com/gh/deltachat/deltachat-core-rust/
+[appveyor-shield]: https://ci.appveyor.com/api/projects/status/lqpegel3ld4ipxj8/branch/master?style=flat-square
+[appveyor]: https://ci.appveyor.com/project/dignifiedquire/deltachat-core-rust/branch/master

appveyor.yml

@@ -0,0 +1,20 @@
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+
+install:
+  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - rustup-init -yv --default-toolchain nightly-2019-07-10
+  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+  - rustc -vV
+  - cargo -vV
+  - cargo update
+
+build: false
+
+test_script:
+  - cargo test --release --all
+
+cache:
+  - target
+  - C:\Users\appveyor\.cargo\registry

assets/icon-broadcast.svg

@@ -1,149 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   enable-background="new 0 0 128 128"
-   viewBox="0 0 60 60"
-   version="1.1"
-   id="svg878"
-   sodipodi:docname="icon-broadcast.svg"
-   width="60"
-   height="60"
-   inkscape:version="1.0.2 (e86c8708, 2021-01-15)"
-   inkscape:export-filename="/Users/bpetersen/projects/deltachat-core-rust/assets/icon-broadcast.png"
-   inkscape:export-xdpi="409.60001"
-   inkscape:export-ydpi="409.60001">
-  <metadata
-     id="metadata884">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <defs
-     id="defs882" />
-  <sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1329"
-     inkscape:window-height="847"
-     id="namedview880"
-     showgrid="false"
-     inkscape:zoom="5.21875"
-     inkscape:cx="36.598802"
-     inkscape:cy="32.191617"
-     inkscape:window-x="111"
-     inkscape:window-y="205"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="svg878"
-     inkscape:document-rotation="0" />
-  <radialGradient
-     id="c"
-     cx="65.25"
-     cy="89"
-     r="26.440001"
-     gradientTransform="matrix(0.77611266,0.11996647,-0.18999676,1.2286617,-11.305867,-60.065999)"
-     gradientUnits="userSpaceOnUse">
-    <stop
-       stop-color="#FFC107"
-       offset="0"
-       id="stop833" />
-    <stop
-       stop-color="#FFBD06"
-       offset=".3502"
-       id="stop835" />
-    <stop
-       stop-color="#FFB104"
-       offset=".6938"
-       id="stop837" />
-    <stop
-       stop-color="#FFA000"
-       offset="1"
-       id="stop839" />
-  </radialGradient>
-  <radialGradient
-     id="b"
-     cx="52.5"
-     cy="19.75"
-     r="92.975998"
-     gradientUnits="userSpaceOnUse"
-     gradientTransform="rotate(45.323856,68.997115,75.979538)">
-    <stop
-       stop-color="#EF5350"
-       offset="0"
-       id="stop848" />
-    <stop
-       stop-color="#EB4F4C"
-       offset=".246"
-       id="stop850" />
-    <stop
-       stop-color="#E04341"
-       offset=".4878"
-       id="stop852" />
-    <stop
-       stop-color="#CD302F"
-       offset=".7272"
-       id="stop854" />
-    <stop
-       stop-color="#C62828"
-       offset=".8004"
-       id="stop856" />
-    <stop
-       stop-color="#C62828"
-       offset="1"
-       id="stop858" />
-  </radialGradient>
-  <radialGradient
-     id="a"
-     cx="16.979"
-     cy="92"
-     r="24.165001"
-     gradientUnits="userSpaceOnUse"
-     gradientTransform="rotate(45.323856,68.997115,75.979538)"
-     xlink:href="#b">
-    <stop
-       stop-color="#E0E0E0"
-       offset="0"
-       id="stop863" />
-    <stop
-       stop-color="#CFCFCF"
-       offset=".3112"
-       id="stop865" />
-    <stop
-       stop-color="#A4A4A4"
-       offset=".9228"
-       id="stop867" />
-    <stop
-       stop-color="#9E9E9E"
-       offset="1"
-       id="stop869" />
-  </radialGradient>
-  <rect
-     y="0"
-     x="0"
-     height="60"
-     width="60"
-     id="rect1420"
-     style="fill:#7cc0bc;fill-opacity:1;stroke:none;stroke-width:1.29077" />
-  <path
-     id="path872"
-     style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.336872;stroke-opacity:1"
-     d="m 8.6780027,35.573064 0.032831,-11.910176 c 0.00138,-0.476406 0.4881282,-0.794259 0.9235226,-0.604877 l 4.1144877,2.345752 -0.02386,8.656315 -4.1268029,2.122946 C 9.1617452,36.370003 8.6766889,36.049472 8.6780027,35.573064 Z m 5.0469633,-1.508222 0.02386,-8.656314 31.145424,-9.537653 c 0.841472,-0.219211 1.65915,0.41667 1.656755,1.283728 l -0.06929,25.139995 c -0.0024,0.867062 -0.825942,1.500799 -1.663803,1.274581 z m 3.8042,6.892234 C 16.681121,40.104348 16.315444,38.819414 16.69043,37.591308 l 2.252234,-7.347193 c 0.2644,-0.861571 0.845185,-1.567441 1.641953,-1.989251 0.796769,-0.421808 1.706956,-0.509819 2.568531,-0.245419 l 7.263888,2.225804 c 1.775518,0.543235 2.780299,2.432591 2.232297,4.208094 L 30.3971,41.790532 c -0.545627,1.777887 -2.432591,2.780297 -4.208095,2.232298 l -7.263891,-2.225804 c -0.545033,-0.165864 -1.01825,-0.460162 -1.395948,-0.83995 z m 12.377693,-7.976728 c -0.07601,-0.07642 -0.17114,-0.133864 -0.280621,-0.167516 l -7.263891,-2.225803 c -0.233244,-0.07209 -0.421626,0.0013 -0.512275,0.04861 -0.09064,0.0474 -0.25772,0.166033 -0.327435,0.396899 l -2.252234,7.347191 c -0.108166,0.354628 0.09088,0.731541 0.447888,0.842099 l 7.263891,2.225802 c 0.354626,0.108174 0.731539,-0.09088 0.842099,-0.447888 l 2.249845,-7.344814 c 0.07453,-0.245145 0.0014,-0.504991 -0.167267,-0.67458 z" />
-</svg>

assets/icon-device.svg

@@ -1,83 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:export-ydpi="409.60001"
-   inkscape:export-xdpi="409.60001"
-   inkscape:export-filename="/Users/bpetersen/projects/deltachat-core-rust/assets/icon-device.png"
-   version="1.0"
-   width="60"
-   height="60"
-   viewBox="0 0 45 45"
-   preserveAspectRatio="xMidYMid meet"
-   id="svg4344"
-   sodipodi:docname="icon-device.svg"
-   inkscape:version="1.0beta1 (32d4812, 2019-09-19)">
-  <defs
-     id="defs4348" />
-  <sodipodi:namedview
-     inkscape:snap-global="false"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     inkscape:document-rotation="0"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1600"
-     inkscape:window-height="1035"
-     id="namedview4346"
-     showgrid="false"
-     units="px"
-     inkscape:zoom="3.959798"
-     inkscape:cx="28.322498"
-     inkscape:cy="24.898474"
-     inkscape:window-x="45"
-     inkscape:window-y="23"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="svg4344" />
-  <metadata
-     id="metadata4336">
-Created by potrace 1.15, written by Peter Selinger 2001-2017
-<rdf:RDF>
-  <cc:Work
-     rdf:about="">
-    <dc:format>image/svg+xml</dc:format>
-    <dc:type
-       rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-    <dc:title />
-  </cc:Work>
-</rdf:RDF>
-</metadata>
-  <rect
-     y="-4.4408921e-16"
-     x="0"
-     height="45"
-     width="45"
-     id="rect860"
-     style="opacity:1;fill:#76868b;fill-opacity:1;stroke-width:0.819271" />
-  <g
-     fill="#000000"
-     stroke="none"
-     style="fill:#ffffff;fill-opacity:1"
-     transform="matrix(0.00255113,0,0,-0.00255113,5.586152,38.200477)"
-     id="g4342">
-    <path
-       style="fill:#ffffff;fill-opacity:1"
-       d="m 8175,12765 c -703,-114 -1248,-608 -1387,-1258 -17,-82 -21,-136 -22,-277 0,-202 15,-307 70,-470 149,-446 499,-733 1009,-828 142,-26 465,-23 619,6 691,131 1201,609 1328,1244 31,158 31,417 0,565 -114,533 -482,889 -1038,1004 -133,27 -448,35 -579,14 z"
-       id="path4338"
-       inkscape:connector-curvature="0" />
-    <path
-       style="fill:#ffffff;fill-opacity:1"
-       d="m 7070,9203 c -212,-20 -275,-27 -397,-48 -691,-117 -1400,-444 -2038,-940 -182,-142 -328,-270 -585,-517 -595,-571 -911,-974 -927,-1181 -6,-76 11,-120 69,-184 75,-80 159,-108 245,-79 109,37 263,181 632,595 539,606 774,826 1035,969 135,75 231,105 341,106 82,1 94,-2 138,-27 116,-68 161,-209 122,-376 -9,-36 -349,-868 -757,-1850 -407,-982 -785,-1892 -838,-2021 -287,-694 -513,-1389 -615,-1889 -70,-342 -90,-683 -52,-874 88,-440 381,-703 882,-792 124,-23 401,-30 562,-16 783,69 1674,461 2561,1125 796,596 1492,1354 1607,1751 43,146 -33,308 -168,360 -61,23 -100,15 -173,-36 -105,-74 -202,-170 -539,-529 -515,-551 -762,-783 -982,-927 -251,-164 -437,-186 -543,-65 -56,64 -74,131 -67,247 13,179 91,434 249,815 135,324 1588,4102 1646,4280 106,325 151,561 159,826 9,281 -22,463 -112,652 -58,122 -114,199 -211,292 -245,233 -582,343 -1044,338 -91,-1 -181,-3 -200,-5 z"
-       id="path4340"
-       inkscape:connector-curvature="0" />
-  </g>
-</svg>

assets/icon-saved-messages.svg

@@ -1,71 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:export-ydpi="409.60001"
-   inkscape:export-xdpi="409.60001"
-   inkscape:export-filename="/home/kerle/test-icon.png"
-   version="1.0"
-   width="60"
-   height="60"
-   viewBox="0 0 45 45"
-   preserveAspectRatio="xMidYMid meet"
-   id="svg4344"
-   sodipodi:docname="icon-saved-messages.svg"
-   inkscape:version="1.0beta1 (32d4812, 2019-09-19)">
-  <defs
-     id="defs4348" />
-  <sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     inkscape:document-rotation="0"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1395"
-     inkscape:window-height="855"
-     id="namedview4346"
-     showgrid="false"
-     units="px"
-     inkscape:zoom="4"
-     inkscape:cx="29.308676"
-     inkscape:cy="49.03624"
-     inkscape:window-x="89"
-     inkscape:window-y="108"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="svg4344"
-     inkscape:lockguides="false" />
-  <metadata
-     id="metadata4336">
-Created by potrace 1.15, written by Peter Selinger 2001-2017
-<rdf:RDF>
-  <cc:Work
-     rdf:about="">
-    <dc:format>image/svg+xml</dc:format>
-    <dc:type
-       rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-    <dc:title />
-  </cc:Work>
-</rdf:RDF>
-</metadata>
-  <rect
-     y="0"
-     x="0"
-     height="45"
-     width="45"
-     id="rect1420"
-     style="fill:#87aade;fill-opacity:1;stroke:none;stroke-width:0.968078" />
-  <path
-     id="rect846"
-     style="fill:#ffffff;stroke-width:0.58409804"
-     d="M 13.5,7.5 V 39 h 0.08654 L 22.533801,29.370239 31.482419,39 h 0.01758 V 7.5 Z m 9.004056,4.108698 1.879508,4.876388 5.039514,0.359779 -3.879358,3.363728 1.227764,5.095749 -4.276893,-2.796643 -4.280949,2.788618 1.237229,-5.093073 -3.873949,-3.371754 5.040866,-0.350417 z"
-     inkscape:connector-curvature="0" />
-</svg>

assets/icon-webxdc.svg

@@ -1,181 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="80mm"
-   height="297mm"
-   viewBox="0 0 80 297"
-   version="1.1"
-   id="svg71"
-   inkscape:version="1.0.2 (e86c8708, 2021-01-15)"
-   sodipodi:docname="icon-webxdc.svg"
-   inkscape:export-filename="C:\Users\user\OneDrive - BFW-Leipzig\Documents\LogoDC\finalohnerand.png"
-   inkscape:export-xdpi="96"
-   inkscape:export-ydpi="96">
-  <metadata
-     id="metadata856">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <sodipodi:namedview
-     id="namedview73"
-     pagecolor="#767676"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0"
-     inkscape:pagecheckerboard="true"
-     inkscape:document-units="mm"
-     showgrid="false"
-     showborder="false"
-     inkscape:snap-bbox="true"
-     inkscape:bbox-paths="true"
-     inkscape:bbox-nodes="true"
-     inkscape:snap-bbox-edge-midpoints="true"
-     inkscape:snap-bbox-midpoints="true"
-     inkscape:object-paths="true"
-     inkscape:snap-intersection-paths="true"
-     inkscape:zoom="1.4142136"
-     inkscape:cx="-90.271136"
-     inkscape:cy="-1233.1209"
-     inkscape:window-width="1864"
-     inkscape:window-height="1027"
-     inkscape:window-x="56"
-     inkscape:window-y="25"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="layer1"
-     inkscape:snap-global="false"
-     showguides="false"
-     inkscape:guide-bbox="true"
-     inkscape:document-rotation="0"
-     units="px">
-    <sodipodi:guide
-       position="-154.76097,641.11689"
-       orientation="0,-1"
-       id="guide21118" />
-    <sodipodi:guide
-       position="-60.286487,633.36619"
-       orientation="0,-1"
-       id="guide21120" />
-  </sodipodi:namedview>
-  <defs
-     id="defs68">
-    <linearGradient
-       id="linearGradient4375">
-      <stop
-         style="stop-color:#364e59;stop-opacity:1;"
-         offset="0"
-         id="stop4377" />
-      <stop
-         style="stop-color:#364e59;stop-opacity:0;"
-         offset="1"
-         id="stop4379" />
-    </linearGradient>
-  </defs>
-  <g
-     inkscape:label="Ebene 1"
-     inkscape:groupmode="layer"
-     id="layer1">
-    <rect
-       style="fill:#1a1a1a;stroke:#000000;stroke-width:0.167903"
-       id="rect880"
-       width="79.8321"
-       height="79.8321"
-       x="-64.03286"
-       y="-375.9097"
-       ry="0" />
-    <path
-       inkscape:connector-curvature="0"
-       id="path3799-2"
-       d="m -24.089585,-372.59579 c -19.986026,0.24336 -36.196903,16.666 -36.196903,36.67011 0,20.00409 16.210877,36.03233 36.196903,35.78912 19.0024236,-0.076 14.5340713,-10.6146 35.538854,-0.85693 -11.50627538,-17.97454 0.390097,-20.36737 0.658079,-35.81316 0,-20.00411 -16.2108788,-36.03235 -36.196911,-35.78914 z"
-       style="fill:#364e59;fill-opacity:1;stroke:none;stroke-width:1.93355"
-       sodipodi:nodetypes="sscccs" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       d="M -54.193871,-325.26419 Z"
-       id="path3846" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       d="M -49.397951,-326.67773 Z"
-       id="path3848" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       d="m -49.397951,-326.67773 v 0 0"
-       id="path3850" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:0.01;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m -51.35133,-325.0334 -7.964067,5.98895 z"
-       id="path3965" />
-    <path
-       inkscape:connector-curvature="0"
-       id="path11037"
-       d="m -24.089585,-372.19891 c -19.986026,0.24156 -36.196903,16.54352 -36.196903,36.40062 0,7.86524 2.543315,15.1113 6.857155,20.97971 6.577146,8.94734 11.123515,9.77363 11.123515,9.77363 1.343237,1.78324 10.270932,4.3223 10.270932,4.3223 l 16.791727,-70.86654 -0.468369,-0.33457 c 0.458597,0.26445 0.428277,-0.27515 -8.378035,-0.27515 z"
-       style="fill:#7cc5cc;fill-opacity:1;stroke:none;stroke-width:1.92643"
-       sodipodi:nodetypes="sssccccss" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       d="M -49.944239,-310.69957 Z"
-       id="path13674" />
-    <g
-       id="g15178"
-       transform="matrix(0.79975737,0,0,0.79975737,53.088959,-63.716396)">
-      <rect
-         style="fill:#364e59;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
-         id="rect15072"
-         width="29.897917"
-         height="6.8791666"
-         x="-334.4964"
-         y="-154.51025"
-         transform="rotate(45)" />
-      <rect
-         style="fill:#364e59;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
-         id="rect15072-5"
-         width="29.897917"
-         height="6.8791666"
-         x="147.63107"
-         y="-334.4964"
-         transform="rotate(-45)"
-         inkscape:transform-center-x="-0.74835017"
-         inkscape:transform-center-y="0.37417525" />
-    </g>
-    <g
-       id="g22468"
-       transform="translate(3.3033974)">
-      <g
-         id="g15178-0"
-         transform="matrix(-0.79975737,0,0,0.79975737,-103.11028,-63.716404)"
-         style="fill:#7cc5cc;fill-opacity:1">
-        <rect
-           style="fill:#7cc5cc;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
-           id="rect15072-2"
-           width="29.897917"
-           height="6.8791666"
-           x="-334.4964"
-           y="-154.51025"
-           transform="rotate(45)" />
-        <rect
-           style="fill:#7cc5cc;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
-           id="rect15072-5-5"
-           width="29.897917"
-           height="6.8791666"
-           x="147.63107"
-           y="-334.4964"
-           transform="rotate(-45)"
-           inkscape:transform-center-x="-0.74835017"
-           inkscape:transform-center-y="0.37417525" />
-      </g>
-    </g>
-  </g>
-</svg>

assets/qrcode_logo_footer.svg

@@ -1,10 +0,0 @@
-<text
-     xml:space="preserve"
-     style="font-weight:bold;font-size:24.4118px;line-height:1.25;font-family:sans-serif;fill:#aaaaaa;fill-opacity:1;stroke:none;stroke-width:0.915439"
-     x="42.325161"
-     y="23.32255"
-     id="text72398">get.delta.chat</text>
-  <path
-     id="path84310"
-     style="opacity:0.25;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.915439"
-     d="M 17.13769,0.00129321 C 7.6753075,0.11650893 0,7.8915283 0,17.362467 c 0,9.47094 7.6753075,17.059745 17.13769,16.944599 8.99669,-0.03598 6.880074,-5.025654 16.824785,-0.405885 -5.447648,-8.510047 0.184241,-9.642482 0.311117,-16.955289 0,-9.4709395 -7.673512,-17.0597453 -17.135895,-16.94459879 z M 17.0769,4.9986797 c 1.84214,0 3.447355,0.253959 4.815003,0.7616693 1.381603,0.5076411 2.072253,1.207862 2.072253,2.0990711 0,0.4286855 -0.167495,0.7836052 -0.50242,1.0656242 -0.334921,0.2819844 -0.724544,0.4237724 -1.171121,0.4237724 -0.641952,0 -1.396532,-0.3909376 -2.261778,-1.169353 C 19.14963,7.3898036 18.402555,6.83791 17.788507,6.5220182 17.188416,6.1950547 16.484552,6.0321266 15.675129,6.0321266 c -1.032717,0 -1.883352,0.1854523 -2.553215,0.5578447 -0.655913,0.372254 -0.98517,0.8460916 -0.98517,1.4214436 0,0.5414792 0.272815,1.0495355 0.817093,1.5233385 0.544275,0.4738026 1.946291,1.3367446 4.207097,2.5889976 2.414319,1.342419 4.117377,2.390985 5.108232,3.146807 1.004795,0.755857 1.821505,1.675853 2.449514,2.758846 0.628002,1.082993 0.942253,2.227607 0.942253,3.434674 0,2.120834 -0.929555,3.993314 -2.785656,5.617786 -1.84214,1.613228 -3.99694,2.41915 -6.467082,2.41915 -2.246845,0 -4.145607,-0.647976 -5.694677,-1.945312 -1.5490699,-1.297336 -2.3225722,-3.028063 -2.3225722,-5.194049 0,-2.087031 0.8506345,-3.83094 2.5532182,-5.229825 1.716541,-1.398884 3.824203,-2.245599 6.322256,-2.538897 -0.697774,-0.631749 -1.668763,-1.387225 -2.910816,-2.267155 -1.367648,-0.970199 -2.287914,-1.73045 -2.762402,-2.283243 -0.474491,-0.5640381 -0.711618,-1.1795944 -0.711618,-1.8451814 0,-0.9927581 0.572093,-1.7710351 1.716451,-2.3351077 1.144362,-0.5753173 2.636724,-0.8635642 4.478865,-0.8635642 z m 1.110327,10.3738083 c -4.005262,0.5302 -6.007576,2.75279 -6.007576,6.667322 0,2.01932 0.49495,3.587291 1.485805,4.704157 1.004806,1.116832 2.169696,1.675299 3.495479,1.675299 1.381602,0 2.520072,-0.535632 3.413229,-1.60738 0.893168,-1.082959 1.339187,-2.545264 1.339187,-4.384079 0,-2.662348 -1.242022,-5.013441 -3.726124,-7.055319 z" />

benches/contacts.rs

@@ -1,37 +0,0 @@
-use async_std::task::block_on;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use deltachat::contact::Contact;
-use deltachat::context::Context;
-use tempfile::tempdir;
-
-async fn address_book_benchmark(n: u32, read_count: u32) {
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    let id = 100;
-    let context = Context::new(dbfile.into(), id).await.unwrap();
-
-    let book = (0..n)
-        .map(|i| format!("Name {}\naddr{}@example.org\n", i, i))
-        .collect::<Vec<String>>()
-        .join("");
-
-    Contact::add_address_book(&context, &book).await.unwrap();
-
-    let query: Option<&str> = None;
-    for _ in 0..read_count {
-        Contact::get_all(&context, 0, query).await.unwrap();
-    }
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("create 500 contacts", |b| {
-        b.iter(|| block_on(async { address_book_benchmark(black_box(500), black_box(0)).await }))
-    });
-
-    c.bench_function("create 100 contacts and read it 1000 times", |b| {
-        b.iter(|| block_on(async { address_book_benchmark(black_box(100), black_box(1000)).await }))
-    });
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

benches/create_account.rs

@@ -1,26 +0,0 @@
-use async_std::path::PathBuf;
-use async_std::task::block_on;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use deltachat::accounts::Accounts;
-use tempfile::tempdir;
-
-async fn create_accounts(n: u32) {
-    let dir = tempdir().unwrap();
-    let p: PathBuf = dir.path().join("accounts").into();
-
-    let mut accounts = Accounts::new(p.clone()).await.unwrap();
-
-    for expected_id in 2..n {
-        let id = accounts.add_account().await.unwrap();
-        assert_eq!(id, expected_id);
-    }
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("create 1 account", |b| {
-        b.iter(|| block_on(async { create_accounts(black_box(1)).await }))
-    });
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

benches/get_chat_msgs.rs

@@ -1,40 +0,0 @@
-use async_std::path::Path;
-
-use criterion::async_executor::AsyncStdExecutor;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-use deltachat::chat::{self, ChatId};
-use deltachat::chatlist::Chatlist;
-use deltachat::context::Context;
-
-async fn get_chat_msgs_benchmark(dbfile: &Path, chats: &[ChatId]) {
-    let id = 100;
-    let context = Context::new(dbfile.into(), id).await.unwrap();
-
-    for c in chats.iter().take(10) {
-        black_box(chat::get_chat_msgs(&context, *c, 0).await.ok());
-    }
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    // To enable this benchmark, set `DELTACHAT_BENCHMARK_DATABASE` to some large database with many
-    // messages, such as your primary account.
-    if let Ok(path) = std::env::var("DELTACHAT_BENCHMARK_DATABASE") {
-        let chats: Vec<_> = async_std::task::block_on(async {
-            let context = Context::new((&path).into(), 100).await.unwrap();
-            let chatlist = Chatlist::try_load(&context, 0, None, None).await.unwrap();
-            let len = chatlist.len();
-            (0..len).map(|i| chatlist.get_chat_id(i).unwrap()).collect()
-        });
-
-        c.bench_function("chat::get_chat_msgs (load messages from 10 chats)", |b| {
-            b.to_async(AsyncStdExecutor)
-                .iter(|| get_chat_msgs_benchmark(black_box(path.as_ref()), black_box(&chats)))
-        });
-    } else {
-        println!("env var not set: DELTACHAT_BENCHMARK_DATABASE");
-    }
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

benches/get_chatlist.rs

@@ -1,27 +0,0 @@
-use criterion::async_executor::AsyncStdExecutor;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-use deltachat::chatlist::Chatlist;
-use deltachat::context::Context;
-
-async fn get_chat_list_benchmark(context: &Context) {
-    Chatlist::try_load(context, 0, None, None).await.unwrap();
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    // To enable this benchmark, set `DELTACHAT_BENCHMARK_DATABASE` to some large database with many
-    // messages, such as your primary account.
-    if let Ok(path) = std::env::var("DELTACHAT_BENCHMARK_DATABASE") {
-        let context =
-            async_std::task::block_on(async { Context::new(path.into(), 100).await.unwrap() });
-        c.bench_function("chatlist:try_load (Get Chatlist)", |b| {
-            b.to_async(AsyncStdExecutor)
-                .iter(|| get_chat_list_benchmark(black_box(&context)))
-        });
-    } else {
-        println!("env var not set: DELTACHAT_BENCHMARK_DATABASE");
-    }
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

benches/receive_emails.rs

@@ -1,84 +0,0 @@
-use async_std::{path::PathBuf, task::block_on};
-use criterion::{
-    async_executor::AsyncStdExecutor, black_box, criterion_group, criterion_main, BatchSize,
-    Criterion,
-};
-use deltachat::{
-    config::Config,
-    context::Context,
-    dc_receive_imf::dc_receive_imf,
-    imex::{imex, ImexMode},
-};
-use tempfile::tempdir;
-
-async fn recv_all_emails(context: Context) -> Context {
-    for i in 0..100 {
-        let imf_raw = format!(
-            "Subject: Benchmark
-Message-ID: Mr.OssSYnOFkhR.{i}@testrun.org
-Date: Sat, 07 Dec 2019 19:00:27 +0000
-To: alice@example.com
-From: sender@testrun.org
-Chat-Version: 1.0
-Chat-Disposition-Notification-To: sender@testrun.org
-Chat-User-Avatar: 0
-In-Reply-To: Mr.OssSYnOFkhR.{i_dec}@testrun.org
-MIME-Version: 1.0
-
-Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
-
-Hello {i}",
-            i = i,
-            i_dec = i - 1,
-        );
-        dc_receive_imf(&context, black_box(imf_raw.as_bytes()), false)
-            .await
-            .unwrap();
-    }
-    context
-}
-
-async fn create_context() -> Context {
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    let id = 100;
-    let context = Context::new(dbfile.into(), id).await.unwrap();
-
-    let backup: PathBuf = std::env::current_dir()
-        .unwrap()
-        .join("delta-chat-backup.tar")
-        .into();
-    if backup.exists().await {
-        println!("Importing backup");
-        imex(&context, ImexMode::ImportBackup, &backup, None)
-            .await
-            .unwrap();
-    }
-
-    let addr = "alice@example.com";
-    context.set_config(Config::Addr, Some(addr)).await.unwrap();
-    context
-        .set_config(Config::ConfiguredAddr, Some(addr))
-        .await
-        .unwrap();
-    context
-        .set_config(Config::Configured, Some("1"))
-        .await
-        .unwrap();
-    context
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let mut group = c.benchmark_group("Receive messages");
-    group.bench_function("Receive 100 simple text msgs", |b| {
-        b.to_async(AsyncStdExecutor).iter_batched(
-            || block_on(create_context()),
-            |context| recv_all_emails(black_box(context)),
-            BatchSize::LargeInput,
-        );
-    });
-    group.finish();
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

benches/search_msgs.rs

@@ -1,29 +0,0 @@
-use async_std::task::block_on;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use deltachat::context::Context;
-use std::path::Path;
-
-async fn search_benchmark(path: impl AsRef<Path>) {
-    let dbfile = path.as_ref();
-    let id = 100;
-    let context = Context::new(dbfile.into(), id).await.unwrap();
-
-    for _ in 0..10u32 {
-        context.search_msgs(None, "hello").await.unwrap();
-    }
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    // To enable this benchmark, set `DELTACHAT_BENCHMARK_DATABASE` to some large database with many
-    // messages, such as your primary account.
-    if let Ok(path) = std::env::var("DELTACHAT_BENCHMARK_DATABASE") {
-        c.bench_function("search hello", |b| {
-            b.iter(|| block_on(async { search_benchmark(black_box(&path)).await }))
-        });
-    } else {
-        println!("env var not set: DELTACHAT_BENCHMARK_DATABASE");
-    }
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

ci_scripts/README.md

@@ -0,0 +1,52 @@
+
+# Continuous Integration Scripts for Delta Chat
+
+Continuous Integration is run through CircleCI
+but is largely independent of it. 
+
+
+## Generating docker containers for performing build step work 
+
+All tests, docs and wheel building is run in docker containers:
+
+- **coredeps/Dockerfile** specifies an image that contains all 
+  of Delta Chat's core dependencies as linkable libraries. 
+  It also serves to run python tests and build wheels 
+  (binary packages for Python). 
+
+- **doxygen/Dockerfile** specifies an image that contains
+  the doxygen tool which is used to generate C-docs. 
+
+To run tests locally you can pull existing images from "docker.io",
+the hub for sharing Docker images::
+
+    docker pull deltachat/coredeps
+    docker pull deltachat/doxygen 
+
+or you can build the docker images yourself locally
+to avoid the relatively large download:: 
+ 
+    cd ci_scripts  # where all CI things are 
+    docker build -t deltachat/coredeps docker-coredeps
+    docker build -t deltachat/doxygen docker-doxygen 
+
+## ci_run.sh (main entrypoint called by circle-ci)
+
+Once you have the docker images available 
+you can run python testing, documentation generation 
+and building binary wheels:: 
+
+    sh DOCS=1 TESTS=1 ci_scripts/ci_run.sh 
+    
+## ci_upload.sh (uploading artifacts on success) 
+
+- python docs to `https://py.delta.chat/_unofficial_unreleased_docs/<BRANCH>`
+
+- doxygen docs to `https://c.delta.chat/_unofficial_unreleased_docs/<BRANCH>`
+
+- python wheels to `https://m.devpi.net/dc/<BRANCH>`
+  so that you install fully self-contained wheels like this:
+  `pip install -U -i https://m.devpi.net/dc/<BRANCH> deltachat`
+
+
+

ci_scripts/ci_upload.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+if [ -z "$DEVPI_LOGIN" ] ; then 
+    echo "required: password for 'dc' user on https://m.devpi/net/dc index"
+    exit 0
+fi
+
+set -xe
+
+PYDOCDIR=${1:?directory with python docs}
+WHEELHOUSEDIR=${2:?directory with pre-built wheels}
+DOXYDOCDIR=${3:?directory where doxygen docs to be found}
+
+export BRANCH=${CIRCLE_BRANCH:?specify branch for uploading purposes}
+
+
+# python docs to py.delta.chat
+ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@py.delta.chat mkdir -p build/${BRANCH}
+rsync -avz \
+  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
+  "$PYDOCDIR/html/" \
+  delta@py.delta.chat:build/${BRANCH}
+
+# C docs to c.delta.chat
+ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@c.delta.chat mkdir -p build-c/${BRANCH}
+rsync -avz \
+  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
+  "$DOXYDOCDIR/html/" \
+  delta@c.delta.chat:build-c/${BRANCH}
+
+echo -----------------------
+echo upload wheels 
+echo -----------------------
+
+# Bundle external shared libraries into the wheels
+pushd $WHEELHOUSEDIR
+
+pip3 install devpi-client
+devpi use https://m.devpi.net
+devpi login dc --password $DEVPI_LOGIN
+
+N_BRANCH=${BRANCH//[\/]}
+
+devpi use dc/$N_BRANCH || {
+    devpi index -c $N_BRANCH 
+    devpi use dc/$N_BRANCH
+}
+devpi index $N_BRANCH bases=/root/pypi
+devpi upload deltachat*.whl
+
+popd

ci_scripts/docker-coredeps/Dockerfile

@@ -1,21 +1,25 @@
-FROM quay.io/pypa/manylinux2014_aarch64
+FROM quay.io/pypa/manylinux1_x86_64
 
 # Configure ld.so/ldconfig and pkg-config
 RUN echo /usr/local/lib64 > /etc/ld.so.conf.d/local.conf && \
     echo /usr/local/lib >> /etc/ld.so.conf.d/local.conf
 ENV PKG_CONFIG_PATH /usr/local/lib64/pkgconfig:/usr/local/lib/pkgconfig
 
-# Install a recent Perl, needed to install the openssl crate
-ADD deps/build_perl.sh /builder/build_perl.sh
-RUN rm /usr/bin/perl
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_perl.sh && cd .. && rm -r tmp1
-
 ENV PIP_DISABLE_PIP_VERSION_CHECK 1
 
 # Install python tools (auditwheels,tox, ...)
 ADD deps/build_python.sh /builder/build_python.sh
 RUN mkdir tmp1 && cd tmp1 && bash /builder/build_python.sh && cd .. && rm -r tmp1
 
-# Install Rust
+# Install Rust nightly 
 ADD deps/build_rust.sh /builder/build_rust.sh
 RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1
+
+# Install a recent Perl, needed to install OpenSSL
+ADD deps/build_perl.sh /builder/build_perl.sh
+RUN mkdir tmp1 && cd tmp1 && bash /builder/build_perl.sh && cd .. && rm -r tmp1
+
+# Install OpenSSL
+ADD deps/build_openssl.sh /builder/build_openssl.sh
+RUN mkdir tmp1 && cd tmp1 && bash /builder/build_openssl.sh && cd .. && rm -r tmp1
+

ci_scripts/docker-coredeps/deps/build_perl.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+PERL_VERSION=5.28.0
+PERL_SHA256=7e929f64d4cb0e9d1159d4a59fc89394e27fa1f7004d0836ca0d514685406ea8
+curl -O https://www.cpan.org/src/5.0/perl-${PERL_VERSION}.tar.gz
+echo "${PERL_SHA256}  perl-${PERL_VERSION}.tar.gz" | sha256sum -c -
+tar xzf perl-${PERL_VERSION}.tar.gz
+cd perl-${PERL_VERSION} 
+
+./Configure -de
+make
+make install

ci_scripts/docker-coredeps/deps/build_python.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -x -e
+
+# we use the python3.5 environment as the base environment 
+/opt/python/cp35-cp35m/bin/pip install tox devpi-client auditwheel 
+
+pushd /usr/bin
+
+ln -s /opt/_internal/cpython-3.5.*/bin/tox
+ln -s /opt/_internal/cpython-3.5.*/bin/devpi
+ln -s /opt/_internal/cpython-3.5.*/bin/auditwheel
+
+popd

ci_scripts/docker-coredeps/deps/build_rust.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e -x 
+
+# Install Rust 
+curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-07-10 -y
+export PATH=/root/.cargo/bin:$PATH
+rustc --version
+
+# remove some 300-400 MB that we don't need for automated builds
+rm -rf /root/.rustup/toolchains/nightly-2019-07-10-x86_64-unknown-linux-gnu/share/

ci_scripts/docker-coredeps/deps/run_all.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+#
+# Build the Delta Chat C/Rust library
+#
+set -e -x
+
+# perform clean build of core and install 
+export TOXWORKDIR=.docker-tox
+
+# build core library
+
+cargo build --release -p deltachat_ffi
+
+# configure access to a base python and 
+# to several python interpreters needed by tox below
+export PATH=$PATH:/opt/python/cp35-cp35m/bin
+export PYTHONDONTWRITEBYTECODE=1
+pushd /bin
+ln -s /opt/python/cp27-cp27m/bin/python2.7
+ln -s /opt/python/cp36-cp36m/bin/python3.6
+ln -s /opt/python/cp37-cp37m/bin/python3.7
+popd
+
+#
+# run python tests
+#
+
+if [ -n "$TESTS" ]; then 
+
+    echo ----------------
+    echo run python tests
+    echo ----------------
+
+    pushd python 
+    # first run all tests ...
+    rm -rf tests/__pycache__
+    rm -rf src/deltachat/__pycache__
+    export PYTHONDONTWRITEBYTECODE=1
+    tox --workdir "$TOXWORKDIR" -e py27,py35,py36,py37
+    popd
+fi
+
+
+if [ -n "$DOCS" ]; then 
+    echo -----------------------
+    echo generating python docs
+    echo -----------------------
+    (cd python && tox --workdir "$TOXWORKDIR" -e doc) 
+fi

ci_scripts/run-doxygen.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -ex
+
+cd deltachat-ffi 
+doxygen 
+

ci_scripts/run-python.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+#
+# Build the Delta Chat C/Rust library typically run in a docker
+# container that contains all library deps but should also work
+# outside if you have the dependencies installed on your system.
+
+set -e -x
+
+# Perform clean build of core and install.
+export TOXWORKDIR=.docker-tox
+
+# install core lib
+
+export PATH=/root/.cargo/bin:$PATH
+cargo build --release -p deltachat_ffi
+# cargo test --all --all-features
+
+# Statically link against libdeltachat.a.
+export DCC_RS_DEV=$(pwd)
+
+# Configure access to a base python and to several python interpreters
+# needed by tox below.
+export PATH=$PATH:/opt/python/cp35-cp35m/bin
+export PYTHONDONTWRITEBYTECODE=1
+pushd /bin
+ln -s /opt/python/cp27-cp27m/bin/python2.7
+ln -s /opt/python/cp36-cp36m/bin/python3.6
+ln -s /opt/python/cp37-cp37m/bin/python3.7
+popd
+
+if [ -n "$TESTS" ]; then
+
+    pushd python
+    # prepare a clean tox run
+    rm -rf tests/__pycache__
+    rm -rf src/deltachat/__pycache__
+    export PYTHONDONTWRITEBYTECODE=1
+
+    # run tox. The circle-ci project env-var-setting DCC_PY_LIVECONFIG 
+    # allows running of "liveconfig" tests but for speed reasons
+    # we run them only for the highest python version we support
+    
+    # we split out qr-tests run to minimize likelyness of flaky tests
+    # (some qr tests are pretty heavy in terms of send/received
+    # messages and rust's imap code likely has concurrency problems) 
+    tox --workdir "$TOXWORKDIR" -e py37 -- --reruns 3 -k "not qr"
+    tox --workdir "$TOXWORKDIR" -e py37 -- --reruns 3 -k "qr"
+    unset DCC_PY_LIVECONFIG
+    tox --workdir "$TOXWORKDIR" -p4 -e lint,py35,py36,doc
+    tox --workdir "$TOXWORKDIR" -e auditwheels
+    popd
+fi
+
+
+# if [ -n "$DOCS" ]; then
+#     echo -----------------------
+#     echo generating python docs
+#     echo -----------------------
+#     (cd python && tox --workdir "$TOXWORKDIR" -e doc)
+# fi

ci_scripts/run-rust-test.sh

@@ -1,9 +1,8 @@
 #!/usr/bin/env bash
 
 set -ex
-shopt -s huponexit
 
-#export RUST_TEST_THREADS=1
+export RUST_TEST_THREADS=1
 export RUST_BACKTRACE=1
 export RUSTFLAGS='--deny warnings'
 export OPT="--target=$TARGET"
@@ -38,9 +37,7 @@ else
     export OPT_RELEASE_IGNORED="${OPT_RELEASE} -- --ignored"
 fi
 
-# Run all the test configurations 
-# RUSTC_WRAPPER=SCCACHE seems to destroy parallelism / prolong the test
-unset RUSTC_WRAPPER
+# Run all the test configurations:
 $CARGO_CMD $CARGO_SUBCMD $OPT
 $CARGO_CMD $CARGO_SUBCMD $OPT_RELEASE
 $CARGO_CMD $CARGO_SUBCMD $OPT_RELEASE_IGNORED

contrib/proxy.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-# Examples:
-#
-# Original server that doesn't use SSL:
-# ./proxy.py 8080 imap.nauta.cu 143
-# ./proxy.py 8081 smtp.nauta.cu 25
-#
-# Original server that uses SSL:
-# ./proxy.py 8080 testrun.org 993 --ssl
-# ./proxy.py 8081 testrun.org 465 --ssl
-
-from datetime import datetime
-import argparse
-import selectors
-import ssl
-import socket
-import socketserver
-
-
-class Proxy(socketserver.ThreadingTCPServer):
-    allow_reuse_address = True
-
-    def __init__(self, proxy_host, proxy_port, real_host, real_port, use_ssl):
-        self.real_host = real_host
-        self.real_port = real_port
-        self.use_ssl = use_ssl
-        super().__init__((proxy_host, proxy_port), RequestHandler)
-
-
-class RequestHandler(socketserver.BaseRequestHandler):
-
-    def handle(self):
-        print('{} - {} CONNECTED.'.format(datetime.now(), self.client_address))
-
-        total = 0
-        real_server = (self.server.real_host, self.server.real_port)
-        with socket.create_connection(real_server) as sock:
-            if self.server.use_ssl:
-                context = ssl.create_default_context()
-                sock = context.wrap_socket(
-                    sock, server_hostname=real_server[0])
-
-            forward = {self.request: sock, sock: self.request}
-
-            sel = selectors.DefaultSelector()
-            sel.register(self.request, selectors.EVENT_READ,
-                         self.client_address)
-            sel.register(sock, selectors.EVENT_READ, real_server)
-
-            active = True
-            while active:
-                events = sel.select()
-                for key, mask in events:
-                    print('\n{} - {} wrote:'.format(datetime.now(), key.data))
-                    data = key.fileobj.recv(1024)
-                    received = len(data)
-                    total += received
-                    print(data)
-                    print('{} Bytes\nTotal: {} Bytes'.format(received, total))
-                    if data:
-                        forward[key.fileobj].sendall(data)
-                    else:
-                        print('\nCLOSING CONNECTION.\n\n')
-                        forward[key.fileobj].close()
-                        key.fileobj.close()
-                        active = False
-
-
-if __name__ == '__main__':
-    p = argparse.ArgumentParser(description='Simple Python Proxy')
-    p.add_argument(
-        "proxy_port", help="the port where the proxy will listen", type=int)
-    p.add_argument('host', help="the real host")
-    p.add_argument('port', help="the port of the real host", type=int)
-    p.add_argument("--ssl", help="use ssl to connect to the real host",
-                   action="store_true")
-    args = p.parse_args()
-
-    with Proxy('', args.proxy_port, args.host, args.port, args.ssl) as proxy:
-        proxy.serve_forever()

deltachat-ffi/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "deltachat_ffi"
-version = "1.81.0"
+version = "1.0.0-beta.7"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 readme = "README.md"
-license = "MPL-2.0"
+license = "MIT OR Apache-2.0"
 
 keywords = ["deltachat", "chat", "openpgp", "email", "encryption"]
 categories = ["cryptography", "std", "email"]
@@ -16,17 +16,13 @@ crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
 deltachat = { path = "../", default-features = false }
+deltachat-provider-database = "0.2.1"
 libc = "0.2"
-human-panic = "1"
-num-traits = "0.2"
-serde_json = "1.0"
-async-std = "1"
-anyhow = "1"
-thiserror = "1"
-rand = "0.7"
+human-panic = "1.0.1"
+num-traits = "0.2.6"
 
 [features]
-default = ["vendored"]
+default = ["vendored", "nightly", "ringbuf"]
 vendored = ["deltachat/vendored"]
 nightly = ["deltachat/nightly"]
-
+ringbuf = ["deltachat/ringbuf"]

deltachat-ffi/Doxyfile

@@ -236,6 +236,12 @@ TAB_SIZE               = 4
 
 ALIASES                =
 
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
 # instance, some of the names that are used will be different. The list of all
@@ -583,7 +589,7 @@ SORT_MEMBERS_CTORS_1ST = NO
 # appear in their defined order.
 # The default value is: NO.
 
-SORT_GROUP_NAMES       = YES
+SORT_GROUP_NAMES       = NO
 
 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
 # fully-qualified names, including namespaces. If set to NO, the class list will

deltachat-ffi/Doxyfile.css

@@ -4,16 +4,4 @@ div.fragment {
 	background-color: #e0e0e0;
 	border: 0;
 	padding: 1em;
-	border-radius: 6px;
 }
-
-code {
-	background-color: #e0e0e0;
-	padding-left: .5em;
-	padding-right: .5em;
-	border-radius: 6px;
-}
-
-li {
-	margin-bottom: .5em;
-}

deltachat-ffi/DoxygenLayout.xml

@@ -1,38 +0,0 @@
-<doxygenlayout version="1.0">
-  <!-- Generated by doxygen 1.8.20 -->
-  <!-- Navigation index tabs for HTML output -->
-  <navindex>
-    <tab type="mainpage" visible="yes" title=""/>
-    <tab type="classes" visible="yes" title="">
-      <tab type="classlist" visible="no" title="" intro=""/>
-      <tab type="classindex" visible="no" title=""/>
-      <tab type="hierarchy" visible="no" title="" intro=""/>
-      <tab type="classmembers" visible="no" title="" intro=""/>
-    </tab>
-    <tab type="modules" visible="yes" title="Constants" intro="Here is a list of constants:"/>
-    <tab type="pages" visible="yes" title="" intro=""/>
-    <tab type="namespaces" visible="yes" title="">
-      <tab type="namespacelist" visible="yes" title="" intro=""/>
-      <tab type="namespacemembers" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="interfaces" visible="yes" title="">
-      <tab type="interfacelist" visible="yes" title="" intro=""/>
-      <tab type="interfaceindex" visible="$ALPHABETICAL_INDEX" title=""/>
-      <tab type="interfacehierarchy" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="structs" visible="yes" title="">
-      <tab type="structlist" visible="yes" title="" intro=""/>
-      <tab type="structindex" visible="$ALPHABETICAL_INDEX" title=""/>
-    </tab>
-    <tab type="exceptions" visible="yes" title="">
-      <tab type="exceptionlist" visible="yes" title="" intro=""/>
-      <tab type="exceptionindex" visible="$ALPHABETICAL_INDEX" title=""/>
-      <tab type="exceptionhierarchy" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="files" visible="yes" title="">
-      <tab type="filelist" visible="yes" title="" intro=""/>
-      <tab type="globals" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="examples" visible="yes" title="" intro=""/>
-  </navindex>
-</doxygenlayout>

deltachat-ffi/README.md

@@ -1,9 +1,5 @@
 # Delta Chat C Interface
 
-## Installation
-
-see `Installing libdeltachat system wide` in [../README.md](../README.md)
-
 ## Documentation
 
 To generate the C Interface documentation,

deltachat-ffi/build.rs

@@ -19,17 +19,15 @@ fn main() {
         include_str!("deltachat.pc.in"),
         name = "deltachat",
         description = env::var("CARGO_PKG_DESCRIPTION").unwrap(),
-        url = env::var("CARGO_PKG_HOMEPAGE").unwrap_or_else(|_| "".to_string()),
+        url = env::var("CARGO_PKG_HOMEPAGE").unwrap_or("".to_string()),
         version = env::var("CARGO_PKG_VERSION").unwrap(),
         libs_priv = libs_priv,
-        prefix = env::var("PREFIX").unwrap_or_else(|_| "/usr/local".to_string()),
-        libdir = env::var("LIBDIR").unwrap_or_else(|_| "/usr/local/lib".to_string()),
-        includedir = env::var("INCLUDEDIR").unwrap_or_else(|_| "/usr/local/include".to_string()),
+        prefix = env::var("PREFIX").unwrap_or("/usr/local".to_string()),
     );
 
     fs::create_dir_all(target_path.join("pkgconfig")).unwrap();
     fs::File::create(target_path.join("pkgconfig").join("deltachat.pc"))
         .unwrap()
-        .write_all(pkg_config.as_bytes())
+        .write_all(&pkg_config.as_bytes())
         .unwrap();
 }

deltachat-ffi/deltachat.pc.in

@@ -1,6 +1,6 @@
 prefix={prefix}
-libdir={libdir}
-includedir={includedir}
+libdir=${{prefix}}/lib
+includedir=${{prefix}}/include
 
 Name: {name}
 Description: {description}

deltachat-ffi/src/dc_array.rs

@@ -1,127 +0,0 @@
-use crate::chat::ChatItem;
-use crate::constants::DC_MSG_ID_DAYMARKER;
-use crate::location::Location;
-use crate::message::MsgId;
-
-/* * the structure behind dc_array_t */
-#[derive(Debug, Clone)]
-pub enum dc_array_t {
-    MsgIds(Vec<MsgId>),
-    Chat(Vec<ChatItem>),
-    Locations(Vec<Location>),
-    Uint(Vec<u32>),
-}
-
-impl dc_array_t {
-    pub(crate) fn get_id(&self, index: usize) -> u32 {
-        match self {
-            Self::MsgIds(array) => array[index].to_u32(),
-            Self::Chat(array) => match array[index] {
-                ChatItem::Message { msg_id } => msg_id.to_u32(),
-                ChatItem::DayMarker { .. } => DC_MSG_ID_DAYMARKER,
-            },
-            Self::Locations(array) => array[index].location_id,
-            Self::Uint(array) => array[index],
-        }
-    }
-
-    pub(crate) fn get_timestamp(&self, index: usize) -> Option<i64> {
-        match self {
-            Self::MsgIds(_) => None,
-            Self::Chat(array) => array.get(index).and_then(|item| match item {
-                ChatItem::Message { .. } => None,
-                ChatItem::DayMarker { timestamp } => Some(*timestamp),
-            }),
-            Self::Locations(array) => array.get(index).map(|location| location.timestamp),
-            Self::Uint(_) => None,
-        }
-    }
-
-    pub(crate) fn get_marker(&self, index: usize) -> Option<&str> {
-        match self {
-            Self::MsgIds(_) => None,
-            Self::Chat(_) => None,
-            Self::Locations(array) => array
-                .get(index)
-                .and_then(|location| location.marker.as_deref()),
-            Self::Uint(_) => None,
-        }
-    }
-
-    pub(crate) fn get_location(&self, index: usize) -> &Location {
-        if let Self::Locations(array) = self {
-            &array[index]
-        } else {
-            panic!("Not an array of locations")
-        }
-    }
-
-    /// Returns the number of elements in the array.
-    pub(crate) fn len(&self) -> usize {
-        match self {
-            Self::MsgIds(array) => array.len(),
-            Self::Chat(array) => array.len(),
-            Self::Locations(array) => array.len(),
-            Self::Uint(array) => array.len(),
-        }
-    }
-
-    pub(crate) fn search_id(&self, needle: u32) -> Option<usize> {
-        (0..self.len()).find(|i| self.get_id(*i) == needle)
-    }
-}
-
-impl From<Vec<u32>> for dc_array_t {
-    fn from(array: Vec<u32>) -> Self {
-        dc_array_t::Uint(array)
-    }
-}
-
-impl From<Vec<MsgId>> for dc_array_t {
-    fn from(array: Vec<MsgId>) -> Self {
-        dc_array_t::MsgIds(array)
-    }
-}
-
-impl From<Vec<ChatItem>> for dc_array_t {
-    fn from(array: Vec<ChatItem>) -> Self {
-        dc_array_t::Chat(array)
-    }
-}
-
-impl From<Vec<Location>> for dc_array_t {
-    fn from(array: Vec<Location>) -> Self {
-        dc_array_t::Locations(array)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_dc_array() {
-        let arr: dc_array_t = Vec::<u32>::new().into();
-        assert!(arr.len() == 0);
-
-        let ids: Vec<u32> = (2..1002).collect();
-        let arr: dc_array_t = ids.into();
-
-        assert_eq!(arr.len(), 1000);
-
-        for i in 0..1000 {
-            assert_eq!(arr.get_id(i), (i + 2) as u32);
-        }
-
-        assert_eq!(arr.search_id(10), Some(8));
-        assert_eq!(arr.search_id(1), None);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_dc_array_out_of_bounds() {
-        let ids: Vec<u32> = (2..1002).collect();
-        let arr: dc_array_t = ids.into();
-        arr.get_id(1000);
-    }
-}

deltachat-ffi/src/lot.rs

@@ -1,245 +0,0 @@
-//! # Legacy generic return values for C API.
-
-use crate::message::MessageState;
-use crate::qr::Qr;
-use crate::summary::{Summary, SummaryPrefix};
-use anyhow::Error;
-use std::borrow::Cow;
-
-/// An object containing a set of values.
-/// The meaning of the values is defined by the function returning the object.
-/// Lot objects are created
-/// eg. by chatlist.get_summary() or dc_msg_get_summary().
-///
-/// *Lot* is used in the meaning *heap* here.
-#[derive(Debug)]
-pub enum Lot {
-    Summary(Summary),
-    Qr(Qr),
-    Error(String),
-}
-
-#[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Meaning {
-    None = 0,
-    Text1Draft = 1,
-    Text1Username = 2,
-    Text1Self = 3,
-}
-
-impl Default for Meaning {
-    fn default() -> Self {
-        Meaning::None
-    }
-}
-
-impl Lot {
-    pub fn get_text1(&self) -> Option<&str> {
-        match self {
-            Self::Summary(summary) => match &summary.prefix {
-                None => None,
-                Some(SummaryPrefix::Draft(text)) => Some(text),
-                Some(SummaryPrefix::Username(username)) => Some(username),
-                Some(SummaryPrefix::Me(text)) => Some(text),
-            },
-            Self::Qr(qr) => match qr {
-                Qr::AskVerifyContact { .. } => None,
-                Qr::AskVerifyGroup { grpname, .. } => Some(grpname),
-                Qr::FprOk { .. } => None,
-                Qr::FprMismatch { .. } => None,
-                Qr::FprWithoutAddr { fingerprint, .. } => Some(fingerprint),
-                Qr::Account { domain } => Some(domain),
-                Qr::WebrtcInstance { domain, .. } => Some(domain),
-                Qr::Addr { .. } => None,
-                Qr::Url { url } => Some(url),
-                Qr::Text { text } => Some(text),
-                Qr::WithdrawVerifyContact { .. } => None,
-                Qr::WithdrawVerifyGroup { grpname, .. } => Some(grpname),
-                Qr::ReviveVerifyContact { .. } => None,
-                Qr::ReviveVerifyGroup { grpname, .. } => Some(grpname),
-            },
-            Self::Error(err) => Some(err),
-        }
-    }
-
-    pub fn get_text2(&self) -> Option<Cow<str>> {
-        match self {
-            Self::Summary(summary) => Some(summary.truncated_text(160)),
-            Self::Qr(_) => None,
-            Self::Error(_) => None,
-        }
-    }
-
-    pub fn get_text1_meaning(&self) -> Meaning {
-        match self {
-            Self::Summary(summary) => match &summary.prefix {
-                None => Meaning::None,
-                Some(SummaryPrefix::Draft(_text)) => Meaning::Text1Draft,
-                Some(SummaryPrefix::Username(_username)) => Meaning::Text1Username,
-                Some(SummaryPrefix::Me(_text)) => Meaning::Text1Self,
-            },
-            Self::Qr(_qr) => Meaning::None,
-            Self::Error(_err) => Meaning::None,
-        }
-    }
-
-    pub fn get_state(&self) -> LotState {
-        match self {
-            Self::Summary(summary) => summary.state.into(),
-            Self::Qr(qr) => match qr {
-                Qr::AskVerifyContact { .. } => LotState::QrAskVerifyContact,
-                Qr::AskVerifyGroup { .. } => LotState::QrAskVerifyGroup,
-                Qr::FprOk { .. } => LotState::QrFprOk,
-                Qr::FprMismatch { .. } => LotState::QrFprMismatch,
-                Qr::FprWithoutAddr { .. } => LotState::QrFprWithoutAddr,
-                Qr::Account { .. } => LotState::QrAccount,
-                Qr::WebrtcInstance { .. } => LotState::QrWebrtcInstance,
-                Qr::Addr { .. } => LotState::QrAddr,
-                Qr::Url { .. } => LotState::QrUrl,
-                Qr::Text { .. } => LotState::QrText,
-                Qr::WithdrawVerifyContact { .. } => LotState::QrWithdrawVerifyContact,
-                Qr::WithdrawVerifyGroup { .. } => LotState::QrWithdrawVerifyGroup,
-                Qr::ReviveVerifyContact { .. } => LotState::QrReviveVerifyContact,
-                Qr::ReviveVerifyGroup { .. } => LotState::QrReviveVerifyGroup,
-            },
-            Self::Error(_err) => LotState::QrError,
-        }
-    }
-
-    pub fn get_id(&self) -> u32 {
-        match self {
-            Self::Summary(_) => Default::default(),
-            Self::Qr(qr) => match qr {
-                Qr::AskVerifyContact { contact_id, .. } => contact_id.to_u32(),
-                Qr::AskVerifyGroup { .. } => Default::default(),
-                Qr::FprOk { contact_id } => contact_id.to_u32(),
-                Qr::FprMismatch { contact_id } => contact_id.unwrap_or_default().to_u32(),
-                Qr::FprWithoutAddr { .. } => Default::default(),
-                Qr::Account { .. } => Default::default(),
-                Qr::WebrtcInstance { .. } => Default::default(),
-                Qr::Addr { contact_id } => contact_id.to_u32(),
-                Qr::Url { .. } => Default::default(),
-                Qr::Text { .. } => Default::default(),
-                Qr::WithdrawVerifyContact { contact_id, .. } => contact_id.to_u32(),
-                Qr::WithdrawVerifyGroup { .. } => Default::default(),
-                Qr::ReviveVerifyContact { contact_id, .. } => contact_id.to_u32(),
-                Qr::ReviveVerifyGroup { .. } => Default::default(),
-            },
-            Self::Error(_) => Default::default(),
-        }
-    }
-
-    pub fn get_timestamp(&self) -> i64 {
-        match self {
-            Self::Summary(summary) => summary.timestamp,
-            Self::Qr(_) => Default::default(),
-            Self::Error(_) => Default::default(),
-        }
-    }
-}
-
-#[repr(u32)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LotState {
-    // Default
-    Undefined = 0,
-
-    // Qr States
-    /// id=contact
-    QrAskVerifyContact = 200,
-
-    /// text1=groupname
-    QrAskVerifyGroup = 202,
-
-    /// id=contact
-    QrFprOk = 210,
-
-    /// id=contact
-    QrFprMismatch = 220,
-
-    /// text1=formatted fingerprint
-    QrFprWithoutAddr = 230,
-
-    /// text1=domain
-    QrAccount = 250,
-
-    /// text1=domain, text2=instance pattern
-    QrWebrtcInstance = 260,
-
-    /// id=contact
-    QrAddr = 320,
-
-    /// text1=text
-    QrText = 330,
-
-    /// text1=URL
-    QrUrl = 332,
-
-    /// text1=error string
-    QrError = 400,
-
-    QrWithdrawVerifyContact = 500,
-
-    /// text1=groupname
-    QrWithdrawVerifyGroup = 502,
-
-    QrReviveVerifyContact = 510,
-
-    /// text1=groupname
-    QrReviveVerifyGroup = 512,
-
-    // Message States
-    MsgInFresh = 10,
-    MsgInNoticed = 13,
-    MsgInSeen = 16,
-    MsgOutPreparing = 18,
-    MsgOutDraft = 19,
-    MsgOutPending = 20,
-    MsgOutFailed = 24,
-    MsgOutDelivered = 26,
-    MsgOutMdnRcvd = 28,
-}
-
-impl Default for LotState {
-    fn default() -> Self {
-        LotState::Undefined
-    }
-}
-
-impl From<MessageState> for LotState {
-    fn from(s: MessageState) -> Self {
-        use MessageState::*;
-        match s {
-            Undefined => LotState::Undefined,
-            InFresh => LotState::MsgInFresh,
-            InNoticed => LotState::MsgInNoticed,
-            InSeen => LotState::MsgInSeen,
-            OutPreparing => LotState::MsgOutPreparing,
-            OutDraft => LotState::MsgOutDraft,
-            OutPending => LotState::MsgOutPending,
-            OutFailed => LotState::MsgOutFailed,
-            OutDelivered => LotState::MsgOutDelivered,
-            OutMdnRcvd => LotState::MsgOutMdnRcvd,
-        }
-    }
-}
-
-impl From<Summary> for Lot {
-    fn from(summary: Summary) -> Self {
-        Lot::Summary(summary)
-    }
-}
-
-impl From<Qr> for Lot {
-    fn from(qr: Qr) -> Self {
-        Lot::Qr(qr)
-    }
-}
-
-// Make it easy to convert errors into the final `Lot`.
-impl From<Error> for Lot {
-    fn from(error: Error) -> Self {
-        Lot::Error(error.to_string())
-    }
-}

deltachat-ffi/src/providers.rs

@@ -0,0 +1,93 @@
+extern crate deltachat_provider_database;
+
+use std::ptr;
+
+use deltachat::dc_tools::{to_string_lossy, StrExt};
+use deltachat_provider_database::StatusState;
+
+#[no_mangle]
+pub type dc_provider_t = deltachat_provider_database::Provider;
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_new_from_domain(
+    domain: *const libc::c_char,
+) -> *const dc_provider_t {
+    match deltachat_provider_database::get_provider_info(&to_string_lossy(domain)) {
+        Some(provider) => provider,
+        None => ptr::null(),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_new_from_email(
+    email: *const libc::c_char,
+) -> *const dc_provider_t {
+    let email = to_string_lossy(email);
+    let domain = deltachat_provider_database::get_domain_from_email(&email);
+    match deltachat_provider_database::get_provider_info(domain) {
+        Some(provider) => provider,
+        None => ptr::null(),
+    }
+}
+
+macro_rules! null_guard {
+    ($context:tt) => {
+        if $context.is_null() {
+            return ptr::null_mut() as *mut libc::c_char;
+        }
+    };
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_overview_page(
+    provider: *const dc_provider_t,
+) -> *mut libc::c_char {
+    null_guard!(provider);
+    format!(
+        "{}/{}",
+        deltachat_provider_database::PROVIDER_OVERVIEW_URL,
+        (*provider).overview_page
+    )
+    .strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_name(provider: *const dc_provider_t) -> *mut libc::c_char {
+    null_guard!(provider);
+    (*provider).name.strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_markdown(
+    provider: *const dc_provider_t,
+) -> *mut libc::c_char {
+    null_guard!(provider);
+    (*provider).markdown.strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_status_date(
+    provider: *const dc_provider_t,
+) -> *mut libc::c_char {
+    null_guard!(provider);
+    (*provider).status.date.strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_status(provider: *const dc_provider_t) -> u32 {
+    if provider.is_null() {
+        return 0;
+    }
+    match (*provider).status.state {
+        StatusState::OK => 1,
+        StatusState::PREPARATION => 2,
+        StatusState::BROKEN => 3,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_unref(_provider: *const dc_provider_t) {
+    ()
+}
+
+// TODO expose general provider overview url?

deltachat-ffi/src/string.rs

@@ -1,421 +0,0 @@
-use std::ffi::{CStr, CString};
-use std::ptr;
-
-/// Duplicates a string
-///
-/// returns an empty string if NULL is given, never returns NULL (exits on errors)
-///
-/// # Examples
-///
-/// ```rust,norun
-/// use crate::string::{dc_strdup, to_string_lossy};
-/// unsafe {
-///     let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
-///     let str_a_copy = dc_strdup(str_a);
-///     assert_eq!(to_string_lossy(str_a_copy), "foobar");
-///     assert_ne!(str_a, str_a_copy);
-/// }
-/// ```
-unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
-    let ret: *mut libc::c_char = if !s.is_null() {
-        libc::strdup(s)
-    } else {
-        libc::calloc(1, 1) as *mut libc::c_char
-    };
-    assert!(!ret.is_null());
-    ret
-}
-
-/// Error type for the [OsStrExt] trait
-#[derive(Debug, PartialEq, thiserror::Error)]
-pub(crate) enum CStringError {
-    /// The string contains an interior null byte
-    #[error("String contains an interior null byte")]
-    InteriorNullByte,
-    /// The string is not valid Unicode
-    #[error("String is not valid unicode")]
-    NotUnicode,
-}
-
-/// Extra convenience methods on [std::ffi::OsStr] to work with `*libc::c_char`.
-///
-/// The primary function of this trait is to more easily convert
-/// [OsStr], [OsString] or [Path] into pointers to C strings.  This always
-/// allocates a new string since it is very common for the source
-/// string not to have the required terminal null byte.
-///
-/// It is implemented for `AsRef<std::ffi::OsStr>>` trait, which
-/// allows any type which implements this trait to transparently use
-/// this.  This is how the conversion for [Path] works.
-///
-/// [OsStr]: std::ffi::OsStr
-/// [OsString]: std::ffi::OsString
-/// [Path]: std::path::Path
-///
-/// # Example
-///
-/// ```
-/// use deltachat::dc_tools::{dc_strdup, OsStrExt};
-/// let path = std::path::Path::new("/some/path");
-/// let path_c = path.to_c_string().unwrap();
-/// unsafe {
-///     let mut c_ptr: *mut libc::c_char = dc_strdup(path_c.as_ptr());
-/// }
-/// ```
-pub(crate) trait OsStrExt {
-    /// Convert a  [std::ffi::OsStr] to an [std::ffi::CString]
-    ///
-    /// This is useful to convert e.g. a [std::path::Path] to
-    /// [*libc::c_char] by using
-    /// [Path::as_os_str()](std::path::Path::as_os_str) and
-    /// [CStr::as_ptr()](std::ffi::CStr::as_ptr).
-    ///
-    /// This returns [CString] and not [&CStr] because not all [OsStr]
-    /// slices end with a null byte, particularly those coming from
-    /// [Path] do not have a null byte and having to handle this as
-    /// the caller would defeat the point of this function.
-    ///
-    /// On Windows this requires that the [OsStr] contains valid
-    /// unicode, which should normally be the case for a [Path].
-    ///
-    /// [CString]: std::ffi::CString
-    /// [CStr]: std::ffi::CStr
-    /// [OsStr]: std::ffi::OsStr
-    /// [Path]: std::path::Path
-    ///
-    /// # Errors
-    ///
-    /// Since a C `*char` is terminated by a NULL byte this conversion
-    /// will fail, when the [OsStr] has an interior null byte.  The
-    /// function will return
-    /// `[Err]([CStringError::InteriorNullByte])`.  When converting
-    /// from a [Path] it should be safe to
-    /// [`.unwrap()`](std::result::Result::unwrap) this anyway since a
-    /// [Path] should not contain interior null bytes.
-    ///
-    /// On windows when the string contains invalid Unicode
-    /// `[Err]([CStringError::NotUnicode])` is returned.
-    fn to_c_string(&self) -> Result<CString, CStringError>;
-}
-
-impl<T: AsRef<std::ffi::OsStr>> OsStrExt for T {
-    #[cfg(not(target_os = "windows"))]
-    fn to_c_string(&self) -> Result<CString, CStringError> {
-        use std::os::unix::ffi::OsStrExt;
-        CString::new(self.as_ref().as_bytes()).map_err(|err| {
-            let std::ffi::NulError { .. } = err;
-            CStringError::InteriorNullByte
-        })
-    }
-
-    #[cfg(target_os = "windows")]
-    fn to_c_string(&self) -> Result<CString, CStringError> {
-        os_str_to_c_string_unicode(&self)
-    }
-}
-
-// Implementation for os_str_to_c_string on windows.
-#[allow(dead_code)]
-fn os_str_to_c_string_unicode(
-    os_str: &dyn AsRef<std::ffi::OsStr>,
-) -> Result<CString, CStringError> {
-    match os_str.as_ref().to_str() {
-        Some(val) => CString::new(val.as_bytes()).map_err(|err| {
-            let std::ffi::NulError { .. } = err;
-            CStringError::InteriorNullByte
-        }),
-        None => Err(CStringError::NotUnicode),
-    }
-}
-
-/// Convenience methods/associated functions for working with [CString]
-trait CStringExt {
-    /// Create a new [CString], best effort
-    ///
-    /// Like the [to_string_lossy] this doesn't give up in the face of
-    /// bad input (embedded null bytes in this case) instead it does
-    /// the best it can by stripping the embedded null bytes.
-    fn new_lossy<T: Into<Vec<u8>>>(t: T) -> CString {
-        let mut s = t.into();
-        s.retain(|&c| c != 0);
-        CString::new(s).unwrap_or_default()
-    }
-}
-
-impl CStringExt for CString {}
-
-/// Convenience methods to turn strings into C strings.
-///
-/// To interact with (legacy) C APIs we often need to convert from
-/// Rust strings to raw C strings.  This can be clumsy to do correctly
-/// and the compiler sometimes allows it in an unsafe way.  These
-/// methods make it more succinct and help you get it right.
-pub(crate) trait Strdup {
-    /// Allocate a new raw C `*char` version of this string.
-    ///
-    /// This allocates a new raw C string which must be freed using
-    /// `free`.  It takes care of some common pitfalls with using
-    /// [CString.as_ptr].
-    ///
-    /// [CString.as_ptr]: std::ffi::CString.as_ptr
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when the original string contains an
-    /// interior null byte as this can not be represented in raw C
-    /// strings.
-    unsafe fn strdup(&self) -> *mut libc::c_char;
-}
-
-impl Strdup for str {
-    unsafe fn strdup(&self) -> *mut libc::c_char {
-        let tmp = CString::new_lossy(self);
-        dc_strdup(tmp.as_ptr())
-    }
-}
-
-impl Strdup for String {
-    unsafe fn strdup(&self) -> *mut libc::c_char {
-        let s: &str = self;
-        s.strdup()
-    }
-}
-
-impl Strdup for std::path::Path {
-    unsafe fn strdup(&self) -> *mut libc::c_char {
-        let tmp = self.to_c_string().unwrap_or_else(|_| CString::default());
-        dc_strdup(tmp.as_ptr())
-    }
-}
-
-impl Strdup for [u8] {
-    unsafe fn strdup(&self) -> *mut libc::c_char {
-        let tmp = CString::new_lossy(self);
-        dc_strdup(tmp.as_ptr())
-    }
-}
-
-/// Convenience methods to turn optional strings into C strings.
-///
-/// This is the same as the [Strdup] trait but a different trait name
-/// to work around the type system not allowing to implement [Strdup]
-/// for `Option<impl Strdup>` When we already have an [Strdup] impl
-/// for `AsRef<&str>`.
-///
-/// When the [Option] is [Option::Some] this behaves just like
-/// [Strdup::strdup], when it is [Option::None] a null pointer is
-/// returned.
-pub(crate) trait OptStrdup {
-    /// Allocate a new raw C `*char` version of this string, or NULL.
-    ///
-    /// See [Strdup::strdup] for details.
-    unsafe fn strdup(&self) -> *mut libc::c_char;
-}
-
-impl<T: AsRef<str>> OptStrdup for Option<T> {
-    unsafe fn strdup(&self) -> *mut libc::c_char {
-        match self {
-            Some(s) => {
-                let tmp = CString::new_lossy(s.as_ref());
-                dc_strdup(tmp.as_ptr())
-            }
-            None => ptr::null_mut(),
-        }
-    }
-}
-
-pub(crate) fn to_string_lossy(s: *const libc::c_char) -> String {
-    if s.is_null() {
-        return "".into();
-    }
-
-    let cstr = unsafe { CStr::from_ptr(s) };
-
-    cstr.to_string_lossy().to_string()
-}
-
-pub(crate) fn to_opt_string_lossy(s: *const libc::c_char) -> Option<String> {
-    if s.is_null() {
-        return None;
-    }
-
-    Some(to_string_lossy(s))
-}
-
-/// Convert a C `*char` pointer to a [std::path::Path] slice.
-///
-/// This converts a `*libc::c_char` pointer to a [Path] slice.  This
-/// essentially has to convert the pointer to [std::ffi::OsStr] to do
-/// so and thus is the inverse of [OsStrExt::to_c_string].  Just like
-/// [OsStrExt::to_c_string] requires valid Unicode on Windows, this
-/// requires that the pointer contains valid UTF-8 on Windows.
-///
-/// Because this returns a reference the [Path] slice can not outlive
-/// the original pointer.
-///
-/// [Path]: std::path::Path
-#[cfg(not(target_os = "windows"))]
-pub(crate) fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    assert!(!s.is_null(), "cannot be used on null pointers");
-    use std::os::unix::ffi::OsStrExt;
-    unsafe {
-        let c_str = std::ffi::CStr::from_ptr(s).to_bytes();
-        let os_str = std::ffi::OsStr::from_bytes(c_str);
-        std::path::Path::new(os_str)
-    }
-}
-
-// as_path() implementation for windows, documented above.
-#[cfg(target_os = "windows")]
-pub(crate) fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    as_path_unicode(s)
-}
-
-// Implementation for as_path() on Windows.
-//
-// Having this as a separate function means it can be tested on unix
-// too.
-#[allow(dead_code)]
-fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    assert!(!s.is_null(), "cannot be used on null pointers");
-
-    let cstr = unsafe { CStr::from_ptr(s) };
-    let str = cstr.to_str().unwrap_or_else(|err| panic!("{}", err));
-
-    std::path::Path::new(str)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use libc::{free, strcmp};
-
-    #[test]
-    fn test_os_str_to_c_string_cwd() {
-        let some_dir = std::env::current_dir().unwrap();
-        some_dir.as_os_str().to_c_string().unwrap();
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_unicode() {
-        let some_str = String::from("/some/valid/utf8");
-        let some_dir = std::path::Path::new(&some_str);
-        assert_eq!(
-            some_dir.as_os_str().to_c_string().unwrap(),
-            CString::new("/some/valid/utf8").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_nul() {
-        let some_str = std::ffi::OsString::from("foo\x00bar");
-        assert_eq!(
-            some_str.to_c_string().err().unwrap(),
-            CStringError::InteriorNullByte
-        )
-    }
-
-    #[test]
-    fn test_path_to_c_string_cwd() {
-        let some_dir = std::env::current_dir().unwrap();
-        some_dir.to_c_string().unwrap();
-    }
-
-    #[test]
-    fn test_path_to_c_string_unicode() {
-        let some_str = String::from("/some/valid/utf8");
-        let some_dir = std::path::Path::new(&some_str);
-        assert_eq!(
-            some_dir.as_os_str().to_c_string().unwrap(),
-            CString::new("/some/valid/utf8").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_unicode_fn() {
-        let some_str = std::ffi::OsString::from("foo");
-        assert_eq!(
-            os_str_to_c_string_unicode(&some_str).unwrap(),
-            CString::new("foo").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_path_to_c_string_unicode_fn() {
-        let some_str = String::from("/some/path");
-        let some_path = std::path::Path::new(&some_str);
-        assert_eq!(
-            os_str_to_c_string_unicode(&some_path).unwrap(),
-            CString::new("/some/path").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_unicode_fn_nul() {
-        let some_str = std::ffi::OsString::from("fooz\x00bar");
-        assert_eq!(
-            os_str_to_c_string_unicode(&some_str).err().unwrap(),
-            CStringError::InteriorNullByte
-        );
-    }
-
-    #[test]
-    fn test_as_path() {
-        let some_path = CString::new("/some/path").unwrap();
-        let ptr = some_path.as_ptr();
-        assert_eq!(as_path(ptr), std::ffi::OsString::from("/some/path"))
-    }
-
-    #[test]
-    fn test_as_path_unicode_fn() {
-        let some_path = CString::new("/some/path").unwrap();
-        let ptr = some_path.as_ptr();
-        assert_eq!(as_path_unicode(ptr), std::ffi::OsString::from("/some/path"));
-    }
-
-    #[test]
-    fn test_cstring_new_lossy() {
-        assert!(CString::new("hel\x00lo").is_err());
-        assert!(CString::new(String::from("hel\x00o")).is_err());
-        let r = CString::new("hello").unwrap();
-        assert_eq!(CString::new_lossy("hello"), r);
-        assert_eq!(CString::new_lossy("hel\x00lo"), r);
-        assert_eq!(CString::new_lossy(String::from("hello")), r);
-        assert_eq!(CString::new_lossy(String::from("hel\x00lo")), r);
-    }
-
-    #[test]
-    fn test_strdup_str() {
-        unsafe {
-            let s = "hello".strdup();
-            let cmp = strcmp(s, b"hello\x00" as *const u8 as *const libc::c_char);
-            free(s as *mut libc::c_void);
-            assert_eq!(cmp, 0);
-        }
-    }
-
-    #[test]
-    fn test_strdup_string() {
-        unsafe {
-            let s = String::from("hello").strdup();
-            let cmp = strcmp(s, b"hello\x00" as *const u8 as *const libc::c_char);
-            free(s as *mut libc::c_void);
-            assert_eq!(cmp, 0);
-        }
-    }
-
-    #[test]
-    fn test_strdup_opt_string() {
-        unsafe {
-            let s = Some("hello");
-            let c = s.strdup();
-            let cmp = strcmp(c, b"hello\x00" as *const u8 as *const libc::c_char);
-            free(c as *mut libc::c_void);
-            assert_eq!(cmp, 0);
-
-            let s: Option<&str> = None;
-            let c = s.strdup();
-            assert_eq!(c, ptr::null_mut());
-        }
-    }
-}

deltachat_derive/Cargo.toml

@@ -1,13 +1,12 @@
 [package]
 name = "deltachat_derive"
-version = "2.0.0"
-authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
+version = "0.1.0"
+authors = ["Dmitry Bogatov <KAction@debian.org>"]
 edition = "2018"
-license = "MPL-2.0"
 
 [lib]
 proc-macro = true
 
 [dependencies]
-syn = "1"
-quote = "1"
+syn = "0.14.4"
+quote = "0.6.3"

deltachat_derive/src/lib.rs

@@ -3,6 +3,7 @@ extern crate proc_macro;
 
 use crate::proc_macro::TokenStream;
 use quote::quote;
+use syn;
 
 // For now, assume (not check) that these macroses are applied to enum without
 // data.  If this assumption is violated, compiler error will point to
@@ -35,11 +36,7 @@ pub fn from_sql_derive(input: TokenStream) -> TokenStream {
         impl rusqlite::types::FromSql for #name {
             fn column_result(col: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
                 let inner = rusqlite::types::FromSql::column_result(col)?;
-                if let Some(value) = num_traits::FromPrimitive::from_i64(inner) {
-                    Ok(value)
-                } else {
-                    Err(rusqlite::types::FromSqlError::OutOfRange(inner))
-                }
+                Ok(num_traits::FromPrimitive::from_i64(inner).unwrap_or_default())
             }
         }
     };

draft/aeap-mvp.rst

@@ -1,33 +0,0 @@
-AEAP MVP
-========
-
-Changes to the UIs
-------------------
-
-- The secondary self addresses (see below) are shown in the UI, but not editable.
-
-- When the user changed the email address in the configure screen, show a dialog to the user, either directly explaining things or with a link to the FAQ (see "Other" below)
-
-Changes in the core
--------------------
-
-- We have one primary self address and any number of secondary self addresses. `is_self_addr()` checks all of them.
-
-- If the user does a reconfigure and changes the email address, the previous address is added as a secondary self address.
-
-  - don't forget to deduplicate secondary self addresses in case the user switches back and forth between addresses).
-
-  - The key stays the same.
-
-- No changes for 1:1 chats, there simply is a new one
-
-- When we send a message to a group, and the primary address is not a member of a group, but a secondary address is:
-  
-  Add Chat-Group-Member-Removed=<old address> and Chat-Group-Member-Added=<new address> headers to this message
-
-  - On the receiving side, make sure that we accept this (even in verified groups) if the message is signed and the key stayed the same
-
-Other
------
-
-- The user is responsible that messages to the old address arrive at the new address, for example by configuring the old provider to forward all emails to the new one.

draft/group-sync.rst

@@ -1,111 +0,0 @@
-
-Problem: missing eventual group consistency
---------------------------------------------
-
-If group members are concurrently adding new members,
-the new members will miss each other's additions, example:
-
-1. Alice and Bob are in a two-member group
-
-2. Then Alice adds Carol, while concurrently Bob adds Doris
-
-Right now, the group has inconsistent memberships:
-
-- Alice and Carol see a (Alice, Carol, Bob) group
-
-- Bob and Doris see a (Bob, Doris, Alice)
-
-This then leads to "sender is unknown" messages in the chat,
-for example when Alice receives a message from Doris,
-or when Bob receives a message from Carol.
-
-There are also other sources for group membership inconsistency:
-
-- leaving/deleting/adding in larger groups, while being offline,
-  increases chances for inconsistent group membership
-
-- dropped group-membership messages
-
-- group-membership messages landing in "Spam"
-
-
-Note that all these problems (can) also happen with verified groups,
-then raising "false alarms" which could lure people to ignore such issues.
-
-IOW, it's clear we need to do something about it to improve overall
-reliability in group-settings.
-
-
-
-Solution: replay group modification messages on inconsistencies
-------------------------------------------------------------------
-
-For brevity let's abbreviate "group membership modification" as **GMM**.
-
-Delta chat has explicit GMM messages, typically encrypted to the group members
-as seen by the device that sends the GMM. The `Spec <https://github.com/deltachat/deltachat-core-rust/blob/master/spec.md#add-and-remove-members>`_ details the Mime headers and format.
-
-If we detect membership inconsistencies we can resend relevant GMM messages
-to the respective chat.  The receiving devices can process those GMM messages
-as if it would be an incoming message. If for example they have already seen
-the Message-ID of the GMM message, they will ignore the message. It's
-probably useful to record GMM message in their original MIME-format and
-not invent a new recording format. Few notes on three aspects:
-
-- **group-membership-tracking**: All valid GMM messages are persisted in
-  their full raw (signed/encrypted?) MIME-format in the DB. Note that GMM messages
-  already are in the msgs table, and there is a mime_header column which we could
-  extend to contain the raw Mime GMM message.
-
-- **consistency_checking**: If an incoming GMM has a member list which is
-  not consistent with our own view, broadcast a "Group-Member-Correction"
-  message to all members containing a multipart list of GMMs.
-
-- **correcting_memberships**: Upon receiving a Group-Member-Correction
-  message we pass the contained GMMs to the "incoming mail pipeline"
-  (without **consistency_checking** them, to avoid recursion issues)
-
-
-Alice/Carol and Bob/Doris getting on the same page
-++++++++++++++++++++++++++++++++++++++++++++++++++
-
-Recall that Alice/Carol and Bob/Doris had a differening view of
-group membership. With the proposed solution, when Bob receives
-Alice's "Carol added" message, he will notice that Alice (and thus
-also carol) did not know about Doris.  Bob's device sends a
-"Chat-Group-Member-Correction" message containing his own GMM
-when adding Doris. Therefore, the group's membership is healed
-for everyone in a single broadcast message.
-
-Alice might also send a Group-member-Correction message,
-so there is a second chance that the group gets to know all GMMs.
-
-Note, for example, that if for some reason Bobs and Carols provider
-drop GMM messages between them (spam) that Alice and Doris can heal
-it by resending GMM messages whenever they detect them to be out of sync.
-
-
-Discussions of variants
-++++++++++++++++++++++++
-
-- instead of acting on GMM messages we could send corrections
-  for any received message that addresses inconsistent group members but
-  a) this could delay group-membership healing
-  b) could lead to a lot of members sending corrections
-  c) means we might rely on "To-Addresses" which we also like to strike
-     at least for protected chats.
-
-- instead of broadcasting correction messages we could only send it to
-  the sender of the inconsistent member-added/removed message.
-  A receiver of such a correction message would then need to forward
-  the message to the members it thinks also have an inconsistent view.
-  This sounds complicated and error-prone.  Concretely, if Alice
-  receives Bob's "Member-added: Doris" message, then Alice
-  broadcasting the correction message with "Member-added: Carol"
-  would reach all four members, healing group consistency in one step.
-  If Bob meanwhile receives Alice's "Member-Added: Carol" message,
-  Bob would broadcast a correction message to all four members as well.
-  (Imagine a situation where Alice/Bob added Carol/Doris
-  while both being in an offline or bad-connection situation).
-
-

draft/msgwork_new_imap_jobs.rst

@@ -1,66 +0,0 @@
-
-simplify/streamline mark-seen/delete/move/send-mdn job handling
----------------------------------------------------------------
-
-Idea: Introduce a new "msgwork" sql table that looks very
-much like the jobs table but has a primary key "msgid"
-and no job id and no foreign-id anymore. This opens up
-bulk-processing by looking at the whole table and combining
-flag-setting to reduce imap-roundtrips and select-folder calls.
-
-Concretely, these IMAP jobs:
-
-    DeleteMsgOnImap
-    MarkseenMsgOnImap
-    MoveMsg
-
-Would be replaced by a few per-message columns in the new msgwork table:
-
-- needs_mark_seen: (bool) message shall be marked as seen on imap
-- needs_to_move: (bool) message should be moved to mvbox_folder
-- deletion_time: (target_time or 0) message shall be deleted at specified time
-- needs_send_mdn: (bool) MDN shall be sent
-
-The various places that currently add the (replaced) jobs
-would now add/modify the respective message record in the message-work table.
-
-Looking at a single message-work entry conceptually looks like this::
-
-    if msg.server_uid==0:
-        return RetryLater  # nothing can be done without server_uid
-
-    if msg.deletion_time > current_time:
-        imap.mark_delete(msg)  # might trigger early exit with a RetryLater/Failed
-        clear(needs_deletion)
-        clear(mark_seen)
-
-    if needs_mark_seen:
-        imap.mark_seen(msg)    # might trigger early exit with a RetryLater/Failed
-        clear(needs_mark_seen)
-
-    if needs_send_mdn:
-        schedule_smtp_send_mdn(msg)
-        clear(needs_send_mdn)
-
-    if any_flag_set():
-        retrylater
-    # remove msgwork entry from table
-
-
-Notes/Questions:
-
-- it's unclear how much we need per-message retry-time tracking/backoff
-
-- drafting bulk processing algo is useful before
-  going for the implementation, i.e. including select_folder calls etc.
-
-- maybe it's better to not have bools for the flags but
-
-  0 (no change)
-  1 (set the imap flag)
-  2 (clear the imap flag)
-
-  and design such that we can cover all imap flags.
-
-- It might not be neccessary to keep needs_send_mdn state in this table
-  if this can be decided rather when we succeed with mark_seen/mark_delete.

draft/webxdc-dev-reference.md

@@ -1,198 +0,0 @@
-# Webxdc Developer Reference
-
-(This document may eventually be merged with the [webxdc guidebook](https://deltachat.github.io/webxdc_docs/), where you may currently find other useful information.)
-
-## Webxdc File Format
-
-- a **Webxdc** is a **ZIP-file** with the extension `.xdc`
-- the ZIP-file must use the default compression methods as of RFC 1950,
-  this is "Deflate" or "Store"
-- the ZIP-file must contain at least the file `index.html`
-- if the Webxdc is started, `index.html` is opened in a restricted webview
-  that allow accessing resources only from the ZIP-file
-
-
-## Webxdc API
-
-There are some additional APIs available once `webxdc.js` is included
-(the file will be provided by the concrete implementations,
-no need to add `webxdc.js` to your ZIP-file):
-
-```html
-<script src="webxdc.js"></script>
-```
-
-### sendUpdate()
-
-```js
-window.webxdc.sendUpdate(update, descr);
-```
-
-A Webxdc is usually shared in a chat and run independently on each peer.
-To get a shared state, the peers use `sendUpdate()` to send updates to each other.
-
-- `update`: an object with the following properties:  
-    - `update.payload`: any javascript primitive, array or object.
-    - `update.info`: optional, short, informational message that will be added to the chat,
-       eg. "Alice voted" or "Bob scored 123 in MyGame";
-       usually only one line of text is shown,
-       use this option sparingly to not spam the chat.
-    - `update.document`: optional, name of the document in edit,
-       must not be used eg. in games where the Webxdc does not create documents
-    - `update.summary`: optional, short text, shown beside Webxdc icon;
-       it is recommended to use some aggregated value,  eg. "8 votes", "Highscore: 123"
-
-- `descr`: short, human-readable description what this update is about.
-  this is shown eg. as a fallback text in an email program.
-
-All peers, including the sending one,
-will receive the update by the callback given to `setUpdateListener()`.
-
-There are situations where the user cannot send messages to a chat,
-eg. if the webxdc instance comes as a contact request or if the user has left a group.
-In these cases, you can still call `sendUpdate()`,
-however, the update won't be sent to other peers
-and you won't get the update by `setUpdateListener()`.
-
-
-### setUpdateListener()
-
-```js
-let promise = window.webxdc.setUpdateListener((update) => {}, serial);
-```
-
-With `setUpdateListener()` you define a callback that receives the updates
-sent by `sendUpdate()`. The callback is called for updates sent by you or other peers.
-The `serial` specifies the last serial that you know about (defaults to 0). 
-The returned promise resolves when the listener has processed all the update messages known at the time when  `setUpdateListener` was called. 
-
-Each `update` which is passed to the callback comes with the following properties: 
-
-- `update.payload`: equals the payload given to `sendUpdate()`
-
-- `update.serial`: the serial number of this update.
-  Serials are larger `0` and newer serials have higher numbers.
-  There may be gaps in the serials
-  and it is not guaranteed that the next serial is exactly incremented by one.
-
-- `update.max_serial`: the maximum serial currently known.
-  If `max_serial` equals `serial` this update is the last update (until new network messages arrive).
-
-- `update.info`: optional, short, informational message (see `sendUpdate()`)
-
-- `update.document`: optional, document name as set by the sender, (see `sendUpdate()`),
-  implementations show the document name eg. beside the app icon or in the title bar
-
-- `update.summary`: optional, short text, shown beside icon (see `sendUpdate()`)
-
-
-### selfAddr
-
-```js
-window.webxdc.selfAddr
-```
-
-Property with the peer's own address.
-This is esp. useful if you want to differ between different peers -
-just send the address along with the payload,
-and, if needed, compare the payload addresses against selfAddr() later on.
-
-
-### selfName
-
-```js
-window.webxdc.selfName
-```
-
-Property with the peer's own name.
-This is name chosen by the user in their settings,
-if there is nothing set, that defaults to the peer's address.
-
-
-## manifest.toml
-
-If the ZIP-file contains a `manifest.toml` in its root directory,
-some basic information are read and used from there.
-
-the `manifest.toml` has the following format
-
-```toml
-name = "My Name"
-source_code_url = "https://example.org/orga/repo"
-```
-
-- `name` - The name of the Webxdc.
-  If no name is set or if there is no manifest, the filename is used as the Webxdc name.
-
-- `source_code_url` - Optional URL where the source code of the Webxdc and maybe other information can be found.
-  UI may make the url accessible via a "Help" menu in the Webxdc window.
-
-
-## Webxdc Icon
-
-If the ZIP-root contains an `icon.png` or `icon.jpg`,
-these files are used as the icon for the Webxdc.
-The icon should be a square at reasonable width/height;
-round corners etc. will be added by the implementations as needed.
-If no icon is set, a default icon will be used.
-
-
-## Webxdc Examples
-
-The following example shows an input field and  every input is show on all peers.
-
-```html
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8"/>
-    <script src="webxdc.js"></script>
-  </head>
-  <body>
-    <input id="input" type="text"/>
-    <a href="" onclick="sendMsg(); return false;">Send</a>
-    <p id="output"></p>
-    <script>
-    
-      function sendMsg() {
-        msg = document.getElementById("input").value;
-        window.webxdc.sendUpdate({payload: msg}, 'Someone typed "'+msg+'".');
-      }
-    
-      function receiveUpdate(update) {
-        document.getElementById('output').innerHTML += update.payload + "<br>";
-      }
-    
-      window.webxdc.setUpdateListener(receiveUpdate, 0);
-    </script>
-  </body>
-</html>
-```
-
-[Webxdc Development Tool](https://github.com/deltachat/webxdc-dev)
-offers an **Webxdc Simulator** that can be used in many browsers without any installation needed.
-You can also use that repository as a template for your own Webxdc -
-just clone and start adapting things to your need.
-
-
-### Advanced Examples
-
-- [2048](https://github.com/adbenitez/2048.xdc)
-- [Draw](https://github.com/adbenitez/draw.xdc)
-- [Poll](https://github.com/r10s/webxdc-poll/)
-- [Tic Tac Toe](https://github.com/Simon-Laux/tictactoe.xdc)
-- Even more with [Topic #webxdc on Github](https://github.com/topics/webxdc) or in the [webxdc GitHub organization](https://github.com/webxdc)
-
-
-## Closing Remarks
-
-- older devices might not have the newest js features in their webview,
-  you may want to transpile your code down to an older js version eg. with https://babeljs.io
-- viewport and scaling features are implementation specific,
-  if you want to have an explicit behavior, you can add eg.
-  `<meta name="viewport" content="initial-scale=1; user-scalable=no">` to your Webxdc
-- the `<title>` tag should not be used and its content is usually not displayed;
-  instead, use the `name` property from `manifest.toml`
-- there are tons of ideas for enhancements of the API and the file format,
-  eg. in the future, we will may define icon- and manifest-files,
-  allow to aggregate the state or add metadata.

examples/repl/main.rs

@@ -6,118 +6,212 @@
 
 #[macro_use]
 extern crate deltachat;
+#[macro_use]
+extern crate failure;
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate rusqlite;
 
 use std::borrow::Cow::{self, Borrowed, Owned};
 use std::io::{self, Write};
+use std::path::Path;
 use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
 
-use ansi_term::Color;
-use anyhow::{bail, Error};
-use async_std::path::Path;
-use deltachat::chat::ChatId;
 use deltachat::config;
+use deltachat::configure::*;
 use deltachat::context::*;
+use deltachat::job::*;
 use deltachat::oauth2::*;
 use deltachat::securejoin::*;
-use deltachat::EventType;
-use log::{error, info, warn};
+use deltachat::Event;
 use rustyline::completion::{Completer, FilenameCompleter, Pair};
 use rustyline::config::OutputStreamType;
 use rustyline::error::ReadlineError;
 use rustyline::highlight::{Highlighter, MatchingBracketHighlighter};
 use rustyline::hint::{Hinter, HistoryHinter};
-use rustyline::validate::Validator;
 use rustyline::{
-    Cmd, CompletionType, Config, Context as RustyContext, EditMode, Editor, Helper, KeyEvent,
+    Cmd, CompletionType, Config, Context as RustyContext, EditMode, Editor, Helper, KeyPress,
 };
 
 mod cmdline;
 use self::cmdline::*;
-use deltachat::qr_code_generator::get_securejoin_qr_svg;
-use std::fs;
 
-/// Event Handler
-fn receive_event(event: EventType) {
-    let yellow = Color::Yellow.normal();
+// Event Handler
+
+fn receive_event(_context: &Context, event: Event) -> libc::uintptr_t {
     match event {
-        EventType::Info(msg) => {
+        Event::Info(msg) => {
             /* do not show the event as this would fill the screen */
-            info!("{}", msg);
+            println!("{}", msg);
         }
-        EventType::SmtpConnected(msg) => {
-            info!("[SMTP_CONNECTED] {}", msg);
+        Event::SmtpConnected(msg) => {
+            println!("[DC_EVENT_SMTP_CONNECTED] {}", msg);
         }
-        EventType::ImapConnected(msg) => {
-            info!("[IMAP_CONNECTED] {}", msg);
+        Event::ImapConnected(msg) => {
+            println!("[DC_EVENT_IMAP_CONNECTED] {}", msg);
         }
-        EventType::SmtpMessageSent(msg) => {
-            info!("[SMTP_MESSAGE_SENT] {}", msg);
+        Event::SmtpMessageSent(msg) => {
+            println!("[DC_EVENT_SMTP_MESSAGE_SENT] {}", msg);
         }
-        EventType::Warning(msg) => {
-            warn!("{}", msg);
+        Event::Warning(msg) => {
+            println!("[Warning] {}", msg);
         }
-        EventType::Error(msg) => {
-            error!("{}", msg);
+        Event::Error(msg) => {
+            println!("\x1b[31m[DC_EVENT_ERROR] {}\x1b[0m", msg);
         }
-        EventType::ErrorSelfNotInGroup(msg) => {
-            error!("[SELF_NOT_IN_GROUP] {}", msg);
+        Event::ErrorNetwork(msg) => {
+            println!("\x1b[31m[DC_EVENT_ERROR_NETWORK] msg={}\x1b[0m", msg);
         }
-        EventType::MsgsChanged { chat_id, msg_id } => {
-            info!(
-                "{}",
-                yellow.paint(format!(
-                    "Received MSGS_CHANGED(chat_id={}, msg_id={})",
-                    chat_id, msg_id,
-                ))
+        Event::ErrorSelfNotInGroup(msg) => {
+            println!("\x1b[31m[DC_EVENT_ERROR_SELF_NOT_IN_GROUP] {}\x1b[0m", msg);
+        }
+        Event::MsgsChanged { chat_id, msg_id } => {
+            print!(
+                "\x1b[33m{{Received DC_EVENT_MSGS_CHANGED(chat_id={}, msg_id={})}}\n\x1b[0m",
+                chat_id, msg_id,
             );
         }
-        EventType::ContactsChanged(_) => {
-            info!("{}", yellow.paint("Received CONTACTS_CHANGED()"));
+        Event::ContactsChanged(_) => {
+            print!("\x1b[33m{{Received DC_EVENT_CONTACTS_CHANGED()}}\n\x1b[0m");
         }
-        EventType::LocationChanged(contact) => {
-            info!(
-                "{}",
-                yellow.paint(format!("Received LOCATION_CHANGED(contact={:?})", contact))
+        Event::LocationChanged(contact) => {
+            print!(
+                "\x1b[33m{{Received DC_EVENT_LOCATION_CHANGED(contact={:?})}}\n\x1b[0m",
+                contact,
             );
         }
-        EventType::ConfigureProgress { progress, comment } => {
-            if let Some(comment) = comment {
-                info!(
-                    "{}",
-                    yellow.paint(format!(
-                        "Received CONFIGURE_PROGRESS({} ‰, {})",
-                        progress, comment
-                    ))
-                );
-            } else {
-                info!(
-                    "{}",
-                    yellow.paint(format!("Received CONFIGURE_PROGRESS({} ‰)", progress))
-                );
-            }
-        }
-        EventType::ImexProgress(progress) => {
-            info!(
-                "{}",
-                yellow.paint(format!("Received IMEX_PROGRESS({} ‰)", progress))
+        Event::ConfigureProgress(progress) => {
+            print!(
+                "\x1b[33m{{Received DC_EVENT_CONFIGURE_PROGRESS({} ‰)}}\n\x1b[0m",
+                progress,
             );
         }
-        EventType::ImexFileWritten(file) => {
-            info!(
-                "{}",
-                yellow.paint(format!("Received IMEX_FILE_WRITTEN({})", file.display()))
+        Event::ImexProgress(progress) => {
+            print!(
+                "\x1b[33m{{Received DC_EVENT_IMEX_PROGRESS({} ‰)}}\n\x1b[0m",
+                progress,
             );
         }
-        EventType::ChatModified(chat) => {
-            info!(
-                "{}",
-                yellow.paint(format!("Received CHAT_MODIFIED({})", chat))
+        Event::ImexFileWritten(file) => {
+            print!(
+                "\x1b[33m{{Received DC_EVENT_IMEX_FILE_WRITTEN({})}}\n\x1b[0m",
+                file.display()
+            );
+        }
+        Event::ChatModified(chat) => {
+            print!(
+                "\x1b[33m{{Received DC_EVENT_CHAT_MODIFIED({})}}\n\x1b[0m",
+                chat
             );
         }
         _ => {
-            info!("Received {:?}", event);
+            print!("\x1b[33m{{Received {:?}}}\n\x1b[0m", event);
         }
     }
+
+    0
+}
+
+// Threads for waiting for messages and for jobs
+
+lazy_static! {
+    static ref HANDLE: Arc<Mutex<Option<Handle>>> = Arc::new(Mutex::new(None));
+    static ref IS_RUNNING: AtomicBool = AtomicBool::new(true);
+}
+
+struct Handle {
+    handle_imap: Option<std::thread::JoinHandle<()>>,
+    handle_mvbox: Option<std::thread::JoinHandle<()>>,
+    handle_sentbox: Option<std::thread::JoinHandle<()>>,
+    handle_smtp: Option<std::thread::JoinHandle<()>>,
+}
+
+macro_rules! while_running {
+    ($code:block) => {
+        if IS_RUNNING.load(Ordering::Relaxed) {
+            $code
+        } else {
+            break;
+        }
+    };
+}
+
+fn start_threads(c: Arc<RwLock<Context>>) {
+    if HANDLE.clone().lock().unwrap().is_some() {
+        return;
+    }
+
+    println!("Starting threads");
+    IS_RUNNING.store(true, Ordering::Relaxed);
+
+    let ctx = c.clone();
+    let handle_imap = std::thread::spawn(move || loop {
+        while_running!({
+            perform_imap_jobs(&ctx.read().unwrap());
+            perform_imap_fetch(&ctx.read().unwrap());
+            while_running!({
+                let context = ctx.read().unwrap();
+                perform_imap_idle(&context);
+            });
+        });
+    });
+
+    let ctx = c.clone();
+    let handle_mvbox = std::thread::spawn(move || loop {
+        while_running!({
+            perform_mvbox_fetch(&ctx.read().unwrap());
+            while_running!({
+                perform_mvbox_idle(&ctx.read().unwrap());
+            });
+        });
+    });
+
+    let ctx = c.clone();
+    let handle_sentbox = std::thread::spawn(move || loop {
+        while_running!({
+            perform_sentbox_fetch(&ctx.read().unwrap());
+            while_running!({
+                perform_sentbox_idle(&ctx.read().unwrap());
+            });
+        });
+    });
+
+    let ctx = c;
+    let handle_smtp = std::thread::spawn(move || loop {
+        while_running!({
+            perform_smtp_jobs(&ctx.read().unwrap());
+            while_running!({
+                perform_smtp_idle(&ctx.read().unwrap());
+            });
+        });
+    });
+
+    *HANDLE.clone().lock().unwrap() = Some(Handle {
+        handle_imap: Some(handle_imap),
+        handle_mvbox: Some(handle_mvbox),
+        handle_sentbox: Some(handle_sentbox),
+        handle_smtp: Some(handle_smtp),
+    });
+}
+
+fn stop_threads(context: &Context) {
+    if let Some(ref mut handle) = *HANDLE.clone().lock().unwrap() {
+        println!("Stopping threads");
+        IS_RUNNING.store(false, Ordering::Relaxed);
+
+        interrupt_imap_idle(context);
+        interrupt_mvbox_idle(context);
+        interrupt_sentbox_idle(context);
+        interrupt_smtp_idle(context);
+
+        handle.handle_imap.take().unwrap().join().unwrap();
+        handle.handle_mvbox.take().unwrap().join().unwrap();
+        handle.handle_sentbox.take().unwrap().join().unwrap();
+        handle.handle_smtp.take().unwrap().join().unwrap();
+    }
 }
 
 // === The main loop
@@ -141,7 +235,7 @@ impl Completer for DcHelper {
     }
 }
 
-const IMEX_COMMANDS: [&str; 12] = [
+const IMEX_COMMANDS: [&'static str; 12] = [
     "initiate-key-transfer",
     "get-setupcodebegin",
     "continue-key-transfer",
@@ -156,27 +250,28 @@ const IMEX_COMMANDS: [&str; 12] = [
     "stop",
 ];
 
-const DB_COMMANDS: [&str; 10] = [
+const DB_COMMANDS: [&'static str; 11] = [
     "info",
+    "open",
+    "close",
     "set",
     "get",
     "oauth2",
     "configure",
     "connect",
     "disconnect",
-    "connectivity",
     "maybenetwork",
     "housekeeping",
 ];
 
-const CHAT_COMMANDS: [&str; 36] = [
+const CHAT_COMMANDS: [&'static str; 24] = [
     "listchats",
     "listarchived",
     "chat",
     "createchat",
+    "createchatbymsg",
     "creategroup",
-    "createbroadcast",
-    "createprotected",
+    "createverified",
     "addmember",
     "removemember",
     "groupname",
@@ -189,63 +284,36 @@ const CHAT_COMMANDS: [&str; 36] = [
     "send",
     "sendimage",
     "sendfile",
-    "sendhtml",
-    "sendsyncmsg",
-    "sendupdate",
-    "videochat",
     "draft",
     "listmedia",
     "archive",
     "unarchive",
-    "pin",
-    "unpin",
-    "mute",
-    "unmute",
-    "protect",
-    "unprotect",
     "delchat",
-    "accept",
-    "blockchat",
 ];
-const MESSAGE_COMMANDS: [&str; 8] = [
+const MESSAGE_COMMANDS: [&'static str; 8] = [
     "listmsgs",
     "msginfo",
     "listfresh",
     "forward",
-    "resend",
     "markseen",
+    "star",
+    "unstar",
     "delmsg",
-    "download",
 ];
-const CONTACT_COMMANDS: [&str; 9] = [
+const CONTACT_COMMANDS: [&'static str; 6] = [
     "listcontacts",
     "listverified",
     "addcontact",
     "contactinfo",
     "delcontact",
     "cleanupcontacts",
-    "block",
-    "unblock",
-    "listblocked",
 ];
-const MISC_COMMANDS: [&str; 11] = [
-    "getqr",
-    "getqrsvg",
-    "getbadqr",
-    "checkqr",
-    "joinqr",
-    "fileinfo",
-    "clear",
-    "exit",
-    "quit",
-    "help",
-    "estimatedeletion",
+const MISC_COMMANDS: [&'static str; 9] = [
+    "getqr", "getbadqr", "checkqr", "event", "fileinfo", "clear", "exit", "quit", "help",
 ];
 
 impl Hinter for DcHelper {
-    type Hint = String;
-
-    fn hint(&self, line: &str, pos: usize, ctx: &RustyContext<'_>) -> Option<Self::Hint> {
+    fn hint(&self, line: &str, pos: usize, ctx: &RustyContext<'_>) -> Option<String> {
         if !line.is_empty() {
             for &cmds in &[
                 &IMEX_COMMANDS[..],
@@ -266,11 +334,12 @@ impl Hinter for DcHelper {
     }
 }
 
-static COLORED_PROMPT: &str = "\x1b[1;32m> \x1b[0m";
+static COLORED_PROMPT: &'static str = "\x1b[1;32m> \x1b[0m";
+static PROMPT: &'static str = "> ";
 
 impl Highlighter for DcHelper {
-    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(&self, prompt: &'p str, default: bool) -> Cow<'b, str> {
-        if default {
+    fn highlight_prompt<'p>(&self, prompt: &'p str) -> Cow<'p, str> {
+        if prompt == PROMPT {
             Borrowed(COLORED_PROMPT)
         } else {
             Borrowed(prompt)
@@ -291,83 +360,70 @@ impl Highlighter for DcHelper {
 }
 
 impl Helper for DcHelper {}
-impl Validator for DcHelper {}
 
-async fn start(args: Vec<String>) -> Result<(), Error> {
+fn main_0(args: Vec<String>) -> Result<(), failure::Error> {
     if args.len() < 2 {
         println!("Error: Bad arguments, expected [db-name].");
-        bail!("No db-name specified");
+        return Err(format_err!("No db-name specified"));
     }
-    let context = Context::new(Path::new(&args[1]).to_path_buf(), 0).await?;
-
-    let events = context.get_event_emitter();
-    async_std::task::spawn(async move {
-        while let Some(event) = events.recv().await {
-            receive_event(event.typ);
-        }
-    });
+    let context = Context::new(
+        Box::new(receive_event),
+        "CLI".into(),
+        Path::new(&args[1]).to_path_buf(),
+    )?;
 
     println!("Delta Chat Core is awaiting your commands.");
 
+    let ctx = Arc::new(RwLock::new(context));
+
     let config = Config::builder()
         .history_ignore_space(true)
         .completion_type(CompletionType::List)
         .edit_mode(EditMode::Emacs)
         .output_stream(OutputStreamType::Stdout)
         .build();
-    let mut selected_chat = ChatId::default();
-    let (reader_s, reader_r) = async_std::channel::bounded(100);
-    let input_loop = async_std::task::spawn_blocking(move || {
-        let h = DcHelper {
-            completer: FilenameCompleter::new(),
-            highlighter: MatchingBracketHighlighter::new(),
-            hinter: HistoryHinter {},
-        };
-        let mut rl = Editor::with_config(config);
-        rl.set_helper(Some(h));
-        rl.bind_sequence(KeyEvent::alt('N'), Cmd::HistorySearchForward);
-        rl.bind_sequence(KeyEvent::alt('P'), Cmd::HistorySearchBackward);
-        if rl.load_history(".dc-history.txt").is_err() {
-            println!("No previous history.");
-        }
+    let h = DcHelper {
+        completer: FilenameCompleter::new(),
+        highlighter: MatchingBracketHighlighter::new(),
+        hinter: HistoryHinter {},
+    };
+    let mut rl = Editor::with_config(config);
+    rl.set_helper(Some(h));
+    rl.bind_sequence(KeyPress::Meta('N'), Cmd::HistorySearchForward);
+    rl.bind_sequence(KeyPress::Meta('P'), Cmd::HistorySearchBackward);
+    if rl.load_history(".dc-history.txt").is_err() {
+        println!("No previous history.");
+    }
 
-        loop {
-            let p = "> ";
-            let readline = rl.readline(p);
-
-            match readline {
-                Ok(line) => {
-                    // TODO: ignore "set mail_pw"
-                    rl.add_history_entry(line.as_str());
-                    async_std::task::block_on(reader_s.send(line)).unwrap();
-                }
-                Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => {
-                    println!("Exiting...");
-                    drop(reader_s);
-                    break;
-                }
-                Err(err) => {
-                    println!("Error: {}", err);
-                    drop(reader_s);
-                    break;
+    loop {
+        let p = "> ";
+        let readline = rl.readline(&p);
+        match readline {
+            Ok(line) => {
+                // TODO: ignore "set mail_pw"
+                rl.add_history_entry(line.as_str());
+                let ctx = ctx.clone();
+                match unsafe { handle_cmd(line.trim(), ctx) } {
+                    Ok(ExitResult::Continue) => {}
+                    Ok(ExitResult::Exit) => break,
+                    Err(err) => println!("Error: {}", err),
                 }
             }
-        }
-
-        rl.save_history(".dc-history.txt")?;
-        println!("history saved");
-        Ok::<_, Error>(())
-    });
-
-    while let Ok(line) = reader_r.recv().await {
-        match handle_cmd(line.trim(), context.clone(), &mut selected_chat).await {
-            Ok(ExitResult::Continue) => {}
-            Ok(ExitResult::Exit) => break,
-            Err(err) => println!("Error: {}", err),
+            Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => {
+                println!("Exiting...");
+                break;
+            }
+            Err(err) => {
+                println!("Error: {}", err);
+                break;
+            }
         }
     }
-    context.stop_io().await;
-    input_loop.await?;
+    rl.save_history(".dc-history.txt")?;
+    println!("history saved");
+    {
+        stop_threads(&ctx.read().unwrap());
+    }
 
     Ok(())
 }
@@ -378,29 +434,43 @@ enum ExitResult {
     Exit,
 }
 
-async fn handle_cmd(
-    line: &str,
-    ctx: Context,
-    selected_chat: &mut ChatId,
-) -> Result<ExitResult, Error> {
+unsafe fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult, failure::Error> {
     let mut args = line.splitn(2, ' ');
     let arg0 = args.next().unwrap_or_default();
     let arg1 = args.next().unwrap_or_default();
 
     match arg0 {
         "connect" => {
-            ctx.start_io().await;
+            start_threads(ctx);
         }
         "disconnect" => {
-            ctx.stop_io().await;
+            stop_threads(&ctx.read().unwrap());
+        }
+        "smtp-jobs" => {
+            if HANDLE.clone().lock().unwrap().is_some() {
+                println!("smtp-jobs are already running in a thread.",);
+            } else {
+                perform_smtp_jobs(&ctx.read().unwrap());
+            }
+        }
+        "imap-jobs" => {
+            if HANDLE.clone().lock().unwrap().is_some() {
+                println!("imap-jobs are already running in a thread.");
+            } else {
+                perform_imap_jobs(&ctx.read().unwrap());
+            }
         }
         "configure" => {
-            ctx.configure().await?;
+            start_threads(ctx.clone());
+            configure(&ctx.read().unwrap());
         }
         "oauth2" => {
-            if let Some(addr) = ctx.get_config(config::Config::Addr).await? {
-                let oauth2_url =
-                    dc_get_oauth2_url(&ctx, &addr, "chat.delta:/com.b44t.messenger").await?;
+            if let Some(addr) = ctx.read().unwrap().get_config(config::Config::Addr) {
+                let oauth2_url = dc_get_oauth2_url(
+                    &ctx.read().unwrap(),
+                    &addr,
+                    "chat.delta:/com.b44t.messenger",
+                );
                 if oauth2_url.is_none() {
                     println!("OAuth2 not available for {}.", &addr);
                 } else {
@@ -415,54 +485,42 @@ async fn handle_cmd(
             print!("\x1b[1;1H\x1b[2J");
         }
         "getqr" | "getbadqr" => {
-            ctx.start_io().await;
-            let group = arg1.parse::<u32>().ok().map(ChatId::new);
-            let mut qr = dc_get_securejoin_qr(&ctx, group).await?;
-            if !qr.is_empty() {
-                if arg0 == "getbadqr" && qr.len() > 40 {
-                    qr.replace_range(12..22, "0000000000")
-                }
-                println!("{}", qr);
-                let output = Command::new("qrencode")
-                    .args(&["-t", "ansiutf8", qr.as_str(), "-o", "-"])
-                    .output()
-                    .expect("failed to execute process");
-                io::stdout().write_all(&output.stdout).unwrap();
-                io::stderr().write_all(&output.stderr).unwrap();
-            }
-        }
-        "getqrsvg" => {
-            ctx.start_io().await;
-            let group = arg1.parse::<u32>().ok().map(ChatId::new);
-            let file = dirs::home_dir().unwrap_or_default().join("qr.svg");
-            match get_securejoin_qr_svg(&ctx, group).await {
-                Ok(svg) => {
-                    fs::write(&file, svg)?;
-                    println!("QR code svg written to: {:#?}", file);
-                }
-                Err(err) => {
-                    bail!("Failed to get QR code svg: {}", err);
+            start_threads(ctx.clone());
+            if let Some(mut qr) =
+                dc_get_securejoin_qr(&ctx.read().unwrap(), arg1.parse().unwrap_or_default())
+            {
+                if !qr.is_empty() {
+                    if arg0 == "getbadqr" && qr.len() > 40 {
+                        qr.replace_range(12..22, "0000000000")
+                    }
+                    println!("{}", qr);
+                    let output = Command::new("qrencode")
+                        .args(&["-t", "ansiutf8", qr.as_str(), "-o", "-"])
+                        .output()
+                        .expect("failed to execute process");
+                    io::stdout().write_all(&output.stdout).unwrap();
+                    io::stderr().write_all(&output.stderr).unwrap();
                 }
             }
         }
         "joinqr" => {
-            ctx.start_io().await;
+            start_threads(ctx.clone());
             if !arg0.is_empty() {
-                dc_join_securejoin(&ctx, arg1).await?;
+                dc_join_securejoin(&ctx.read().unwrap(), arg1);
             }
         }
         "exit" | "quit" => return Ok(ExitResult::Exit),
-        _ => cmdline(ctx.clone(), line, selected_chat).await?,
+        _ => dc_cmdline(&ctx.read().unwrap(), line)?,
     }
 
     Ok(ExitResult::Continue)
 }
 
-fn main() -> Result<(), Error> {
+pub fn main() -> Result<(), failure::Error> {
     let _ = pretty_env_logger::try_init();
 
-    let args = std::env::args().collect();
-    async_std::task::block_on(async move { start(args).await })?;
+    let args: Vec<String> = std::env::args().collect();
+    main_0(args)?;
 
     Ok(())
 }

examples/simple.rs

@@ -1,100 +1,124 @@
+extern crate deltachat;
+
+use std::sync::{Arc, RwLock};
+use std::{thread, time};
 use tempfile::tempdir;
 
-use deltachat::chat::{self, ChatId};
+use deltachat::chat;
 use deltachat::chatlist::*;
 use deltachat::config;
+use deltachat::configure::*;
 use deltachat::contact::*;
 use deltachat::context::*;
-use deltachat::message::Message;
-use deltachat::EventType;
+use deltachat::job::{
+    perform_imap_fetch, perform_imap_idle, perform_imap_jobs, perform_smtp_idle, perform_smtp_jobs,
+};
+use deltachat::Event;
+
+fn cb(_ctx: &Context, event: Event) -> usize {
+    print!("[{:?}]", event);
 
-fn cb(event: EventType) {
     match event {
-        EventType::ConfigureProgress { progress, .. } => {
-            log::info!("progress: {}", progress);
+        Event::ConfigureProgress(progress) => {
+            print!("  progress: {}\n", progress);
+            0
         }
-        EventType::Info(msg) => {
-            log::info!("{}", msg);
+        Event::Info(msg) | Event::Warning(msg) | Event::Error(msg) | Event::ErrorNetwork(msg) => {
+            print!("  {}\n", msg);
+            0
         }
-        EventType::Warning(msg) => {
-            log::warn!("{}", msg);
-        }
-        EventType::Error(msg) => {
-            log::error!("{}", msg);
-        }
-        event => {
-            log::info!("{:?}", event);
+        _ => {
+            print!("\n");
+            0
         }
     }
 }
 
-/// Run with `RUST_LOG=simple=info cargo run --release --example simple --features repl -- email pw`.
-#[async_std::main]
-async fn main() {
-    pretty_env_logger::try_init_timed().ok();
-
+fn main() {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
-    log::info!("creating database {:?}", dbfile);
-    let ctx = Context::new(dbfile.into(), 0)
-        .await
-        .expect("Failed to create context");
-    let info = ctx.get_info().await;
-    log::info!("info: {:#?}", info);
+    println!("creating database {:?}", dbfile);
+    let ctx =
+        Context::new(Box::new(cb), "FakeOs".into(), dbfile).expect("Failed to create context");
+    let running = Arc::new(RwLock::new(true));
+    let info = ctx.get_info();
+    let duration = time::Duration::from_millis(4000);
+    println!("info: {:#?}", info);
 
-    let events = ctx.get_event_emitter();
-    let events_spawn = async_std::task::spawn(async move {
-        while let Some(event) = events.recv().await {
-            cb(event.typ);
+    let ctx = Arc::new(ctx);
+    let ctx1 = ctx.clone();
+    let r1 = running.clone();
+    let t1 = thread::spawn(move || {
+        while *r1.read().unwrap() {
+            perform_imap_jobs(&ctx1);
+            if *r1.read().unwrap() {
+                perform_imap_fetch(&ctx1);
+
+                if *r1.read().unwrap() {
+                    perform_imap_idle(&ctx1);
+                }
+            }
         }
     });
 
-    log::info!("configuring");
+    let ctx1 = ctx.clone();
+    let r1 = running.clone();
+    let t2 = thread::spawn(move || {
+        while *r1.read().unwrap() {
+            perform_smtp_jobs(&ctx1);
+            if *r1.read().unwrap() {
+                perform_smtp_idle(&ctx1);
+            }
+        }
+    });
+
+    println!("configuring");
     let args = std::env::args().collect::<Vec<String>>();
-    assert_eq!(args.len(), 3, "requires email password");
-    let email = args[1].clone();
-    let pw = args[2].clone();
-    ctx.set_config(config::Config::Addr, Some(&email))
-        .await
-        .unwrap();
-    ctx.set_config(config::Config::MailPw, Some(&pw))
-        .await
+    assert_eq!(args.len(), 2, "missing password");
+    let pw = args[1].clone();
+    ctx.set_config(config::Config::Addr, Some("d@testrun.org"))
         .unwrap();
+    ctx.set_config(config::Config::MailPw, Some(&pw)).unwrap();
+    configure(&ctx);
 
-    ctx.configure().await.unwrap();
+    thread::sleep(duration);
 
-    log::info!("------ RUN ------");
-    ctx.start_io().await;
-    log::info!("--- SENDING A MESSAGE ---");
+    println!("sending a message");
+    let contact_id = Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com").unwrap();
+    let chat_id = chat::create_by_contact_id(&ctx, contact_id).unwrap();
+    chat::send_text_msg(&ctx, chat_id, "Hi, here is my first message!".into()).unwrap();
 
-    let contact_id = Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com")
-        .await
-        .unwrap();
-    let chat_id = ChatId::create_for_contact(&ctx, contact_id).await.unwrap();
-
-    for i in 0..1 {
-        log::info!("sending message {}", i);
-        chat::send_text_msg(&ctx, chat_id, format!("Hi, here is my {}nth message!", i))
-            .await
-            .unwrap();
-    }
-
-    // wait for the message to be sent out
-    async_std::task::sleep(std::time::Duration::from_secs(1)).await;
-
-    log::info!("fetching chats..");
-    let chats = Chatlist::try_load(&ctx, 0, None, None).await.unwrap();
+    println!("fetching chats..");
+    let chats = Chatlist::try_load(&ctx, 0, None, None).unwrap();
 
     for i in 0..chats.len() {
-        let msg = Message::load_from_db(&ctx, chats.get_msg_id(i).unwrap().unwrap())
-            .await
-            .unwrap();
-        log::info!("[{}] msg: {:?}", i, msg);
+        let summary = chats.get_summary(&ctx, 0, None);
+        let text1 = summary.get_text1();
+        let text2 = summary.get_text2();
+        println!("chat: {} - {:?} - {:?}", i, text1, text2,);
     }
 
-    log::info!("stopping");
-    ctx.stop_io().await;
-    log::info!("closing");
-    drop(ctx);
-    events_spawn.await;
+    thread::sleep(duration);
+
+    // let msglist = dc_get_chat_msgs(&ctx, chat_id, 0, 0);
+    // for i in 0..dc_array_get_cnt(msglist) {
+    //     let msg_id = dc_array_get_id(msglist, i);
+    //     let msg = dc_get_msg(context, msg_id);
+    //     let text = CStr::from_ptr(dc_msg_get_text(msg)).unwrap();
+    //     println!("Message {}: {}\n", i + 1, text.to_str().unwrap());
+    //     dc_msg_unref(msg);
+    // }
+    // dc_array_unref(msglist);
+
+    println!("stopping threads");
+
+    *running.clone().write().unwrap() = false;
+    deltachat::job::interrupt_imap_idle(&ctx);
+    deltachat::job::interrupt_smtp_idle(&ctx);
+
+    println!("joining");
+    t1.join().unwrap();
+    t2.join().unwrap();
+
+    println!("closing");
 }

mmime/.circleci/config.yml

@@ -0,0 +1,42 @@
+# copied from http://koushiro.me/2019/04/30/Building-and-Testing-Rust-projects-on-CircleCI/
+
+version: 2.1
+jobs:
+  build:
+    docker:
+      - image: ubuntu:18.04
+
+    working_directory: ~/deltachat-core-rust
+
+    steps:
+      - checkout
+
+      - run:
+          name: Setup build environment
+          command: |
+            apt update
+            apt install -y curl build-essential autoconf libtool git python pkg-config
+            # this will pick default toolchain from `rust-toolchain` file
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --no-modify-path --default-toolchain none -y;
+            source $HOME/.cargo/env
+          no_output_timeout: 1800s
+
+      - run:
+          name: Format
+          command: |
+            export PATH=~/.cargo/bin:$PATH
+            rustup component add rustfmt
+            cargo fmt -- --check
+
+      - run:
+          name: Test
+          command: |
+            export PATH=~/.cargo/bin:$PATH
+            export RUST_BACKTRACE=1
+            cargo test
+
+workflows:
+  version: 2.1
+  build:
+    jobs:
+      - build

mmime/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "mmime"
+version = "0.1.2"
+authors = ["dignifiedquire <dignifiedquire@users.noreply.github.com>"]
+edition = "2018"
+license = "MIT OR Apache-2.0"
+homepage = "https://github.com/deltachat/deltachat-core-rust"
+repository = "https://github.com/deltachat/deltachat-core-rust"
+readme = "README.md"
+description = "Mime parsing for email"
+
+
+keywords = ["mail", "mim", "email", "imap", "smtp"]
+categories = ["std", "email"]
+
+[dependencies]
+libc = "0.2.54"
+charset = "0.1.2"
+memmap = "0.7.0"
+lazy_static = "1.3.0"
+rand = "0.6.5"
+chrono = "0.4.6"
+hex = "0.3.2"

mmime/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

mmime/LICENSE-MIT

@@ -0,0 +1,23 @@
+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.

mmime/LICENSE.md

@@ -0,0 +1,4 @@
+This library is primarly distributed under the terms of both the MIT license and
+the Apache License (Version 2.0).
+
+See LICENSE-MIT and LICENSE-APACHE for details.

mmime/README.md

@@ -0,0 +1,16 @@
+# mmime
+
+[![CircleCI build status][circle-shield]][circle] [![Appveyor build status][appveyor-shield]][appveyor] [![License][license-shield]][license]
+
+> mmmmmmime parsing
+
+Base code was compiled using c2rust from libetpan.
+
+
+
+[circle-shield]: https://img.shields.io/circleci/project/github/dignifiedquire/mmime/master.svg?style=flat-square
+[circle]: https://circleci.com/gh/dignifiedquire/mmime/
+[appveyor-shield]: https://ci.appveyor.com/api/projects/status/l26co5rba32knrlu/branch/master?style=flat-square
+[appveyor]: https://ci.appveyor.com/project/dignifiedquire/mmime/branch/master
+[license-shield]: https://img.shields.io/badge/License-MIT%2FApache2.0-green.svg?style=flat-square
+[license]: https://github.com/rpgp/rpgp/blob/master/LICENSE.md

mmime/src/charconv.rs

@@ -0,0 +1,32 @@
+use crate::other::*;
+use libc;
+use std::ffi::{CStr, CString};
+
+pub const MAIL_CHARCONV_ERROR_CONV: libc::c_uint = 3;
+pub const MAIL_CHARCONV_ERROR_MEMORY: libc::c_uint = 2;
+pub const MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET: libc::c_uint = 1;
+pub const MAIL_CHARCONV_NO_ERROR: libc::c_uint = 0;
+
+pub unsafe fn charconv(
+    tocode: *const libc::c_char,
+    fromcode: *const libc::c_char,
+    s: *const libc::c_char,
+    length: size_t,
+    result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    assert!(!fromcode.is_null(), "invalid fromcode");
+    assert!(!s.is_null(), "invalid input string");
+    if let Some(encoding) =
+        charset::Charset::for_label(CStr::from_ptr(fromcode).to_string_lossy().as_bytes())
+    {
+        let data = std::slice::from_raw_parts(s as *const u8, strlen(s));
+
+        let (res, _, _) = encoding.decode(data);
+        let res_c = CString::new(res.as_bytes()).unwrap_or_default();
+        *result = strdup(res_c.as_ptr()) as *mut _;
+
+        MAIL_CHARCONV_NO_ERROR as libc::c_int
+    } else {
+        MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET as libc::c_int
+    }
+}

mmime/src/chash.rs

@@ -0,0 +1,427 @@
+use libc;
+
+use crate::other::*;
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct chashdatum {
+    pub data: *mut libc::c_void,
+    pub len: libc::c_uint,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct chash {
+    pub size: libc::c_uint,
+    pub count: libc::c_uint,
+    pub copyvalue: libc::c_int,
+    pub copykey: libc::c_int,
+    pub cells: *mut *mut chashcell,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct chashcell {
+    pub func: libc::c_uint,
+    pub key: chashdatum,
+    pub value: chashdatum,
+    pub next: *mut chashcell,
+}
+
+pub type chashiter = chashcell;
+/* Allocates a new (empty) hash using this initial size and the given flags,
+  specifying which data should be copied in the hash.
+   CHASH_COPYNONE  : Keys/Values are not copied.
+   CHASH_COPYKEY   : Keys are dupped and freed as needed in the hash.
+   CHASH_COPYVALUE : Values are dupped and freed as needed in the hash.
+   CHASH_COPYALL   : Both keys and values are dupped in the hash.
+*/
+pub unsafe fn chash_new(mut size: libc::c_uint, mut flags: libc::c_int) -> *mut chash {
+    let mut h: *mut chash = 0 as *mut chash;
+    h = malloc(::std::mem::size_of::<chash>() as libc::size_t) as *mut chash;
+    if h.is_null() {
+        return 0 as *mut chash;
+    }
+    if size < 13i32 as libc::c_uint {
+        size = 13i32 as libc::c_uint
+    }
+    (*h).count = 0i32 as libc::c_uint;
+    (*h).cells = calloc(
+        size as libc::size_t,
+        ::std::mem::size_of::<*mut chashcell>() as libc::size_t,
+    ) as *mut *mut chashcell;
+    if (*h).cells.is_null() {
+        free(h as *mut libc::c_void);
+        return 0 as *mut chash;
+    }
+    (*h).size = size;
+    (*h).copykey = flags & 1i32;
+    (*h).copyvalue = flags & 2i32;
+    return h;
+}
+
+/* Frees a hash */
+pub unsafe fn chash_free(mut hash: *mut chash) {
+    let mut indx: libc::c_uint = 0;
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    let mut next: *mut chashiter = 0 as *mut chashiter;
+    indx = 0i32 as libc::c_uint;
+    while indx < (*hash).size {
+        iter = *(*hash).cells.offset(indx as isize);
+        while !iter.is_null() {
+            next = (*iter).next;
+            if 0 != (*hash).copykey {
+                free((*iter).key.data);
+            }
+            if 0 != (*hash).copyvalue {
+                free((*iter).value.data);
+            }
+            free(iter as *mut libc::c_void);
+            iter = next
+        }
+        indx = indx.wrapping_add(1)
+    }
+    free((*hash).cells as *mut libc::c_void);
+    free(hash as *mut libc::c_void);
+}
+
+/* Removes all elements from a hash */
+pub unsafe fn chash_clear(mut hash: *mut chash) {
+    let mut indx: libc::c_uint = 0;
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    let mut next: *mut chashiter = 0 as *mut chashiter;
+    indx = 0i32 as libc::c_uint;
+    while indx < (*hash).size {
+        iter = *(*hash).cells.offset(indx as isize);
+        while !iter.is_null() {
+            next = (*iter).next;
+            if 0 != (*hash).copykey {
+                free((*iter).key.data);
+            }
+            if 0 != (*hash).copyvalue {
+                free((*iter).value.data);
+            }
+            free(iter as *mut libc::c_void);
+            iter = next
+        }
+        indx = indx.wrapping_add(1)
+    }
+    memset(
+        (*hash).cells as *mut libc::c_void,
+        0i32,
+        ((*hash).size as libc::size_t)
+            .wrapping_mul(::std::mem::size_of::<*mut chashcell>() as libc::size_t),
+    );
+    (*hash).count = 0i32 as libc::c_uint;
+}
+/* Adds an entry in the hash table.
+Length can be 0 if key/value are strings.
+If an entry already exists for this key, it is replaced, and its value
+is returned. Otherwise, the data pointer will be NULL and the length
+field be set to TRUE or FALSe to indicate success or failure. */
+pub unsafe fn chash_set(
+    mut hash: *mut chash,
+    mut key: *mut chashdatum,
+    mut value: *mut chashdatum,
+    mut oldvalue: *mut chashdatum,
+) -> libc::c_int {
+    let mut current_block: u64;
+    let mut func: libc::c_uint = 0;
+    let mut indx: libc::c_uint = 0;
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    let mut cell: *mut chashiter = 0 as *mut chashiter;
+    let mut r: libc::c_int = 0;
+    if (*hash).count > (*hash).size.wrapping_mul(3i32 as libc::c_uint) {
+        r = chash_resize(
+            hash,
+            (*hash)
+                .count
+                .wrapping_div(3i32 as libc::c_uint)
+                .wrapping_mul(2i32 as libc::c_uint)
+                .wrapping_add(1i32 as libc::c_uint),
+        );
+        if r < 0i32 {
+            current_block = 17701753836843438419;
+        } else {
+            current_block = 7095457783677275021;
+        }
+    } else {
+        current_block = 7095457783677275021;
+    }
+    match current_block {
+        7095457783677275021 => {
+            func = chash_func((*key).data as *const libc::c_char, (*key).len);
+            indx = func.wrapping_rem((*hash).size);
+            iter = *(*hash).cells.offset(indx as isize);
+            loop {
+                if iter.is_null() {
+                    current_block = 17788412896529399552;
+                    break;
+                }
+                if (*iter).key.len == (*key).len
+                    && (*iter).func == func
+                    && 0 == memcmp((*iter).key.data, (*key).data, (*key).len as libc::size_t)
+                {
+                    /* found, replacing entry */
+                    if 0 != (*hash).copyvalue {
+                        let mut data: *mut libc::c_char = 0 as *mut libc::c_char;
+                        data = chash_dup((*value).data, (*value).len);
+                        if data.is_null() {
+                            current_block = 17701753836843438419;
+                            break;
+                        }
+                        free((*iter).value.data);
+                        (*iter).value.data = data as *mut libc::c_void;
+                        (*iter).value.len = (*value).len
+                    } else {
+                        if !oldvalue.is_null() {
+                            (*oldvalue).data = (*iter).value.data;
+                            (*oldvalue).len = (*iter).value.len
+                        }
+                        (*iter).value.data = (*value).data;
+                        (*iter).value.len = (*value).len
+                    }
+                    if 0 == (*hash).copykey {
+                        (*iter).key.data = (*key).data
+                    }
+                    if !oldvalue.is_null() {
+                        (*oldvalue).data = (*value).data;
+                        (*oldvalue).len = (*value).len
+                    }
+                    return 0i32;
+                } else {
+                    iter = (*iter).next
+                }
+            }
+            match current_block {
+                17701753836843438419 => {}
+                _ => {
+                    if !oldvalue.is_null() {
+                        (*oldvalue).data = 0 as *mut libc::c_void;
+                        (*oldvalue).len = 0i32 as libc::c_uint
+                    }
+                    cell = malloc(::std::mem::size_of::<chashcell>() as libc::size_t)
+                        as *mut chashcell;
+                    if !cell.is_null() {
+                        if 0 != (*hash).copykey {
+                            (*cell).key.data =
+                                chash_dup((*key).data, (*key).len) as *mut libc::c_void;
+                            if (*cell).key.data.is_null() {
+                                current_block = 4267898785354516004;
+                            } else {
+                                current_block = 7226443171521532240;
+                            }
+                        } else {
+                            (*cell).key.data = (*key).data;
+                            current_block = 7226443171521532240;
+                        }
+                        match current_block {
+                            7226443171521532240 => {
+                                (*cell).key.len = (*key).len;
+                                if 0 != (*hash).copyvalue {
+                                    (*cell).value.data =
+                                        chash_dup((*value).data, (*value).len) as *mut libc::c_void;
+                                    if (*cell).value.data.is_null() {
+                                        if 0 != (*hash).copykey {
+                                            free((*cell).key.data);
+                                        }
+                                        current_block = 4267898785354516004;
+                                    } else {
+                                        current_block = 6717214610478484138;
+                                    }
+                                } else {
+                                    (*cell).value.data = (*value).data;
+                                    current_block = 6717214610478484138;
+                                }
+                                match current_block {
+                                    4267898785354516004 => {}
+                                    _ => {
+                                        (*cell).value.len = (*value).len;
+                                        (*cell).func = func;
+                                        (*cell).next = *(*hash).cells.offset(indx as isize);
+                                        let ref mut fresh0 = *(*hash).cells.offset(indx as isize);
+                                        *fresh0 = cell;
+                                        (*hash).count = (*hash).count.wrapping_add(1);
+                                        return 0i32;
+                                    }
+                                }
+                            }
+                            _ => {}
+                        }
+                        free(cell as *mut libc::c_void);
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    return -1i32;
+}
+#[inline]
+unsafe fn chash_dup(mut data: *const libc::c_void, mut len: libc::c_uint) -> *mut libc::c_char {
+    let mut r: *mut libc::c_void = 0 as *mut libc::c_void;
+    r = malloc(len as libc::size_t) as *mut libc::c_char as *mut libc::c_void;
+    if r.is_null() {
+        return 0 as *mut libc::c_char;
+    }
+    memcpy(r, data, len as libc::size_t);
+    return r as *mut libc::c_char;
+}
+
+#[inline]
+unsafe fn chash_func(mut key: *const libc::c_char, mut len: libc::c_uint) -> libc::c_uint {
+    let mut c: libc::c_uint = 5381i32 as libc::c_uint;
+    let mut k: *const libc::c_char = key;
+    loop {
+        let fresh1 = len;
+        len = len.wrapping_sub(1);
+        if !(0 != fresh1) {
+            break;
+        }
+        let fresh2 = k;
+        k = k.offset(1);
+        c = (c << 5i32)
+            .wrapping_add(c)
+            .wrapping_add(*fresh2 as libc::c_uint)
+    }
+    return c;
+}
+
+/* Resizes the hash table to the passed size. */
+pub unsafe fn chash_resize(mut hash: *mut chash, mut size: libc::c_uint) -> libc::c_int {
+    let mut cells: *mut *mut chashcell = 0 as *mut *mut chashcell;
+    let mut indx: libc::c_uint = 0;
+    let mut nindx: libc::c_uint = 0;
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    let mut next: *mut chashiter = 0 as *mut chashiter;
+    if (*hash).size == size {
+        return 0i32;
+    }
+    cells = calloc(
+        size as libc::size_t,
+        ::std::mem::size_of::<*mut chashcell>() as libc::size_t,
+    ) as *mut *mut chashcell;
+    if cells.is_null() {
+        return -1i32;
+    }
+    indx = 0i32 as libc::c_uint;
+    while indx < (*hash).size {
+        iter = *(*hash).cells.offset(indx as isize);
+        while !iter.is_null() {
+            next = (*iter).next;
+            nindx = (*iter).func.wrapping_rem(size);
+            (*iter).next = *cells.offset(nindx as isize);
+            let ref mut fresh3 = *cells.offset(nindx as isize);
+            *fresh3 = iter;
+            iter = next
+        }
+        indx = indx.wrapping_add(1)
+    }
+    free((*hash).cells as *mut libc::c_void);
+    (*hash).size = size;
+    (*hash).cells = cells;
+    return 0i32;
+}
+
+/* Retrieves the data associated to the key if it is found in the hash table.
+The data pointer and the length will be NULL if not found*/
+pub unsafe fn chash_get(
+    mut hash: *mut chash,
+    mut key: *mut chashdatum,
+    mut result: *mut chashdatum,
+) -> libc::c_int {
+    let mut func: libc::c_uint = 0;
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    func = chash_func((*key).data as *const libc::c_char, (*key).len);
+    iter = *(*hash)
+        .cells
+        .offset(func.wrapping_rem((*hash).size) as isize);
+    while !iter.is_null() {
+        if (*iter).key.len == (*key).len
+            && (*iter).func == func
+            && 0 == memcmp((*iter).key.data, (*key).data, (*key).len as libc::size_t)
+        {
+            *result = (*iter).value;
+            return 0i32;
+        }
+        iter = (*iter).next
+    }
+    return -1i32;
+}
+/* Removes the entry associated to this key if it is found in the hash table,
+and returns its contents if not dupped (otherwise, pointer will be NULL
+and len TRUE). If entry is not found both pointer and len will be NULL. */
+pub unsafe fn chash_delete(
+    mut hash: *mut chash,
+    mut key: *mut chashdatum,
+    mut oldvalue: *mut chashdatum,
+) -> libc::c_int {
+    /*  chashdatum result = { NULL, TRUE }; */
+    let mut func: libc::c_uint = 0;
+    let mut indx: libc::c_uint = 0;
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    let mut old: *mut chashiter = 0 as *mut chashiter;
+    func = chash_func((*key).data as *const libc::c_char, (*key).len);
+    indx = func.wrapping_rem((*hash).size);
+    old = 0 as *mut chashiter;
+    iter = *(*hash).cells.offset(indx as isize);
+    while !iter.is_null() {
+        if (*iter).key.len == (*key).len
+            && (*iter).func == func
+            && 0 == memcmp((*iter).key.data, (*key).data, (*key).len as libc::size_t)
+        {
+            if !old.is_null() {
+                (*old).next = (*iter).next
+            } else {
+                let ref mut fresh4 = *(*hash).cells.offset(indx as isize);
+                *fresh4 = (*iter).next
+            }
+            if 0 != (*hash).copykey {
+                free((*iter).key.data);
+            }
+            if 0 != (*hash).copyvalue {
+                free((*iter).value.data);
+            } else if !oldvalue.is_null() {
+                (*oldvalue).data = (*iter).value.data;
+                (*oldvalue).len = (*iter).value.len
+            }
+            free(iter as *mut libc::c_void);
+            (*hash).count = (*hash).count.wrapping_sub(1);
+            return 0i32;
+        }
+        old = iter;
+        iter = (*iter).next
+    }
+    return -1i32;
+}
+/* Returns an iterator to the first non-empty entry of the hash table */
+pub unsafe fn chash_begin(mut hash: *mut chash) -> *mut chashiter {
+    let mut iter: *mut chashiter = 0 as *mut chashiter;
+    let mut indx: libc::c_uint = 0i32 as libc::c_uint;
+    iter = *(*hash).cells.offset(0isize);
+    while iter.is_null() {
+        indx = indx.wrapping_add(1);
+        if indx >= (*hash).size {
+            return 0 as *mut chashiter;
+        }
+        iter = *(*hash).cells.offset(indx as isize)
+    }
+    return iter;
+}
+/* Returns the next non-empty entry of the hash table */
+pub unsafe fn chash_next(mut hash: *mut chash, mut iter: *mut chashiter) -> *mut chashiter {
+    let mut indx: libc::c_uint = 0;
+    if iter.is_null() {
+        return 0 as *mut chashiter;
+    }
+    indx = (*iter).func.wrapping_rem((*hash).size);
+    iter = (*iter).next;
+    while iter.is_null() {
+        indx = indx.wrapping_add(1);
+        if indx >= (*hash).size {
+            return 0 as *mut chashiter;
+        }
+        iter = *(*hash).cells.offset(indx as isize)
+    }
+    return iter;
+}

mmime/src/clist.rs

@@ -0,0 +1,202 @@
+use libc;
+
+use crate::other::*;
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct clistcell {
+    pub data: *mut libc::c_void,
+    pub previous: *mut clistcell,
+    pub next: *mut clistcell,
+}
+
+#[derive(Clone)]
+#[repr(C)]
+pub struct clist {
+    pub first: *mut clistcell,
+    pub last: *mut clistcell,
+    pub count: libc::c_int,
+}
+
+impl Default for clist {
+    fn default() -> Self {
+        Self {
+            first: std::ptr::null_mut(),
+            last: std::ptr::null_mut(),
+            count: 0,
+        }
+    }
+}
+
+impl Drop for clist {
+    fn drop(&mut self) {
+        unsafe {
+            let mut l1 = self.first;
+            while !l1.is_null() {
+                let l2 = (*l1).next;
+                free(l1 as *mut libc::c_void);
+                l1 = l2
+            }
+        }
+    }
+}
+
+pub type clistiter = clistcell;
+pub struct CListIterator {
+    cur: *mut clistiter,
+}
+impl Iterator for CListIterator {
+    type Item = *mut libc::c_void;
+    fn next(&mut self) -> Option<Self::Item> {
+        unsafe {
+            if self.cur.is_null() {
+                None
+            } else {
+                let data = (*self.cur).data;
+                self.cur = (*self.cur).next;
+                Some(data)
+            }
+        }
+    }
+}
+
+impl IntoIterator for &clist {
+    type Item = *mut libc::c_void;
+    type IntoIter = CListIterator;
+    fn into_iter(self) -> Self::IntoIter {
+        return CListIterator { cur: self.first };
+    }
+}
+
+pub type clist_func =
+    Option<unsafe extern "C" fn(_: *mut libc::c_void, _: *mut libc::c_void) -> ()>;
+
+/* Allocate a new pointer list */
+pub fn clist_new() -> *mut clist {
+    Box::into_raw(Box::new(Default::default()))
+}
+/* Destroys a list. Data pointed by data pointers is NOT freed. */
+pub unsafe fn clist_free(mut lst: *mut clist) {
+    Box::from_raw(lst);
+}
+/* Inserts this data pointer after the element pointed by the iterator */
+pub unsafe fn clist_insert_after(
+    mut lst: *mut clist,
+    mut iter: *mut clistiter,
+    mut data: *mut libc::c_void,
+) -> libc::c_int {
+    let mut c: *mut clistcell = 0 as *mut clistcell;
+    c = malloc(::std::mem::size_of::<clistcell>() as libc::size_t) as *mut clistcell;
+    if c.is_null() {
+        return -1i32;
+    }
+    (*c).data = data;
+    (*lst).count += 1;
+    if (*lst).first == (*lst).last && (*lst).last.is_null() {
+        (*c).next = 0 as *mut clistcell;
+        (*c).previous = (*c).next;
+        (*lst).last = c;
+        (*lst).first = (*lst).last;
+        return 0i32;
+    }
+    if iter.is_null() {
+        (*c).previous = (*lst).last;
+        (*(*c).previous).next = c;
+        (*c).next = 0 as *mut clistcell;
+        (*lst).last = c;
+        return 0i32;
+    }
+    (*c).previous = iter;
+    (*c).next = (*iter).next;
+    if !(*c).next.is_null() {
+        (*(*c).next).previous = c
+    } else {
+        (*lst).last = c
+    }
+    (*(*c).previous).next = c;
+    return 0i32;
+}
+/* Deletes the element pointed by the iterator.
+Returns an iterator to the next element. */
+pub unsafe fn clist_delete(mut lst: *mut clist, mut iter: *mut clistiter) -> *mut clistiter {
+    let mut ret: *mut clistiter = 0 as *mut clistiter;
+    if iter.is_null() {
+        return 0 as *mut clistiter;
+    }
+    if !(*iter).previous.is_null() {
+        (*(*iter).previous).next = (*iter).next
+    } else {
+        (*lst).first = (*iter).next
+    }
+    if !(*iter).next.is_null() {
+        (*(*iter).next).previous = (*iter).previous;
+        ret = (*iter).next
+    } else {
+        (*lst).last = (*iter).previous;
+        ret = 0 as *mut clistiter
+    }
+    free(iter as *mut libc::c_void);
+    (*lst).count -= 1;
+    return ret;
+}
+pub unsafe fn clist_foreach(
+    mut lst: *mut clist,
+    mut func: clist_func,
+    mut data: *mut libc::c_void,
+) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*lst).first;
+    while !cur.is_null() {
+        func.expect("non-null function pointer")((*cur).data, data);
+        cur = (*cur).next
+    }
+}
+
+pub unsafe fn clist_nth_data(mut lst: *mut clist, mut indx: libc::c_int) -> *mut libc::c_void {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = internal_clist_nth(lst, indx);
+    if cur.is_null() {
+        return 0 as *mut libc::c_void;
+    }
+    return (*cur).data;
+}
+#[inline]
+unsafe fn internal_clist_nth(mut lst: *mut clist, mut indx: libc::c_int) -> *mut clistiter {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*lst).first;
+    while indx > 0i32 && !cur.is_null() {
+        cur = (*cur).next;
+        indx -= 1
+    }
+    if cur.is_null() {
+        return 0 as *mut clistiter;
+    }
+    return cur;
+}
+
+pub unsafe fn clist_nth(mut lst: *mut clist, mut indx: libc::c_int) -> *mut clistiter {
+    return internal_clist_nth(lst, indx);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ptr;
+    #[test]
+    fn test_clist_iterator() {
+        unsafe {
+            let mut c = clist_new();
+            assert!(!c.is_null());
+            clist_insert_after(c, ptr::null_mut(), clist_nth as _);
+            assert_eq!((*c).count, 1);
+
+            /* Only one iteration */
+            for data in &*c {
+                assert_eq!(data, clist_nth as _);
+            }
+            assert_eq!((*c).count, 1);
+
+            clist_free(c);
+        }
+    }
+}

mmime/src/constants.rs

@@ -0,0 +1,71 @@
+pub const MAIL_ERROR_SSL: libc::c_uint = 58;
+pub const MAIL_ERROR_FOLDER: libc::c_uint = 57;
+pub const MAIL_ERROR_UNABLE: libc::c_uint = 56;
+pub const MAIL_ERROR_SYSTEM: libc::c_uint = 55;
+pub const MAIL_ERROR_COMMAND: libc::c_uint = 54;
+pub const MAIL_ERROR_SEND: libc::c_uint = 53;
+pub const MAIL_ERROR_CHAR_ENCODING_FAILED: libc::c_uint = 52;
+pub const MAIL_ERROR_SUBJECT_NOT_FOUND: libc::c_uint = 51;
+/* 50 */
+pub const MAIL_ERROR_PROGRAM_ERROR: libc::c_uint = 50;
+pub const MAIL_ERROR_NO_PERMISSION: libc::c_uint = 49;
+pub const MAIL_ERROR_COMMAND_NOT_SUPPORTED: libc::c_uint = 48;
+pub const MAIL_ERROR_NO_APOP: libc::c_uint = 47;
+pub const MAIL_ERROR_READONLY: libc::c_uint = 46;
+pub const MAIL_ERROR_FATAL: libc::c_uint = 45;
+pub const MAIL_ERROR_CLOSE: libc::c_uint = 44;
+pub const MAIL_ERROR_CAPABILITY: libc::c_uint = 43;
+pub const MAIL_ERROR_PROTOCOL: libc::c_uint = 42;
+/* misc errors */
+pub const MAIL_ERROR_MISC: libc::c_uint = 41;
+/* 40 */
+pub const MAIL_ERROR_EXPUNGE: libc::c_uint = 40;
+pub const MAIL_ERROR_NO_TLS: libc::c_uint = 39;
+pub const MAIL_ERROR_CACHE_MISS: libc::c_uint = 38;
+pub const MAIL_ERROR_STARTTLS: libc::c_uint = 37;
+pub const MAIL_ERROR_MOVE: libc::c_uint = 36;
+pub const MAIL_ERROR_FOLDER_NOT_FOUND: libc::c_uint = 35;
+pub const MAIL_ERROR_REMOVE: libc::c_uint = 34;
+pub const MAIL_ERROR_PART_NOT_FOUND: libc::c_uint = 33;
+pub const MAIL_ERROR_INVAL: libc::c_uint = 32;
+pub const MAIL_ERROR_PARSE: libc::c_uint = 31;
+/* 30 */
+pub const MAIL_ERROR_MSG_NOT_FOUND: libc::c_uint = 30;
+pub const MAIL_ERROR_DISKSPACE: libc::c_uint = 29;
+pub const MAIL_ERROR_SEARCH: libc::c_uint = 28;
+pub const MAIL_ERROR_STORE: libc::c_uint = 27;
+pub const MAIL_ERROR_FETCH: libc::c_uint = 26;
+pub const MAIL_ERROR_COPY: libc::c_uint = 25;
+pub const MAIL_ERROR_APPEND: libc::c_uint = 24;
+pub const MAIL_ERROR_LSUB: libc::c_uint = 23;
+pub const MAIL_ERROR_LIST: libc::c_uint = 22;
+pub const MAIL_ERROR_UNSUBSCRIBE: libc::c_uint = 21;
+/* 20 */
+pub const MAIL_ERROR_SUBSCRIBE: libc::c_uint = 20;
+pub const MAIL_ERROR_STATUS: libc::c_uint = 19;
+pub const MAIL_ERROR_MEMORY: libc::c_uint = 18;
+pub const MAIL_ERROR_SELECT: libc::c_uint = 17;
+pub const MAIL_ERROR_EXAMINE: libc::c_uint = 16;
+pub const MAIL_ERROR_CHECK: libc::c_uint = 15;
+pub const MAIL_ERROR_RENAME: libc::c_uint = 14;
+pub const MAIL_ERROR_NOOP: libc::c_uint = 13;
+pub const MAIL_ERROR_LOGOUT: libc::c_uint = 12;
+pub const MAIL_ERROR_DELETE: libc::c_uint = 11;
+/* 10 */
+pub const MAIL_ERROR_CREATE: libc::c_uint = 10;
+pub const MAIL_ERROR_LOGIN: libc::c_uint = 9;
+pub const MAIL_ERROR_STREAM: libc::c_uint = 8;
+pub const MAIL_ERROR_FILE: libc::c_uint = 7;
+pub const MAIL_ERROR_BAD_STATE: libc::c_uint = 6;
+pub const MAIL_ERROR_CONNECT: libc::c_uint = 5;
+pub const MAIL_ERROR_UNKNOWN: libc::c_uint = 4;
+pub const MAIL_ERROR_NOT_IMPLEMENTED: libc::c_uint = 3;
+pub const MAIL_NO_ERROR_NON_AUTHENTICATED: libc::c_uint = 2;
+pub const MAIL_NO_ERROR_AUTHENTICATED: libc::c_uint = 1;
+pub const MAIL_NO_ERROR: libc::c_uint = 0;
+
+pub const MAILIMF_ERROR_FILE: libc::c_uint = 4;
+pub const MAILIMF_ERROR_INVAL: libc::c_uint = 3;
+pub const MAILIMF_ERROR_MEMORY: libc::c_uint = 2;
+pub const MAILIMF_ERROR_PARSE: libc::c_uint = 1;
+pub const MAILIMF_NO_ERROR: libc::c_uint = 0;

mmime/src/display.rs

@@ -0,0 +1,386 @@
+use crate::clist::*;
+
+use crate::mailimf::types::*;
+use crate::mailmime::types::*;
+
+use std::ffi::CStr;
+
+pub unsafe fn display_mime(mut mime: *mut Mailmime) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    println!("{}", (*mime).mm_type);
+
+    match (*mime).mm_type as u32 {
+        MAILMIME_SINGLE => {
+            println!("single part");
+        }
+        MAILMIME_MULTIPLE => {
+            println!("multipart");
+        }
+        MAILMIME_MESSAGE => println!("message"),
+        _ => {}
+    }
+    if !(*mime).mm_mime_fields.is_null() {
+        if !(*(*(*mime).mm_mime_fields).fld_list).first.is_null() {
+            print!("MIME headers begin");
+            display_mime_fields((*mime).mm_mime_fields);
+            println!("MIME headers end");
+        }
+    }
+    display_mime_content((*mime).mm_content_type);
+    match (*mime).mm_type as u32 {
+        MAILMIME_SINGLE => {
+            display_mime_data((*mime).mm_data.mm_single);
+        }
+        MAILMIME_MULTIPLE => {
+            cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
+            while !cur.is_null() {
+                display_mime(
+                    (if !cur.is_null() {
+                        (*cur).data
+                    } else {
+                        0 as *mut libc::c_void
+                    }) as *mut Mailmime,
+                );
+                cur = if !cur.is_null() {
+                    (*cur).next
+                } else {
+                    0 as *mut clistcell
+                }
+            }
+        }
+        MAILMIME_MESSAGE => {
+            if !(*mime).mm_data.mm_message.mm_fields.is_null() {
+                if !(*(*(*mime).mm_data.mm_message.mm_fields).fld_list)
+                    .first
+                    .is_null()
+                {
+                    println!("headers begin");
+                    display_fields((*mime).mm_data.mm_message.mm_fields);
+                    println!("headers end");
+                }
+                if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
+                    display_mime((*mime).mm_data.mm_message.mm_msg_mime);
+                }
+            }
+        }
+        _ => {}
+    };
+}
+
+unsafe fn display_mime_content(mut content_type: *mut mailmime_content) {
+    print!("type: ");
+    display_mime_type((*content_type).ct_type);
+    println!(
+        "/{}",
+        CStr::from_ptr((*content_type).ct_subtype).to_str().unwrap()
+    );
+}
+unsafe fn display_mime_type(mut type_0: *mut mailmime_type) {
+    match (*type_0).tp_type {
+        1 => {
+            display_mime_discrete_type((*type_0).tp_data.tp_discrete_type);
+        }
+        2 => {
+            display_mime_composite_type((*type_0).tp_data.tp_composite_type);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_composite_type(mut ct: *mut mailmime_composite_type) {
+    match (*ct).ct_type {
+        1 => {
+            print!("message");
+        }
+        2 => {
+            print!("multipart");
+        }
+        3 => {
+            print!("{}", CStr::from_ptr((*ct).ct_token).to_str().unwrap());
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_discrete_type(mut discrete_type: *mut mailmime_discrete_type) {
+    match (*discrete_type).dt_type {
+        1 => {
+            print!("text");
+        }
+        2 => {
+            print!("image");
+        }
+        3 => {
+            print!("audio");
+        }
+        4 => {
+            print!("video");
+        }
+        5 => {
+            print!("application");
+        }
+        6 => {
+            print!("{}", (*discrete_type).dt_extension as u8 as char);
+        }
+        _ => {}
+    };
+}
+pub unsafe fn display_mime_data(mut data: *mut mailmime_data) {
+    match (*data).dt_type {
+        0 => {
+            println!(
+                "data : {} bytes",
+                (*data).dt_data.dt_text.dt_length as libc::c_uint,
+            );
+        }
+        1 => {
+            println!(
+                "data (file) : {}",
+                CStr::from_ptr((*data).dt_data.dt_filename)
+                    .to_str()
+                    .unwrap()
+            );
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_dsp_parm(mut param: *mut mailmime_disposition_parm) {
+    match (*param).pa_type {
+        0 => {
+            println!(
+                "filename: {}",
+                CStr::from_ptr((*param).pa_data.pa_filename)
+                    .to_str()
+                    .unwrap()
+            );
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_disposition(mut disposition: *mut mailmime_disposition) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*disposition).dsp_parms).first;
+    while !cur.is_null() {
+        let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
+        param = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailmime_disposition_parm;
+        display_mime_dsp_parm(param);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_mime_field(mut field: *mut mailmime_field) {
+    match (*field).fld_type {
+        1 => {
+            print!("content-type: ");
+            display_mime_content((*field).fld_data.fld_content);
+            println!("");
+        }
+        6 => {
+            display_mime_disposition((*field).fld_data.fld_disposition);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_fields(mut fields: *mut mailmime_fields) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*fields).fld_list).first;
+    while !cur.is_null() {
+        let mut field: *mut mailmime_field = 0 as *mut mailmime_field;
+        field = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailmime_field;
+        display_mime_field(field);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_date_time(mut d: *mut mailimf_date_time) {
+    print!(
+        "{:02}/{:02}/{:02} {:02}:{:02}:{:02} +{:04}",
+        (*d).dt_day,
+        (*d).dt_month,
+        (*d).dt_year,
+        (*d).dt_hour,
+        (*d).dt_min,
+        (*d).dt_sec,
+        (*d).dt_zone,
+    );
+}
+unsafe fn display_orig_date(mut orig_date: *mut mailimf_orig_date) {
+    display_date_time((*orig_date).dt_date_time);
+}
+unsafe fn display_mailbox(mut mb: *mut mailimf_mailbox) {
+    if !(*mb).mb_display_name.is_null() {
+        print!(
+            "{}",
+            CStr::from_ptr((*mb).mb_display_name).to_str().unwrap()
+        );
+    }
+    print!("<{}>", CStr::from_ptr((*mb).mb_addr_spec).to_str().unwrap());
+}
+unsafe fn display_mailbox_list(mut mb_list: *mut mailimf_mailbox_list) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*mb_list).mb_list).first;
+    while !cur.is_null() {
+        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
+        mb = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_mailbox;
+        display_mailbox(mb);
+        if !if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+        .is_null()
+        {
+            print!(", ");
+        }
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_group(mut group: *mut mailimf_group) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    print!(
+        "{}: ",
+        CStr::from_ptr((*group).grp_display_name).to_str().unwrap()
+    );
+    cur = (*(*(*group).grp_mb_list).mb_list).first;
+    while !cur.is_null() {
+        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
+        mb = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_mailbox;
+        display_mailbox(mb);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+    print!("; ");
+}
+unsafe fn display_address(mut a: *mut mailimf_address) {
+    match (*a).ad_type {
+        2 => {
+            display_group((*a).ad_data.ad_group);
+        }
+        1 => {
+            display_mailbox((*a).ad_data.ad_mailbox);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_address_list(mut addr_list: *mut mailimf_address_list) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*addr_list).ad_list).first;
+    while !cur.is_null() {
+        let mut addr: *mut mailimf_address = 0 as *mut mailimf_address;
+        addr = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_address;
+        display_address(addr);
+        if !if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+        .is_null()
+        {
+            print!(", ");
+        }
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_from(mut from: *mut mailimf_from) {
+    display_mailbox_list((*from).frm_mb_list);
+}
+unsafe fn display_to(mut to: *mut mailimf_to) {
+    display_address_list((*to).to_addr_list);
+}
+unsafe fn display_cc(mut cc: *mut mailimf_cc) {
+    display_address_list((*cc).cc_addr_list);
+}
+unsafe fn display_subject(mut subject: *mut mailimf_subject) {
+    print!("{}", CStr::from_ptr((*subject).sbj_value).to_str().unwrap());
+}
+unsafe fn display_field(mut field: *mut mailimf_field) {
+    match (*field).fld_type {
+        9 => {
+            print!("Date: ");
+            display_orig_date((*field).fld_data.fld_orig_date);
+            println!("");
+        }
+        10 => {
+            print!("From: ");
+            display_from((*field).fld_data.fld_from);
+            println!("");
+        }
+        13 => {
+            print!("To: ");
+            display_to((*field).fld_data.fld_to);
+            println!("");
+        }
+        14 => {
+            print!("Cc: ");
+            display_cc((*field).fld_data.fld_cc);
+            println!("");
+        }
+        19 => {
+            print!("Subject: ");
+            display_subject((*field).fld_data.fld_subject);
+            println!("");
+        }
+        16 => {
+            println!(
+                "Message-ID: {}",
+                CStr::from_ptr((*(*field).fld_data.fld_message_id).mid_value)
+                    .to_str()
+                    .unwrap(),
+            );
+        }
+        _ => {}
+    };
+}
+unsafe fn display_fields(mut fields: *mut mailimf_fields) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*fields).fld_list).first;
+    while !cur.is_null() {
+        let mut f: *mut mailimf_field = 0 as *mut mailimf_field;
+        f = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_field;
+        display_field(f);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}

mmime/src/lib.rs

@@ -0,0 +1,78 @@
+#![deny(clippy::correctness)]
+// TODO: make all of these errors, such that clippy actually passes.
+#![warn(clippy::all, clippy::perf, clippy::not_unsafe_ptr_arg_deref)]
+// This is nice, but for now just annoying.
+#![allow(clippy::unreadable_literal)]
+#![feature(ptr_wrapping_offset_from)]
+#![allow(unused_attributes)]
+#![allow(unused_variables)]
+#![allow(mutable_transmutes)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(unused_assignments)]
+#![allow(unused_mut)]
+#![allow(unused_must_use)]
+#![feature(extern_types)]
+#![feature(const_raw_ptr_to_usize_cast)]
+
+pub mod charconv;
+pub mod chash;
+pub mod clist;
+pub mod display;
+pub mod mailimf;
+pub mod mailmime;
+pub mod mmapstring;
+pub mod other;
+
+pub use self::charconv::*;
+pub use self::chash::*;
+pub use self::clist::*;
+pub use self::display::*;
+pub use self::mailimf::*;
+pub use self::mailmime::*;
+pub use self::mmapstring::*;
+pub use self::other::*;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mailmime_parse_test() {
+        unsafe {
+            let data = "MIME-Version: 1.0\
+                        Content-Type: multipart/mixed; boundary=frontier\
+                        \
+                        This is a message with multiple parts in MIME format.\
+                        --frontier\
+                        Content-Type: text/plain\
+                        \
+                        This is the body of the message.\
+                        --frontier\
+                        Content-Type: application/octet-stream\
+                        Content-Transfer-Encoding: base64\
+                        \
+                        PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUg\
+                        Ym9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==\
+                        --frontier--";
+            let c_data = std::ffi::CString::new(data).unwrap();
+
+            let mut current_index = 0;
+            let mut mime = std::ptr::null_mut();
+            let res = crate::mailmime::content::mailmime_parse(
+                c_data.as_ptr(),
+                data.len() as usize,
+                &mut current_index,
+                &mut mime,
+            );
+
+            assert_eq!(res, MAIL_NO_ERROR as libc::c_int);
+            assert!(!mime.is_null());
+
+            display_mime(mime);
+
+            mailmime::types::mailmime_free(mime);
+        }
+    }
+}

mmime/src/mailimf/types_helper.rs

@@ -0,0 +1,89 @@
+use crate::clist::*;
+use crate::mailimf::types::*;
+use crate::other::*;
+
+/*
+  this function creates a new mailimf_fields structure with no fields
+*/
+pub unsafe fn mailimf_fields_new_empty() -> *mut mailimf_fields {
+    let mut list: *mut clist = 0 as *mut clist;
+    let mut fields_list: *mut mailimf_fields = 0 as *mut mailimf_fields;
+    list = clist_new();
+    if list.is_null() {
+        return 0 as *mut mailimf_fields;
+    }
+    fields_list = mailimf_fields_new(list);
+    if fields_list.is_null() {
+        return 0 as *mut mailimf_fields;
+    }
+    return fields_list;
+}
+/*
+ this function adds a field to the mailimf_fields structure
+
+ @return MAILIMF_NO_ERROR will be returned on success,
+ other code will be returned otherwise
+*/
+pub unsafe fn mailimf_fields_add(
+    mut fields: *mut mailimf_fields,
+    mut field: *mut mailimf_field,
+) -> libc::c_int {
+    let mut r: libc::c_int = 0;
+    r = clist_insert_after(
+        (*fields).fld_list,
+        (*(*fields).fld_list).last,
+        field as *mut libc::c_void,
+    );
+    if r < 0i32 {
+        return MAILIMF_ERROR_MEMORY as libc::c_int;
+    }
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+
+/*
+  mailimf_field_new_custom creates a new field of type optional
+
+  @param name should be allocated with malloc()
+  @param value should be allocated with malloc()
+*/
+pub unsafe fn mailimf_field_new_custom(
+    mut name: *mut libc::c_char,
+    mut value: *mut libc::c_char,
+) -> *mut mailimf_field {
+    let mut opt_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field;
+    let mut field: *mut mailimf_field = 0 as *mut mailimf_field;
+    opt_field = mailimf_optional_field_new(name, value);
+    if !opt_field.is_null() {
+        field = mailimf_field_new(
+            MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int,
+            0 as *mut mailimf_return,
+            0 as *mut mailimf_orig_date,
+            0 as *mut mailimf_from,
+            0 as *mut mailimf_sender,
+            0 as *mut mailimf_to,
+            0 as *mut mailimf_cc,
+            0 as *mut mailimf_bcc,
+            0 as *mut mailimf_message_id,
+            0 as *mut mailimf_orig_date,
+            0 as *mut mailimf_from,
+            0 as *mut mailimf_sender,
+            0 as *mut mailimf_reply_to,
+            0 as *mut mailimf_to,
+            0 as *mut mailimf_cc,
+            0 as *mut mailimf_bcc,
+            0 as *mut mailimf_message_id,
+            0 as *mut mailimf_in_reply_to,
+            0 as *mut mailimf_references,
+            0 as *mut mailimf_subject,
+            0 as *mut mailimf_comments,
+            0 as *mut mailimf_keywords,
+            opt_field,
+        );
+        if field.is_null() {
+            mailimf_optional_field_free(opt_field);
+        } else {
+            return field;
+        }
+    }
+    return 0 as *mut mailimf_field;
+}

mmime/src/mailmime/decode.rs

@@ -0,0 +1,860 @@
+use libc;
+use libc::toupper;
+
+use crate::charconv::*;
+use crate::mailimf::*;
+use crate::mailmime::content::*;
+use crate::mailmime::types::*;
+use crate::mmapstring::*;
+use crate::other::*;
+
+pub const TYPE_WORD: libc::c_uint = 1;
+pub const TYPE_ENCODED_WORD: libc::c_uint = 2;
+pub const MAILMIME_ENCODING_Q: libc::c_uint = 1;
+pub const MAILMIME_ENCODING_B: libc::c_uint = 0;
+pub const TYPE_ERROR: libc::c_uint = 0;
+
+pub unsafe fn mailmime_encoded_phrase_parse(
+    mut default_fromcode: *const libc::c_char,
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut tocode: *const libc::c_char,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    let mut current_block: u64;
+    let mut gphrase: *mut MMAPString = 0 as *mut MMAPString;
+    let mut word: *mut mailmime_encoded_word = 0 as *mut mailmime_encoded_word;
+    let mut first: libc::c_int = 0;
+    let mut cur_token: size_t = 0;
+    let mut r: libc::c_int = 0;
+    let mut res: libc::c_int = 0;
+    let mut str: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut wordutf8: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut type_0: libc::c_int = 0;
+    let mut missing_closing_quote: libc::c_int = 0;
+    cur_token = *indx;
+    gphrase = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
+    if gphrase.is_null() {
+        res = MAILIMF_ERROR_MEMORY as libc::c_int
+    } else {
+        first = 1i32;
+        type_0 = TYPE_ERROR as libc::c_int;
+        loop {
+            let mut has_fwd: libc::c_int = 0;
+            word = 0 as *mut mailmime_encoded_word;
+            r = mailmime_encoded_word_parse(
+                message,
+                length,
+                &mut cur_token,
+                &mut word,
+                &mut has_fwd,
+                &mut missing_closing_quote,
+            );
+            if r == MAILIMF_NO_ERROR as libc::c_int {
+                if 0 == first && 0 != has_fwd {
+                    if type_0 != TYPE_ENCODED_WORD as libc::c_int {
+                        if mmap_string_append_c(gphrase, ' ' as i32 as libc::c_char).is_null() {
+                            mailmime_encoded_word_free(word);
+                            res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                            current_block = 13246848547199022064;
+                            break;
+                        }
+                    }
+                }
+                type_0 = TYPE_ENCODED_WORD as libc::c_int;
+                wordutf8 = 0 as *mut libc::c_char;
+                r = charconv(
+                    tocode,
+                    (*word).wd_charset,
+                    (*word).wd_text,
+                    strlen((*word).wd_text),
+                    &mut wordutf8,
+                );
+                match r {
+                    2 => {
+                        mailmime_encoded_word_free(word);
+                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                    1 => {
+                        r = charconv(
+                            tocode,
+                            b"iso-8859-1\x00" as *const u8 as *const libc::c_char,
+                            (*word).wd_text,
+                            strlen((*word).wd_text),
+                            &mut wordutf8,
+                        )
+                    }
+                    3 => {
+                        mailmime_encoded_word_free(word);
+                        res = MAILIMF_ERROR_PARSE as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                    _ => {}
+                }
+                match r {
+                    2 => {
+                        mailmime_encoded_word_free(word);
+                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                    3 => {
+                        mailmime_encoded_word_free(word);
+                        res = MAILIMF_ERROR_PARSE as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                    _ => {
+                        if !wordutf8.is_null() {
+                            if mmap_string_append(gphrase, wordutf8).is_null() {
+                                mailmime_encoded_word_free(word);
+                                free(wordutf8 as *mut libc::c_void);
+                                res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                                current_block = 13246848547199022064;
+                                break;
+                            } else {
+                                free(wordutf8 as *mut libc::c_void);
+                            }
+                        }
+                        mailmime_encoded_word_free(word);
+                        first = 0i32
+                    }
+                }
+            } else if !(r == MAILIMF_ERROR_PARSE as libc::c_int) {
+                /* do nothing */
+                res = r;
+                current_block = 13246848547199022064;
+                break;
+            }
+            if !(r == MAILIMF_ERROR_PARSE as libc::c_int) {
+                continue;
+            }
+            let mut raw_word: *mut libc::c_char = 0 as *mut libc::c_char;
+            raw_word = 0 as *mut libc::c_char;
+            r = mailmime_non_encoded_word_parse(
+                message,
+                length,
+                &mut cur_token,
+                &mut raw_word,
+                &mut has_fwd,
+            );
+            if r == MAILIMF_NO_ERROR as libc::c_int {
+                if 0 == first && 0 != has_fwd {
+                    if mmap_string_append_c(gphrase, ' ' as i32 as libc::c_char).is_null() {
+                        free(raw_word as *mut libc::c_void);
+                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                }
+                type_0 = TYPE_WORD as libc::c_int;
+                wordutf8 = 0 as *mut libc::c_char;
+                r = charconv(
+                    tocode,
+                    default_fromcode,
+                    raw_word,
+                    strlen(raw_word),
+                    &mut wordutf8,
+                );
+                match r {
+                    2 => {
+                        free(raw_word as *mut libc::c_void);
+                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                    1 | 3 => {
+                        free(raw_word as *mut libc::c_void);
+                        res = MAILIMF_ERROR_PARSE as libc::c_int;
+                        current_block = 13246848547199022064;
+                        break;
+                    }
+                    _ => {
+                        if mmap_string_append(gphrase, wordutf8).is_null() {
+                            free(wordutf8 as *mut libc::c_void);
+                            free(raw_word as *mut libc::c_void);
+                            res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                            current_block = 13246848547199022064;
+                            break;
+                        } else {
+                            free(wordutf8 as *mut libc::c_void);
+                            free(raw_word as *mut libc::c_void);
+                            first = 0i32
+                        }
+                    }
+                }
+            } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                r = mailimf_fws_parse(message, length, &mut cur_token);
+                if r != MAILIMF_NO_ERROR as libc::c_int {
+                    current_block = 5005389895767293342;
+                    break;
+                }
+                if mmap_string_append_c(gphrase, ' ' as i32 as libc::c_char).is_null() {
+                    res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                    current_block = 13246848547199022064;
+                    break;
+                } else {
+                    first = 0i32;
+                    current_block = 5005389895767293342;
+                    break;
+                }
+            } else {
+                res = r;
+                current_block = 13246848547199022064;
+                break;
+            }
+        }
+        match current_block {
+            5005389895767293342 => {
+                if 0 != first {
+                    if cur_token != length {
+                        res = MAILIMF_ERROR_PARSE as libc::c_int;
+                        current_block = 13246848547199022064;
+                    } else {
+                        current_block = 7072655752890836508;
+                    }
+                } else {
+                    current_block = 7072655752890836508;
+                }
+                match current_block {
+                    13246848547199022064 => {}
+                    _ => {
+                        str = strdup((*gphrase).str_0);
+                        if str.is_null() {
+                            res = MAILIMF_ERROR_MEMORY as libc::c_int
+                        } else {
+                            mmap_string_free(gphrase);
+                            *result = str;
+                            *indx = cur_token;
+                            return MAILIMF_NO_ERROR as libc::c_int;
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+        mmap_string_free(gphrase);
+    }
+    return res;
+}
+unsafe fn mailmime_non_encoded_word_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+    mut p_has_fwd: *mut libc::c_int,
+) -> libc::c_int {
+    let mut end: libc::c_int = 0;
+    let mut cur_token: size_t = 0;
+    let mut res: libc::c_int = 0;
+    let mut text: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut r: libc::c_int = 0;
+    let mut begin: size_t = 0;
+    let mut state: libc::c_int = 0;
+    let mut has_fwd: libc::c_int = 0;
+    cur_token = *indx;
+    has_fwd = 0i32;
+    r = mailimf_fws_parse(message, length, &mut cur_token);
+    if r == MAILIMF_NO_ERROR as libc::c_int {
+        has_fwd = 1i32
+    }
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        res = r
+    } else {
+        begin = cur_token;
+        state = 0i32;
+        end = 0i32;
+        while !(cur_token >= length) {
+            let mut current_block_17: u64;
+            match *message.offset(cur_token as isize) as libc::c_int {
+                32 | 9 | 13 | 10 => {
+                    state = 0i32;
+                    end = 1i32;
+                    current_block_17 = 16924917904204750491;
+                }
+                61 => {
+                    state = 1i32;
+                    current_block_17 = 16924917904204750491;
+                }
+                63 => {
+                    if state == 1i32 {
+                        cur_token = cur_token.wrapping_sub(1);
+                        end = 1i32
+                    }
+                    current_block_17 = 10192508258555769664;
+                }
+                _ => {
+                    current_block_17 = 10192508258555769664;
+                }
+            }
+            match current_block_17 {
+                10192508258555769664 => state = 0i32,
+                _ => {}
+            }
+            if 0 != end {
+                break;
+            }
+            cur_token = cur_token.wrapping_add(1)
+        }
+        if cur_token.wrapping_sub(begin) == 0i32 as libc::size_t {
+            res = MAILIMF_ERROR_PARSE as libc::c_int
+        } else {
+            text = malloc(
+                cur_token
+                    .wrapping_sub(begin)
+                    .wrapping_add(1i32 as libc::size_t),
+            ) as *mut libc::c_char;
+            if text.is_null() {
+                res = MAILIMF_ERROR_MEMORY as libc::c_int
+            } else {
+                memcpy(
+                    text as *mut libc::c_void,
+                    message.offset(begin as isize) as *const libc::c_void,
+                    cur_token.wrapping_sub(begin),
+                );
+                *text.offset(cur_token.wrapping_sub(begin) as isize) =
+                    '\u{0}' as i32 as libc::c_char;
+                *indx = cur_token;
+                *result = text;
+                *p_has_fwd = has_fwd;
+                return MAILIMF_NO_ERROR as libc::c_int;
+            }
+        }
+    }
+    return res;
+}
+
+pub unsafe fn mailmime_encoded_word_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut mailmime_encoded_word,
+    mut p_has_fwd: *mut libc::c_int,
+    mut p_missing_closing_quote: *mut libc::c_int,
+) -> libc::c_int {
+    let mut current_block: u64;
+    /*
+    Parse the following, when a unicode character encoding is split.
+    =?UTF-8?B?4Lij4Liw4LmA4Lia4Li04LiU4LiE4Lin4Liy4Lih4Lih4Lix4LiZ4Liq4LmM?=
+    =?UTF-8?B?4LmA4LiV4LmH4Lih4Lie4Li04LiB4Lix4LiUIFRSQU5TRk9STUVSUyA0IOC4?=
+    =?UTF-8?B?oeC4seC4meC4quC5jOC4hOC4o+C4muC4l+C4uOC4geC4o+C4sOC4muC4miDg?=
+    =?UTF-8?B?uJfguLXguYjguYDguJTguLXguKLguKfguYPguJnguYDguKHguLfguK3guIfg?=
+    =?UTF-8?B?uYTguJfguKI=?=
+    Expected result:
+    ระเบิดความมันส์เต็มพิกัด TRANSFORMERS 4 มันส์ครบทุกระบบ ที่เดียวในเมืองไทย
+    libetpan result:
+    ระเบิดความมันส์เต็มพิกัด TRANSFORMERS 4 ?ันส์ครบทุกระบบ ??ี่เดียวในเมือง??ทย
+
+    See https://github.com/dinhviethoa/libetpan/pull/211
+    */
+    let mut cur_token: size_t = 0;
+    let mut charset: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut encoding: libc::c_int = 0;
+    let mut body: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut old_body_len: size_t = 0;
+    let mut text: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut end_encoding: size_t = 0;
+    let mut lookfwd_cur_token: size_t = 0;
+    let mut lookfwd_charset: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut lookfwd_encoding: libc::c_int = 0;
+    let mut copy_len: size_t = 0;
+    let mut decoded_token: size_t = 0;
+    let mut decoded: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut decoded_len: size_t = 0;
+    let mut ew: *mut mailmime_encoded_word = 0 as *mut mailmime_encoded_word;
+    let mut r: libc::c_int = 0;
+    let mut res: libc::c_int = 0;
+    let mut opening_quote: libc::c_int = 0;
+    let mut end: libc::c_int = 0;
+    let mut has_fwd: libc::c_int = 0;
+    let mut missing_closing_quote: libc::c_int = 0;
+    cur_token = *indx;
+    text = 0 as *mut libc::c_char;
+    lookfwd_charset = 0 as *mut libc::c_char;
+    missing_closing_quote = 0i32;
+    has_fwd = 0i32;
+    r = mailimf_fws_parse(message, length, &mut cur_token);
+    if r == MAILIMF_NO_ERROR as libc::c_int {
+        has_fwd = 1i32
+    }
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        res = r
+    } else {
+        opening_quote = 0i32;
+        r = mailimf_char_parse(message, length, &mut cur_token, '\"' as i32 as libc::c_char);
+        if r == MAILIMF_NO_ERROR as libc::c_int {
+            opening_quote = 1i32;
+            current_block = 17788412896529399552;
+        } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+            current_block = 17788412896529399552;
+        } else {
+            /* do nothing */
+            res = r;
+            current_block = 7995813543095296079;
+        }
+        match current_block {
+            7995813543095296079 => {}
+            _ => {
+                r = mailimf_token_case_insensitive_len_parse(
+                    message,
+                    length,
+                    &mut cur_token,
+                    b"=?\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+                    strlen(b"=?\x00" as *const u8 as *const libc::c_char),
+                );
+                if r != MAILIMF_NO_ERROR as libc::c_int {
+                    res = r
+                } else {
+                    r = mailmime_charset_parse(message, length, &mut cur_token, &mut charset);
+                    if r != MAILIMF_NO_ERROR as libc::c_int {
+                        res = r
+                    } else {
+                        r = mailimf_char_parse(
+                            message,
+                            length,
+                            &mut cur_token,
+                            '?' as i32 as libc::c_char,
+                        );
+                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                            res = r
+                        } else {
+                            r = mailmime_encoding_parse(
+                                message,
+                                length,
+                                &mut cur_token,
+                                &mut encoding,
+                            );
+                            if r != MAILIMF_NO_ERROR as libc::c_int {
+                                res = r
+                            } else {
+                                r = mailimf_char_parse(
+                                    message,
+                                    length,
+                                    &mut cur_token,
+                                    '?' as i32 as libc::c_char,
+                                );
+                                if r != MAILIMF_NO_ERROR as libc::c_int {
+                                    res = r
+                                } else {
+                                    lookfwd_cur_token = cur_token;
+                                    body = 0 as *mut libc::c_char;
+                                    old_body_len = 0i32 as size_t;
+                                    loop {
+                                        let mut has_base64_padding: libc::c_int = 0;
+                                        end = 0i32;
+                                        has_base64_padding = 0i32;
+                                        end_encoding = cur_token;
+                                        while !(end_encoding >= length) {
+                                            if end_encoding.wrapping_add(1i32 as libc::size_t)
+                                                < length
+                                            {
+                                                if *message.offset(end_encoding as isize)
+                                                    as libc::c_int
+                                                    == '?' as i32
+                                                    && *message.offset(
+                                                        end_encoding
+                                                            .wrapping_add(1i32 as libc::size_t)
+                                                            as isize,
+                                                    )
+                                                        as libc::c_int
+                                                        == '=' as i32
+                                                {
+                                                    end = 1i32
+                                                }
+                                            }
+                                            if 0 != end {
+                                                break;
+                                            }
+                                            end_encoding = end_encoding.wrapping_add(1)
+                                        }
+                                        copy_len = end_encoding.wrapping_sub(lookfwd_cur_token);
+                                        if copy_len > 0i32 as libc::size_t {
+                                            if encoding == MAILMIME_ENCODING_B as libc::c_int {
+                                                if end_encoding >= 1i32 as libc::size_t {
+                                                    if *message.offset(
+                                                        end_encoding
+                                                            .wrapping_sub(1i32 as libc::size_t)
+                                                            as isize,
+                                                    )
+                                                        as libc::c_int
+                                                        == '=' as i32
+                                                    {
+                                                        has_base64_padding = 1i32
+                                                    }
+                                                }
+                                            }
+                                            body = realloc(
+                                                body as *mut libc::c_void,
+                                                old_body_len
+                                                    .wrapping_add(copy_len)
+                                                    .wrapping_add(1i32 as libc::size_t),
+                                            )
+                                                as *mut libc::c_char;
+                                            if body.is_null() {
+                                                res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                                                current_block = 13900684162107791171;
+                                                break;
+                                            } else {
+                                                memcpy(
+                                                    body.offset(old_body_len as isize)
+                                                        as *mut libc::c_void,
+                                                    &*message.offset(cur_token as isize)
+                                                        as *const libc::c_char
+                                                        as *const libc::c_void,
+                                                    copy_len,
+                                                );
+                                                *body
+                                                    .offset(old_body_len.wrapping_add(copy_len)
+                                                        as isize) = '\u{0}' as i32 as libc::c_char;
+                                                old_body_len = (old_body_len as libc::size_t)
+                                                    .wrapping_add(copy_len)
+                                                    as size_t
+                                                    as size_t
+                                            }
+                                        }
+                                        cur_token = end_encoding;
+                                        r = mailimf_token_case_insensitive_len_parse(
+                                            message,
+                                            length,
+                                            &mut cur_token,
+                                            b"?=\x00" as *const u8 as *const libc::c_char
+                                                as *mut libc::c_char,
+                                            strlen(b"?=\x00" as *const u8 as *const libc::c_char),
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        if 0 != has_base64_padding {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        lookfwd_cur_token = cur_token;
+                                        r = mailimf_fws_parse(
+                                            message,
+                                            length,
+                                            &mut lookfwd_cur_token,
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int
+                                            && r != MAILIMF_ERROR_PARSE as libc::c_int
+                                        {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        r = mailimf_token_case_insensitive_len_parse(
+                                            message,
+                                            length,
+                                            &mut lookfwd_cur_token,
+                                            b"=?\x00" as *const u8 as *const libc::c_char
+                                                as *mut libc::c_char,
+                                            strlen(b"=?\x00" as *const u8 as *const libc::c_char),
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        r = mailmime_charset_parse(
+                                            message,
+                                            length,
+                                            &mut lookfwd_cur_token,
+                                            &mut lookfwd_charset,
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        r = mailimf_char_parse(
+                                            message,
+                                            length,
+                                            &mut lookfwd_cur_token,
+                                            '?' as i32 as libc::c_char,
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        r = mailmime_encoding_parse(
+                                            message,
+                                            length,
+                                            &mut lookfwd_cur_token,
+                                            &mut lookfwd_encoding,
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        r = mailimf_char_parse(
+                                            message,
+                                            length,
+                                            &mut lookfwd_cur_token,
+                                            '?' as i32 as libc::c_char,
+                                        );
+                                        if r != MAILIMF_NO_ERROR as libc::c_int {
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                        if strcasecmp(charset, lookfwd_charset) == 0i32
+                                            && encoding == lookfwd_encoding
+                                        {
+                                            cur_token = lookfwd_cur_token;
+                                            mailmime_charset_free(lookfwd_charset);
+                                            lookfwd_charset = 0 as *mut libc::c_char
+                                        } else {
+                                            /* the next charset is not matched with the current one,
+                                            therefore exit the loop to decode the body appended so far */
+                                            current_block = 2652804691515851435;
+                                            break;
+                                        }
+                                    }
+                                    match current_block {
+                                        2652804691515851435 => {
+                                            if !lookfwd_charset.is_null() {
+                                                mailmime_charset_free(lookfwd_charset);
+                                                lookfwd_charset = 0 as *mut libc::c_char
+                                            }
+                                            if body.is_null() {
+                                                body = strdup(
+                                                    b"\x00" as *const u8 as *const libc::c_char,
+                                                );
+                                                if body.is_null() {
+                                                    res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                                                    current_block = 13900684162107791171;
+                                                } else {
+                                                    current_block = 16778110326724371720;
+                                                }
+                                            } else {
+                                                current_block = 16778110326724371720;
+                                            }
+                                            match current_block {
+                                                13900684162107791171 => {}
+                                                _ => {
+                                                    decoded_token = 0i32 as size_t;
+                                                    decoded_len = 0i32 as size_t;
+                                                    decoded = 0 as *mut libc::c_char;
+                                                    match encoding {
+                                                        0 => {
+                                                            r = mailmime_base64_body_parse(
+                                                                body,
+                                                                strlen(body),
+                                                                &mut decoded_token,
+                                                                &mut decoded,
+                                                                &mut decoded_len,
+                                                            );
+                                                            if r != MAILIMF_NO_ERROR as libc::c_int
+                                                            {
+                                                                res = r;
+                                                                current_block =
+                                                                    13900684162107791171;
+                                                            } else {
+                                                                current_block = 7337917895049117968;
+                                                            }
+                                                        }
+                                                        1 => {
+                                                            r =
+                                                                mailmime_quoted_printable_body_parse(body,
+                                                                                                     strlen(body),
+                                                                                                     &mut decoded_token,
+                                                                                                     &mut decoded,
+                                                                                                     &mut decoded_len,
+                                                                                                     1i32);
+                                                            if r != MAILIMF_NO_ERROR as libc::c_int
+                                                            {
+                                                                res = r;
+                                                                current_block =
+                                                                    13900684162107791171;
+                                                            } else {
+                                                                current_block = 7337917895049117968;
+                                                            }
+                                                        }
+                                                        _ => {
+                                                            current_block = 7337917895049117968;
+                                                        }
+                                                    }
+                                                    match current_block {
+                                                        13900684162107791171 => {}
+                                                        _ => {
+                                                            text =
+                                                                malloc(decoded_len.wrapping_add(
+                                                                    1i32 as libc::size_t,
+                                                                ))
+                                                                    as *mut libc::c_char;
+                                                            if text.is_null() {
+                                                                res = MAILIMF_ERROR_MEMORY
+                                                                    as libc::c_int
+                                                            } else {
+                                                                if decoded_len
+                                                                    > 0i32 as libc::size_t
+                                                                {
+                                                                    memcpy(
+                                                                        text as *mut libc::c_void,
+                                                                        decoded
+                                                                            as *const libc::c_void,
+                                                                        decoded_len,
+                                                                    );
+                                                                }
+                                                                *text
+                                                                    .offset(decoded_len as isize) =
+                                                                    '\u{0}' as i32 as libc::c_char;
+                                                                if 0 != opening_quote {
+                                                                    r = mailimf_char_parse(
+                                                                        message,
+                                                                        length,
+                                                                        &mut cur_token,
+                                                                        '\"' as i32 as libc::c_char,
+                                                                    );
+                                                                    if r == MAILIMF_ERROR_PARSE
+                                                                        as libc::c_int
+                                                                    {
+                                                                        missing_closing_quote = 1i32
+                                                                    }
+                                                                }
+                                                                if strcasecmp(
+                                                                    charset,
+                                                                    b"utf8\x00" as *const u8
+                                                                        as *const libc::c_char,
+                                                                ) == 0i32
+                                                                {
+                                                                    free(
+                                                                        charset
+                                                                            as *mut libc::c_void,
+                                                                    );
+                                                                    charset = strdup(
+                                                                        b"utf-8\x00" as *const u8
+                                                                            as *const libc::c_char,
+                                                                    )
+                                                                }
+                                                                ew = mailmime_encoded_word_new(
+                                                                    charset, text,
+                                                                );
+                                                                if ew.is_null() {
+                                                                    res = MAILIMF_ERROR_MEMORY
+                                                                        as libc::c_int
+                                                                } else {
+                                                                    *result = ew;
+                                                                    *indx = cur_token;
+                                                                    *p_has_fwd = has_fwd;
+                                                                    *p_missing_closing_quote =
+                                                                        missing_closing_quote;
+                                                                    mailmime_decoded_part_free(
+                                                                        decoded,
+                                                                    );
+                                                                    free(body as *mut libc::c_void);
+                                                                    return MAILIMF_NO_ERROR
+                                                                        as libc::c_int;
+                                                                }
+                                                            }
+                                                            mailmime_decoded_part_free(decoded);
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        _ => {}
+                                    }
+                                    free(body as *mut libc::c_void);
+                                    mailmime_encoded_text_free(text);
+                                }
+                            }
+                        }
+                        mailmime_charset_free(charset);
+                    }
+                }
+            }
+        }
+    }
+    return res;
+}
+unsafe fn mailmime_encoding_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut libc::c_int,
+) -> libc::c_int {
+    let mut cur_token: size_t = 0;
+    let mut encoding: libc::c_int = 0;
+    cur_token = *indx;
+    if cur_token >= length {
+        return MAILIMF_ERROR_PARSE as libc::c_int;
+    }
+    match toupper(*message.offset(cur_token as isize) as libc::c_uchar as libc::c_int)
+        as libc::c_char as libc::c_int
+    {
+        81 => encoding = MAILMIME_ENCODING_Q as libc::c_int,
+        66 => encoding = MAILMIME_ENCODING_B as libc::c_int,
+        _ => return MAILIMF_ERROR_INVAL as libc::c_int,
+    }
+    cur_token = cur_token.wrapping_add(1);
+    *result = encoding;
+    *indx = cur_token;
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+
+/*
+ * libEtPan! -- a mail stuff library
+ *
+ * Copyright (C) 2001, 2005 - DINH Viet Hoa
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the libEtPan! project nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * $Id: mailmime_decode.c,v 1.37 2010/11/16 20:52:28 hoa Exp $
+ */
+/*
+  RFC 2047 : MIME (Multipurpose Internet Mail Extensions) Part Three:
+             Message Header Extensions for Non-ASCII Text
+*/
+unsafe fn mailmime_charset_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut charset: *mut *mut libc::c_char,
+) -> libc::c_int {
+    return mailmime_etoken_parse(message, length, indx, charset);
+}
+unsafe fn mailmime_etoken_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    return mailimf_custom_string_parse(message, length, indx, result, Some(is_etoken_char));
+}
+
+unsafe fn is_etoken_char(mut ch: libc::c_char) -> libc::c_int {
+    let mut uch: libc::c_uchar = ch as libc::c_uchar;
+    if (uch as libc::c_int) < 31i32 {
+        return 0i32;
+    }
+    match uch as libc::c_int {
+        32 | 40 | 41 | 60 | 62 | 64 | 44 | 59 | 58 | 34 | 47 | 91 | 93 | 63 | 61 => return 0i32,
+        _ => {}
+    }
+    return 1i32;
+}

mmime/src/mailmime/disposition.rs

@@ -0,0 +1,583 @@
+use libc::{self, toupper};
+
+use crate::clist::*;
+use crate::mailimf::*;
+use crate::mailmime::types::*;
+use crate::mailmime::*;
+use crate::other::*;
+
+pub const MAILMIME_DISPOSITION_TYPE_EXTENSION: libc::c_uint = 3;
+pub const MAILMIME_DISPOSITION_TYPE_ATTACHMENT: libc::c_uint = 2;
+pub const MAILMIME_DISPOSITION_TYPE_INLINE: libc::c_uint = 1;
+pub const MAILMIME_DISPOSITION_TYPE_ERROR: libc::c_uint = 0;
+
+pub unsafe fn mailmime_disposition_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut mailmime_disposition,
+) -> libc::c_int {
+    let mut current_block: u64;
+    let mut final_token: size_t = 0;
+    let mut cur_token: size_t = 0;
+    let mut dsp_type: *mut mailmime_disposition_type = 0 as *mut mailmime_disposition_type;
+    let mut list: *mut clist = 0 as *mut clist;
+    let mut dsp: *mut mailmime_disposition = 0 as *mut mailmime_disposition;
+    let mut r: libc::c_int = 0;
+    let mut res: libc::c_int = 0;
+    cur_token = *indx;
+    r = mailmime_disposition_type_parse(message, length, &mut cur_token, &mut dsp_type);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        res = r
+    } else {
+        list = clist_new();
+        if list.is_null() {
+            res = MAILIMF_ERROR_MEMORY as libc::c_int
+        } else {
+            loop {
+                let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
+                final_token = cur_token;
+                r = mailimf_unstrict_char_parse(
+                    message,
+                    length,
+                    &mut cur_token,
+                    ';' as i32 as libc::c_char,
+                );
+                if r == MAILIMF_NO_ERROR as libc::c_int {
+                    param = 0 as *mut mailmime_disposition_parm;
+                    r = mailmime_disposition_parm_parse(
+                        message,
+                        length,
+                        &mut cur_token,
+                        &mut param,
+                    );
+                    if r == MAILIMF_NO_ERROR as libc::c_int {
+                        r = clist_insert_after(list, (*list).last, param as *mut libc::c_void);
+                        if !(r < 0i32) {
+                            continue;
+                        }
+                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                        current_block = 18290070879695007868;
+                        break;
+                    } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                        cur_token = final_token;
+                        current_block = 652864300344834934;
+                        break;
+                    } else {
+                        res = r;
+                        current_block = 18290070879695007868;
+                        break;
+                    }
+                } else {
+                    /* do nothing */
+                    if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                        current_block = 652864300344834934;
+                        break;
+                    }
+                    res = r;
+                    current_block = 18290070879695007868;
+                    break;
+                }
+            }
+            match current_block {
+                652864300344834934 => {
+                    dsp = mailmime_disposition_new(dsp_type, list);
+                    if dsp.is_null() {
+                        res = MAILIMF_ERROR_MEMORY as libc::c_int
+                    } else {
+                        *result = dsp;
+                        *indx = cur_token;
+                        return MAILIMF_NO_ERROR as libc::c_int;
+                    }
+                }
+                _ => {}
+            }
+            clist_foreach(
+                list,
+                ::std::mem::transmute::<
+                    Option<unsafe fn(_: *mut mailmime_disposition_parm) -> ()>,
+                    clist_func,
+                >(Some(mailmime_disposition_parm_free)),
+                0 as *mut libc::c_void,
+            );
+            clist_free(list);
+        }
+        mailmime_disposition_type_free(dsp_type);
+    }
+    return res;
+}
+/*
+ * libEtPan! -- a mail stuff library
+ *
+ * Copyright (C) 2001, 2005 - DINH Viet Hoa
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the libEtPan! project nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * $Id: mailmime_disposition.c,v 1.17 2011/05/03 16:30:22 hoa Exp $
+ */
+unsafe fn mailmime_disposition_parm_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut mailmime_disposition_parm,
+) -> libc::c_int {
+    let mut current_block: u64;
+    let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut creation_date: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut modification_date: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut read_date: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut size: size_t = 0;
+    let mut parameter: *mut mailmime_parameter = 0 as *mut mailmime_parameter;
+    let mut cur_token: size_t = 0;
+    let mut dsp_parm: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
+    let mut type_0: libc::c_int = 0;
+    let mut guessed_type: libc::c_int = 0;
+    let mut r: libc::c_int = 0;
+    let mut res: libc::c_int = 0;
+    cur_token = *indx;
+    filename = 0 as *mut libc::c_char;
+    creation_date = 0 as *mut libc::c_char;
+    modification_date = 0 as *mut libc::c_char;
+    read_date = 0 as *mut libc::c_char;
+    size = 0i32 as size_t;
+    parameter = 0 as *mut mailmime_parameter;
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        res = r
+    } else {
+        guessed_type = mailmime_disposition_guess_type(message, length, cur_token);
+        type_0 = MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int;
+        match guessed_type {
+            0 => {
+                r = mailmime_filename_parm_parse(message, length, &mut cur_token, &mut filename);
+                if r == MAILIMF_NO_ERROR as libc::c_int {
+                    type_0 = guessed_type;
+                    current_block = 13826291924415791078;
+                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                    current_block = 13826291924415791078;
+                } else {
+                    /* do nothing */
+                    res = r;
+                    current_block = 9120900589700563584;
+                }
+            }
+            1 => {
+                r = mailmime_creation_date_parm_parse(
+                    message,
+                    length,
+                    &mut cur_token,
+                    &mut creation_date,
+                );
+                if r == MAILIMF_NO_ERROR as libc::c_int {
+                    type_0 = guessed_type;
+                    current_block = 13826291924415791078;
+                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                    current_block = 13826291924415791078;
+                } else {
+                    /* do nothing */
+                    res = r;
+                    current_block = 9120900589700563584;
+                }
+            }
+            2 => {
+                r = mailmime_modification_date_parm_parse(
+                    message,
+                    length,
+                    &mut cur_token,
+                    &mut modification_date,
+                );
+                if r == MAILIMF_NO_ERROR as libc::c_int {
+                    type_0 = guessed_type;
+                    current_block = 13826291924415791078;
+                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                    current_block = 13826291924415791078;
+                } else {
+                    /* do nothing */
+                    res = r;
+                    current_block = 9120900589700563584;
+                }
+            }
+            3 => {
+                r = mailmime_read_date_parm_parse(message, length, &mut cur_token, &mut read_date);
+                if r == MAILIMF_NO_ERROR as libc::c_int {
+                    type_0 = guessed_type;
+                    current_block = 13826291924415791078;
+                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                    current_block = 13826291924415791078;
+                } else {
+                    /* do nothing */
+                    res = r;
+                    current_block = 9120900589700563584;
+                }
+            }
+            4 => {
+                r = mailmime_size_parm_parse(message, length, &mut cur_token, &mut size);
+                if r == MAILIMF_NO_ERROR as libc::c_int {
+                    type_0 = guessed_type;
+                    current_block = 13826291924415791078;
+                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
+                    current_block = 13826291924415791078;
+                } else {
+                    /* do nothing */
+                    res = r;
+                    current_block = 9120900589700563584;
+                }
+            }
+            _ => {
+                current_block = 13826291924415791078;
+            }
+        }
+        match current_block {
+            9120900589700563584 => {}
+            _ => {
+                if type_0 == MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int {
+                    r = mailmime_parameter_parse(message, length, &mut cur_token, &mut parameter);
+                    if r != MAILIMF_NO_ERROR as libc::c_int {
+                        type_0 = guessed_type;
+                        res = r;
+                        current_block = 9120900589700563584;
+                    } else {
+                        current_block = 6721012065216013753;
+                    }
+                } else {
+                    current_block = 6721012065216013753;
+                }
+                match current_block {
+                    9120900589700563584 => {}
+                    _ => {
+                        dsp_parm = mailmime_disposition_parm_new(
+                            type_0,
+                            filename,
+                            creation_date,
+                            modification_date,
+                            read_date,
+                            size,
+                            parameter,
+                        );
+                        if dsp_parm.is_null() {
+                            res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                            if !filename.is_null() {
+                                mailmime_filename_parm_free(filename);
+                            }
+                            if !creation_date.is_null() {
+                                mailmime_creation_date_parm_free(creation_date);
+                            }
+                            if !modification_date.is_null() {
+                                mailmime_modification_date_parm_free(modification_date);
+                            }
+                            if !read_date.is_null() {
+                                mailmime_read_date_parm_free(read_date);
+                            }
+                            if !parameter.is_null() {
+                                mailmime_parameter_free(parameter);
+                            }
+                        } else {
+                            *result = dsp_parm;
+                            *indx = cur_token;
+                            return MAILIMF_NO_ERROR as libc::c_int;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return res;
+}
+unsafe fn mailmime_size_parm_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut size_t,
+) -> libc::c_int {
+    let mut value: uint32_t = 0;
+    let mut cur_token: size_t = 0;
+    let mut r: libc::c_int = 0;
+    cur_token = *indx;
+    r = mailimf_token_case_insensitive_len_parse(
+        message,
+        length,
+        &mut cur_token,
+        b"size\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+        strlen(b"size\x00" as *const u8 as *const libc::c_char),
+    );
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        return r;
+    }
+    r = mailimf_number_parse(message, length, &mut cur_token, &mut value);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    *indx = cur_token;
+    *result = value as size_t;
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+unsafe fn mailmime_read_date_parm_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut cur_token: size_t = 0;
+    let mut r: libc::c_int = 0;
+    cur_token = *indx;
+    r = mailimf_token_case_insensitive_len_parse(
+        message,
+        length,
+        &mut cur_token,
+        b"read-date\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+        strlen(b"read-date\x00" as *const u8 as *const libc::c_char),
+    );
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        return r;
+    }
+    r = mailmime_quoted_date_time_parse(message, length, &mut cur_token, &mut value);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    *indx = cur_token;
+    *result = value;
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+unsafe fn mailmime_quoted_date_time_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    return mailimf_quoted_string_parse(message, length, indx, result);
+}
+unsafe fn mailmime_modification_date_parm_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut cur_token: size_t = 0;
+    let mut r: libc::c_int = 0;
+    cur_token = *indx;
+    r = mailimf_token_case_insensitive_len_parse(
+        message,
+        length,
+        &mut cur_token,
+        b"modification-date\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+        strlen(b"modification-date\x00" as *const u8 as *const libc::c_char),
+    );
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        return r;
+    }
+    r = mailmime_quoted_date_time_parse(message, length, &mut cur_token, &mut value);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    *indx = cur_token;
+    *result = value;
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+unsafe fn mailmime_creation_date_parm_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut r: libc::c_int = 0;
+    let mut cur_token: size_t = 0;
+    cur_token = *indx;
+    r = mailimf_token_case_insensitive_len_parse(
+        message,
+        length,
+        &mut cur_token,
+        b"creation-date\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+        strlen(b"creation-date\x00" as *const u8 as *const libc::c_char),
+    );
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        return r;
+    }
+    r = mailmime_quoted_date_time_parse(message, length, &mut cur_token, &mut value);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    *indx = cur_token;
+    *result = value;
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+unsafe fn mailmime_filename_parm_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut libc::c_char,
+) -> libc::c_int {
+    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut r: libc::c_int = 0;
+    let mut cur_token: size_t = 0;
+    cur_token = *indx;
+    r = mailimf_token_case_insensitive_len_parse(
+        message,
+        length,
+        &mut cur_token,
+        b"filename\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+        strlen(b"filename\x00" as *const u8 as *const libc::c_char),
+    );
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        return r;
+    }
+    r = mailmime_value_parse(message, length, &mut cur_token, &mut value);
+    if r != MAILIMF_NO_ERROR as libc::c_int {
+        return r;
+    }
+    *indx = cur_token;
+    *result = value;
+    return MAILIMF_NO_ERROR as libc::c_int;
+}
+
+pub unsafe fn mailmime_disposition_guess_type(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: size_t,
+) -> libc::c_int {
+    if indx >= length {
+        return MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int;
+    }
+    match toupper(*message.offset(indx as isize) as libc::c_uchar as libc::c_int) as libc::c_char
+        as libc::c_int
+    {
+        70 => return MAILMIME_DISPOSITION_PARM_FILENAME as libc::c_int,
+        67 => return MAILMIME_DISPOSITION_PARM_CREATION_DATE as libc::c_int,
+        77 => return MAILMIME_DISPOSITION_PARM_MODIFICATION_DATE as libc::c_int,
+        82 => return MAILMIME_DISPOSITION_PARM_READ_DATE as libc::c_int,
+        83 => return MAILMIME_DISPOSITION_PARM_SIZE as libc::c_int,
+        _ => return MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int,
+    };
+}
+
+pub unsafe fn mailmime_disposition_type_parse(
+    mut message: *const libc::c_char,
+    mut length: size_t,
+    mut indx: *mut size_t,
+    mut result: *mut *mut mailmime_disposition_type,
+) -> libc::c_int {
+    let mut cur_token: size_t = 0;
+    let mut type_0: libc::c_int = 0;
+    let mut extension: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mut dsp_type: *mut mailmime_disposition_type = 0 as *mut mailmime_disposition_type;
+    let mut r: libc::c_int = 0;
+    let mut res: libc::c_int = 0;
+    cur_token = *indx;
+    r = mailimf_cfws_parse(message, length, &mut cur_token);
+    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
+        res = r
+    } else {
+        type_0 = MAILMIME_DISPOSITION_TYPE_ERROR as libc::c_int;
+        extension = 0 as *mut libc::c_char;
+        r = mailimf_token_case_insensitive_len_parse(
+            message,
+            length,
+            &mut cur_token,
+            b"inline\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+            strlen(b"inline\x00" as *const u8 as *const libc::c_char),
+        );
+        if r == MAILIMF_NO_ERROR as libc::c_int {
+            type_0 = MAILMIME_DISPOSITION_TYPE_INLINE as libc::c_int
+        }
+        if r == MAILIMF_ERROR_PARSE as libc::c_int {
+            r = mailimf_token_case_insensitive_len_parse(
+                message,
+                length,
+                &mut cur_token,
+                b"attachment\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
+                strlen(b"attachment\x00" as *const u8 as *const libc::c_char),
+            );
+            if r == MAILIMF_NO_ERROR as libc::c_int {
+                type_0 = MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int
+            }
+        }
+        if r == MAILIMF_ERROR_PARSE as libc::c_int {
+            r = mailmime_extension_token_parse(message, length, &mut cur_token, &mut extension);
+            if r == MAILIMF_NO_ERROR as libc::c_int {
+                type_0 = MAILMIME_DISPOSITION_TYPE_EXTENSION as libc::c_int
+            }
+        }
+        if r != MAILIMF_NO_ERROR as libc::c_int {
+            res = r
+        } else {
+            dsp_type = mailmime_disposition_type_new(type_0, extension);
+            if dsp_type.is_null() {
+                res = MAILIMF_ERROR_MEMORY as libc::c_int;
+                if !extension.is_null() {
+                    free(extension as *mut libc::c_void);
+                }
+            } else {
+                *result = dsp_type;
+                *indx = cur_token;
+                return MAILIMF_NO_ERROR as libc::c_int;
+            }
+        }
+    }
+    return res;
+}

mmime/src/mailmime/types.rs

@@ -0,0 +1,891 @@
+use crate::clist::*;
+use crate::mailimf::types::*;
+use crate::mmapstring::*;
+use crate::other::*;
+
+pub const MAILMIME_MECHANISM_TOKEN: libc::c_uint = 6;
+pub const MAILMIME_MECHANISM_BASE64: libc::c_uint = 5;
+pub const MAILMIME_MECHANISM_QUOTED_PRINTABLE: libc::c_uint = 4;
+pub const MAILMIME_MECHANISM_BINARY: libc::c_uint = 3;
+pub const MAILMIME_MECHANISM_8BIT: libc::c_uint = 2;
+pub const MAILMIME_MECHANISM_7BIT: libc::c_uint = 1;
+pub const MAILMIME_MECHANISM_ERROR: libc::c_uint = 0;
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_composite_type {
+    pub ct_type: libc::c_int,
+    pub ct_token: *mut libc::c_char,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_content {
+    pub ct_type: *mut mailmime_type,
+    pub ct_subtype: *mut libc::c_char,
+    pub ct_parameters: *mut clist,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_type {
+    pub tp_type: libc::c_int,
+    pub tp_data: unnamed,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union unnamed {
+    pub tp_discrete_type: *mut mailmime_discrete_type,
+    pub tp_composite_type: *mut mailmime_composite_type,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_discrete_type {
+    pub dt_type: libc::c_int,
+    pub dt_extension: *mut libc::c_char,
+}
+pub type unnamed_0 = libc::c_uint;
+pub const MAILMIME_FIELD_LOCATION: unnamed_0 = 8;
+pub const MAILMIME_FIELD_LANGUAGE: unnamed_0 = 7;
+pub const MAILMIME_FIELD_DISPOSITION: unnamed_0 = 6;
+pub const MAILMIME_FIELD_VERSION: unnamed_0 = 5;
+pub const MAILMIME_FIELD_DESCRIPTION: unnamed_0 = 4;
+pub const MAILMIME_FIELD_ID: unnamed_0 = 3;
+pub const MAILMIME_FIELD_TRANSFER_ENCODING: unnamed_0 = 2;
+pub const MAILMIME_FIELD_TYPE: unnamed_0 = 1;
+pub const MAILMIME_FIELD_NONE: unnamed_0 = 0;
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_field {
+    pub fld_type: libc::c_int,
+    pub fld_data: unnamed_1,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union unnamed_1 {
+    pub fld_content: *mut mailmime_content,
+    pub fld_encoding: *mut mailmime_mechanism,
+    pub fld_id: *mut libc::c_char,
+    pub fld_description: *mut libc::c_char,
+    pub fld_version: uint32_t,
+    pub fld_disposition: *mut mailmime_disposition,
+    pub fld_language: *mut mailmime_language,
+    pub fld_location: *mut libc::c_char,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_language {
+    pub lg_list: *mut clist,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_disposition {
+    pub dsp_type: *mut mailmime_disposition_type,
+    pub dsp_parms: *mut clist,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_disposition_type {
+    pub dsp_type: libc::c_int,
+    pub dsp_extension: *mut libc::c_char,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_mechanism {
+    pub enc_type: libc::c_int,
+    pub enc_token: *mut libc::c_char,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_fields {
+    pub fld_list: *mut clist,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_parameter {
+    pub pa_name: *mut libc::c_char,
+    pub pa_value: *mut libc::c_char,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_disposition_parm {
+    pub pa_type: libc::c_int,
+    pub pa_data: unnamed_3,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union unnamed_3 {
+    pub pa_filename: *mut libc::c_char,
+    pub pa_creation_date: *mut libc::c_char,
+    pub pa_modification_date: *mut libc::c_char,
+    pub pa_read_date: *mut libc::c_char,
+    pub pa_size: size_t,
+    pub pa_parameter: *mut mailmime_parameter,
+}
+pub const MAILMIME_DISPOSITION_PARM_PARAMETER: unnamed_11 = 5;
+pub const MAILMIME_DISPOSITION_PARM_READ_DATE: unnamed_11 = 3;
+pub const MAILMIME_DISPOSITION_PARM_MODIFICATION_DATE: unnamed_11 = 2;
+pub const MAILMIME_DISPOSITION_PARM_CREATION_DATE: unnamed_11 = 1;
+pub const MAILMIME_DISPOSITION_PARM_FILENAME: unnamed_11 = 0;
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_multipart_body {
+    pub bd_list: *mut clist,
+}
+pub type unnamed_4 = libc::c_uint;
+pub const MAILMIME_DATA_FILE: unnamed_4 = 1;
+pub const MAILMIME_DATA_TEXT: unnamed_4 = 0;
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_data {
+    pub dt_type: libc::c_int,
+    pub dt_encoding: libc::c_int,
+    pub dt_encoded: libc::c_int,
+    pub dt_data: unnamed_5,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union unnamed_5 {
+    pub dt_text: unnamed_6,
+    pub dt_filename: *mut libc::c_char,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct unnamed_6 {
+    pub dt_data: *const libc::c_char,
+    pub dt_length: size_t,
+}
+pub type unnamed_7 = libc::c_uint;
+pub const MAILMIME_MESSAGE: unnamed_7 = 3;
+pub const MAILMIME_MULTIPLE: unnamed_7 = 2;
+pub const MAILMIME_SINGLE: unnamed_7 = 1;
+pub const MAILMIME_NONE: unnamed_7 = 0;
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct Mailmime {
+    pub mm_parent_type: libc::c_int,
+    pub mm_parent: *mut Mailmime,
+    pub mm_multipart_pos: *mut clistiter,
+    pub mm_type: libc::c_int,
+    pub mm_mime_start: *const libc::c_char,
+    pub mm_length: size_t,
+    pub mm_mime_fields: *mut mailmime_fields,
+    pub mm_content_type: *mut mailmime_content,
+    pub mm_body: *mut mailmime_data,
+    pub mm_data: unnamed_8,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union unnamed_8 {
+    pub mm_single: *mut mailmime_data,
+    pub mm_multipart: unnamed_10,
+    pub mm_message: unnamed_9,
+}
+/* message */
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct unnamed_9 {
+    pub mm_fields: *mut mailimf_fields,
+    pub mm_msg_mime: *mut Mailmime,
+}
+/* multi-part */
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct unnamed_10 {
+    pub mm_preamble: *mut mailmime_data,
+    pub mm_epilogue: *mut mailmime_data,
+    pub mm_mp_list: *mut clist,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_encoded_word {
+    pub wd_charset: *mut libc::c_char,
+    pub wd_text: *mut libc::c_char,
+}
+pub type unnamed_11 = libc::c_uint;
+pub const MAILMIME_DISPOSITION_PARM_SIZE: unnamed_11 = 4;
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct mailmime_section {
+    pub sec_list: *mut clist,
+}
+
+pub unsafe fn mailmime_attribute_free(mut attribute: *mut libc::c_char) {
+    mailmime_token_free(attribute);
+}
+
+pub unsafe fn mailmime_token_free(mut token: *mut libc::c_char) {
+    free(token as *mut libc::c_void);
+}
+pub unsafe fn mailmime_composite_type_new(
+    mut ct_type: libc::c_int,
+    mut ct_token: *mut libc::c_char,
+) -> *mut mailmime_composite_type {
+    let mut ct: *mut mailmime_composite_type = 0 as *mut mailmime_composite_type;
+    ct = malloc(::std::mem::size_of::<mailmime_composite_type>() as libc::size_t)
+        as *mut mailmime_composite_type;
+    if ct.is_null() {
+        return 0 as *mut mailmime_composite_type;
+    }
+    (*ct).ct_type = ct_type;
+    (*ct).ct_token = ct_token;
+    return ct;
+}
+
+pub unsafe fn mailmime_composite_type_free(mut ct: *mut mailmime_composite_type) {
+    if !(*ct).ct_token.is_null() {
+        mailmime_extension_token_free((*ct).ct_token);
+    }
+    free(ct as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_extension_token_free(mut extension: *mut libc::c_char) {
+    mailmime_token_free(extension);
+}
+
+pub unsafe fn mailmime_content_new(
+    mut ct_type: *mut mailmime_type,
+    mut ct_subtype: *mut libc::c_char,
+    mut ct_parameters: *mut clist,
+) -> *mut mailmime_content {
+    let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
+    content =
+        malloc(::std::mem::size_of::<mailmime_content>() as libc::size_t) as *mut mailmime_content;
+    if content.is_null() {
+        return 0 as *mut mailmime_content;
+    }
+    (*content).ct_type = ct_type;
+    (*content).ct_subtype = ct_subtype;
+    (*content).ct_parameters = ct_parameters;
+    return content;
+}
+
+pub unsafe fn mailmime_content_free(mut content: *mut mailmime_content) {
+    mailmime_type_free((*content).ct_type);
+    mailmime_subtype_free((*content).ct_subtype);
+    if !(*content).ct_parameters.is_null() {
+        clist_foreach(
+            (*content).ct_parameters,
+            ::std::mem::transmute::<Option<unsafe fn(_: *mut mailmime_parameter) -> ()>, clist_func>(
+                Some(mailmime_parameter_free),
+            ),
+            0 as *mut libc::c_void,
+        );
+        clist_free((*content).ct_parameters);
+    }
+    free(content as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_parameter_free(mut parameter: *mut mailmime_parameter) {
+    mailmime_attribute_free((*parameter).pa_name);
+    mailmime_value_free((*parameter).pa_value);
+    free(parameter as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_value_free(mut value: *mut libc::c_char) {
+    free(value as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_subtype_free(mut subtype: *mut libc::c_char) {
+    mailmime_extension_token_free(subtype);
+}
+
+pub unsafe fn mailmime_type_free(mut type_0: *mut mailmime_type) {
+    match (*type_0).tp_type {
+        1 => {
+            mailmime_discrete_type_free((*type_0).tp_data.tp_discrete_type);
+        }
+        2 => {
+            mailmime_composite_type_free((*type_0).tp_data.tp_composite_type);
+        }
+        _ => {}
+    }
+    free(type_0 as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_discrete_type_free(mut discrete_type: *mut mailmime_discrete_type) {
+    if !(*discrete_type).dt_extension.is_null() {
+        mailmime_extension_token_free((*discrete_type).dt_extension);
+    }
+    free(discrete_type as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_description_free(mut description: *mut libc::c_char) {
+    free(description as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_location_free(mut location: *mut libc::c_char) {
+    free(location as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_discrete_type_new(
+    mut dt_type: libc::c_int,
+    mut dt_extension: *mut libc::c_char,
+) -> *mut mailmime_discrete_type {
+    let mut discrete_type: *mut mailmime_discrete_type = 0 as *mut mailmime_discrete_type;
+    discrete_type = malloc(::std::mem::size_of::<mailmime_discrete_type>() as libc::size_t)
+        as *mut mailmime_discrete_type;
+    if discrete_type.is_null() {
+        return 0 as *mut mailmime_discrete_type;
+    }
+    (*discrete_type).dt_type = dt_type;
+    (*discrete_type).dt_extension = dt_extension;
+    return discrete_type;
+}
+
+pub unsafe fn mailmime_encoding_free(mut encoding: *mut mailmime_mechanism) {
+    mailmime_mechanism_free(encoding);
+}
+
+pub unsafe fn mailmime_mechanism_free(mut mechanism: *mut mailmime_mechanism) {
+    if !(*mechanism).enc_token.is_null() {
+        mailmime_token_free((*mechanism).enc_token);
+    }
+    free(mechanism as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_id_free(mut id: *mut libc::c_char) {
+    mailimf_msg_id_free(id);
+}
+
+pub unsafe fn mailmime_mechanism_new(
+    mut enc_type: libc::c_int,
+    mut enc_token: *mut libc::c_char,
+) -> *mut mailmime_mechanism {
+    let mut mechanism: *mut mailmime_mechanism = 0 as *mut mailmime_mechanism;
+    mechanism = malloc(::std::mem::size_of::<mailmime_mechanism>() as libc::size_t)
+        as *mut mailmime_mechanism;
+    if mechanism.is_null() {
+        return 0 as *mut mailmime_mechanism;
+    }
+    (*mechanism).enc_type = enc_type;
+    (*mechanism).enc_token = enc_token;
+    return mechanism;
+}
+
+pub unsafe fn mailmime_parameter_new(
+    mut pa_name: *mut libc::c_char,
+    mut pa_value: *mut libc::c_char,
+) -> *mut mailmime_parameter {
+    let mut parameter: *mut mailmime_parameter = 0 as *mut mailmime_parameter;
+    parameter = malloc(::std::mem::size_of::<mailmime_parameter>() as libc::size_t)
+        as *mut mailmime_parameter;
+    if parameter.is_null() {
+        return 0 as *mut mailmime_parameter;
+    }
+    (*parameter).pa_name = pa_name;
+    (*parameter).pa_value = pa_value;
+    return parameter;
+}
+
+pub unsafe fn mailmime_type_new(
+    mut tp_type: libc::c_int,
+    mut tp_discrete_type: *mut mailmime_discrete_type,
+    mut tp_composite_type: *mut mailmime_composite_type,
+) -> *mut mailmime_type {
+    let mut mime_type: *mut mailmime_type = 0 as *mut mailmime_type;
+    mime_type =
+        malloc(::std::mem::size_of::<mailmime_type>() as libc::size_t) as *mut mailmime_type;
+    if mime_type.is_null() {
+        return 0 as *mut mailmime_type;
+    }
+    (*mime_type).tp_type = tp_type;
+    match tp_type {
+        1 => (*mime_type).tp_data.tp_discrete_type = tp_discrete_type,
+        2 => (*mime_type).tp_data.tp_composite_type = tp_composite_type,
+        _ => {}
+    }
+    return mime_type;
+}
+
+pub unsafe fn mailmime_language_new(mut lg_list: *mut clist) -> *mut mailmime_language {
+    let mut lang: *mut mailmime_language = 0 as *mut mailmime_language;
+    lang = malloc(::std::mem::size_of::<mailmime_language>() as libc::size_t)
+        as *mut mailmime_language;
+    if lang.is_null() {
+        return 0 as *mut mailmime_language;
+    }
+    (*lang).lg_list = lg_list;
+    return lang;
+}
+
+pub unsafe fn mailmime_language_free(mut lang: *mut mailmime_language) {
+    clist_foreach(
+        (*lang).lg_list,
+        ::std::mem::transmute::<Option<unsafe fn(_: *mut libc::c_char) -> ()>, clist_func>(Some(
+            mailimf_atom_free,
+        )),
+        0 as *mut libc::c_void,
+    );
+    clist_free((*lang).lg_list);
+    free(lang as *mut libc::c_void);
+}
+/*
+void mailmime_x_token_free(gchar * x_token);
+*/
+pub unsafe fn mailmime_field_new(
+    mut fld_type: libc::c_int,
+    mut fld_content: *mut mailmime_content,
+    mut fld_encoding: *mut mailmime_mechanism,
+    mut fld_id: *mut libc::c_char,
+    mut fld_description: *mut libc::c_char,
+    mut fld_version: uint32_t,
+    mut fld_disposition: *mut mailmime_disposition,
+    mut fld_language: *mut mailmime_language,
+    mut fld_location: *mut libc::c_char,
+) -> *mut mailmime_field {
+    let mut field: *mut mailmime_field = 0 as *mut mailmime_field;
+    field = malloc(::std::mem::size_of::<mailmime_field>() as libc::size_t) as *mut mailmime_field;
+    if field.is_null() {
+        return 0 as *mut mailmime_field;
+    }
+    (*field).fld_type = fld_type;
+    match fld_type {
+        1 => (*field).fld_data.fld_content = fld_content,
+        2 => (*field).fld_data.fld_encoding = fld_encoding,
+        3 => (*field).fld_data.fld_id = fld_id,
+        4 => (*field).fld_data.fld_description = fld_description,
+        5 => (*field).fld_data.fld_version = fld_version,
+        6 => (*field).fld_data.fld_disposition = fld_disposition,
+        7 => (*field).fld_data.fld_language = fld_language,
+        8 => (*field).fld_data.fld_location = fld_location,
+        _ => {}
+    }
+    return field;
+}
+
+pub unsafe fn mailmime_field_free(mut field: *mut mailmime_field) {
+    match (*field).fld_type {
+        1 => {
+            if !(*field).fld_data.fld_content.is_null() {
+                mailmime_content_free((*field).fld_data.fld_content);
+            }
+        }
+        2 => {
+            if !(*field).fld_data.fld_encoding.is_null() {
+                mailmime_encoding_free((*field).fld_data.fld_encoding);
+            }
+        }
+        3 => {
+            if !(*field).fld_data.fld_id.is_null() {
+                mailmime_id_free((*field).fld_data.fld_id);
+            }
+        }
+        4 => {
+            if !(*field).fld_data.fld_description.is_null() {
+                mailmime_description_free((*field).fld_data.fld_description);
+            }
+        }
+        6 => {
+            if !(*field).fld_data.fld_disposition.is_null() {
+                mailmime_disposition_free((*field).fld_data.fld_disposition);
+            }
+        }
+        7 => {
+            if !(*field).fld_data.fld_language.is_null() {
+                mailmime_language_free((*field).fld_data.fld_language);
+            }
+        }
+        8 => {
+            if !(*field).fld_data.fld_location.is_null() {
+                mailmime_location_free((*field).fld_data.fld_location);
+            }
+        }
+        _ => {}
+    }
+    free(field as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_disposition_free(mut dsp: *mut mailmime_disposition) {
+    mailmime_disposition_type_free((*dsp).dsp_type);
+    clist_foreach(
+        (*dsp).dsp_parms,
+        ::std::mem::transmute::<
+            Option<unsafe fn(_: *mut mailmime_disposition_parm) -> ()>,
+            clist_func,
+        >(Some(mailmime_disposition_parm_free)),
+        0 as *mut libc::c_void,
+    );
+    clist_free((*dsp).dsp_parms);
+    free(dsp as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_disposition_parm_free(mut dsp_parm: *mut mailmime_disposition_parm) {
+    match (*dsp_parm).pa_type {
+        0 => {
+            mailmime_filename_parm_free((*dsp_parm).pa_data.pa_filename);
+        }
+        1 => {
+            mailmime_creation_date_parm_free((*dsp_parm).pa_data.pa_creation_date);
+        }
+        2 => {
+            mailmime_modification_date_parm_free((*dsp_parm).pa_data.pa_modification_date);
+        }
+        3 => {
+            mailmime_read_date_parm_free((*dsp_parm).pa_data.pa_read_date);
+        }
+        5 => {
+            mailmime_parameter_free((*dsp_parm).pa_data.pa_parameter);
+        }
+        _ => {}
+    }
+    free(dsp_parm as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_read_date_parm_free(mut date: *mut libc::c_char) {
+    mailmime_quoted_date_time_free(date);
+}
+
+pub unsafe fn mailmime_quoted_date_time_free(mut date: *mut libc::c_char) {
+    mailimf_quoted_string_free(date);
+}
+
+pub unsafe fn mailmime_modification_date_parm_free(mut date: *mut libc::c_char) {
+    mailmime_quoted_date_time_free(date);
+}
+
+pub unsafe fn mailmime_creation_date_parm_free(mut date: *mut libc::c_char) {
+    mailmime_quoted_date_time_free(date);
+}
+
+pub unsafe fn mailmime_filename_parm_free(mut filename: *mut libc::c_char) {
+    mailmime_value_free(filename);
+}
+
+pub unsafe fn mailmime_disposition_type_free(mut dsp_type: *mut mailmime_disposition_type) {
+    if !(*dsp_type).dsp_extension.is_null() {
+        free((*dsp_type).dsp_extension as *mut libc::c_void);
+    }
+    free(dsp_type as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_fields_new(mut fld_list: *mut clist) -> *mut mailmime_fields {
+    let mut fields: *mut mailmime_fields = 0 as *mut mailmime_fields;
+    fields =
+        malloc(::std::mem::size_of::<mailmime_fields>() as libc::size_t) as *mut mailmime_fields;
+    if fields.is_null() {
+        return 0 as *mut mailmime_fields;
+    }
+    (*fields).fld_list = fld_list;
+    return fields;
+}
+
+pub unsafe fn mailmime_fields_free(mut fields: *mut mailmime_fields) {
+    clist_foreach(
+        (*fields).fld_list,
+        ::std::mem::transmute::<Option<unsafe fn(_: *mut mailmime_field) -> ()>, clist_func>(Some(
+            mailmime_field_free,
+        )),
+        0 as *mut libc::c_void,
+    );
+    clist_free((*fields).fld_list);
+    free(fields as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_multipart_body_new(mut bd_list: *mut clist) -> *mut mailmime_multipart_body {
+    let mut mp_body: *mut mailmime_multipart_body = 0 as *mut mailmime_multipart_body;
+    mp_body = malloc(::std::mem::size_of::<mailmime_multipart_body>() as libc::size_t)
+        as *mut mailmime_multipart_body;
+    if mp_body.is_null() {
+        return 0 as *mut mailmime_multipart_body;
+    }
+    (*mp_body).bd_list = bd_list;
+    return mp_body;
+}
+
+pub unsafe fn mailmime_multipart_body_free(mut mp_body: *mut mailmime_multipart_body) {
+    clist_foreach(
+        (*mp_body).bd_list,
+        ::std::mem::transmute::<Option<unsafe fn(_: *mut mailimf_body) -> ()>, clist_func>(Some(
+            mailimf_body_free,
+        )),
+        0 as *mut libc::c_void,
+    );
+    clist_free((*mp_body).bd_list);
+    free(mp_body as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_data_new(
+    mut dt_type: libc::c_int,
+    mut dt_encoding: libc::c_int,
+    mut dt_encoded: libc::c_int,
+    mut dt_data: *const libc::c_char,
+    mut dt_length: size_t,
+    mut dt_filename: *mut libc::c_char,
+) -> *mut mailmime_data {
+    let mut mime_data: *mut mailmime_data = 0 as *mut mailmime_data;
+    mime_data =
+        malloc(::std::mem::size_of::<mailmime_data>() as libc::size_t) as *mut mailmime_data;
+    if mime_data.is_null() {
+        return 0 as *mut mailmime_data;
+    }
+    (*mime_data).dt_type = dt_type;
+    (*mime_data).dt_encoding = dt_encoding;
+    (*mime_data).dt_encoded = dt_encoded;
+    match dt_type {
+        0 => {
+            (*mime_data).dt_data.dt_text.dt_data = dt_data;
+            (*mime_data).dt_data.dt_text.dt_length = dt_length
+        }
+        1 => (*mime_data).dt_data.dt_filename = dt_filename,
+        _ => {}
+    }
+    return mime_data;
+}
+
+pub unsafe fn mailmime_data_free(mut mime_data: *mut mailmime_data) {
+    match (*mime_data).dt_type {
+        1 => {
+            free((*mime_data).dt_data.dt_filename as *mut libc::c_void);
+        }
+        _ => {}
+    }
+    free(mime_data as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_new(
+    mut mm_type: libc::c_int,
+    mut mm_mime_start: *const libc::c_char,
+    mut mm_length: size_t,
+    mut mm_mime_fields: *mut mailmime_fields,
+    mut mm_content_type: *mut mailmime_content,
+    mut mm_body: *mut mailmime_data,
+    mut mm_preamble: *mut mailmime_data,
+    mut mm_epilogue: *mut mailmime_data,
+    mut mm_mp_list: *mut clist,
+    mut mm_fields: *mut mailimf_fields,
+    mut mm_msg_mime: *mut Mailmime,
+) -> *mut Mailmime {
+    let mut mime: *mut Mailmime = 0 as *mut Mailmime;
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    mime = malloc(::std::mem::size_of::<Mailmime>() as libc::size_t) as *mut Mailmime;
+    if mime.is_null() {
+        return 0 as *mut Mailmime;
+    }
+    (*mime).mm_parent = 0 as *mut Mailmime;
+    (*mime).mm_parent_type = MAILMIME_NONE as libc::c_int;
+    (*mime).mm_multipart_pos = 0 as *mut clistiter;
+    (*mime).mm_type = mm_type;
+    (*mime).mm_mime_start = mm_mime_start;
+    (*mime).mm_length = mm_length;
+    (*mime).mm_mime_fields = mm_mime_fields;
+    (*mime).mm_content_type = mm_content_type;
+    (*mime).mm_body = mm_body;
+    match mm_type {
+        1 => (*mime).mm_data.mm_single = mm_body,
+        2 => {
+            (*mime).mm_data.mm_multipart.mm_preamble = mm_preamble;
+            (*mime).mm_data.mm_multipart.mm_epilogue = mm_epilogue;
+            (*mime).mm_data.mm_multipart.mm_mp_list = mm_mp_list;
+            cur = (*mm_mp_list).first;
+            while !cur.is_null() {
+                let mut submime: *mut Mailmime = 0 as *mut Mailmime;
+                submime = (if !cur.is_null() {
+                    (*cur).data
+                } else {
+                    0 as *mut libc::c_void
+                }) as *mut Mailmime;
+                (*submime).mm_parent = mime;
+                (*submime).mm_parent_type = MAILMIME_MULTIPLE as libc::c_int;
+                (*submime).mm_multipart_pos = cur;
+                cur = if !cur.is_null() {
+                    (*cur).next
+                } else {
+                    0 as *mut clistcell
+                }
+            }
+        }
+        3 => {
+            (*mime).mm_data.mm_message.mm_fields = mm_fields;
+            (*mime).mm_data.mm_message.mm_msg_mime = mm_msg_mime;
+            if !mm_msg_mime.is_null() {
+                (*mm_msg_mime).mm_parent = mime;
+                (*mm_msg_mime).mm_parent_type = MAILMIME_MESSAGE as libc::c_int
+            }
+        }
+        _ => {}
+    }
+    return mime;
+}
+
+pub unsafe fn mailmime_new_simple(
+    mut mm_type: libc::c_int,
+    mut mm_mime_fields: *mut mailmime_fields,
+    mut mm_content_type: *mut mailmime_content,
+    mut mm_fields: *mut mailimf_fields,
+    mut mm_msg_mime: *mut Mailmime,
+) -> *mut Mailmime {
+    mailmime_new(
+        mm_type,
+        std::ptr::null(),
+        0,
+        mm_mime_fields,
+        mm_content_type,
+        std::ptr::null_mut(),
+        std::ptr::null_mut(),
+        std::ptr::null_mut(),
+        std::ptr::null_mut(),
+        mm_fields,
+        mm_msg_mime,
+    )
+}
+
+pub unsafe fn mailmime_free(mut mime: *mut Mailmime) {
+    match (*mime).mm_type {
+        1 => {
+            if (*mime).mm_body.is_null() && !(*mime).mm_data.mm_single.is_null() {
+                mailmime_data_free((*mime).mm_data.mm_single);
+            }
+        }
+        2 => {
+            /* do nothing */
+            if !(*mime).mm_data.mm_multipart.mm_preamble.is_null() {
+                mailmime_data_free((*mime).mm_data.mm_multipart.mm_preamble);
+            }
+            if !(*mime).mm_data.mm_multipart.mm_epilogue.is_null() {
+                mailmime_data_free((*mime).mm_data.mm_multipart.mm_epilogue);
+            }
+            clist_foreach(
+                (*mime).mm_data.mm_multipart.mm_mp_list,
+                ::std::mem::transmute::<Option<unsafe fn(_: *mut Mailmime) -> ()>, clist_func>(
+                    Some(mailmime_free),
+                ),
+                0 as *mut libc::c_void,
+            );
+            clist_free((*mime).mm_data.mm_multipart.mm_mp_list);
+        }
+        3 => {
+            if !(*mime).mm_data.mm_message.mm_fields.is_null() {
+                mailimf_fields_free((*mime).mm_data.mm_message.mm_fields);
+            }
+            if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
+                mailmime_free((*mime).mm_data.mm_message.mm_msg_mime);
+            }
+        }
+        _ => {}
+    }
+    if !(*mime).mm_body.is_null() {
+        mailmime_data_free((*mime).mm_body);
+    }
+    if !(*mime).mm_mime_fields.is_null() {
+        mailmime_fields_free((*mime).mm_mime_fields);
+    }
+    if !(*mime).mm_content_type.is_null() {
+        mailmime_content_free((*mime).mm_content_type);
+    }
+    free(mime as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_encoded_word_new(
+    mut wd_charset: *mut libc::c_char,
+    mut wd_text: *mut libc::c_char,
+) -> *mut mailmime_encoded_word {
+    let mut ew: *mut mailmime_encoded_word = 0 as *mut mailmime_encoded_word;
+    ew = malloc(::std::mem::size_of::<mailmime_encoded_word>() as libc::size_t)
+        as *mut mailmime_encoded_word;
+    if ew.is_null() {
+        return 0 as *mut mailmime_encoded_word;
+    }
+    (*ew).wd_charset = wd_charset;
+    (*ew).wd_text = wd_text;
+    return ew;
+}
+
+pub unsafe fn mailmime_encoded_word_free(mut ew: *mut mailmime_encoded_word) {
+    mailmime_charset_free((*ew).wd_charset);
+    mailmime_encoded_text_free((*ew).wd_text);
+    free(ew as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_encoded_text_free(mut text: *mut libc::c_char) {
+    free(text as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_charset_free(mut charset: *mut libc::c_char) {
+    free(charset as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_disposition_new(
+    mut dsp_type: *mut mailmime_disposition_type,
+    mut dsp_parms: *mut clist,
+) -> *mut mailmime_disposition {
+    let mut dsp: *mut mailmime_disposition = 0 as *mut mailmime_disposition;
+    dsp = malloc(::std::mem::size_of::<mailmime_disposition>() as libc::size_t)
+        as *mut mailmime_disposition;
+    if dsp.is_null() {
+        return 0 as *mut mailmime_disposition;
+    }
+    (*dsp).dsp_type = dsp_type;
+    (*dsp).dsp_parms = dsp_parms;
+    return dsp;
+}
+
+pub unsafe fn mailmime_disposition_type_new(
+    mut dsp_type: libc::c_int,
+    mut dsp_extension: *mut libc::c_char,
+) -> *mut mailmime_disposition_type {
+    let mut m_dsp_type: *mut mailmime_disposition_type = 0 as *mut mailmime_disposition_type;
+    m_dsp_type = malloc(::std::mem::size_of::<mailmime_disposition_type>() as libc::size_t)
+        as *mut mailmime_disposition_type;
+    if m_dsp_type.is_null() {
+        return 0 as *mut mailmime_disposition_type;
+    }
+    (*m_dsp_type).dsp_type = dsp_type;
+    (*m_dsp_type).dsp_extension = dsp_extension;
+    return m_dsp_type;
+}
+
+pub unsafe fn mailmime_disposition_parm_new(
+    mut pa_type: libc::c_int,
+    mut pa_filename: *mut libc::c_char,
+    mut pa_creation_date: *mut libc::c_char,
+    mut pa_modification_date: *mut libc::c_char,
+    mut pa_read_date: *mut libc::c_char,
+    mut pa_size: size_t,
+    mut pa_parameter: *mut mailmime_parameter,
+) -> *mut mailmime_disposition_parm {
+    let mut dsp_parm: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
+    dsp_parm = malloc(::std::mem::size_of::<mailmime_disposition_parm>() as libc::size_t)
+        as *mut mailmime_disposition_parm;
+    if dsp_parm.is_null() {
+        return 0 as *mut mailmime_disposition_parm;
+    }
+    (*dsp_parm).pa_type = pa_type;
+    match pa_type {
+        0 => (*dsp_parm).pa_data.pa_filename = pa_filename,
+        1 => (*dsp_parm).pa_data.pa_creation_date = pa_creation_date,
+        2 => (*dsp_parm).pa_data.pa_modification_date = pa_modification_date,
+        3 => (*dsp_parm).pa_data.pa_read_date = pa_read_date,
+        4 => (*dsp_parm).pa_data.pa_size = pa_size,
+        5 => (*dsp_parm).pa_data.pa_parameter = pa_parameter,
+        _ => {}
+    }
+    return dsp_parm;
+}
+
+pub unsafe fn mailmime_section_new(mut sec_list: *mut clist) -> *mut mailmime_section {
+    let mut section: *mut mailmime_section = 0 as *mut mailmime_section;
+    section =
+        malloc(::std::mem::size_of::<mailmime_section>() as libc::size_t) as *mut mailmime_section;
+    if section.is_null() {
+        return 0 as *mut mailmime_section;
+    }
+    (*section).sec_list = sec_list;
+    return section;
+}
+
+pub unsafe fn mailmime_section_free(mut section: *mut mailmime_section) {
+    clist_foreach(
+        (*section).sec_list,
+        ::std::mem::transmute::<Option<unsafe extern "C" fn(_: *mut libc::c_void) -> ()>, clist_func>(
+            Some(free),
+        ),
+        0 as *mut libc::c_void,
+    );
+    clist_free((*section).sec_list);
+    free(section as *mut libc::c_void);
+}
+
+pub unsafe fn mailmime_decoded_part_free(mut part: *mut libc::c_char) {
+    mmap_string_unref(part);
+}

mmime/src/mailmime/write_mem.rs

@@ -0,0 +1,82 @@
+use crate::mailmime::types::*;
+use crate::mailmime::write_generic::*;
+use crate::mmapstring::*;
+use crate::other::*;
+
+unsafe fn do_write(
+    mut data: *mut libc::c_void,
+    mut str: *const libc::c_char,
+    mut length: size_t,
+) -> libc::c_int {
+    let mut f: *mut MMAPString = 0 as *mut MMAPString;
+    f = data as *mut MMAPString;
+    if mmap_string_append_len(f, str, length).is_null() {
+        return 0i32;
+    } else {
+        return length as libc::c_int;
+    };
+}
+
+pub unsafe fn mailmime_content_write_mem(
+    mut f: *mut MMAPString,
+    mut col: *mut libc::c_int,
+    mut content: *mut mailmime_content,
+) -> libc::c_int {
+    return mailmime_content_write_driver(Some(do_write), f as *mut libc::c_void, col, content);
+}
+
+pub unsafe fn mailmime_content_type_write_mem(
+    mut f: *mut MMAPString,
+    mut col: *mut libc::c_int,
+    mut content: *mut mailmime_content,
+) -> libc::c_int {
+    return mailmime_content_type_write_driver(
+        Some(do_write),
+        f as *mut libc::c_void,
+        col,
+        content,
+    );
+}
+
+pub unsafe fn mailmime_write_mem(
+    mut f: *mut MMAPString,
+    mut col: *mut libc::c_int,
+    mut build_info: *mut Mailmime,
+) -> libc::c_int {
+    return mailmime_write_driver(Some(do_write), f as *mut libc::c_void, col, build_info);
+}
+
+pub unsafe fn mailmime_quoted_printable_write_mem(
+    mut f: *mut MMAPString,
+    mut col: *mut libc::c_int,
+    mut istext: libc::c_int,
+    mut text: *const libc::c_char,
+    mut size: size_t,
+) -> libc::c_int {
+    return mailmime_quoted_printable_write_driver(
+        Some(do_write),
+        f as *mut libc::c_void,
+        col,
+        istext,
+        text,
+        size,
+    );
+}
+
+pub unsafe fn mailmime_base64_write_mem(
+    mut f: *mut MMAPString,
+    mut col: *mut libc::c_int,
+    mut text: *const libc::c_char,
+    mut size: size_t,
+) -> libc::c_int {
+    return mailmime_base64_write_driver(Some(do_write), f as *mut libc::c_void, col, text, size);
+}
+
+pub unsafe fn mailmime_data_write_mem(
+    mut f: *mut MMAPString,
+    mut col: *mut libc::c_int,
+    mut data: *mut mailmime_data,
+    mut istext: libc::c_int,
+) -> libc::c_int {
+    return mailmime_data_write_driver(Some(do_write), f as *mut libc::c_void, col, data, istext);
+}

mmime/src/mmapstring.rs

@@ -0,0 +1,397 @@
+use std::sync::Mutex;
+
+use lazy_static::lazy_static;
+use libc;
+
+use crate::chash::*;
+use crate::other::*;
+
+lazy_static! {
+    static ref mmapstring_lock: Mutex<()> = Mutex::new(());
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct MMAPString {
+    pub str_0: *mut libc::c_char,
+    pub len: size_t,
+    pub allocated_len: size_t,
+    pub fd: libc::c_int,
+    pub mmapped_size: size_t,
+}
+
+pub const TMPDIR: &'static str = "/tmp";
+
+pub unsafe fn mmap_string_new(mut init: *const libc::c_char) -> *mut MMAPString {
+    let mut string: *mut MMAPString = 0 as *mut MMAPString;
+    string = mmap_string_sized_new(if !init.is_null() {
+        strlen(init).wrapping_add(2i32 as libc::size_t)
+    } else {
+        2i32 as libc::size_t
+    });
+    if string.is_null() {
+        return 0 as *mut MMAPString;
+    }
+    if !init.is_null() {
+        mmap_string_append(string, init);
+    }
+    return string;
+}
+
+pub unsafe fn mmap_string_append(
+    mut string: *mut MMAPString,
+    mut val: *const libc::c_char,
+) -> *mut MMAPString {
+    return mmap_string_insert_len(string, (*string).len, val, strlen(val));
+}
+
+pub unsafe fn mmap_string_insert_len(
+    mut string: *mut MMAPString,
+    mut pos: size_t,
+    mut val: *const libc::c_char,
+    mut len: size_t,
+) -> *mut MMAPString {
+    if mmap_string_maybe_expand(string, len).is_null() {
+        return 0 as *mut MMAPString;
+    }
+    if pos < (*string).len {
+        memmove(
+            (*string).str_0.offset(pos as isize).offset(len as isize) as *mut libc::c_void,
+            (*string).str_0.offset(pos as isize) as *const libc::c_void,
+            (*string).len.wrapping_sub(pos),
+        );
+    }
+    memmove(
+        (*string).str_0.offset(pos as isize) as *mut libc::c_void,
+        val as *const libc::c_void,
+        len,
+    );
+    (*string).len = ((*string).len as libc::size_t).wrapping_add(len) as size_t as size_t;
+    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
+    return string;
+}
+unsafe fn mmap_string_maybe_expand(
+    mut string: *mut MMAPString,
+    mut len: size_t,
+) -> *mut MMAPString {
+    if (*string).len.wrapping_add(len) >= (*string).allocated_len {
+        let mut old_size: size_t = 0;
+        let mut newstring: *mut MMAPString = 0 as *mut MMAPString;
+        old_size = (*string).allocated_len;
+        (*string).allocated_len = nearest_power(
+            1i32 as size_t,
+            (*string)
+                .len
+                .wrapping_add(len)
+                .wrapping_add(1i32 as libc::size_t),
+        );
+        newstring = mmap_string_realloc_memory(string);
+        if newstring.is_null() {
+            (*string).allocated_len = old_size
+        }
+        return newstring;
+    }
+    return string;
+}
+/* Strings.
+ */
+/* SEB */
+unsafe fn mmap_string_realloc_memory(mut string: *mut MMAPString) -> *mut MMAPString {
+    let mut tmp: *mut libc::c_char = 0 as *mut libc::c_char;
+    tmp = realloc(
+        (*string).str_0 as *mut libc::c_void,
+        (*string).allocated_len,
+    ) as *mut libc::c_char;
+    if tmp.is_null() {
+        string = 0 as *mut MMAPString
+    } else {
+        (*string).str_0 = tmp
+    }
+    return string;
+}
+/* MMAPString */
+#[inline]
+unsafe fn nearest_power(mut base: size_t, mut num: size_t) -> size_t {
+    if num > (-1i32 as size_t).wrapping_div(2i32 as libc::size_t) {
+        return -1i32 as size_t;
+    } else {
+        let mut n: size_t = base;
+        while n < num {
+            n <<= 1i32
+        }
+        return n;
+    };
+}
+
+pub unsafe fn mmap_string_sized_new(mut dfl_size: size_t) -> *mut MMAPString {
+    let mut string: *mut MMAPString = 0 as *mut MMAPString;
+    string = malloc(::std::mem::size_of::<MMAPString>() as libc::size_t) as *mut MMAPString;
+    if string.is_null() {
+        return 0 as *mut MMAPString;
+    }
+    (*string).allocated_len = 0i32 as size_t;
+    (*string).len = 0i32 as size_t;
+    (*string).str_0 = 0 as *mut libc::c_char;
+    (*string).fd = -1i32;
+    (*string).mmapped_size = 0i32 as size_t;
+    if mmap_string_maybe_expand(
+        string,
+        if dfl_size > 2i32 as libc::size_t {
+            dfl_size
+        } else {
+            2i32 as libc::size_t
+        },
+    )
+    .is_null()
+    {
+        free(string as *mut libc::c_void);
+        return 0 as *mut MMAPString;
+    }
+    *(*string).str_0.offset(0isize) = 0i32 as libc::c_char;
+    return string;
+}
+
+pub unsafe fn mmap_string_new_len(
+    mut init: *const libc::c_char,
+    mut len: size_t,
+) -> *mut MMAPString {
+    let mut string: *mut MMAPString = 0 as *mut MMAPString;
+    if len <= 0i32 as libc::size_t {
+        return mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
+    } else {
+        string = mmap_string_sized_new(len);
+        if string.is_null() {
+            return string;
+        }
+        if !init.is_null() {
+            mmap_string_append_len(string, init, len);
+        }
+        return string;
+    };
+}
+
+pub unsafe fn mmap_string_append_len(
+    mut string: *mut MMAPString,
+    mut val: *const libc::c_char,
+    mut len: size_t,
+) -> *mut MMAPString {
+    return mmap_string_insert_len(string, (*string).len, val, len);
+}
+
+pub unsafe fn mmap_string_free(mut string: *mut MMAPString) {
+    if string.is_null() {
+        return;
+    }
+    free((*string).str_0 as *mut libc::c_void);
+    free(string as *mut libc::c_void);
+}
+
+pub unsafe fn mmap_string_assign(
+    mut string: *mut MMAPString,
+    mut rval: *const libc::c_char,
+) -> *mut MMAPString {
+    mmap_string_truncate(string, 0i32 as size_t);
+    if mmap_string_append(string, rval).is_null() {
+        return 0 as *mut MMAPString;
+    }
+    return string;
+}
+
+pub unsafe fn mmap_string_truncate(
+    mut string: *mut MMAPString,
+    mut len: size_t,
+) -> *mut MMAPString {
+    (*string).len = if len < (*string).len {
+        len
+    } else {
+        (*string).len
+    };
+    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
+    return string;
+}
+
+pub unsafe fn mmap_string_set_size(
+    mut string: *mut MMAPString,
+    mut len: size_t,
+) -> *mut MMAPString {
+    if len >= (*string).allocated_len {
+        if mmap_string_maybe_expand(string, len.wrapping_sub((*string).len)).is_null() {
+            return 0 as *mut MMAPString;
+        }
+    }
+    (*string).len = len;
+    *(*string).str_0.offset(len as isize) = 0i32 as libc::c_char;
+    return string;
+}
+
+pub unsafe fn mmap_string_append_c(
+    mut string: *mut MMAPString,
+    mut c: libc::c_char,
+) -> *mut MMAPString {
+    return mmap_string_insert_c(string, (*string).len, c);
+}
+
+pub unsafe fn mmap_string_insert_c(
+    mut string: *mut MMAPString,
+    mut pos: size_t,
+    mut c: libc::c_char,
+) -> *mut MMAPString {
+    if mmap_string_maybe_expand(string, 1i32 as size_t).is_null() {
+        return 0 as *mut MMAPString;
+    }
+    if pos < (*string).len {
+        memmove(
+            (*string).str_0.offset(pos as isize).offset(1isize) as *mut libc::c_void,
+            (*string).str_0.offset(pos as isize) as *const libc::c_void,
+            (*string).len.wrapping_sub(pos),
+        );
+    }
+    *(*string).str_0.offset(pos as isize) = c;
+    (*string).len =
+        ((*string).len as libc::size_t).wrapping_add(1i32 as libc::size_t) as size_t as size_t;
+    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
+    return string;
+}
+
+pub unsafe fn mmap_string_prepend(
+    mut string: *mut MMAPString,
+    mut val: *const libc::c_char,
+) -> *mut MMAPString {
+    return mmap_string_insert_len(string, 0i32 as size_t, val, strlen(val));
+}
+
+pub unsafe fn mmap_string_prepend_c(
+    mut string: *mut MMAPString,
+    mut c: libc::c_char,
+) -> *mut MMAPString {
+    return mmap_string_insert_c(string, 0i32 as size_t, c);
+}
+
+pub unsafe fn mmap_string_prepend_len(
+    mut string: *mut MMAPString,
+    mut val: *const libc::c_char,
+    mut len: size_t,
+) -> *mut MMAPString {
+    return mmap_string_insert_len(string, 0i32 as size_t, val, len);
+}
+
+pub unsafe fn mmap_string_insert(
+    mut string: *mut MMAPString,
+    mut pos: size_t,
+    mut val: *const libc::c_char,
+) -> *mut MMAPString {
+    return mmap_string_insert_len(string, pos, val, strlen(val));
+}
+
+pub unsafe fn mmap_string_erase(
+    mut string: *mut MMAPString,
+    mut pos: size_t,
+    mut len: size_t,
+) -> *mut MMAPString {
+    if pos.wrapping_add(len) < (*string).len {
+        memmove(
+            (*string).str_0.offset(pos as isize) as *mut libc::c_void,
+            (*string).str_0.offset(pos as isize).offset(len as isize) as *const libc::c_void,
+            (*string).len.wrapping_sub(pos.wrapping_add(len)),
+        );
+    }
+    (*string).len = ((*string).len as libc::size_t).wrapping_sub(len) as size_t as size_t;
+    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
+    return string;
+}
+
+pub unsafe fn mmap_string_set_ceil(mut ceil: size_t) {
+    mmap_string_ceil = ceil;
+}
+static mut mmap_string_ceil: size_t = (8i32 * 1024i32 * 1024i32) as size_t;
+
+pub unsafe fn mmap_string_ref(mut string: *mut MMAPString) -> libc::c_int {
+    let mut ht: *mut chash = 0 as *mut chash;
+    let mut r: libc::c_int = 0;
+    let mut key: chashdatum = chashdatum {
+        data: 0 as *mut libc::c_void,
+        len: 0,
+    };
+    let mut data: chashdatum = chashdatum {
+        data: 0 as *mut libc::c_void,
+        len: 0,
+    };
+    mmapstring_lock.lock().unwrap();
+    if mmapstring_hashtable.is_null() {
+        mmapstring_hashtable_init();
+    }
+    ht = mmapstring_hashtable;
+    if ht.is_null() {
+        return -1i32;
+    }
+    key.data = &mut (*string).str_0 as *mut *mut libc::c_char as *mut libc::c_void;
+    key.len = ::std::mem::size_of::<*mut libc::c_char>() as libc::size_t as libc::c_uint;
+    data.data = string as *mut libc::c_void;
+    data.len = 0i32 as libc::c_uint;
+    r = chash_set(
+        mmapstring_hashtable,
+        &mut key,
+        &mut data,
+        0 as *mut chashdatum,
+    );
+
+    if r < 0i32 {
+        return r;
+    }
+    return 0i32;
+}
+
+static mut mmapstring_hashtable: *mut chash = 0 as *const chash as *mut chash;
+unsafe fn mmapstring_hashtable_init() {
+    mmapstring_hashtable = chash_new(13i32 as libc::c_uint, 1i32);
+}
+
+pub unsafe fn mmap_string_unref(mut str: *mut libc::c_char) -> libc::c_int {
+    let mut string: *mut MMAPString = 0 as *mut MMAPString;
+    let mut ht: *mut chash = 0 as *mut chash;
+    let mut key: chashdatum = chashdatum {
+        data: 0 as *mut libc::c_void,
+        len: 0,
+    };
+    let mut data: chashdatum = chashdatum {
+        data: 0 as *mut libc::c_void,
+        len: 0,
+    };
+    let mut r: libc::c_int = 0;
+    if str.is_null() {
+        return -1i32;
+    }
+    mmapstring_lock.lock().unwrap();
+    ht = mmapstring_hashtable;
+    if ht.is_null() {
+        return -1i32;
+    }
+    key.data = &mut str as *mut *mut libc::c_char as *mut libc::c_void;
+    key.len = ::std::mem::size_of::<*mut libc::c_char>() as libc::size_t as libc::c_uint;
+    r = chash_get(ht, &mut key, &mut data);
+    if r < 0i32 {
+        string = 0 as *mut MMAPString
+    } else {
+        string = data.data as *mut MMAPString
+    }
+    if !string.is_null() {
+        chash_delete(ht, &mut key, 0 as *mut chashdatum);
+        if chash_count(ht) == 0i32 as libc::c_uint {
+            chash_free(ht);
+            mmapstring_hashtable = 0 as *mut chash
+        }
+    }
+    if !string.is_null() {
+        mmap_string_free(string);
+        return 0i32;
+    } else {
+        return -1i32;
+    };
+}
+#[inline]
+unsafe fn chash_count(mut hash: *mut chash) -> libc::c_uint {
+    return (*hash).count;
+}
+
+pub unsafe fn mmapstring_init_lock() {}
+pub unsafe fn mmapstring_uninit_lock() {}