Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-05-02 21:06:31 +03:00
Code Issues Packages Projects Releases Wiki Activity

cleanup: convert i32s in dc_aheader.rs

Browse Source
This commit is contained in:
Lars-Magnus Skog
2019-05-01 00:08:15 +02:00
parent 8d770b6dfd
commit e148532c73
1 changed files with 33 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/dc_aheader.rs
View File

@@ -21,7 +21,8 @@ pub unsafe fn dc_aheader_new() -> *mut dc_aheader_t {
let mut aheader = calloc(1, ::std::mem::size_of::<dc_aheader_t>()) as *mut dc_aheader_t; let mut aheader = calloc(1, ::std::mem::size_of::<dc_aheader_t>()) as *mut dc_aheader_t;
if aheader.is_null() { if aheader.is_null() {
exit(37i32); // TODO replace with enum (hardcoded in deltachat-core) /rtn
exit(37);
} }
(*aheader).public_key = dc_key_new(); (*aheader).public_key = dc_key_new();
@@ -55,11 +56,11 @@ pub unsafe fn dc_aheader_new_from_imffields(
&& strcasecmp( && strcasecmp(
(*optional_field).fld_name, (*optional_field).fld_name,
b"Autocrypt\x00" as *const u8 as *const libc::c_char, b"Autocrypt\x00" as *const u8 as *const libc::c_char,
) == 0i32 ) == 0
{ {
let mut test = dc_aheader_new(); let mut test = dc_aheader_new();
if 0 == dc_aheader_set_from_string(test, (*optional_field).fld_value) if 0 == dc_aheader_set_from_string(test, (*optional_field).fld_value)
|| dc_addr_cmp((*test).addr, wanted_from) != 0i32 || dc_addr_cmp((*test).addr, wanted_from) != 0
{ {
dc_aheader_unref(test); dc_aheader_unref(test);
test = 0 as *mut dc_aheader_t test = 0 as *mut dc_aheader_t
@@ -80,7 +81,8 @@ pub unsafe fn dc_aheader_new_from_imffields(
0 as *mut clistcell_s 0 as *mut clistcell_s
} }
} }
return fine_header;
fine_header
} }
pub unsafe fn dc_aheader_unref(mut aheader: *mut dc_aheader_t) { pub unsafe fn dc_aheader_unref(mut aheader: *mut dc_aheader_t) {
@@ -107,11 +109,11 @@ pub unsafe fn dc_aheader_set_from_string(
let mut beg_attr_name = 0 as *mut libc::c_char; let mut beg_attr_name = 0 as *mut libc::c_char;
let mut after_attr_name = 0 as *mut libc::c_char; let mut after_attr_name = 0 as *mut libc::c_char;
let mut beg_attr_value = 0 as *mut libc::c_char; let mut beg_attr_value = 0 as *mut libc::c_char;
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0;
dc_aheader_empty(aheader); dc_aheader_empty(aheader);
if !(aheader.is_null() || header_str__.is_null()) { if !(aheader.is_null() || header_str__.is_null()) {
(*aheader).prefer_encrypt = 0i32; (*aheader).prefer_encrypt = 0;
header_str = dc_strdup(header_str__); header_str = dc_strdup(header_str__);
p = header_str; p = header_str;
loop { loop {
@@ -155,7 +157,7 @@ pub unsafe fn dc_aheader_set_from_string(
9271062167157603455 => {} 9271062167157603455 => {}
_ => { _ => {
if !(*aheader).addr.is_null() && !(*(*aheader).public_key).binary.is_null() { if !(*aheader).addr.is_null() && !(*(*aheader).public_key).binary.is_null() {
success = 1i32 success = 1
} }
} }
} }
@@ -172,14 +174,14 @@ pub unsafe fn dc_aheader_empty(mut aheader: *mut dc_aheader_t) {
if aheader.is_null() { if aheader.is_null() {
return; return;
} }
(*aheader).prefer_encrypt = 0i32; (*aheader).prefer_encrypt = 0;
free((*aheader).addr as *mut libc::c_void); free((*aheader).addr as *mut libc::c_void);
(*aheader).addr = 0 as *mut libc::c_char; (*aheader).addr = 0 as *mut libc::c_char;
if !(*(*aheader).public_key).binary.is_null() { if !(*(*aheader).public_key).binary.is_null() {
dc_key_unref((*aheader).public_key); dc_key_unref((*aheader).public_key);
(*aheader).public_key = dc_key_new() (*aheader).public_key = dc_key_new()
}; }
} }
/* ****************************************************************************** /* ******************************************************************************
@@ -191,46 +193,47 @@ unsafe fn add_attribute(
mut name: *const libc::c_char, mut name: *const libc::c_char,
mut value: *const libc::c_char, mut value: *const libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
if strcasecmp(name, b"addr\x00" as *const u8 as *const libc::c_char) == 0i32 { if strcasecmp(name, b"addr\x00" as *const u8 as *const libc::c_char) == 0 {
if value.is_null() || 0 == dc_may_be_valid_addr(value) || !(*aheader).addr.is_null() { if value.is_null() || 0 == dc_may_be_valid_addr(value) || !(*aheader).addr.is_null() {
return 0i32; return 0;
} }
(*aheader).addr = dc_addr_normalize(value); (*aheader).addr = dc_addr_normalize(value);
return 1i32; return 1;
} else { } else {
if strcasecmp( if strcasecmp(
name, name,
b"prefer-encrypt\x00" as *const u8 as *const libc::c_char, b"prefer-encrypt\x00" as *const u8 as *const libc::c_char,
) == 0i32 ) == 0
{ {
if !value.is_null() if !value.is_null()
&& strcasecmp(value, b"mutual\x00" as *const u8 as *const libc::c_char) == 0i32 && strcasecmp(value, b"mutual\x00" as *const u8 as *const libc::c_char) == 0
{ {
(*aheader).prefer_encrypt = 1i32; (*aheader).prefer_encrypt = 1;
return 1i32; return 1;
} }
return 1i32; return 1;
} else { } else {
if strcasecmp(name, b"keydata\x00" as *const u8 as *const libc::c_char) == 0i32 { if strcasecmp(name, b"keydata\x00" as *const u8 as *const libc::c_char) == 0 {
if value.is_null() if value.is_null()
|| !(*(*aheader).public_key).binary.is_null() || !(*(*aheader).public_key).binary.is_null()
|| 0 != (*(*aheader).public_key).bytes || 0 != (*(*aheader).public_key).bytes
{ {
return 0i32; return 0;
} }
return dc_key_set_from_base64((*aheader).public_key, value, 0i32); return dc_key_set_from_base64((*aheader).public_key, value, 0);
} else { } else {
if *name.offset(0isize) as libc::c_int == '_' as i32 { if *name.offset(0isize) as libc::c_int == '_' as i32 {
return 1i32; return 1;
} }
} }
} }
} }
return 0i32;
0
} }
pub unsafe fn dc_aheader_render(mut aheader: *const dc_aheader_t) -> *mut libc::c_char { pub unsafe fn dc_aheader_render(mut aheader: *const dc_aheader_t) -> *mut libc::c_char {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0;
let mut keybase64_wrapped: *mut libc::c_char = 0 as *mut libc::c_char; let mut keybase64_wrapped: *mut libc::c_char = 0 as *mut libc::c_char;
let mut ret: dc_strbuilder_t = dc_strbuilder_t { let mut ret: dc_strbuilder_t = dc_strbuilder_t {
buf: 0 as *mut libc::c_char, buf: 0 as *mut libc::c_char,
@@ -238,16 +241,16 @@ pub unsafe fn dc_aheader_render(mut aheader: *const dc_aheader_t) -> *mut libc::
free: 0, free: 0,
eos: 0 as *mut libc::c_char, eos: 0 as *mut libc::c_char,
}; };
dc_strbuilder_init(&mut ret, 0i32); dc_strbuilder_init(&mut ret, 0);
if !(aheader.is_null() if !(aheader.is_null()
|| (*aheader).addr.is_null() || (*aheader).addr.is_null()
|| (*(*aheader).public_key).binary.is_null() || (*(*aheader).public_key).binary.is_null()
|| (*(*aheader).public_key).type_0 != 0i32) || (*(*aheader).public_key).type_0 != 0)
{ {
dc_strbuilder_cat(&mut ret, b"addr=\x00" as *const u8 as *const libc::c_char); dc_strbuilder_cat(&mut ret, b"addr=\x00" as *const u8 as *const libc::c_char);
dc_strbuilder_cat(&mut ret, (*aheader).addr); dc_strbuilder_cat(&mut ret, (*aheader).addr);
dc_strbuilder_cat(&mut ret, b"; \x00" as *const u8 as *const libc::c_char); dc_strbuilder_cat(&mut ret, b"; \x00" as *const u8 as *const libc::c_char);
if (*aheader).prefer_encrypt == 1i32 { if (*aheader).prefer_encrypt == 1 {
dc_strbuilder_cat( dc_strbuilder_cat(
&mut ret, &mut ret,
b"prefer-encrypt=mutual; \x00" as *const u8 as *const libc::c_char, b"prefer-encrypt=mutual; \x00" as *const u8 as *const libc::c_char,
@@ -257,18 +260,19 @@ pub unsafe fn dc_aheader_render(mut aheader: *const dc_aheader_t) -> *mut libc::
&mut ret, &mut ret,
b"keydata= \x00" as *const u8 as *const libc::c_char, b"keydata= \x00" as *const u8 as *const libc::c_char,
); );
// TODO replace 78 with enum /rtn
/* adds a whitespace every 78 characters, this allows libEtPan to wrap the lines according to RFC 5322 /* adds a whitespace every 78 characters, this allows libEtPan to wrap the lines according to RFC 5322
(which may insert a linebreak before every whitespace) */ (which may insert a linebreak before every whitespace) */
keybase64_wrapped = dc_key_render_base64( keybase64_wrapped = dc_key_render_base64(
(*aheader).public_key, (*aheader).public_key,
78i32, 78,
b" \x00" as *const u8 as *const libc::c_char, b" \x00" as *const u8 as *const libc::c_char,
0i32, 0,
); );
if !keybase64_wrapped.is_null() { if !keybase64_wrapped.is_null() {
/*no checksum*/ /*no checksum*/
dc_strbuilder_cat(&mut ret, keybase64_wrapped); dc_strbuilder_cat(&mut ret, keybase64_wrapped);
success = 1i32 success = 1
} }
} }