Hocuri 7d8989a068 fix: If importing a backup fails, delete the partially-imported profile (#7885)
fix https://github.com/chatmail/core/issues/7863

`test_import_encrypted_bak_into_encrypted_acct` CFFI test fails because
it tests that trying to import an encrypted account with a wrong
passphrase into an already-encrypted database will fail, but leave the
already-encrypted database (esp, leave it with the same password).

But in order to reset the database after a failed login attempt, I'm
using this code:

```rust
        context.sql.close().await;
        fs::remove_file(context.sql.dbfile.as_path())
            .await
            .log_err(context)
            .ok();
        context
            .sql
            .open(context, "".to_string()) // <-- NOTE THIS LINE
            .await
            .log_err(context)
            .ok();
```

We're not remembering the password, so, we can't just pass the correct
password there.

Since password-protected databases are not really supported anyways, we
decided to just skip the test.

I also tried two tricks for deleting everything [found on
Stackoverflow](https://stackoverflow.com/questions/525512/drop-all-tables-command),
but neither of them managed to actually reset the database (i.e. they
led to a failed Rust test, because asserting
`!context2.is_configured().await?` failed):

```rust
        context
            .sql
            .call_write(|conn| {
                let mut stmt = conn.prepare(
                    "select 'drop table ' || name || ';' from sqlite_master where type = 'table';",
                )?;
                let mut iter = stmt.query(())?;
                while iter.next()?.is_some() {}
                Ok(())
            })
            .await
            .log_err(context)
            .ok();
        context
            .sql
            .run_migrations(context)
            .await
            .log_err(context)
            .ok();
```

```rust
        context
            .sql
            .transaction(|t| {
                t.execute_batch(
                    "
PRAGMA writable_schema = 1;
delete from sqlite_master where type in ('table', 'index', 'trigger');
PRAGMA writable_schema = 0",
                )?;
                Ok(())
            })
            .await
            .log_err(context)
            .ok();
        context
            .sql
            .run_migrations(context)
            .await
            .log_err(context)
            .ok();
```

---------

Co-authored-by: l <link2xt@testrun.org>
2026-02-25 16:25:33 +01:00
2023-10-29 13:13:44 +00:00
2023-07-04 00:52:31 +02:00
2026-01-17 14:40:17 +00:00
2023-10-29 13:13:44 +00:00

Chatmail logo

Rust CI dependency status

The chatmail core library implements low-level network and encryption protocols, integrated by many chat bots and higher level applications, allowing to securely participate in the globally scaled e-mail server network. We provide reproducibly-built deltachat-rpc-server static binaries that offer a stdio-based high-level JSON-RPC API for instant messaging purposes.

The following protocols are handled without requiring API users to know much about them:

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

On Windows, you may need to also install Perl to be able to compile deltachat-core.

Using the CLI client

Compile and run the command line utility, using cargo:

$ cargo run --locked -p deltachat-repl -- ~/profile-db

where ~/profile-db is the database file. The utility will create it if it does not exist.

Optionally, install deltachat-repl binary with

$ cargo install --locked --path deltachat-repl/

and run as

$ deltachat-repl ~/profile-db

Configure your account (if not already configured):

Chatmail is awaiting your commands.
> set addr your@email.org
> set mail_pw yourpassword
> configure

Connect to your mail server (if already configured):

> connect

Export your public key to a vCard file:

> make-vcard my.vcard 1

Create contacts by address or vCard file:

> addcontact yourfriends@email.org
> import-vcard key-contact.vcard

List contacts:

> listcontacts
Contact#Contact#11: key-contact@email.org <key-contact@email.org>
Contact#Contact#Self: Me √ <your@email.org>
2 key contacts.
Contact#Contact#10: yourfriends@email.org <yourfriends@email.org>
1 address contacts.

Create a chat with your friend and send a message:

> createchat 10
Single#Chat#12 created successfully.
> chat 12
Selecting chat Chat#12
Single#Chat#12: yourfriends@email.org [yourfriends@email.org] Icon: profile-db-blobs/4138c52e5bc1c576cda7dd44d088c07.png
0 messages.
81.252µs to create this list, 123.625µs to mark all messages as noticed.
> send hi

List messages when inside a chat:

> chat

For more commands type:

> help

Installing libdeltachat system wide

$ git clone https://github.com/chatmail/core.git
$ cd deltachat-core-rust
$ cmake -B build . -DCMAKE_INSTALL_PREFIX=/usr
$ cmake --build build
$ sudo cmake --install build

Development

# run tests
$ cargo test --all
# build c-ffi
$ cargo build -p deltachat_ffi --release

Debugging environment variables

  • DCC_MIME_DEBUG: if set outgoing and incoming message will be printed

  • RUST_LOG=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 use the --ignored argument to the test binary (not to cargo itself):

$ cargo test -- --ignored

Fuzzing

Install cargo-bolero with

$ cargo install cargo-bolero

Run fuzzing tests with

$ cd fuzz
$ cargo bolero test fuzz_mailparse -s NONE

Corpus is created at fuzz/fuzz_targets/corpus, you can add initial inputs there. For fuzz_mailparse target corpus can be populated with ../test-data/message/*.eml.

Features

  • vendored: When using Openssl for TLS, this bundles a vendored version.

Update Provider Data

To add the updates from the provider-db to the core, check line REV= inside ./scripts/update-provider-database.sh and then run the script.

Language bindings and frontend projects

Language bindings are available for:

The following "frontend" projects make use of the Rust-library or its language bindings:

Description
Chatmail Rust Core library, used by Android/iOS/desktop chatmail apps, bindings and bots 📧
Readme MPL-2.0 83 MiB
Languages
Rust 74.3%
Tcl 9.1%
Python 8.9%
C 4.9%
DIGITAL Command Language 1.1%
Other 1.6%