mirror of
https://github.com/chatmail/core.git
synced 2026-04-28 19:06:35 +03:00
reduce code duplication (round 1)
This commit is contained in:
dignifiedquire
@@ -6,609 +6,8 @@ use crate::dc_jobthread::dc_jobthread_t;
|
||||
use crate::dc_lot::dc_lot_t;
|
||||
use crate::dc_smtp::dc_smtp_t;
|
||||
use crate::types::*;
|
||||
use crate::x::*;
|
||||
|
||||
extern "C" {
|
||||
#[no_mangle]
|
||||
fn getpid() -> pid_t;
|
||||
#[no_mangle]
|
||||
fn calloc(_: libc::c_ulong, _: libc::c_ulong) -> *mut libc::c_void;
|
||||
#[no_mangle]
|
||||
fn free(_: *mut libc::c_void);
|
||||
#[no_mangle]
|
||||
fn exit(_: libc::c_int) -> !;
|
||||
#[no_mangle]
|
||||
fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn strlen(_: *const libc::c_char) -> libc::c_ulong;
|
||||
#[no_mangle]
|
||||
fn strcasecmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn time(_: *mut time_t) -> time_t;
|
||||
#[no_mangle]
|
||||
fn pthread_cond_destroy(_: *mut pthread_cond_t) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn pthread_cond_init(_: *mut pthread_cond_t, _: *const pthread_condattr_t) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn pthread_mutex_destroy(_: *mut pthread_mutex_t) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn pthread_mutex_init(_: *mut pthread_mutex_t, _: *const pthread_mutexattr_t) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn pthread_self() -> pthread_t;
|
||||
#[no_mangle]
|
||||
fn libetpan_get_version_major() -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn libetpan_get_version_minor() -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_pgp_rand_seed(_: *mut dc_context_t, buf: *const libc::c_void, bytes: size_t);
|
||||
#[no_mangle]
|
||||
fn dc_smtp_new(_: *mut dc_context_t) -> *mut dc_smtp_t;
|
||||
#[no_mangle]
|
||||
fn dc_receive_imf(
|
||||
_: *mut dc_context_t,
|
||||
imf_raw_not_terminated: *const libc::c_char,
|
||||
imf_raw_bytes: size_t,
|
||||
server_folder: *const libc::c_char,
|
||||
server_uid: uint32_t,
|
||||
flags: uint32_t,
|
||||
);
|
||||
#[no_mangle]
|
||||
fn dc_job_add(
|
||||
_: *mut dc_context_t,
|
||||
action: libc::c_int,
|
||||
foreign_id: libc::c_int,
|
||||
param: *const libc::c_char,
|
||||
delay: libc::c_int,
|
||||
);
|
||||
#[no_mangle]
|
||||
fn dc_do_heuristics_moves(_: *mut dc_context_t, folder: *const libc::c_char, msg_id: uint32_t);
|
||||
#[no_mangle]
|
||||
fn dc_update_server_uid(
|
||||
_: *mut dc_context_t,
|
||||
rfc724_mid: *const libc::c_char,
|
||||
server_folder: *const libc::c_char,
|
||||
server_uid: uint32_t,
|
||||
);
|
||||
#[no_mangle]
|
||||
fn dc_update_msg_move_state(
|
||||
_: *mut dc_context_t,
|
||||
rfc724_mid: *const libc::c_char,
|
||||
_: dc_move_state_t,
|
||||
);
|
||||
#[no_mangle]
|
||||
fn dc_log_info(_: *mut dc_context_t, data1: libc::c_int, msg: *const libc::c_char, _: ...);
|
||||
#[no_mangle]
|
||||
fn dc_rfc724_mid_exists(
|
||||
_: *mut dc_context_t,
|
||||
rfc724_mid: *const libc::c_char,
|
||||
ret_server_folder: *mut *mut libc::c_char,
|
||||
ret_server_uid: *mut uint32_t,
|
||||
) -> uint32_t;
|
||||
/* handle configurations, private */
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_set_config(
|
||||
_: *mut dc_sqlite3_t,
|
||||
key: *const libc::c_char,
|
||||
value: *const libc::c_char,
|
||||
) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_get_config(
|
||||
_: *mut dc_sqlite3_t,
|
||||
key: *const libc::c_char,
|
||||
def: *const libc::c_char,
|
||||
) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_imap_new(
|
||||
_: dc_get_config_t,
|
||||
_: dc_set_config_t,
|
||||
_: dc_precheck_imf_t,
|
||||
_: dc_receive_imf_t,
|
||||
userData: *mut libc::c_void,
|
||||
_: *mut dc_context_t,
|
||||
) -> *mut dc_imap_t;
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_new(_: *mut dc_context_t) -> *mut dc_sqlite3_t;
|
||||
/* ** library-private **********************************************************/
|
||||
/* validation errors */
|
||||
/* misc. */
|
||||
#[no_mangle]
|
||||
fn dc_pgp_init();
|
||||
/* ** library-private **********************************************************/
|
||||
#[no_mangle]
|
||||
fn dc_openssl_init();
|
||||
#[no_mangle]
|
||||
fn dc_strdup_keep_null(_: *const libc::c_char) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_jobthread_init(
|
||||
_: *mut dc_jobthread_t,
|
||||
context: *mut dc_context_t,
|
||||
name: *const libc::c_char,
|
||||
folder_config_name: *const libc::c_char,
|
||||
);
|
||||
#[no_mangle]
|
||||
fn dc_jobthread_exit(_: *mut dc_jobthread_t);
|
||||
#[no_mangle]
|
||||
fn dc_openssl_exit();
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_unref(_: *mut dc_sqlite3_t);
|
||||
#[no_mangle]
|
||||
fn dc_smtp_unref(_: *mut dc_smtp_t);
|
||||
#[no_mangle]
|
||||
fn dc_imap_unref(_: *mut dc_imap_t);
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_close(_: *mut dc_sqlite3_t);
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_is_open(_: *const dc_sqlite3_t) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_smtp_disconnect(_: *mut dc_smtp_t);
|
||||
#[no_mangle]
|
||||
fn dc_imap_disconnect(_: *mut dc_imap_t);
|
||||
#[no_mangle]
|
||||
fn dc_pgp_exit();
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_open(
|
||||
_: *mut dc_sqlite3_t,
|
||||
dbfile: *const libc::c_char,
|
||||
flags: libc::c_int,
|
||||
) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_create_folder(_: *mut dc_context_t, pathNfilename: *const libc::c_char) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_mprintf(format: *const libc::c_char, _: ...) -> *mut libc::c_char;
|
||||
/* file tools */
|
||||
#[no_mangle]
|
||||
fn dc_ensure_no_slash(pathNfilename: *mut libc::c_char);
|
||||
/* string tools */
|
||||
#[no_mangle]
|
||||
fn dc_strdup(_: *const libc::c_char) -> *mut libc::c_char;
|
||||
/* Return the string with the given ID by calling DC_EVENT_GET_STRING.
|
||||
The result must be free()'d! */
|
||||
#[no_mangle]
|
||||
fn dc_stock_str(_: *mut dc_context_t, id: libc::c_int) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_interrupt_mvbox_idle(_: *mut dc_context_t);
|
||||
#[no_mangle]
|
||||
fn dc_interrupt_sentbox_idle(_: *mut dc_context_t);
|
||||
#[no_mangle]
|
||||
fn dc_interrupt_imap_idle(_: *mut dc_context_t);
|
||||
#[no_mangle]
|
||||
fn dc_make_rel_and_copy(
|
||||
_: *mut dc_context_t,
|
||||
pathNfilename: *mut *mut libc::c_char,
|
||||
) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_get_abs_path(
|
||||
_: *mut dc_context_t,
|
||||
pathNfilename: *const libc::c_char,
|
||||
) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_strbuilder_cat(_: *mut dc_strbuilder_t, text: *const libc::c_char) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_strbuilder_init(_: *mut dc_strbuilder_t, init_bytes: libc::c_int);
|
||||
#[no_mangle]
|
||||
fn dc_key_new() -> *mut dc_key_t;
|
||||
#[no_mangle]
|
||||
fn dc_key_unref(_: *mut dc_key_t);
|
||||
#[no_mangle]
|
||||
fn dc_loginparam_unref(_: *mut dc_loginparam_t);
|
||||
#[no_mangle]
|
||||
fn sqlite3_threadsafe() -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_get_config_int(
|
||||
_: *mut dc_sqlite3_t,
|
||||
key: *const libc::c_char,
|
||||
def: int32_t,
|
||||
) -> int32_t;
|
||||
#[no_mangle]
|
||||
fn dc_loginparam_get_readable(_: *const dc_loginparam_t) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_key_get_fingerprint(_: *const dc_key_t) -> *mut libc::c_char;
|
||||
#[no_mangle]
|
||||
fn dc_key_load_self_public(
|
||||
_: *mut dc_key_t,
|
||||
self_addr: *const libc::c_char,
|
||||
sql: *mut dc_sqlite3_t,
|
||||
) -> libc::c_int;
|
||||
/* tools, these functions are compatible to the corresponding sqlite3_* functions */
|
||||
#[no_mangle]
|
||||
fn dc_sqlite3_prepare(_: *mut dc_sqlite3_t, sql: *const libc::c_char) -> *mut sqlite3_stmt;
|
||||
#[no_mangle]
|
||||
fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn sqlite3_column_int(_: *mut sqlite3_stmt, iCol: libc::c_int) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn sqlite3_step(_: *mut sqlite3_stmt) -> libc::c_int;
|
||||
// Context functions to work with contacts
|
||||
#[no_mangle]
|
||||
fn dc_get_real_contact_cnt(_: *mut dc_context_t) -> size_t;
|
||||
#[no_mangle]
|
||||
fn dc_get_deaddrop_msg_cnt(_: *mut dc_context_t) -> size_t;
|
||||
#[no_mangle]
|
||||
fn dc_get_real_msg_cnt(_: *mut dc_context_t) -> size_t;
|
||||
#[no_mangle]
|
||||
fn dc_get_chat_cnt(_: *mut dc_context_t) -> size_t;
|
||||
#[no_mangle]
|
||||
fn dc_loginparam_read(
|
||||
_: *mut dc_loginparam_t,
|
||||
_: *mut dc_sqlite3_t,
|
||||
prefix: *const libc::c_char,
|
||||
);
|
||||
#[no_mangle]
|
||||
fn dc_loginparam_new() -> *mut dc_loginparam_t;
|
||||
#[no_mangle]
|
||||
fn dc_array_new(_: *mut dc_context_t, initsize: size_t) -> *mut dc_array_t;
|
||||
#[no_mangle]
|
||||
fn dc_array_add_id(_: *mut dc_array_t, _: uint32_t);
|
||||
#[no_mangle]
|
||||
fn sqlite3_bind_int(_: *mut sqlite3_stmt, _: libc::c_int, _: libc::c_int) -> libc::c_int;
|
||||
/* *
|
||||
* @class dc_array_t
|
||||
*
|
||||
* An object containing a simple array.
|
||||
* This object is used in several places where functions need to return an array.
|
||||
* The items of the array are typically IDs.
|
||||
* To free an array object, use dc_array_unref().
|
||||
*/
|
||||
#[no_mangle]
|
||||
fn dc_array_unref(_: *mut dc_array_t);
|
||||
#[no_mangle]
|
||||
fn sqlite3_bind_text(
|
||||
_: *mut sqlite3_stmt,
|
||||
_: libc::c_int,
|
||||
_: *const libc::c_char,
|
||||
_: libc::c_int,
|
||||
_: Option<unsafe extern "C" fn(_: *mut libc::c_void) -> ()>,
|
||||
) -> libc::c_int;
|
||||
#[no_mangle]
|
||||
fn dc_trim(_: *mut libc::c_char);
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct carray_s {
|
||||
pub array: *mut *mut libc::c_void,
|
||||
pub len: libc::c_uint,
|
||||
pub max: libc::c_uint,
|
||||
}
|
||||
pub type carray = carray_s;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _mailstream {
|
||||
pub buffer_max_size: size_t,
|
||||
pub write_buffer: *mut libc::c_char,
|
||||
pub write_buffer_len: size_t,
|
||||
pub read_buffer: *mut libc::c_char,
|
||||
pub read_buffer_len: size_t,
|
||||
pub low: *mut mailstream_low,
|
||||
pub idle: *mut mailstream_cancel,
|
||||
pub idling: libc::c_int,
|
||||
pub logger: Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut mailstream,
|
||||
_: libc::c_int,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *mut libc::c_void,
|
||||
) -> (),
|
||||
>,
|
||||
pub logger_context: *mut libc::c_void,
|
||||
}
|
||||
pub type mailstream = _mailstream;
|
||||
pub type mailstream_low = _mailstream_low;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _mailstream_low {
|
||||
pub data: *mut libc::c_void,
|
||||
pub driver: *mut mailstream_low_driver,
|
||||
pub privacy: libc::c_int,
|
||||
pub identifier: *mut libc::c_char,
|
||||
pub timeout: libc::c_ulong,
|
||||
pub logger: Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut mailstream_low,
|
||||
_: libc::c_int,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *mut libc::c_void,
|
||||
) -> (),
|
||||
>,
|
||||
pub logger_context: *mut libc::c_void,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailstream_low_driver {
|
||||
pub mailstream_read: Option<
|
||||
unsafe extern "C" fn(_: *mut mailstream_low, _: *mut libc::c_void, _: size_t) -> ssize_t,
|
||||
>,
|
||||
pub mailstream_write: Option<
|
||||
unsafe extern "C" fn(_: *mut mailstream_low, _: *const libc::c_void, _: size_t) -> ssize_t,
|
||||
>,
|
||||
pub mailstream_close: Option<unsafe extern "C" fn(_: *mut mailstream_low) -> libc::c_int>,
|
||||
pub mailstream_get_fd: Option<unsafe extern "C" fn(_: *mut mailstream_low) -> libc::c_int>,
|
||||
pub mailstream_free: Option<unsafe extern "C" fn(_: *mut mailstream_low) -> ()>,
|
||||
pub mailstream_cancel: Option<unsafe extern "C" fn(_: *mut mailstream_low) -> ()>,
|
||||
pub mailstream_get_cancel:
|
||||
Option<unsafe extern "C" fn(_: *mut mailstream_low) -> *mut mailstream_cancel>,
|
||||
pub mailstream_get_certificate_chain:
|
||||
Option<unsafe extern "C" fn(_: *mut mailstream_low) -> *mut carray>,
|
||||
pub mailstream_setup_idle: Option<unsafe extern "C" fn(_: *mut mailstream_low) -> libc::c_int>,
|
||||
pub mailstream_unsetup_idle:
|
||||
Option<unsafe extern "C" fn(_: *mut mailstream_low) -> libc::c_int>,
|
||||
pub mailstream_interrupt_idle:
|
||||
Option<unsafe extern "C" fn(_: *mut mailstream_low) -> libc::c_int>,
|
||||
}
|
||||
pub type progress_function = unsafe extern "C" fn(_: size_t, _: size_t) -> ();
|
||||
pub type mailprogress_function =
|
||||
unsafe extern "C" fn(_: size_t, _: size_t, _: *mut libc::c_void) -> ();
|
||||
#[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 type MMAPString = _MMAPString;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct clistcell_s {
|
||||
pub data: *mut libc::c_void,
|
||||
pub previous: *mut clistcell_s,
|
||||
pub next: *mut clistcell_s,
|
||||
}
|
||||
pub type clistcell = clistcell_s;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct clist_s {
|
||||
pub first: *mut clistcell,
|
||||
pub last: *mut clistcell,
|
||||
pub count: libc::c_int,
|
||||
}
|
||||
pub type clist = clist_s;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailsmtp {
|
||||
pub stream: *mut mailstream,
|
||||
pub progr_rate: size_t,
|
||||
pub progr_fun: Option<unsafe extern "C" fn(_: size_t, _: size_t) -> ()>,
|
||||
pub response: *mut libc::c_char,
|
||||
pub line_buffer: *mut MMAPString,
|
||||
pub response_buffer: *mut MMAPString,
|
||||
pub esmtp: libc::c_int,
|
||||
pub auth: libc::c_int,
|
||||
pub smtp_sasl: unnamed,
|
||||
pub smtp_max_msg_size: size_t,
|
||||
pub smtp_progress_fun:
|
||||
Option<unsafe extern "C" fn(_: size_t, _: size_t, _: *mut libc::c_void) -> ()>,
|
||||
pub smtp_progress_context: *mut libc::c_void,
|
||||
pub response_code: libc::c_int,
|
||||
pub smtp_timeout: time_t,
|
||||
pub smtp_logger: Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut mailsmtp,
|
||||
_: libc::c_int,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *mut libc::c_void,
|
||||
) -> (),
|
||||
>,
|
||||
pub smtp_logger_context: *mut libc::c_void,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct unnamed {
|
||||
pub sasl_conn: *mut libc::c_void,
|
||||
pub sasl_server_fqdn: *const libc::c_char,
|
||||
pub sasl_login: *const libc::c_char,
|
||||
pub sasl_auth_name: *const libc::c_char,
|
||||
pub sasl_password: *const libc::c_char,
|
||||
pub sasl_realm: *const libc::c_char,
|
||||
pub sasl_secret: *mut libc::c_void,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_capability_data {
|
||||
pub cap_list: *mut clist,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_msg_att_body_section {
|
||||
pub sec_section: *mut mailimap_section,
|
||||
pub sec_origin_octet: uint32_t,
|
||||
pub sec_body_part: *mut libc::c_char,
|
||||
pub sec_length: size_t,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_section {
|
||||
pub sec_spec: *mut mailimap_section_spec,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_section_spec {
|
||||
pub sec_type: libc::c_int,
|
||||
pub sec_data: unnamed_0,
|
||||
pub sec_text: *mut mailimap_section_text,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_section_text {
|
||||
pub sec_type: libc::c_int,
|
||||
pub sec_msgtext: *mut mailimap_section_msgtext,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_section_msgtext {
|
||||
pub sec_type: libc::c_int,
|
||||
pub sec_header_list: *mut mailimap_header_list,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_header_list {
|
||||
pub hdr_list: *mut clist,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub union unnamed_0 {
|
||||
pub sec_msgtext: *mut mailimap_section_msgtext,
|
||||
pub sec_part: *mut mailimap_section_part,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_section_part {
|
||||
pub sec_id: *mut clist,
|
||||
}
|
||||
pub type mailimap_msg_body_handler = unsafe extern "C" fn(
|
||||
_: libc::c_int,
|
||||
_: *mut mailimap_msg_att_body_section,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *mut libc::c_void,
|
||||
) -> bool;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_flag_list {
|
||||
pub fl_list: *mut clist,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_mailbox_data_status {
|
||||
pub st_mailbox: *mut libc::c_char,
|
||||
pub st_info_list: *mut clist,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_msg_att {
|
||||
pub att_list: *mut clist,
|
||||
pub att_number: uint32_t,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_fetch_att {
|
||||
pub att_type: libc::c_int,
|
||||
pub att_section: *mut mailimap_section,
|
||||
pub att_offset: uint32_t,
|
||||
pub att_size: uint32_t,
|
||||
pub att_extension: *mut libc::c_char,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_fetch_type {
|
||||
pub ft_type: libc::c_int,
|
||||
pub ft_data: unnamed_1,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub union unnamed_1 {
|
||||
pub ft_fetch_att: *mut mailimap_fetch_att,
|
||||
pub ft_fetch_att_list: *mut clist,
|
||||
}
|
||||
pub type mailimap_msg_att_handler =
|
||||
unsafe extern "C" fn(_: *mut mailimap_msg_att, _: *mut libc::c_void) -> ();
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap {
|
||||
pub imap_response: *mut libc::c_char,
|
||||
pub imap_stream: *mut mailstream,
|
||||
pub imap_progr_rate: size_t,
|
||||
pub imap_progr_fun: Option<unsafe extern "C" fn(_: size_t, _: size_t) -> ()>,
|
||||
pub imap_stream_buffer: *mut MMAPString,
|
||||
pub imap_response_buffer: *mut MMAPString,
|
||||
pub imap_state: libc::c_int,
|
||||
pub imap_tag: libc::c_int,
|
||||
pub imap_connection_info: *mut mailimap_connection_info,
|
||||
pub imap_selection_info: *mut mailimap_selection_info,
|
||||
pub imap_response_info: *mut mailimap_response_info,
|
||||
pub imap_sasl: unnamed_2,
|
||||
pub imap_idle_timestamp: time_t,
|
||||
pub imap_idle_maxdelay: time_t,
|
||||
pub imap_body_progress_fun:
|
||||
Option<unsafe extern "C" fn(_: size_t, _: size_t, _: *mut libc::c_void) -> ()>,
|
||||
pub imap_items_progress_fun:
|
||||
Option<unsafe extern "C" fn(_: size_t, _: size_t, _: *mut libc::c_void) -> ()>,
|
||||
pub imap_progress_context: *mut libc::c_void,
|
||||
pub imap_msg_att_handler:
|
||||
Option<unsafe extern "C" fn(_: *mut mailimap_msg_att, _: *mut libc::c_void) -> ()>,
|
||||
pub imap_msg_att_handler_context: *mut libc::c_void,
|
||||
pub imap_msg_body_handler: Option<
|
||||
unsafe extern "C" fn(
|
||||
_: libc::c_int,
|
||||
_: *mut mailimap_msg_att_body_section,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *mut libc::c_void,
|
||||
) -> bool,
|
||||
>,
|
||||
pub imap_msg_body_handler_context: *mut libc::c_void,
|
||||
pub imap_timeout: time_t,
|
||||
pub imap_logger: Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut mailimap,
|
||||
_: libc::c_int,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *mut libc::c_void,
|
||||
) -> (),
|
||||
>,
|
||||
pub imap_logger_context: *mut libc::c_void,
|
||||
pub is_163_workaround_enabled: libc::c_int,
|
||||
pub is_rambler_workaround_enabled: libc::c_int,
|
||||
pub is_qip_workaround_enabled: libc::c_int,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct unnamed_2 {
|
||||
pub sasl_conn: *mut libc::c_void,
|
||||
pub sasl_server_fqdn: *const libc::c_char,
|
||||
pub sasl_login: *const libc::c_char,
|
||||
pub sasl_auth_name: *const libc::c_char,
|
||||
pub sasl_password: *const libc::c_char,
|
||||
pub sasl_realm: *const libc::c_char,
|
||||
pub sasl_secret: *mut libc::c_void,
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_response_info {
|
||||
pub rsp_alert: *mut libc::c_char,
|
||||
pub rsp_parse: *mut libc::c_char,
|
||||
pub rsp_badcharset: *mut clist,
|
||||
pub rsp_trycreate: libc::c_int,
|
||||
pub rsp_mailbox_list: *mut clist,
|
||||
pub rsp_mailbox_lsub: *mut clist,
|
||||
pub rsp_search_result: *mut clist,
|
||||
pub rsp_status: *mut mailimap_mailbox_data_status,
|
||||
pub rsp_expunged: *mut clist,
|
||||
pub rsp_fetch_list: *mut clist,
|
||||
pub rsp_extension_list: *mut clist,
|
||||
pub rsp_atom: *mut libc::c_char,
|
||||
pub rsp_value: *mut libc::c_char,
|
||||
}
|
||||
#[derive(BitfieldStruct, Clone, Copy)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_selection_info {
|
||||
pub sel_perm_flags: *mut clist,
|
||||
pub sel_perm: libc::c_int,
|
||||
pub sel_uidnext: uint32_t,
|
||||
pub sel_uidvalidity: uint32_t,
|
||||
pub sel_first_unseen: uint32_t,
|
||||
pub sel_flags: *mut mailimap_flag_list,
|
||||
pub sel_exists: uint32_t,
|
||||
pub sel_recent: uint32_t,
|
||||
pub sel_unseen: uint32_t,
|
||||
#[bitfield(name = "sel_has_exists", ty = "uint8_t", bits = "0..=0")]
|
||||
#[bitfield(name = "sel_has_recent", ty = "uint8_t", bits = "1..=1")]
|
||||
pub sel_has_exists_sel_has_recent: [u8; 1],
|
||||
pub _pad: [u8; 3],
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct mailimap_connection_info {
|
||||
pub imap_capability: *mut mailimap_capability_data,
|
||||
}
|
||||
/* define DC_USE_RPGP to enable use of rPGP instead of netpgp where available;
|
||||
preferrably, this should be done in the project configuration currently */
|
||||
//#define DC_USE_RPGP 1
|
||||
/* Includes that are used frequently. This file may also be used to create predefined headers. */
|
||||
/* * Structure behind dc_context_t */
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct dc_context_t {
|
||||
@@ -647,305 +46,7 @@ pub struct dc_context_t {
|
||||
|
||||
unsafe impl Send for dc_context_t {}
|
||||
unsafe impl Sync for dc_context_t {}
|
||||
/* *
|
||||
* Callback function that should be given to dc_context_new().
|
||||
*
|
||||
* @memberof dc_context_t
|
||||
* @param context The context object as returned by dc_context_new().
|
||||
* @param event one of the @ref DC_EVENT constants
|
||||
* @param data1 depends on the event parameter
|
||||
* @param data2 depends on the event parameter
|
||||
* @return return 0 unless stated otherwise in the event parameter documentation
|
||||
*/
|
||||
pub type dc_callback_t = Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut dc_context_t,
|
||||
_: libc::c_int,
|
||||
_: uintptr_t,
|
||||
_: uintptr_t,
|
||||
) -> uintptr_t,
|
||||
>;
|
||||
/* *
|
||||
* @mainpage Getting started
|
||||
*
|
||||
* This document describes how to handle the Delta Chat core library.
|
||||
* For general information about Delta Chat itself,
|
||||
* see <https://delta.chat> and <https://github.com/deltachat>.
|
||||
*
|
||||
* Let's start.
|
||||
*
|
||||
* First of all, you have to **define an event-handler-function**
|
||||
* that is called by the library on specific events
|
||||
* (eg. when the configuration is done or when fresh messages arrive).
|
||||
* With this function you can create a Delta Chat context then:
|
||||
*
|
||||
* ~~~
|
||||
* #include <deltachat.h>
|
||||
*
|
||||
* uintptr_t event_handler_func(dc_context_t* context, int event,
|
||||
* uintptr_t data1, uintptr_t data2)
|
||||
* {
|
||||
* return 0; // for unhandled events, it is always safe to return 0
|
||||
* }
|
||||
*
|
||||
* dc_context_t* context = dc_context_new(event_handler_func, NULL, NULL);
|
||||
* ~~~
|
||||
*
|
||||
* After that, you should make sure,
|
||||
* sending and receiving jobs are processed as needed.
|
||||
* For this purpose, you have to **create two threads:**
|
||||
*
|
||||
* ~~~
|
||||
* #include <pthread.h>
|
||||
*
|
||||
* void* imap_thread_func(void* context)
|
||||
* {
|
||||
* while (true) {
|
||||
* dc_perform_imap_jobs(context);
|
||||
* dc_perform_imap_fetch(context);
|
||||
* dc_perform_imap_idle(context);
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* void* smtp_thread_func(void* context)
|
||||
* {
|
||||
* while (true) {
|
||||
* dc_perform_smtp_jobs(context);
|
||||
* dc_perform_smtp_idle(context);
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* static pthread_t imap_thread, smtp_thread;
|
||||
* pthread_create(&imap_thread, NULL, imap_thread_func, context);
|
||||
* pthread_create(&smtp_thread, NULL, smtp_thread_func, context);
|
||||
* ~~~
|
||||
*
|
||||
* The example above uses "pthreads",
|
||||
* however, you can also use anything else for thread handling.
|
||||
* NB: The deltachat-core library itself does not create any threads on its own,
|
||||
* however, functions, unless stated otherwise, are thread-safe.
|
||||
*
|
||||
* After that you can **define and open a database.**
|
||||
* The database is a normal sqlite-file and is created as needed:
|
||||
*
|
||||
* ~~~
|
||||
* dc_open(context, "example.db", NULL);
|
||||
* ~~~
|
||||
*
|
||||
* Now you can **configure the context:**
|
||||
*
|
||||
* ~~~
|
||||
* // use some real test credentials here
|
||||
* dc_set_config(context, "addr", "alice@example.org");
|
||||
* dc_set_config(context, "mail_pw", "***");
|
||||
* dc_configure(context);
|
||||
* ~~~
|
||||
*
|
||||
* dc_configure() returns immediately, the configuration itself may take a while
|
||||
* and is done by a job in the imap-thread you've defined above.
|
||||
* Once done, the #DC_EVENT_CONFIGURE_PROGRESS reports success
|
||||
* to the event_handler_func() that is also defined above.
|
||||
*
|
||||
* The configuration result is saved in the database,
|
||||
* on subsequent starts it is not needed to call dc_configure()
|
||||
* (you can check this using dc_is_configured()).
|
||||
*
|
||||
* Now you can **send the first message:**
|
||||
*
|
||||
* ~~~
|
||||
* // use a real testing address here
|
||||
* uint32_t contact_id = dc_create_contact(context, NULL, "bob@example.org");
|
||||
* uint32_t chat_id = dc_create_chat_by_contact_id(context, contact_id);
|
||||
*
|
||||
* dc_send_text_msg(context, chat_id, "Hi, here is my first message!");
|
||||
* ~~~
|
||||
*
|
||||
* dc_send_text_msg() returns immediately;
|
||||
* the sending itself is done by a job in the smtp-thread you've defined above.
|
||||
* If you check the testing address (bob)
|
||||
* and you should have received a normal email.
|
||||
* Answer this email in any email program with "Got it!"
|
||||
* and the imap-thread you've create above will **receive the message**.
|
||||
*
|
||||
* You can then **list all messages** of a chat as follow:
|
||||
*
|
||||
* ~~~
|
||||
* dc_array_t* msglist = dc_get_chat_msgs(context, chat_id, 0, 0);
|
||||
* for (int i = 0; i < dc_array_get_cnt(msglist); i++)
|
||||
* {
|
||||
* uint32_t msg_id = dc_array_get_id(msglist, i);
|
||||
* dc_msg_t* msg = dc_get_msg(context, msg_id);
|
||||
* char* text = dc_msg_get_text(msg);
|
||||
*
|
||||
* printf("Message %i: %s\n", i+1, text);
|
||||
*
|
||||
* free(text);
|
||||
* dc_msg_unref(msg);
|
||||
* }
|
||||
* dc_array_unref(msglist);
|
||||
* ~~~
|
||||
*
|
||||
* This will output the following two lines:
|
||||
*
|
||||
* ~~~
|
||||
* Message 1: Hi, here is my first message!
|
||||
* Message 2: Got it!
|
||||
* ~~~
|
||||
*
|
||||
*
|
||||
* ## Class reference
|
||||
*
|
||||
* For a class reference, see the "Classes" link atop.
|
||||
*
|
||||
*
|
||||
* ## Further hints
|
||||
*
|
||||
* Here are some additional, unsorted hints that may be useful.
|
||||
*
|
||||
* - For `get`-functions, you have to unref the return value in some way.
|
||||
*
|
||||
* - Strings in function arguments or return values are usually UTF-8 encoded.
|
||||
*
|
||||
* - The issue-tracker for the core library is here:
|
||||
* <https://github.com/deltachat/deltachat-core/issues>
|
||||
*
|
||||
* The following points are important mainly
|
||||
* for the authors of the library itself:
|
||||
*
|
||||
* - For indentation, use tabs.
|
||||
* Alignments that are not placed at the beginning of a line
|
||||
* should be done with spaces.
|
||||
*
|
||||
* - For padding between functions,
|
||||
* classes etc. use 2 empty lines
|
||||
*
|
||||
* - Source files are encoded as UTF-8 with Unix line endings
|
||||
* (a simple `LF`, `0x0A` or `\n`)
|
||||
*
|
||||
* If you need further assistance,
|
||||
* please do not hesitate to contact us
|
||||
* through the channels shown at https://delta.chat/en/contribute
|
||||
*
|
||||
* Please keep in mind, that your derived work
|
||||
* must respect the Mozilla Public License 2.0 of libdeltachat
|
||||
* and the respective licenses of the libraries libdeltachat links with.
|
||||
*
|
||||
* See you.
|
||||
*/
|
||||
/* *
|
||||
* @class dc_context_t
|
||||
*
|
||||
* An object representing a single account.
|
||||
*
|
||||
* Each account is linked to an IMAP/SMTP account and uses a separate
|
||||
* SQLite database for offline functionality and for account-related
|
||||
* settings.
|
||||
*/
|
||||
|
||||
/* ** library-private **********************************************************/
|
||||
|
||||
/* *
|
||||
* Library-internal.
|
||||
*/
|
||||
pub type dc_receive_imf_t = Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut dc_imap_t,
|
||||
_: *const libc::c_char,
|
||||
_: size_t,
|
||||
_: *const libc::c_char,
|
||||
_: uint32_t,
|
||||
_: uint32_t,
|
||||
) -> (),
|
||||
>;
|
||||
/* Purpose: Reading from IMAP servers with no dependencies to the database.
|
||||
dc_context_t is only used for logging and to get information about
|
||||
the online state. */
|
||||
pub type dc_precheck_imf_t = Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut dc_imap_t,
|
||||
_: *const libc::c_char,
|
||||
_: *const libc::c_char,
|
||||
_: uint32_t,
|
||||
) -> libc::c_int,
|
||||
>;
|
||||
pub type dc_set_config_t = Option<
|
||||
unsafe extern "C" fn(_: *mut dc_imap_t, _: *const libc::c_char, _: *const libc::c_char) -> (),
|
||||
>;
|
||||
pub type dc_get_config_t = Option<
|
||||
unsafe extern "C" fn(
|
||||
_: *mut dc_imap_t,
|
||||
_: *const libc::c_char,
|
||||
_: *const libc::c_char,
|
||||
) -> *mut libc::c_char,
|
||||
>;
|
||||
/* ** library-private **********************************************************/
|
||||
use crate::dc_sqlite3::dc_sqlite3_t;
|
||||
/* *
|
||||
* Library-internal.
|
||||
*/
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _dc_sqlite3 {
|
||||
pub cobj: *mut sqlite3,
|
||||
pub context: *mut dc_context_t,
|
||||
}
|
||||
/* * the structure behind dc_array_t */
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _dc_array {
|
||||
pub magic: uint32_t,
|
||||
pub context: *mut dc_context_t,
|
||||
pub allocated: size_t,
|
||||
pub count: size_t,
|
||||
pub type_0: libc::c_int,
|
||||
pub array: *mut uintptr_t,
|
||||
}
|
||||
pub type dc_array_t = _dc_array;
|
||||
pub type dc_move_state_t = libc::c_uint;
|
||||
pub const DC_MOVE_STATE_MOVING: dc_move_state_t = 3;
|
||||
pub const DC_MOVE_STATE_STAY: dc_move_state_t = 2;
|
||||
pub const DC_MOVE_STATE_PENDING: dc_move_state_t = 1;
|
||||
pub const DC_MOVE_STATE_UNDEFINED: dc_move_state_t = 0;
|
||||
pub type dc_strbuilder_t = _dc_strbuilder;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _dc_strbuilder {
|
||||
pub buf: *mut libc::c_char,
|
||||
pub allocated: libc::c_int,
|
||||
pub free: libc::c_int,
|
||||
pub eos: *mut libc::c_char,
|
||||
}
|
||||
pub type dc_key_t = _dc_key;
|
||||
/* *
|
||||
* Library-internal.
|
||||
*/
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _dc_key {
|
||||
pub binary: *mut libc::c_void,
|
||||
pub bytes: libc::c_int,
|
||||
pub type_0: libc::c_int,
|
||||
pub _m_heap_refcnt: libc::c_int,
|
||||
}
|
||||
pub type dc_loginparam_t = _dc_loginparam;
|
||||
/* *
|
||||
* Library-internal.
|
||||
*/
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct _dc_loginparam {
|
||||
pub addr: *mut libc::c_char,
|
||||
pub mail_server: *mut libc::c_char,
|
||||
pub mail_user: *mut libc::c_char,
|
||||
pub mail_pw: *mut libc::c_char,
|
||||
pub mail_port: uint16_t,
|
||||
pub send_server: *mut libc::c_char,
|
||||
pub send_user: *mut libc::c_char,
|
||||
pub send_pw: *mut libc::c_char,
|
||||
pub send_port: libc::c_int,
|
||||
pub server_flags: libc::c_int,
|
||||
}
|
||||
pub type sqlite3_destructor_type = Option<unsafe extern "C" fn(_: *mut libc::c_void) -> ()>;
|
||||
// create/open/config/information
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn dc_context_new(
|
||||
@@ -1459,7 +560,7 @@ unsafe extern "C" fn get_sys_config_str(mut key: *const libc::c_char) -> *mut li
|
||||
};
|
||||
}
|
||||
unsafe extern "C" fn get_config_keys_str() -> *mut libc::c_char {
|
||||
let mut ret: dc_strbuilder_t = _dc_strbuilder {
|
||||
let mut ret: dc_strbuilder_t = dc_strbuilder_t {
|
||||
buf: 0 as *mut libc::c_char,
|
||||
allocated: 0,
|
||||
free: 0,
|
||||
@@ -1520,7 +621,7 @@ pub unsafe extern "C" fn dc_get_info(mut context: *mut dc_context_t) -> *mut lib
|
||||
let mut self_public: *mut dc_key_t = dc_key_new();
|
||||
let mut rpgp_enabled: libc::c_int = 0i32;
|
||||
rpgp_enabled = 1i32;
|
||||
let mut ret: dc_strbuilder_t = _dc_strbuilder {
|
||||
let mut ret: dc_strbuilder_t = dc_strbuilder_t {
|
||||
buf: 0 as *mut libc::c_char,
|
||||
allocated: 0,
|
||||
free: 0,
|
||||
|
||||
Reference in New Issue
Block a user