Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-24 17:06:28 +03:00
Code Issues Packages Projects Releases Wiki Activity

Ci updates & closer to windows builds

Browse Source 
* chore: update some ci

* feat: no more libiconv

* refactor: updates for updated mmime api

* fixup: correct mmime path

* cleanup

* use newer visual studio

* Update appveyor.yml

* unify libc imports and improve windows situation

* refactor: use rust based sleep

* improve cross platform state of types

* docs: update readme badges
This commit is contained in:
Friedel Ziegelmayer
2019-05-16 17:16:07 +02:00
committed by GitHub
parent b992b8ea09
commit 342e416b4e
33 changed files with 420 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.circleci/config.yml
View File

@@ -15,7 +15,7 @@ jobs:
name: Setup build environment name: Setup build environment
command: | command: |
apt update apt update
apt install -y curl build-essential autoconf libtool git python pkg-config zlib1g-dev libssl-dev libetpan-dev libsasl2-dev apt install -y curl build-essential autoconf libtool git python pkg-config libssl-dev
# this will pick default toolchain from `rust-toolchain` file # 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; curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --no-modify-path --default-toolchain none -y;
source $HOME/.cargo/env source $HOME/.cargo/env

2
Cargo.toml
View File

@@ -9,7 +9,6 @@ cc = "1.0.35"
pkg-config = "0.3" pkg-config = "0.3"
[dependencies] [dependencies]
c2rust-bitfields = "0.1.0"
libc = "0.2.51" libc = "0.2.51"
pgp = "0.2.0" pgp = "0.2.0"
hex = "0.3.2" hex = "0.3.2"
@@ -25,6 +24,7 @@ lettre = "0.9.0"
imap = "1.0.1" imap = "1.0.1"
mmime = { git = "https://github.com/dignifiedquire/mmime" } mmime = { git = "https://github.com/dignifiedquire/mmime" }
base64 = "0.10.1" base64 = "0.10.1"
charset = "0.1.2"
[dev-dependencies] [dev-dependencies]
tempfile = "3.0.7" tempfile = "3.0.7"

8
README.md
View File

@@ -2,7 +2,8 @@
> Project porting deltachat-core to rust > Project porting deltachat-core to rust
[![CircleCI](https://circleci.com/gh/deltachat/deltachat-core-rust.svg?style=svg)](https://circleci.com/gh/deltachat/deltachat-core-rust)
[![CircleCI build status][circle-shield]][circle] [![Appveyor build status][appveyor-shield]][appveyor]
Current commit on deltachat/deltachat-core: `12ef73c8e76185f9b78e844ea673025f56a959ab`. Current commit on deltachat/deltachat-core: `12ef73c8e76185f9b78e844ea673025f56a959ab`.
@@ -17,3 +18,8 @@ $ cat deltachat-ffi/deltachat.h
# run tests # run tests
$ cargo test --all $ cargo test --all
``` ```
[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

37
appveyor.yml Normal file
View File

@@ -0,0 +1,37 @@
environment:
matrix:
# MinGW
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TARGET: i686-pc-windows-gnu
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TARGET: x86_64-pc-windows-gnu
# MSVC
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TARGET: i686-pc-windows-msvc
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TARGET: x86_64-pc-windows-msvc
install:
- ps: >-
If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
$Env:PATH += ';C:\msys64\mingw64\bin'
} ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
$Env:PATH += ';C:\msys64\mingw32\bin'
}
- appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
- rustup-init -yv --default-host %target% --default-toolchain none
- set PATH=%PATH%;%USERPROFILE%\.cargo\bin
- rustc -vV
- cargo -vV
- cd %APPVEYOR_BUILD_FOLDER%
- git submodule update --init --recursive
build: false
test_script:
- cargo test
cache:
- target
- C:\Users\appveyor\.cargo\registry

2
deltachat-ffi/src/lib.rs
View File

@@ -1014,7 +1014,7 @@ pub unsafe extern "C" fn dc_array_get_accuracy(
pub unsafe extern "C" fn dc_array_get_timestamp( pub unsafe extern "C" fn dc_array_get_timestamp(
array: *const dc_array_t, array: *const dc_array_t,
index: libc::size_t, index: libc::size_t,
) -> libc::c_long { ) -> libc::time_t {
dc_array::dc_array_get_timestamp(array, index) dc_array::dc_array_get_timestamp(array, index)
} }
#[no_mangle] #[no_mangle]

3
examples/simple.rs
View File

@@ -16,6 +16,7 @@ use deltachat::dc_job::{
dc_perform_smtp_jobs, dc_perform_smtp_jobs,
}; };
use deltachat::dc_lot::*; use deltachat::dc_lot::*;
use deltachat::x::strdup;
extern "C" fn cb(_ctx: &dc_context_t, event: Event, data1: usize, data2: usize) -> usize { extern "C" fn cb(_ctx: &dc_context_t, event: Event, data1: usize, data2: usize) -> usize {
println!("[{:?}]", event); println!("[{:?}]", event);
@@ -33,7 +34,7 @@ extern "C" fn cb(_ctx: &dc_context_t, event: Event, data1: usize, data2: usize)
let c_res = CString::new(res.text().unwrap()).unwrap(); let c_res = CString::new(res.text().unwrap()).unwrap();
// need to use strdup to allocate the result with malloc // need to use strdup to allocate the result with malloc
// so it can be `free`d later. // so it can be `free`d later.
unsafe { libc::strdup(c_res.as_ptr()) as usize } unsafe { strdup(c_res.as_ptr()) as usize }
} }
Err(err) => { Err(err) => {
println!("failed to download: {}: {:?}", url, err); println!("failed to download: {}: {:?}", url, err);

1
src/dc_aheader.rs
View File

@@ -162,7 +162,6 @@ impl str::FromStr for Aheader {
{ {
Some(key) => key, Some(key) => key,
None => { None => {
println!("invalid key");
return Err(()); return Err(());
} }
}; };

2
src/dc_apeerstate.rs
View File

@@ -261,7 +261,7 @@ pub unsafe fn dc_apeerstate_render_gossip_header(
let header = Aheader::new(addr, key.clone(), EncryptPreference::NoPreference); let header = Aheader::new(addr, key.clone(), EncryptPreference::NoPreference);
let rendered = header.to_string(); let rendered = header.to_string();
let rendered_c = CString::new(rendered).unwrap(); let rendered_c = CString::new(rendered).unwrap();
return libc::strdup(rendered_c.as_ptr()); return strdup(rendered_c.as_ptr());
} }
std::ptr::null_mut() std::ptr::null_mut()

13
src/dc_chat.rs
View File

@@ -188,9 +188,8 @@ unsafe fn set_from_stmt(mut chat: *mut dc_chat_t, row: *mut sqlite3_stmt) -> lib
(*chat).gossiped_timestamp = sqlite3_column_int64(row, fresh7) as time_t; (*chat).gossiped_timestamp = sqlite3_column_int64(row, fresh7) as time_t;
let fresh8 = row_offset; let fresh8 = row_offset;
row_offset = row_offset + 1; row_offset = row_offset + 1;
(*chat).is_sending_locations = (sqlite3_column_int64(row, fresh8) (*chat).is_sending_locations =
> time(0 as *mut time_t) as libc::c_longlong) (sqlite3_column_int64(row, fresh8) > time(0 as *mut time_t)) as libc::c_int;
as libc::c_int;
if (*chat).id == 1i32 as libc::c_uint { if (*chat).id == 1i32 as libc::c_uint {
free((*chat).name as *mut libc::c_void); free((*chat).name as *mut libc::c_void);
(*chat).name = dc_stock_str((*chat).context, 8i32) (*chat).name = dc_stock_str((*chat).context, 8i32)
@@ -314,7 +313,7 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
create_blocked, create_blocked,
(*contact).addr, (*contact).addr,
); );
if 0 != !('K' as i32 == 'K' as i32) as libc::c_int as libc::c_long { if 0 != !('K' as i32 == 'K' as i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 40], &[libc::c_char; 40]>( (*::std::mem::transmute::<&[u8; 40], &[libc::c_char; 40]>(
b"dc_create_or_lookup_nchat_by_contact_id\x00", b"dc_create_or_lookup_nchat_by_contact_id\x00",
@@ -1227,8 +1226,8 @@ pub unsafe fn dc_get_chat_msgs(
let mut curr_id: uint32_t; let mut curr_id: uint32_t;
let mut curr_local_timestamp: time_t; let mut curr_local_timestamp: time_t;
let mut curr_day: libc::c_int; let mut curr_day: libc::c_int;
let mut last_day: libc::c_int = 0i32; let mut last_day = 0;
let cnv_to_local: libc::c_long = dc_gm2local_offset(); let cnv_to_local = dc_gm2local_offset();
if !ret.is_null() { if !ret.is_null() {
if chat_id == 1i32 as libc::c_uint { if chat_id == 1i32 as libc::c_uint {
let show_emails: libc::c_int = dc_sqlite3_get_config_int( let show_emails: libc::c_int = dc_sqlite3_get_config_int(
@@ -1264,7 +1263,7 @@ pub unsafe fn dc_get_chat_msgs(
} }
if 0 != flags & 0x1i32 as libc::c_uint { if 0 != flags & 0x1i32 as libc::c_uint {
curr_local_timestamp = sqlite3_column_int64(stmt, 1i32) as time_t + cnv_to_local; curr_local_timestamp = sqlite3_column_int64(stmt, 1i32) as time_t + cnv_to_local;
curr_day = (curr_local_timestamp / 86400i32 as libc::c_long) as libc::c_int; curr_day = (curr_local_timestamp / 86400) as libc::c_int;
if curr_day != last_day { if curr_day != last_day {
dc_array_add_id(ret, 9i32 as uint32_t); dc_array_add_id(ret, 9i32 as uint32_t);
last_day = curr_day last_day = curr_day

4
src/dc_contact.rs
View File

@@ -51,12 +51,12 @@ pub unsafe fn dc_may_be_valid_addr(addr: *const libc::c_char) -> bool {
return false; return false;
} }
let at: *const libc::c_char = strchr(addr, '@' as i32); let at: *const libc::c_char = strchr(addr, '@' as i32);
if at.is_null() || (at.wrapping_offset_from(addr) as libc::c_long) < 1i32 as libc::c_long { if at.is_null() || at.wrapping_offset_from(addr) < 1 {
return false; return false;
} }
let dot: *const libc::c_char = strchr(at, '.' as i32); let dot: *const libc::c_char = strchr(at, '.' as i32);
if dot.is_null() if dot.is_null()
|| (dot.wrapping_offset_from(at) as libc::c_long) < 2i32 as libc::c_long || dot.wrapping_offset_from(at) < 2
|| *dot.offset(1isize) as libc::c_int == 0i32 || *dot.offset(1isize) as libc::c_int == 0i32
|| *dot.offset(2isize) as libc::c_int == 0i32 || *dot.offset(2isize) as libc::c_int == 0i32
{ {

14
src/dc_e2ee.rs
View File

@@ -309,7 +309,7 @@ pub unsafe fn dc_e2ee_encrypt(
) { ) {
let ctext_bytes = ctext_v.len(); let ctext_bytes = ctext_v.len();
let ctext_c = CString::new(ctext_v).unwrap(); let ctext_c = CString::new(ctext_v).unwrap();
let ctext = libc::strdup(ctext_c.as_ptr()); let ctext = strdup(ctext_c.as_ptr());
(*helper).cdata_to_free = ctext as *mut libc::c_void; (*helper).cdata_to_free = ctext as *mut libc::c_void;
@@ -375,7 +375,7 @@ pub unsafe fn dc_e2ee_encrypt(
imffields_unprotected, imffields_unprotected,
mailimf_field_new_custom( mailimf_field_new_custom(
strdup(b"Autocrypt\x00" as *const u8 as *const libc::c_char), strdup(b"Autocrypt\x00" as *const u8 as *const libc::c_char),
libc::strdup(rendered.as_ptr()), strdup(rendered.as_ptr()),
), ),
); );
} }
@@ -612,16 +612,14 @@ pub unsafe fn dc_e2ee_decrypt(
let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date; let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
if !orig_date.is_null() { if !orig_date.is_null() {
message_time = dc_timestamp_from_date((*orig_date).dt_date_time); message_time = dc_timestamp_from_date((*orig_date).dt_date_time);
if message_time != -1i32 as libc::c_long if message_time != -1 && message_time > time(0 as *mut time_t) {
&& message_time > time(0 as *mut time_t)
{
message_time = time(0 as *mut time_t) message_time = time(0 as *mut time_t)
} }
} }
} }
} }
let autocryptheader = Aheader::from_imffields(from, imffields); let autocryptheader = Aheader::from_imffields(from, imffields);
if message_time > 0i32 as libc::c_long && !from.is_null() { if message_time > 0 && !from.is_null() {
if 0 != dc_apeerstate_load_by_addr( if 0 != dc_apeerstate_load_by_addr(
&mut peerstate, &mut peerstate,
&context.sql.clone().read().unwrap(), &context.sql.clone().read().unwrap(),
@@ -662,7 +660,7 @@ pub unsafe fn dc_e2ee_decrypt(
self_addr, self_addr,
&context.sql.clone().read().unwrap(), &context.sql.clone().read().unwrap(),
) { ) {
if peerstate.last_seen == 0i32 as libc::c_long { if peerstate.last_seen == 0 {
dc_apeerstate_load_by_addr( dc_apeerstate_load_by_addr(
&mut peerstate, &mut peerstate,
&context.sql.clone().read().unwrap(), &context.sql.clone().read().unwrap(),
@@ -1032,7 +1030,7 @@ unsafe fn decrypt_part(
) { ) {
let plain_bytes = plain.len(); let plain_bytes = plain.len();
let plain_c = CString::new(plain).unwrap(); let plain_c = CString::new(plain).unwrap();
let plain_buf = libc::strdup(plain_c.as_ptr()); let plain_buf = strdup(plain_c.as_ptr());
let mut index: size_t = 0i32 as size_t; let mut index: size_t = 0i32 as size_t;
let mut decrypted_mime: *mut mailmime = 0 as *mut mailmime; let mut decrypted_mime: *mut mailmime = 0 as *mut mailmime;

12
src/dc_hash.rs
View File

@@ -73,7 +73,7 @@ pub unsafe fn dc_hash_init(
keyClass: libc::c_int, keyClass: libc::c_int,
mut copyKey: libc::c_int, mut copyKey: libc::c_int,
) { ) {
if 0 != pNew.is_null() as libc::c_int as libc::c_long { if 0 != pNew.is_null() as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 13], &[libc::c_char; 13]>(b"dc_hash_init\x00")) (*::std::mem::transmute::<&[u8; 13], &[libc::c_char; 13]>(b"dc_hash_init\x00"))
.as_ptr(), .as_ptr(),
@@ -83,7 +83,7 @@ pub unsafe fn dc_hash_init(
); );
} else { } else {
}; };
if 0 != !(keyClass >= 1i32 && keyClass <= 4i32) as libc::c_int as libc::c_long { if 0 != !(keyClass >= 1i32 && keyClass <= 4i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 13], &[libc::c_char; 13]>(b"dc_hash_init\x00")) (*::std::mem::transmute::<&[u8; 13], &[libc::c_char; 13]>(b"dc_hash_init\x00"))
.as_ptr(), .as_ptr(),
@@ -126,7 +126,7 @@ pub unsafe fn dc_hash_insert(
assert!(xHash.is_some(), "missing hashing function"); assert!(xHash.is_some(), "missing hashing function");
hraw = xHash.expect("non-null function pointer")(pKey, nKey); hraw = xHash.expect("non-null function pointer")(pKey, nKey);
if 0 != !((*pH).htsize & (*pH).htsize - 1i32 == 0i32) as libc::c_int as libc::c_long { if 0 != !((*pH).htsize & (*pH).htsize - 1i32 == 0i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00")) (*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00"))
.as_ptr(), .as_ptr(),
@@ -178,7 +178,7 @@ pub unsafe fn dc_hash_insert(
if (*pH).count > (*pH).htsize { if (*pH).count > (*pH).htsize {
rehash(pH, (*pH).htsize * 2); rehash(pH, (*pH).htsize * 2);
} }
if 0 != !((*pH).htsize > 0i32) as libc::c_int as libc::c_long { if 0 != !((*pH).htsize > 0i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00")) (*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00"))
.as_ptr(), .as_ptr(),
@@ -188,7 +188,7 @@ pub unsafe fn dc_hash_insert(
); );
} else { } else {
}; };
if 0 != !((*pH).htsize & (*pH).htsize - 1i32 == 0i32) as libc::c_int as libc::c_long { if 0 != !((*pH).htsize & (*pH).htsize - 1i32 == 0i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00")) (*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00"))
.as_ptr(), .as_ptr(),
@@ -248,7 +248,7 @@ unsafe fn rehash(mut pH: *mut dc_hash_t, new_size: libc::c_int) {
let mut next_elem: *mut dc_hashelem_t; let mut next_elem: *mut dc_hashelem_t;
/* The hash function */ /* The hash function */
let xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>; let xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
if 0 != !(new_size & new_size - 1i32 == 0i32) as libc::c_int as libc::c_long { if 0 != !(new_size & new_size - 1i32 == 0i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 7], &[libc::c_char; 7]>(b"rehash\x00")).as_ptr(), (*::std::mem::transmute::<&[u8; 7], &[libc::c_char; 7]>(b"rehash\x00")).as_ptr(),
b"../src/dc_hash.c\x00" as *const u8 as *const libc::c_char, b"../src/dc_hash.c\x00" as *const u8 as *const libc::c_char,

9
src/dc_imex.rs
View File

@@ -103,8 +103,7 @@ pub unsafe fn dc_imex_has_backup(
b"backup_time\x00" as *const u8 as *const libc::c_char, b"backup_time\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
) as time_t; ) as time_t;
if curr_backup_time > 0i32 as libc::c_long && curr_backup_time > ret_backup_time if curr_backup_time > 0 && curr_backup_time > ret_backup_time {
{
free(ret as *mut libc::c_void); free(ret as *mut libc::c_void);
ret = curr_pathNfilename; ret = curr_pathNfilename;
ret_backup_time = curr_backup_time; ret_backup_time = curr_backup_time;
@@ -243,7 +242,7 @@ pub unsafe fn dc_initiate_key_transfer(context: &dc_context_t) -> *mut libc::c_c
current_block = 6116957410927263949; current_block = 6116957410927263949;
break; break;
} }
sleep(1i32 as libc::c_uint); std::thread::sleep(std::time::Duration::from_secs(1));
msg = dc_get_msg(context, msg_id); msg = dc_get_msg(context, msg_id);
if 0 != dc_msg_is_sent(msg) { if 0 != dc_msg_is_sent(msg) {
current_block = 6450636197030046351; current_block = 6450636197030046351;
@@ -326,7 +325,7 @@ pub unsafe extern "C" fn dc_render_setup_file(
strlen(payload_key_asc), strlen(payload_key_asc),
) { ) {
let encr_string_c = CString::new(encr).unwrap(); let encr_string_c = CString::new(encr).unwrap();
let mut encr_string = libc::strdup(encr_string_c.as_ptr()); let mut encr_string = strdup(encr_string_c.as_ptr());
free(payload_key_asc as *mut libc::c_void); free(payload_key_asc as *mut libc::c_void);
let replacement: *mut libc::c_char = let replacement: *mut libc::c_char =
@@ -666,7 +665,7 @@ pub unsafe fn dc_decrypt_setup_file(
if let Some(plain) = if let Some(plain) =
dc_pgp_symm_decrypt(passphrase, binary as *const libc::c_void, binary_bytes) dc_pgp_symm_decrypt(passphrase, binary as *const libc::c_void, binary_bytes)
{ {
payload = libc::strdup(CString::new(plain).unwrap().as_ptr()); payload = strdup(CString::new(plain).unwrap().as_ptr());
} }
} }
} }

18
src/dc_job.rs
View File

@@ -268,15 +268,15 @@ unsafe fn dc_job_delete(context: &dc_context_t, job: &dc_job_t) {
******************************************************************************/ ******************************************************************************/
unsafe fn get_backoff_time_offset(c_tries: libc::c_int) -> time_t { unsafe fn get_backoff_time_offset(c_tries: libc::c_int) -> time_t {
// results in ~3 weeks for the last backoff timespan // results in ~3 weeks for the last backoff timespan
let mut N: time_t = pow(2i32 as libc::c_double, (c_tries - 1i32) as libc::c_double) as time_t; let mut N = 2_i32.pow((c_tries - 1) as u32);
N = N * 60i32 as libc::c_long; N = N * 60;
let mut rng = thread_rng(); let mut rng = thread_rng();
let n: libc::c_long = rng.gen(); let n: i32 = rng.gen();
let mut seconds: time_t = n % (N + 1i32 as libc::c_long); let mut seconds = n % (N + 1);
if seconds < 1i32 as libc::c_long { if seconds < 1 {
seconds = 1i32 as time_t seconds = 1;
} }
return seconds; seconds as time_t
} }
unsafe fn dc_job_update(context: &dc_context_t, job: &dc_job_t) { unsafe fn dc_job_update(context: &dc_context_t, job: &dc_job_t) {
let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
@@ -299,7 +299,7 @@ unsafe fn dc_suspend_smtp_thread(context: &dc_context_t, suspend: libc::c_int) {
if context.smtp_state.0.lock().unwrap().doing_jobs == 0 { if context.smtp_state.0.lock().unwrap().doing_jobs == 0 {
return; return;
} }
usleep((300i32 * 1000i32) as libc::useconds_t); std::thread::sleep(std::time::Duration::from_micros(300 * 1000));
} }
} }
} }
@@ -891,7 +891,7 @@ pub unsafe fn dc_job_add(
sqlite3_bind_int64( sqlite3_bind_int64(
stmt, stmt,
6i32, 6i32,
(timestamp + delay_seconds as libc::c_long) as sqlite3_int64, (timestamp + delay_seconds as time_t) as sqlite3_int64,
); );
sqlite3_step(stmt); sqlite3_step(stmt);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);

3
src/dc_jobthread.rs
View File

@@ -6,7 +6,6 @@ use crate::dc_imap::Imap;
use crate::dc_log::*; use crate::dc_log::*;
use crate::dc_sqlite3::*; use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::types::*;
use crate::x::*; use crate::x::*;
#[repr(C)] #[repr(C)]
@@ -67,7 +66,7 @@ pub unsafe fn dc_jobthread_suspend(
if using_handle == 0 { if using_handle == 0 {
return; return;
} }
usleep((300i32 * 1000i32) as useconds_t); std::thread::sleep(std::time::Duration::from_micros(300 * 1000));
} }
} else { } else {
dc_log_info( dc_log_info(

18
src/dc_key.rs
View File

@@ -4,7 +4,6 @@ use std::io::Cursor;
use std::slice; use std::slice;
use libc; use libc;
use mmime::other::*;
use pgp::composed::{Deserializable, SignedPublicKey, SignedSecretKey}; use pgp::composed::{Deserializable, SignedPublicKey, SignedSecretKey};
use pgp::ser::Serialize; use pgp::ser::Serialize;
use pgp::types::{KeyTrait, SecretKeyTrait}; use pgp::types::{KeyTrait, SecretKeyTrait};
@@ -15,6 +14,7 @@ use crate::dc_log::*;
use crate::dc_sqlite3::*; use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::types::*; use crate::types::*;
use crate::x::*;
#[derive(Debug, PartialEq, Eq, Clone)] #[derive(Debug, PartialEq, Eq, Clone)]
pub enum Key { pub enum Key {
@@ -106,7 +106,7 @@ impl Key {
} }
} }
Err(err) => { Err(err) => {
println!("Invalid key bytes: {:?}\n{}", err, hex::encode(bytes)); eprintln!("Invalid key bytes: {:?}\n{}", err, hex::encode(bytes));
None None
} }
} }
@@ -246,7 +246,7 @@ impl Key {
// need to use strdup to allocate the result with malloc // need to use strdup to allocate the result with malloc
// so it can be `free`d later. // so it can be `free`d later.
unsafe { libc::strdup(res_c.as_ptr()) } unsafe { strdup(res_c.as_ptr()) }
} }
pub fn to_armored_string( pub fn to_armored_string(
@@ -274,7 +274,7 @@ impl Key {
// need to use strdup to allocate the result with malloc // need to use strdup to allocate the result with malloc
// so it can be `free`d later. // so it can be `free`d later.
unsafe { libc::strdup(buf_c.as_ptr()) } unsafe { strdup(buf_c.as_ptr()) }
} }
pub fn write_asc_to_file(&self, file: *const libc::c_char, context: &dc_context_t) -> bool { pub fn write_asc_to_file(&self, file: *const libc::c_char, context: &dc_context_t) -> bool {
@@ -314,7 +314,7 @@ impl Key {
pub fn fingerprint_c(&self) -> *mut libc::c_char { pub fn fingerprint_c(&self) -> *mut libc::c_char {
let res = CString::new(self.fingerprint()).unwrap(); let res = CString::new(self.fingerprint()).unwrap();
unsafe { libc::strdup(res.as_ptr()) } unsafe { strdup(res.as_ptr()) }
} }
pub fn formatted_fingerprint(&self) -> String { pub fn formatted_fingerprint(&self) -> String {
@@ -325,7 +325,7 @@ impl Key {
pub fn formatted_fingerprint_c(&self) -> *mut libc::c_char { pub fn formatted_fingerprint_c(&self) -> *mut libc::c_char {
let res = CString::new(self.formatted_fingerprint()).unwrap(); let res = CString::new(self.formatted_fingerprint()).unwrap();
unsafe { libc::strdup(res.as_ptr()) } unsafe { strdup(res.as_ptr()) }
} }
pub fn split_key(&self) -> Option<Key> { pub fn split_key(&self) -> Option<Key> {
@@ -384,7 +384,7 @@ pub fn dc_key_save_self_keypair(
None, None,
) )
}; };
unsafe { sqlite3_bind_int64(stmt, 5, time(0 as *mut time_t) as sqlite3_int64) }; unsafe { sqlite3_bind_int64(stmt, 5, libc::time(0 as *mut time_t) as sqlite3_int64) };
let success = if unsafe { sqlite3_step(stmt) } == 101 { let success = if unsafe { sqlite3_step(stmt) } == 101 {
true true
} else { } else {
@@ -419,7 +419,7 @@ pub fn dc_format_fingerprint_c(fp: *const libc::c_char) -> *mut libc::c_char {
let res = dc_format_fingerprint(input); let res = dc_format_fingerprint(input);
let res_c = CString::new(res).unwrap(); let res_c = CString::new(res).unwrap();
unsafe { libc::strdup(res_c.as_ptr()) } unsafe { strdup(res_c.as_ptr()) }
} }
/// Bring a human-readable or otherwise formatted fingerprint back to the 40-characters-uppercase-hex format. /// Bring a human-readable or otherwise formatted fingerprint back to the 40-characters-uppercase-hex format.
@@ -435,7 +435,7 @@ pub fn dc_normalize_fingerprint_c(fp: *const libc::c_char) -> *mut libc::c_char
let res = dc_normalize_fingerprint(input); let res = dc_normalize_fingerprint(input);
let res_c = CString::new(res).unwrap(); let res_c = CString::new(res).unwrap();
unsafe { libc::strdup(res_c.as_ptr()) } unsafe { strdup(res_c.as_ptr()) }
} }
#[cfg(test)] #[cfg(test)]

26
src/dc_location.rs
View File

@@ -60,19 +60,15 @@ pub unsafe fn dc_send_locations_to_chat(
sqlite3_bind_int64( sqlite3_bind_int64(
stmt, stmt,
1i32, 1i32,
(if 0 != seconds { (if 0 != seconds { now } else { 0 }) as sqlite3_int64,
now
} else {
0i32 as libc::c_long
}) as sqlite3_int64,
); );
sqlite3_bind_int64( sqlite3_bind_int64(
stmt, stmt,
2i32, 2i32,
(if 0 != seconds { (if 0 != seconds {
now + seconds as libc::c_long now + seconds as time_t
} else { } else {
0i32 as libc::c_long 0
}) as sqlite3_int64, }) as sqlite3_int64,
); );
sqlite3_bind_int(stmt, 3i32, chat_id as libc::c_int); sqlite3_bind_int(stmt, 3i32, chat_id as libc::c_int);
@@ -224,8 +220,8 @@ pub unsafe fn dc_get_locations(
let ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t); let ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t);
let stmt: *mut sqlite3_stmt; let stmt: *mut sqlite3_stmt;
if timestamp_to == 0i32 as libc::c_long { if timestamp_to == 0 {
timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long timestamp_to = time(0 as *mut time_t) + 10;
} }
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context, context,
@@ -361,7 +357,7 @@ pub unsafe fn dc_get_location_kml(
locations_last_sent = sqlite3_column_int64(stmt, 2i32) as time_t; locations_last_sent = sqlite3_column_int64(stmt, 2i32) as time_t;
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin == 0i32 as libc::c_long || now > locations_send_until) { if !(locations_send_begin == 0 || now > locations_send_until) {
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t, dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
b"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"%s\">\n\x00" b"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"%s\">\n\x00"
as *const u8 as *const libc::c_char, as *const u8 as *const libc::c_char,
@@ -806,7 +802,7 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
let locations_last_sent: time_t = sqlite3_column_int64(stmt_chats, 2i32) as time_t; let locations_last_sent: time_t = sqlite3_column_int64(stmt_chats, 2i32) as time_t;
continue_streaming = 1i32; continue_streaming = 1i32;
// be a bit tolerant as the timer may not align exactly with time(NULL) // be a bit tolerant as the timer may not align exactly with time(NULL)
if now - locations_last_sent < (60i32 - 3i32) as libc::c_long { if now - locations_last_sent < (60 - 3) {
continue; continue;
} }
if stmt_locations.is_null() { if stmt_locations.is_null() {
@@ -875,15 +871,11 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context: &dc_context_t, job:
locations_send_until = sqlite3_column_int64(stmt, 1i32) as time_t; locations_send_until = sqlite3_column_int64(stmt, 1i32) as time_t;
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin != 0i32 as libc::c_long if !(locations_send_begin != 0 && time(0 as *mut time_t) <= locations_send_until) {
&& time(0 as *mut time_t) <= locations_send_until)
{
// still streaming - // still streaming -
// may happen as several calls to dc_send_locations_to_chat() // may happen as several calls to dc_send_locations_to_chat()
// do not un-schedule pending DC_MAYBE_SEND_LOC_ENDED jobs // do not un-schedule pending DC_MAYBE_SEND_LOC_ENDED jobs
if !(locations_send_begin == 0i32 as libc::c_long if !(locations_send_begin == 0 && locations_send_until == 0) {
&& locations_send_until == 0i32 as libc::c_long)
{
// not streaming, device-message already sent // not streaming, device-message already sent
stmt = stmt =
dc_sqlite3_prepare( dc_sqlite3_prepare(

5
src/dc_mimefactory.rs
View File

@@ -529,9 +529,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
e2ee_guaranteed = dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0i32) e2ee_guaranteed = dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0i32)
} }
} }
if (*chat).gossiped_timestamp == 0i32 as libc::c_long if (*chat).gossiped_timestamp == 0
|| ((*chat).gossiped_timestamp + (2i32 * 24i32 * 60i32 * 60i32) as libc::c_long) || ((*chat).gossiped_timestamp + (2 * 24 * 60 * 60)) < time(0 as *mut time_t)
< time(0 as *mut time_t)
{ {
do_gossip = 1i32 do_gossip = 1i32
} }

67
src/dc_mimeparser.rs
View File

@@ -1,4 +1,6 @@
use mmime::charconv::*; use std::ffi::{CStr, CString};
use charset::Charset;
use mmime::mailimf::*; use mmime::mailimf::*;
use mmime::mailimf_types::*; use mmime::mailimf_types::*;
use mmime::mailmime::*; use mmime::mailmime::*;
@@ -289,10 +291,8 @@ pub unsafe fn dc_mimeparser_parse(
let mut prepend_subject: libc::c_int = 1i32; let mut prepend_subject: libc::c_int = 1i32;
if 0 == (*mimeparser).decrypting_failed { if 0 == (*mimeparser).decrypting_failed {
let p: *mut libc::c_char = strchr((*mimeparser).subject, ':' as i32); let p: *mut libc::c_char = strchr((*mimeparser).subject, ':' as i32);
if p.wrapping_offset_from((*mimeparser).subject) as libc::c_long if p.wrapping_offset_from((*mimeparser).subject) == 2
== 2i32 as libc::c_long || p.wrapping_offset_from((*mimeparser).subject) == 3
|| p.wrapping_offset_from((*mimeparser).subject) as libc::c_long
== 3i32 as libc::c_long
|| 0 != (*mimeparser).is_send_by_messenger || 0 != (*mimeparser).is_send_by_messenger
|| !strstr( || !strstr(
(*mimeparser).subject, (*mimeparser).subject,
@@ -1172,8 +1172,6 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
let mut raw_mime: *mut libc::c_char = 0 as *mut libc::c_char; let mut raw_mime: *mut libc::c_char = 0 as *mut libc::c_char;
/* mmap_string_unref()'d if set */ /* mmap_string_unref()'d if set */
let mut transfer_decoding_buffer: *mut libc::c_char = 0 as *mut libc::c_char; let mut transfer_decoding_buffer: *mut libc::c_char = 0 as *mut libc::c_char;
/* charconv_buffer_free()'d if set (just calls mmap_string_unref()) */
let mut charset_buffer: *mut libc::c_char = 0 as *mut libc::c_char;
/* must not be free()'d */ /* must not be free()'d */
let mut decoded_data: *const libc::c_char = 0 as *const libc::c_char; let mut decoded_data: *const libc::c_char = 0 as *const libc::c_char;
let mut decoded_data_bytes = 0; let mut decoded_data_bytes = 0;
@@ -1225,32 +1223,34 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
b"UTF-8\x00" as *const u8 as *const libc::c_char, b"UTF-8\x00" as *const u8 as *const libc::c_char,
) != 0i32 ) != 0i32
{ {
let mut ret_bytes = 0; if let Some(encoding) = Charset::for_label(
let r: libc::c_int = charconv_buffer( CStr::from_ptr(charset).to_str().unwrap().as_bytes(),
b"utf-8\x00" as *const u8 as *const libc::c_char, ) {
charset, let data = std::slice::from_raw_parts(
decoded_data, decoded_data as *const u8,
decoded_data_bytes, decoded_data_bytes,
&mut charset_buffer, );
&mut ret_bytes,
); let (res, _, _) = encoding.decode(data);
if r != MAIL_CHARCONV_NO_ERROR as libc::c_int { if res.is_empty() {
dc_log_warning((*mimeparser).context, /* no error - but nothing to add */
0i32, current_block = 8795901732489102124;
b"Cannot convert %i bytes from \"%s\" to \"utf-8\"; errorcode is %i.\x00" } else {
as *const u8 as decoded_data_bytes = res.len();
*const libc::c_char, let res_c = CString::new(res.as_bytes()).unwrap();
decoded_data_bytes as decoded_data = strdup(res_c.as_ptr());
libc::c_int, current_block = 17788412896529399552;
charset, }
r as libc::c_int);
current_block = 17788412896529399552;
} else if charset_buffer.is_null() || ret_bytes <= 0 {
/* no error - but nothing to add */
current_block = 8795901732489102124;
} else { } else {
decoded_data = charset_buffer; dc_log_warning(
decoded_data_bytes = ret_bytes; (*mimeparser).context,
0i32,
b"Cannot convert %i bytes from \"%s\" to \"utf-8\".\x00"
as *const u8
as *const libc::c_char,
decoded_data_bytes as libc::c_int,
charset,
);
current_block = 17788412896529399552; current_block = 17788412896529399552;
} }
} else { } else {
@@ -1484,9 +1484,6 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
} }
/* add object? (we do not add all objetcs, eg. signatures etc. are ignored) */ /* add object? (we do not add all objetcs, eg. signatures etc. are ignored) */
dc_simplify_unref(simplifier); dc_simplify_unref(simplifier);
if !charset_buffer.is_null() {
charconv_buffer_free(charset_buffer);
}
if !transfer_decoding_buffer.is_null() { if !transfer_decoding_buffer.is_null() {
mmap_string_unref(transfer_decoding_buffer); mmap_string_unref(transfer_decoding_buffer);
} }

5
src/dc_msg.rs
View File

@@ -1061,12 +1061,11 @@ pub unsafe fn dc_msg_get_summarytext_by_raw(
} }
pub unsafe fn dc_msg_has_deviating_timestamp(msg: *const dc_msg_t) -> libc::c_int { pub unsafe fn dc_msg_has_deviating_timestamp(msg: *const dc_msg_t) -> libc::c_int {
let cnv_to_local: libc::c_long = dc_gm2local_offset(); let cnv_to_local = dc_gm2local_offset();
let sort_timestamp: time_t = dc_msg_get_sort_timestamp(msg) + cnv_to_local; let sort_timestamp: time_t = dc_msg_get_sort_timestamp(msg) + cnv_to_local;
let send_timestamp: time_t = dc_msg_get_timestamp(msg) + cnv_to_local; let send_timestamp: time_t = dc_msg_get_timestamp(msg) + cnv_to_local;
(sort_timestamp / 86400i32 as libc::c_long != send_timestamp / 86400i32 as libc::c_long) (sort_timestamp / 86400 != send_timestamp / 86400) as libc::c_int
as libc::c_int
} }
// TODO should return bool /rtn // TODO should return bool /rtn

12
src/dc_oauth2.rs
View File

@@ -326,11 +326,7 @@ pub unsafe fn dc_get_oauth2_access_token(
); );
if !expires_in_str.is_null() { if !expires_in_str.is_null() {
let val: time_t = atol(expires_in_str); let val: time_t = atol(expires_in_str);
if val > 20i32 as libc::c_long if val > 20 && val < (60 * 60 * 24 * 365 * 5) {
&& val
< (60i32 * 60i32 * 24i32 * 365i32 * 5i32)
as libc::c_long
{
expires_in = val expires_in = val
} }
free(expires_in_str as *mut libc::c_void); free(expires_in_str as *mut libc::c_void);
@@ -419,9 +415,9 @@ pub unsafe fn dc_get_oauth2_access_token(
b"oauth2_timestamp_expires\x00" as *const u8 b"oauth2_timestamp_expires\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
(if 0 != expires_in { (if 0 != expires_in {
time(0 as *mut time_t) + expires_in - 5i32 as libc::c_long time(0 as *mut time_t) + expires_in - 5
} else { } else {
0i32 as libc::c_long 0
}) as int64_t, }) as int64_t,
); );
if 0 != update_redirect_uri_on_success { if 0 != update_redirect_uri_on_success {
@@ -495,7 +491,7 @@ unsafe fn is_expired(context: &dc_context_t) -> bool {
b"oauth2_timestamp_expires\x00" as *const u8 as *const libc::c_char, b"oauth2_timestamp_expires\x00" as *const u8 as *const libc::c_char,
0i32 as int64_t, 0i32 as int64_t,
) as time_t; ) as time_t;
if expire_timestamp <= 0i32 as libc::c_long { if expire_timestamp <= 0 {
return false; return false;
} }
if expire_timestamp > time(0 as *mut time_t) { if expire_timestamp > time(0 as *mut time_t) {

2
src/dc_pgp.rs
View File

@@ -260,7 +260,7 @@ pub fn dc_pgp_pk_decrypt(
let fp_r = hex::encode_upper(pkey.fingerprint()); let fp_r = hex::encode_upper(pkey.fingerprint());
let len = fp_r.len() as libc::c_int; let len = fp_r.len() as libc::c_int;
let fp_c = CString::new(fp_r).unwrap(); let fp_c = CString::new(fp_r).unwrap();
let fp = unsafe { libc::strdup(fp_c.as_ptr()) }; let fp = unsafe { strdup(fp_c.as_ptr()) };
unsafe { unsafe {
dc_hash_insert( dc_hash_insert(

29
src/dc_receive_imf.rs
View File

@@ -268,12 +268,8 @@ pub unsafe fn dc_receive_imf(
} }
} }
if 0 != incoming { if 0 != incoming {
state = if 0 != flags as libc::c_long & 0x1 { state = if 0 != flags & 0x1 { 16 } else { 10 };
16i32 to_id = 1 as uint32_t;
} else {
10i32
};
to_id = 1i32 as uint32_t;
if !dc_mimeparser_lookup_field( if !dc_mimeparser_lookup_field(
mime_parser, mime_parser,
b"Secure-Join\x00" as *const u8 as *const libc::c_char, b"Secure-Join\x00" as *const u8 as *const libc::c_char,
@@ -454,11 +450,7 @@ pub unsafe fn dc_receive_imf(
chat_id, chat_id,
from_id, from_id,
sent_timestamp, sent_timestamp,
if 0 != flags as libc::c_long & 0x1 { if 0 != flags & 0x1 { 0 } else { 1 },
0i32
} else {
1i32
},
&mut sort_timestamp, &mut sort_timestamp,
&mut sent_timestamp, &mut sent_timestamp,
&mut rcvd_timestamp, &mut rcvd_timestamp,
@@ -481,8 +473,7 @@ pub unsafe fn dc_receive_imf(
); );
if !p.is_null() { if !p.is_null() {
header_bytes = (p.wrapping_offset_from(imf_raw_not_terminated) header_bytes = (p.wrapping_offset_from(imf_raw_not_terminated)
as libc::c_long + 4)
+ 4i32 as libc::c_long)
as libc::c_int as libc::c_int
} else { } else {
p = strstr( p = strstr(
@@ -490,11 +481,9 @@ pub unsafe fn dc_receive_imf(
b"\n\n\x00" as *const u8 as *const libc::c_char, b"\n\n\x00" as *const u8 as *const libc::c_char,
); );
if !p.is_null() { if !p.is_null() {
header_bytes = (p header_bytes =
.wrapping_offset_from(imf_raw_not_terminated) (p.wrapping_offset_from(imf_raw_not_terminated) + 2)
as libc::c_long as libc::c_int
+ 2i32 as libc::c_long)
as libc::c_int
} }
} }
} }
@@ -1059,9 +1048,9 @@ unsafe fn calc_timestamps(
sqlite3_bind_int64(stmt, 3i32, *sort_timestamp as sqlite3_int64); sqlite3_bind_int64(stmt, 3i32, *sort_timestamp as sqlite3_int64);
if sqlite3_step(stmt) == 100i32 { if sqlite3_step(stmt) == 100i32 {
let last_msg_time: time_t = sqlite3_column_int64(stmt, 0i32) as time_t; let last_msg_time: time_t = sqlite3_column_int64(stmt, 0i32) as time_t;
if last_msg_time > 0i32 as libc::c_long { if last_msg_time > 0 {
if *sort_timestamp <= last_msg_time { if *sort_timestamp <= last_msg_time {
*sort_timestamp = last_msg_time + 1i32 as libc::c_long *sort_timestamp = last_msg_time + 1
} }
} }
} }

12
src/dc_saxparser.rs
View File

@@ -103,7 +103,7 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
call_text_cb( call_text_cb(
saxparser, saxparser,
last_text_start, last_text_start,
p.wrapping_offset_from(last_text_start) as libc::c_long as size_t, p.wrapping_offset_from(last_text_start) as size_t,
'&' as i32 as libc::c_char, '&' as i32 as libc::c_char,
); );
p = p.offset(1isize); p = p.offset(1isize);
@@ -123,7 +123,7 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
call_text_cb( call_text_cb(
saxparser, saxparser,
text_beg, text_beg,
p.wrapping_offset_from(text_beg) as libc::c_long as size_t, p.wrapping_offset_from(text_beg) as size_t,
'c' as i32 as libc::c_char, 'c' as i32 as libc::c_char,
); );
p = p.offset(3isize) p = p.offset(3isize)
@@ -341,7 +341,7 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
call_text_cb( call_text_cb(
saxparser, saxparser,
last_text_start, last_text_start,
p.wrapping_offset_from(last_text_start) as libc::c_long as size_t, p.wrapping_offset_from(last_text_start) as size_t,
'&' as i32 as libc::c_char, '&' as i32 as libc::c_char,
); );
} }
@@ -465,7 +465,7 @@ unsafe fn xml_decode(mut s: *mut libc::c_char, type_0: libc::c_char) -> *mut lib
s = s.offset(1); s = s.offset(1);
*fresh2 = c as libc::c_char *fresh2 = c as libc::c_char
} else { } else {
b = 0i32 as libc::c_long; b = 0;
d = c; d = c;
while 0 != d { while 0 != d {
b += 1; b += 1;
@@ -491,7 +491,7 @@ unsafe fn xml_decode(mut s: *mut libc::c_char, type_0: libc::c_char) -> *mut lib
} else if *s as libc::c_int == '&' as i32 } else if *s as libc::c_int == '&' as i32
&& (type_0 as libc::c_int == '&' as i32 || type_0 as libc::c_int == ' ' as i32) && (type_0 as libc::c_int == '&' as i32 || type_0 as libc::c_int == ' ' as i32)
{ {
b = 0i32 as libc::c_long; b = 0;
while !s_ent[b as usize].is_null() while !s_ent[b as usize].is_null()
&& 0 != strncmp( && 0 != strncmp(
s.offset(1isize), s.offset(1isize),
@@ -499,7 +499,7 @@ unsafe fn xml_decode(mut s: *mut libc::c_char, type_0: libc::c_char) -> *mut lib
strlen(s_ent[b as usize]), strlen(s_ent[b as usize]),
) )
{ {
b += 2i32 as libc::c_long b += 2;
} }
let fresh5 = b; let fresh5 = b;
b = b + 1; b = b + 1;

2
src/dc_securejoin.rs
View File

@@ -267,7 +267,7 @@ pub unsafe fn dc_join_securejoin(context: &dc_context_t, qr: *const libc::c_char
.unwrap() .unwrap()
.shall_stop_ongoing) .shall_stop_ongoing)
{ {
usleep((300i32 * 1000i32) as useconds_t); std::thread::sleep(std::time::Duration::from_micros(300 * 1000));
} }
} }
} }

2
src/dc_smtp.rs
View File

@@ -184,7 +184,7 @@ impl Smtp {
Err(err) => { Err(err) => {
let error_msg = format!("SMTP failed to send message: {:?}", err); let error_msg = format!("SMTP failed to send message: {:?}", err);
let msg = CString::new(error_msg).unwrap(); let msg = CString::new(error_msg).unwrap();
self.error = unsafe { libc::strdup(msg.as_ptr()) }; self.error = unsafe { strdup(msg.as_ptr()) };
warn!(context, 0, "%s", msg,); warn!(context, 0, "%s", msg,);

22
src/dc_sqlite3.rs
View File

@@ -725,9 +725,7 @@ pub unsafe fn dc_sqlite3_open(
as *const u8 as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
if 0 != !(DC_MOVE_STATE_UNDEFINED as libc::c_int == 0) as libc::c_int if 0 != !(DC_MOVE_STATE_UNDEFINED as libc::c_int == 0) as usize {
as libc::c_long
{
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>( (*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(
b"dc_sqlite3_open\x00", b"dc_sqlite3_open\x00",
@@ -740,9 +738,7 @@ pub unsafe fn dc_sqlite3_open(
); );
} else { } else {
}; };
if 0 != !(DC_MOVE_STATE_PENDING as libc::c_int == 1) as libc::c_int if 0 != !(DC_MOVE_STATE_PENDING as libc::c_int == 1) as usize {
as libc::c_long
{
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>( (*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(
b"dc_sqlite3_open\x00", b"dc_sqlite3_open\x00",
@@ -755,9 +751,7 @@ pub unsafe fn dc_sqlite3_open(
); );
} else { } else {
}; };
if 0 != !(DC_MOVE_STATE_STAY as libc::c_int == 2) as libc::c_int if 0 != !(DC_MOVE_STATE_STAY as libc::c_int == 2) as usize {
as libc::c_long
{
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>( (*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(
b"dc_sqlite3_open\x00", b"dc_sqlite3_open\x00",
@@ -770,9 +764,7 @@ pub unsafe fn dc_sqlite3_open(
); );
} else { } else {
}; };
if 0 != !(DC_MOVE_STATE_MOVING as libc::c_int == 3) as libc::c_int if 0 != !(DC_MOVE_STATE_MOVING as libc::c_int == 3) as usize {
as libc::c_long
{
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>( (*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(
b"dc_sqlite3_open\x00", b"dc_sqlite3_open\x00",
@@ -935,7 +927,7 @@ pub unsafe fn dc_sqlite3_open(
context.get_blobdir(), context.get_blobdir(),
); );
dc_ensure_no_slash(repl_from); dc_ensure_no_slash(repl_from);
if 0 != !('f' as i32 == 'f' as i32) as libc::c_int as libc::c_long { if 0 != !('f' as i32 == 'f' as i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>( (*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(
b"dc_sqlite3_open\x00", b"dc_sqlite3_open\x00",
@@ -954,7 +946,7 @@ pub unsafe fn dc_sqlite3_open(
repl_from); repl_from);
dc_sqlite3_execute(context, sql, q3); dc_sqlite3_execute(context, sql, q3);
sqlite3_free(q3 as *mut libc::c_void); sqlite3_free(q3 as *mut libc::c_void);
if 0 != !('i' as i32 == 'i' as i32) as libc::c_int as libc::c_long { if 0 != !('i' as i32 == 'i' as i32) as usize {
__assert_rtn( __assert_rtn(
(*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>( (*::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(
b"dc_sqlite3_open\x00", b"dc_sqlite3_open\x00",
@@ -1298,7 +1290,7 @@ pub unsafe fn dc_sqlite3_set_config_int64(
) -> libc::c_int { ) -> libc::c_int {
let value_str = dc_mprintf( let value_str = dc_mprintf(
b"%lld\x00" as *const u8 as *const libc::c_char, b"%lld\x00" as *const u8 as *const libc::c_char,
value as libc::c_long, value as time_t,
); );
if value_str.is_null() { if value_str.is_null() {
return 0; return 0;

4
src/dc_strbuilder.rs
View File

@@ -40,8 +40,8 @@ pub unsafe fn dc_strbuilder_cat(
} else { } else {
(*strbuilder).allocated (*strbuilder).allocated
}; };
let old_offset: libc::c_int = (*strbuilder).eos.wrapping_offset_from((*strbuilder).buf) let old_offset: libc::c_int =
as libc::c_long as libc::c_int; (*strbuilder).eos.wrapping_offset_from((*strbuilder).buf) as libc::c_int;
(*strbuilder).allocated = (*strbuilder).allocated + add_bytes; (*strbuilder).allocated = (*strbuilder).allocated + add_bytes;
(*strbuilder).buf = realloc( (*strbuilder).buf = realloc(
(*strbuilder).buf as *mut libc::c_void, (*strbuilder).buf as *mut libc::c_void,

73
src/dc_strencode.rs
View File

@@ -1,10 +1,13 @@
use mmime::charconv::*; use std::ffi::{CStr, CString};
use charset::Charset;
use mmime::mailmime_decode::*; use mmime::mailmime_decode::*;
use mmime::mmapstring::*; use mmime::mmapstring::*;
use mmime::other::*; use mmime::other::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::types::*; use crate::types::*;
use crate::x::*;
#[inline] #[inline]
pub fn isalnum(mut _c: libc::c_int) -> libc::c_int { pub fn isalnum(mut _c: libc::c_int) -> libc::c_int {
@@ -32,9 +35,8 @@ pub unsafe fn dc_urlencode(to_encode: *const libc::c_char) -> *mut libc::c_char
let buf: *mut libc::c_char = let buf: *mut libc::c_char =
malloc(strlen(to_encode).wrapping_mul(3).wrapping_add(1)) as *mut libc::c_char; malloc(strlen(to_encode).wrapping_mul(3).wrapping_add(1)) as *mut libc::c_char;
let mut pbuf: *mut libc::c_char = buf; let mut pbuf: *mut libc::c_char = buf;
if buf.is_null() { assert!(!buf.is_null());
exit(46i32);
}
while 0 != *pstr { while 0 != *pstr {
if 0 != isalnum(*pstr as libc::c_int) if 0 != isalnum(*pstr as libc::c_int)
|| *pstr as libc::c_int == '-' as i32 || *pstr as libc::c_int == '-' as i32
@@ -85,9 +87,8 @@ pub unsafe fn dc_urldecode(to_decode: *const libc::c_char) -> *mut libc::c_char
} }
let buf: *mut libc::c_char = malloc(strlen(to_decode).wrapping_add(1)) as *mut libc::c_char; let buf: *mut libc::c_char = malloc(strlen(to_decode).wrapping_add(1)) as *mut libc::c_char;
let mut pbuf: *mut libc::c_char = buf; let mut pbuf: *mut libc::c_char = buf;
if buf.is_null() { assert!(!buf.is_null());
exit(50i32);
}
while 0 != *pstr { while 0 != *pstr {
if *pstr as libc::c_int == '%' as i32 { if *pstr as libc::c_int == '%' as i32 {
if 0 != *pstr.offset(1isize) as libc::c_int && 0 != *pstr.offset(2isize) as libc::c_int if 0 != *pstr.offset(1isize) as libc::c_int && 0 != *pstr.offset(2isize) as libc::c_int
@@ -119,7 +120,7 @@ unsafe fn hex_2_int(ch: libc::c_char) -> libc::c_char {
return (if 0 != isdigit(ch as libc::c_int) { return (if 0 != isdigit(ch as libc::c_int) {
ch as libc::c_int - '0' as i32 ch as libc::c_int - '0' as i32
} else { } else {
libc::tolower(ch as libc::c_int) - 'a' as i32 + 10i32 tolower(ch as libc::c_int) - 'a' as i32 + 10i32
}) as libc::c_char; }) as libc::c_char;
} }
@@ -167,7 +168,7 @@ pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut lib
b"utf-8\x00" as *const u8 as *const libc::c_char, b"utf-8\x00" as *const u8 as *const libc::c_char,
mmapstr, mmapstr,
begin, begin,
end.wrapping_offset_from(begin) as libc::c_long as size_t, end.wrapping_offset_from(begin) as size_t,
) { ) {
current_block = 8550051112593613029; current_block = 8550051112593613029;
continue; continue;
@@ -183,7 +184,7 @@ pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut lib
if mmap_string_append_len( if mmap_string_append_len(
mmapstr, mmapstr,
end, end,
cur.wrapping_offset_from(end) as libc::c_long as size_t, cur.wrapping_offset_from(end) as size_t,
) )
.is_null() .is_null()
{ {
@@ -194,7 +195,7 @@ pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut lib
} else if mmap_string_append_len( } else if mmap_string_append_len(
mmapstr, mmapstr,
begin, begin,
cur.wrapping_offset_from(begin) as libc::c_long as size_t, cur.wrapping_offset_from(begin) as size_t,
) )
.is_null() .is_null()
{ {
@@ -297,10 +298,7 @@ unsafe fn get_word(
{ {
cur = cur.offset(1isize) cur = cur.offset(1isize)
} }
*pto_be_quoted = to_be_quoted( *pto_be_quoted = to_be_quoted(begin, cur.wrapping_offset_from(begin) as size_t);
begin,
cur.wrapping_offset_from(begin) as libc::c_long as size_t,
);
*pend = cur; *pend = cur;
} }
@@ -369,9 +367,8 @@ pub unsafe fn dc_encode_modified_utf7(
} }
res = malloc(2usize.wrapping_mul(strlen(to_encode)).wrapping_add(1)) as *mut libc::c_char; res = malloc(2usize.wrapping_mul(strlen(to_encode)).wrapping_add(1)) as *mut libc::c_char;
dst = res; dst = res;
if dst.is_null() { assert!(!dst.is_null());
exit(51i32);
}
utf7mode = 0i32 as libc::c_uint; utf7mode = 0i32 as libc::c_uint;
utf8total = 0i32 as libc::c_uint; utf8total = 0i32 as libc::c_uint;
bitstogo = 0i32 as libc::c_uint; bitstogo = 0i32 as libc::c_uint;
@@ -521,10 +518,9 @@ pub unsafe fn dc_decode_modified_utf7(
res = malloc(4usize.wrapping_mul(strlen(to_decode)).wrapping_add(1)) as *mut libc::c_char; res = malloc(4usize.wrapping_mul(strlen(to_decode)).wrapping_add(1)) as *mut libc::c_char;
dst = res; dst = res;
src = to_decode; src = to_decode;
if dst.is_null() { assert!(!dst.is_null());
exit(52i32);
} libc::memset(
memset(
base64.as_mut_ptr() as *mut libc::c_void, base64.as_mut_ptr() as *mut libc::c_void,
64, 64,
::std::mem::size_of::<[libc::c_uchar; 256]>(), ::std::mem::size_of::<[libc::c_uchar; 256]>(),
@@ -642,9 +638,8 @@ pub unsafe fn dc_encode_ext_header(to_encode: *const libc::c_char) -> *mut libc:
.wrapping_add(strlen(to_encode).wrapping_mul(3)) .wrapping_add(strlen(to_encode).wrapping_mul(3))
.wrapping_add(1), .wrapping_add(1),
) as *mut libc::c_char; ) as *mut libc::c_char;
if buf.is_null() { assert!(!buf.is_null());
exit(46i32);
}
let mut pbuf: *mut libc::c_char = buf; let mut pbuf: *mut libc::c_char = buf;
strcpy(pbuf, b"utf-8\'\'\x00" as *const u8 as *const libc::c_char); strcpy(pbuf, b"utf-8\'\'\x00" as *const u8 as *const libc::c_char);
pbuf = pbuf.offset(strlen(pbuf) as isize); pbuf = pbuf.offset(strlen(pbuf) as isize);
@@ -685,10 +680,8 @@ pub unsafe fn dc_decode_ext_header(to_decode: *const libc::c_char) -> *mut libc:
p2 = strchr(to_decode, '\'' as i32); p2 = strchr(to_decode, '\'' as i32);
if !(p2.is_null() || p2 == to_decode) { if !(p2.is_null() || p2 == to_decode) {
/*no empty charset allowed*/ /*no empty charset allowed*/
charset = dc_null_terminate( charset =
to_decode, dc_null_terminate(to_decode, p2.wrapping_offset_from(to_decode) as libc::c_int);
p2.wrapping_offset_from(to_decode) as libc::c_long as libc::c_int,
);
p2 = p2.offset(1isize); p2 = p2.offset(1isize);
// skip language // skip language
p2 = strchr(p2, '\'' as i32); p2 = strchr(p2, '\'' as i32);
@@ -699,19 +692,17 @@ pub unsafe fn dc_decode_ext_header(to_decode: *const libc::c_char) -> *mut libc:
&& strcmp(charset, b"utf-8\x00" as *const u8 as *const libc::c_char) != 0i32 && strcmp(charset, b"utf-8\x00" as *const u8 as *const libc::c_char) != 0i32
&& strcmp(charset, b"UTF-8\x00" as *const u8 as *const libc::c_char) != 0i32 && strcmp(charset, b"UTF-8\x00" as *const u8 as *const libc::c_char) != 0i32
{ {
let mut converted: *mut libc::c_char = 0 as *mut libc::c_char; if let Some(encoding) =
let r: libc::c_int = charconv( Charset::for_label(CStr::from_ptr(charset).to_str().unwrap().as_bytes())
b"utf-8\x00" as *const u8 as *const libc::c_char, {
charset, let data =
decoded, std::slice::from_raw_parts(decoded as *const u8, strlen(decoded));
strlen(decoded),
&mut converted, let (res, _, _) = encoding.decode(data);
);
if r == MAIL_CHARCONV_NO_ERROR as libc::c_int && !converted.is_null() {
free(decoded as *mut libc::c_void); free(decoded as *mut libc::c_void);
decoded = converted let res_c = CString::new(res.as_bytes()).unwrap();
} else {
free(converted as *mut libc::c_void); decoded = strdup(res_c.as_ptr());
} }
} }
} }

55
src/dc_tools.rs
View File

@@ -96,8 +96,8 @@ pub unsafe fn dc_str_replace(
if p2.is_null() { if p2.is_null() {
break; break;
} }
start_search_pos = (p2.wrapping_offset_from(*haystack) as libc::c_long start_search_pos =
+ replacement_len as libc::c_long) as libc::c_int; (p2.wrapping_offset_from(*haystack) + replacement_len as isize) as libc::c_int;
*p2 = 0i32 as libc::c_char; *p2 = 0i32 as libc::c_char;
p2 = p2.offset(needle_len as isize); p2 = p2.offset(needle_len as isize);
let new_string: *mut libc::c_char = dc_mprintf( let new_string: *mut libc::c_char = dc_mprintf(
@@ -185,7 +185,7 @@ pub unsafe fn dc_strlower(in_0: *const libc::c_char) -> *mut libc::c_char {
let out: *mut libc::c_char = dc_strdup(in_0); let out: *mut libc::c_char = dc_strdup(in_0);
let mut p: *mut libc::c_char = out; let mut p: *mut libc::c_char = out;
while 0 != *p { while 0 != *p {
*p = libc::tolower(*p as libc::c_int) as libc::c_char; *p = tolower(*p as libc::c_int) as libc::c_char;
p = p.offset(1isize) p = p.offset(1isize)
} }
@@ -195,7 +195,7 @@ pub unsafe fn dc_strlower(in_0: *const libc::c_char) -> *mut libc::c_char {
pub unsafe fn dc_strlower_in_place(in_0: *mut libc::c_char) { pub unsafe fn dc_strlower_in_place(in_0: *mut libc::c_char) {
let mut p: *mut libc::c_char = in_0; let mut p: *mut libc::c_char = in_0;
while 0 != *p { while 0 != *p {
*p = libc::tolower(*p as libc::c_int) as libc::c_char; *p = tolower(*p as libc::c_int) as libc::c_char;
p = p.offset(1isize) p = p.offset(1isize)
} }
} }
@@ -593,10 +593,7 @@ pub unsafe fn dc_str_to_clist(
clist_insert_after( clist_insert_after(
list, list,
(*list).last, (*list).last,
strndup( strndup(p1, p2.wrapping_offset_from(p1) as libc::c_ulong) as *mut libc::c_void,
p1,
p2.wrapping_offset_from(p1) as libc::c_long as libc::c_ulong,
) as *mut libc::c_void,
); );
p1 = p2.offset(strlen(delimiter) as isize) p1 = p2.offset(strlen(delimiter) as isize)
} }
@@ -725,7 +722,7 @@ pub unsafe fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> time_
zone_hour = -(-(*date_time).dt_zone / 100i32); zone_hour = -(-(*date_time).dt_zone / 100i32);
zone_min = -(-(*date_time).dt_zone % 100i32) zone_min = -(-(*date_time).dt_zone % 100i32)
} }
timeval -= (zone_hour * 3600i32 + zone_min * 60i32) as libc::c_long; timeval -= (zone_hour * 3600 + zone_min * 60) as time_t;
timeval timeval
} }
@@ -754,18 +751,14 @@ pub unsafe fn mkgmtime(tmp: *mut tm) -> time_t {
yourtm.tm_sec = 0i32; yourtm.tm_sec = 0i32;
bits = 0i32; bits = 0i32;
t = 1i32 as time_t; t = 1i32 as time_t;
while t > 0i32 as libc::c_long { while t > 0 {
bits += 1; bits += 1;
t <<= 1i32 t <<= 1i32
} }
if bits > 40i32 { if bits > 40i32 {
bits = 40i32 bits = 40i32
} }
t = if t < 0i32 as libc::c_long { t = if t < 0 { 0 } else { (1i32 as time_t) << bits };
0i32 as libc::c_long
} else {
(1i32 as time_t) << bits
};
loop { loop {
gmtime_r(&mut t, &mut mytm); gmtime_r(&mut t, &mut mytm);
dir = tmcomp(&mut mytm, &mut yourtm); dir = tmcomp(&mut mytm, &mut yourtm);
@@ -785,7 +778,7 @@ pub unsafe fn mkgmtime(tmp: *mut tm) -> time_t {
t += (1i32 as time_t) << bits t += (1i32 as time_t) << bits
} }
} }
t += saved_seconds as libc::c_long; t += saved_seconds as time_t;
t t
} }
@@ -851,7 +844,7 @@ pub unsafe fn dc_timestamp_to_str(mut wanted: time_t) -> *mut libc::c_char {
); );
} }
pub unsafe fn dc_gm2local_offset() -> libc::c_long { pub unsafe fn dc_gm2local_offset() -> time_t {
/* returns the offset that must be _added_ to an UTC/GMT-time to create the localtime. /* returns the offset that must be _added_ to an UTC/GMT-time to create the localtime.
the function may return nagative values. */ the function may return nagative values. */
let mut gmtime: time_t = time(0 as *mut time_t); let mut gmtime: time_t = time(0 as *mut time_t);
@@ -902,14 +895,15 @@ pub unsafe fn dc_create_smeared_timestamp(context: &dc_context_t) -> time_t {
pub unsafe fn dc_create_smeared_timestamps(context: &dc_context_t, count: libc::c_int) -> time_t { pub unsafe fn dc_create_smeared_timestamps(context: &dc_context_t, count: libc::c_int) -> time_t {
/* get a range to timestamps that can be used uniquely */ /* get a range to timestamps that can be used uniquely */
let now: time_t = time(0 as *mut time_t); let now = time(0 as *mut time_t);
let mut start: time_t = let start = now + (if count < 5 { count } else { 5 }) as time_t - count as time_t;
now + (if count < 5i32 { count } else { 5i32 }) as libc::c_long - count as libc::c_long;
let ts = *context.last_smeared_timestamp.clone().write().unwrap(); let ts = *context.last_smeared_timestamp.clone().write().unwrap();
start = if ts + 1 > start { ts + 1 } else { start }; if ts + 1 > start {
ts + 1
start } else {
start
}
} }
/* Message-ID tools */ /* Message-ID tools */
@@ -1212,11 +1206,10 @@ pub unsafe fn dc_get_filemeta(
as uint32_t; as uint32_t;
return 1i32; return 1i32;
} }
pos += (2i32 pos += 2
+ ((*buf.offset((pos + 2) as isize) as libc::c_int) << 8i32) + ((*buf.offset((pos + 2) as isize) as libc::c_int) << 8)
+ *buf.offset((pos + 3) as isize) as libc::c_int) + *buf.offset((pos + 3) as isize) as libc::c_int;
as libc::c_long; if (pos + 12) > buf_bytes as libc::c_int {
if (pos + 12) > buf_bytes as libc::c_long {
break; break;
} }
} }
@@ -1552,10 +1545,10 @@ pub unsafe fn dc_get_fine_pathNfilename(
while i < 1000i32 { while i < 1000i32 {
/*no deadlocks, please*/ /*no deadlocks, please*/
if 0 != i { if 0 != i {
let idx: time_t = if i < 100i32 { let idx = if i < 100 {
i as libc::c_long i as time_t
} else { } else {
now + i as libc::c_long now + i as time_t
}; };
ret = dc_mprintf( ret = dc_mprintf(
b"%s/%s-%lu%s\x00" as *const u8 as *const libc::c_char, b"%s/%s-%lu%s\x00" as *const u8 as *const libc::c_char,

7
src/types.rs
View File

@@ -21,12 +21,6 @@ pub type __darwin_ct_rune_t = libc::c_int;
pub type __darwin_wchar_t = libc::c_int; pub type __darwin_wchar_t = libc::c_int;
pub type __darwin_rune_t = __darwin_wchar_t; pub type __darwin_rune_t = __darwin_wchar_t;
pub type uint64_t = libc::c_ulonglong; pub type uint64_t = libc::c_ulonglong;
pub type uid_t = libc::uid_t;
pub type gid_t = libc::gid_t;
pub type dev_t = libc::dev_t;
pub type blkcnt_t = libc::blkcnt_t;
pub type blksize_t = libc::blksize_t;
pub type nlink_t = __uint16_t;
/** /**
* Callback function that should be given to dc_context_new(). * Callback function that should be given to dc_context_new().
@@ -73,7 +67,6 @@ pub type dc_get_config_t = unsafe fn(
pub type sqlite_int64 = libc::int64_t; pub type sqlite_int64 = libc::int64_t;
pub type sqlite3_int64 = sqlite_int64; pub type sqlite3_int64 = sqlite_int64;
pub type useconds_t = libc::useconds_t;
pub type int32_t = libc::int32_t; pub type int32_t = libc::int32_t;
pub type int64_t = libc::int64_t; pub type int64_t = libc::int64_t;
pub type uintptr_t = libc::uintptr_t; pub type uintptr_t = libc::uintptr_t;

66
src/x.rs
View File

@@ -4,15 +4,23 @@ use crate::types::*;
pub use libc::{ pub use libc::{
atoi, calloc, close, closedir, exit, fclose, fgets, fopen, fread, free, fseek, ftell, fwrite, atoi, calloc, close, closedir, exit, fclose, fgets, fopen, fread, free, fseek, ftell, fwrite,
gmtime, gmtime_r, localtime, localtime_r, malloc, memcmp, memcpy, memmove, memset, mkdir, open, gmtime, gmtime_r, localtime, localtime_r, malloc, memcmp, memcpy, memmove, memset, mkdir, open,
opendir, printf, read, readdir, realloc, remove, sleep, snprintf, sprintf, sscanf, strcasecmp, opendir, printf, read, readdir, realloc, remove, sprintf, sscanf, strcat, strchr, strcmp,
strcat, strchr, strcmp, strcpy, strcspn, strdup, strlen, strncasecmp, strncmp, strncpy, strcpy, strcspn, strlen, strncmp, strncpy, strrchr, strspn, strstr, strtol, system, time,
strrchr, strspn, strstr, strtol, system, time, tolower as __tolower, toupper as __toupper, tolower, write,
usleep, write,
}; };
extern "C" { pub unsafe fn strdup(s: *const libc::c_char) -> *mut libc::c_char {
// pub static mut _DefaultRuneLocale: _RuneLocale; let slen = libc::strlen(s);
let result = libc::malloc(slen + 1);
if result.is_null() {
return std::ptr::null_mut();
}
libc::memcpy(result, s as *const _, slen + 1);
result as *mut _
}
extern "C" {
pub fn clock() -> libc::clock_t; pub fn clock() -> libc::clock_t;
pub fn qsort( pub fn qsort(
__base: *mut libc::c_void, __base: *mut libc::c_void,
@@ -53,12 +61,23 @@ extern "C" {
_: *const libc::c_char, _: *const libc::c_char,
) -> !; ) -> !;
#[cfg(windows)]
pub(crate) fn snprintf(
s: *mut libc::c_char,
n: libc::size_t,
format: *const libc::c_char,
_: ...
) -> libc::c_int;
// -- DC Methods // -- DC Methods
pub fn dc_strbuilder_catf(_: *mut dc_strbuilder_t, format: *const libc::c_char, _: ...); pub fn dc_strbuilder_catf(_: *mut dc_strbuilder_t, format: *const libc::c_char, _: ...);
pub fn dc_mprintf(format: *const libc::c_char, _: ...) -> *mut libc::c_char; pub fn dc_mprintf(format: *const libc::c_char, _: ...) -> *mut libc::c_char;
} }
#[cfg(not(windows))]
pub(crate) use libc::snprintf;
#[cfg(not(target_os = "macos"))] #[cfg(not(target_os = "macos"))]
pub unsafe extern "C" fn __assert_rtn( pub unsafe extern "C" fn __assert_rtn(
a: *const libc::c_char, a: *const libc::c_char,
@@ -77,6 +96,41 @@ pub unsafe fn atof(nptr: *mut libc::c_char) -> libc::c_double {
libc::strtod(nptr, std::ptr::null_mut()) libc::strtod(nptr, std::ptr::null_mut())
} }
pub(crate) unsafe fn strcasecmp(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_int {
let s1 = std::ffi::CStr::from_ptr(s1)
.to_string_lossy()
.to_lowercase();
let s2 = std::ffi::CStr::from_ptr(s2)
.to_string_lossy()
.to_lowercase();
if s1 == s2 {
0
} else {
1
}
}
pub(crate) unsafe fn strncasecmp(
s1: *const libc::c_char,
s2: *const libc::c_char,
n: libc::size_t,
) -> libc::c_int {
let s1 = std::ffi::CStr::from_ptr(s1)
.to_string_lossy()
.to_lowercase();
let s2 = std::ffi::CStr::from_ptr(s2)
.to_string_lossy()
.to_lowercase();
let m1 = std::cmp::min(n, s1.len());
let m2 = std::cmp::min(n, s2.len());
if s1[..m1] == s2[..m2] {
0
} else {
1
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

306
tests/stress.rs
View File

File diff suppressed because it is too large Load Diff