yetangitu/deltachat-core
1
0
Fork 0
mirror of https://github.com/deltachat/deltachat-core.git synced 2025-10-05 10:39:27 +02:00
Code Issues Releases Wiki Activity

refactor tools

Browse source
This commit is contained in:
B. Petersen 2018-06-25 21:59:52 +02:00
parent 31f80e3f1a
commit 177c08799d
36 changed files with 510 additions and 509 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/dc_aheader.c
View file

@ -180,7 +180,7 @@ int dc_aheader_set_from_string(dc_aheader_t* ths, const char* header_str__)
ths->m_prefer_encrypt = DC_PE_NOPREFERENCE; /* value to use if the prefer-encrypted header is missing */
header_str = safe_strdup(header_str__);
header_str = dc_strdup(header_str__);
p = header_str;
while( *p )
{
@ -204,7 +204,7 @@ int dc_aheader_set_from_string(dc_aheader_t* ths, const char* header_str__)
*p = '\0';
p++;
}
mr_trim(beg_attr_value);
dc_trim(beg_attr_value);
}
else
{

18
src/dc_apeerstate.c
View file

@ -78,17 +78,17 @@ static void dc_apeerstate_empty(dc_apeerstate_t* ths)
static void dc_apeerstate_set_from_stmt__(dc_apeerstate_t* peerstate, sqlite3_stmt* stmt)
{
#define PEERSTATE_FIELDS "addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint"
peerstate->m_addr = safe_strdup((char*)sqlite3_column_text (stmt, 0));
peerstate->m_addr = dc_strdup((char*)sqlite3_column_text (stmt, 0));
peerstate->m_last_seen = sqlite3_column_int64 (stmt, 1);
peerstate->m_last_seen_autocrypt = sqlite3_column_int64 (stmt, 2);
peerstate->m_prefer_encrypt = sqlite3_column_int (stmt, 3);
#define PUBLIC_KEY_COL 4
peerstate->m_gossip_timestamp = sqlite3_column_int (stmt, 5);
#define GOSSIP_KEY_COL 6
peerstate->m_public_key_fingerprint = safe_strdup((char*)sqlite3_column_text (stmt, 7));
peerstate->m_gossip_key_fingerprint = safe_strdup((char*)sqlite3_column_text (stmt, 8));
peerstate->m_public_key_fingerprint = dc_strdup((char*)sqlite3_column_text (stmt, 7));
peerstate->m_gossip_key_fingerprint = dc_strdup((char*)sqlite3_column_text (stmt, 8));
#define VERIFIED_KEY_COL 9
peerstate->m_verified_key_fingerprint = safe_strdup((char*)sqlite3_column_text(stmt, 10));
peerstate->m_verified_key_fingerprint = dc_strdup((char*)sqlite3_column_text(stmt, 10));
if( sqlite3_column_type(stmt, PUBLIC_KEY_COL)!=SQLITE_NULL ) {
peerstate->m_public_key = dc_key_new();
@ -278,7 +278,7 @@ char* dc_apeerstate_render_gossip_header(const dc_apeerstate_t* peerstate, int m
}
autocryptheader->m_prefer_encrypt = DC_PE_NOPREFERENCE; /* the spec says, we SHOULD NOT gossip this flag */
autocryptheader->m_addr = safe_strdup(peerstate->m_addr);
autocryptheader->m_addr = dc_strdup(peerstate->m_addr);
autocryptheader->m_public_key = dc_key_ref(dc_apeerstate_peek_key(peerstate, min_verified)); /* may be NULL */
ret = dc_aheader_render(autocryptheader);
@ -342,7 +342,7 @@ int dc_apeerstate_init_from_header(dc_apeerstate_t* ths, const dc_aheader_t* hea
}
dc_apeerstate_empty(ths);
ths->m_addr = safe_strdup(header->m_addr);
ths->m_addr = dc_strdup(header->m_addr);
ths->m_last_seen = message_time;
ths->m_last_seen_autocrypt = message_time;
ths->m_to_save = DC_SAVE_ALL;
@ -363,7 +363,7 @@ int dc_apeerstate_init_from_gossip(dc_apeerstate_t* peerstate, const dc_aheader_
}
dc_apeerstate_empty(peerstate);
peerstate->m_addr = safe_strdup(gossip_header->m_addr);
peerstate->m_addr = dc_strdup(gossip_header->m_addr);
peerstate->m_gossip_timestamp = message_time;
peerstate->m_to_save = DC_SAVE_ALL;
@ -564,7 +564,7 @@ int dc_apeerstate_set_verified(dc_apeerstate_t* peerstate, int which_key, const
{
peerstate->m_to_save |= DC_SAVE_ALL;
peerstate->m_verified_key = dc_key_ref(peerstate->m_public_key);
peerstate->m_verified_key_fingerprint = safe_strdup(peerstate->m_public_key_fingerprint);
peerstate->m_verified_key_fingerprint = dc_strdup(peerstate->m_public_key_fingerprint);
success = 1;
}
@ -576,7 +576,7 @@ int dc_apeerstate_set_verified(dc_apeerstate_t* peerstate, int which_key, const
{
peerstate->m_to_save |= DC_SAVE_ALL;
peerstate->m_verified_key = dc_key_ref(peerstate->m_gossip_key);
peerstate->m_verified_key_fingerprint = safe_strdup(peerstate->m_gossip_key_fingerprint);
peerstate->m_verified_key_fingerprint = dc_strdup(peerstate->m_gossip_key_fingerprint);
success = 1;
}

4
src/dc_array.c
View file

@ -408,7 +408,7 @@ char* dc_arr_to_string(const uint32_t* arr, int cnt)
const char* sep = ",";
if( arr==NULL || cnt <= 0 ) {
return safe_strdup("");
return dc_strdup("");
}
/* use a macro to allow using integers of different bitwidths */
@ -436,7 +436,7 @@ char* dc_array_get_string(const dc_array_t* array, const char* sep)
char* ret = NULL;
if( array == NULL || array->m_magic != MR_ARRAY_MAGIC || sep==NULL ) {
return safe_strdup("");
return dc_strdup("");
}
INT_ARR_TO_STR(array->m_array, array->m_count);

18
src/dc_chat.c
View file

@ -192,10 +192,10 @@ int dc_chat_get_type(dc_chat_t* chat)
char* dc_chat_get_name(dc_chat_t* chat)
{
if( chat == NULL || chat->m_magic != MR_CHAT_MAGIC ) {
return safe_strdup("Err");
return dc_strdup("Err");
}
return safe_strdup(chat->m_name);
return dc_strdup(chat->m_name);
}
@ -218,7 +218,7 @@ char* dc_chat_get_subtitle(dc_chat_t* chat)
sqlite3_stmt* stmt;
if( chat == NULL || chat->m_magic != MR_CHAT_MAGIC ) {
return safe_strdup("Err");
return dc_strdup("Err");
}
if( chat->m_type == DC_CHAT_TYPE_SINGLE && dc_param_exists(chat->m_param, DC_PARAM_SELFTALK) )
@ -238,7 +238,7 @@ char* dc_chat_get_subtitle(dc_chat_t* chat)
r = sqlite3_step(stmt);
if( r == SQLITE_ROW ) {
ret = safe_strdup((const char*)sqlite3_column_text(stmt, 0));
ret = dc_strdup((const char*)sqlite3_column_text(stmt, 0));
}
dc_sqlite3_unlock(chat->m_context->m_sql);
@ -261,7 +261,7 @@ char* dc_chat_get_subtitle(dc_chat_t* chat)
}
}
return ret? ret : safe_strdup("Err");
return ret? ret : dc_strdup("Err");
}
@ -305,7 +305,7 @@ char* dc_chat_get_draft(dc_chat_t* chat)
if( chat == NULL || chat->m_magic != MR_CHAT_MAGIC ) {
return NULL;
}
return strdup_keep_null(chat->m_draft_text); /* may be NULL */
return dc_strdup_keep_null(chat->m_draft_text); /* may be NULL */
}
@ -488,10 +488,10 @@ static int dc_chat_set_from_stmt__(dc_chat_t* ths, sqlite3_stmt* row)
#define MR_CHAT_FIELDS " c.id,c.type,c.name, c.draft_timestamp,c.draft_txt,c.grpid,c.param,c.archived, c.blocked "
ths->m_id = sqlite3_column_int (row, row_offset++); /* the columns are defined in MR_CHAT_FIELDS */
ths->m_type = sqlite3_column_int (row, row_offset++);
ths->m_name = safe_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_name = dc_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_draft_timestamp = sqlite3_column_int64(row, row_offset++);
draft_text = (const char*)sqlite3_column_text (row, row_offset++);
ths->m_grpid = safe_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_grpid = dc_strdup((char*)sqlite3_column_text (row, row_offset++));
dc_param_set_packed(ths->m_param, (char*)sqlite3_column_text (row, row_offset++));
ths->m_archived = sqlite3_column_int (row, row_offset++);
ths->m_blocked = sqlite3_column_int (row, row_offset++);
@ -499,7 +499,7 @@ static int dc_chat_set_from_stmt__(dc_chat_t* ths, sqlite3_stmt* row)
/* We leave a NULL-pointer for the very usual situation of "no draft".
Also make sure, m_draft_text and m_draft_timestamp are set together */
if( ths->m_draft_timestamp && draft_text && draft_text[0] ) {
ths->m_draft_text = safe_strdup(draft_text);
ths->m_draft_text = dc_strdup(draft_text);
}
else {
ths->m_draft_timestamp = 0;

14
src/dc_chatlist.c
View file

@ -207,7 +207,7 @@ dc_lot_t* dc_chatlist_get_summary(dc_chatlist_t* chatlist, size_t index, dc_chat
dc_chat_t* chat_to_delete = NULL;
if( chatlist == NULL || chatlist->m_magic != MR_CHATLIST_MAGIC || index >= chatlist->m_cnt ) {
ret->m_text2 = safe_strdup("ErrBadChatlistIndex");
ret->m_text2 = dc_strdup("ErrBadChatlistIndex");
goto cleanup;
}
@ -221,7 +221,7 @@ dc_lot_t* dc_chatlist_get_summary(dc_chatlist_t* chatlist, size_t index, dc_chat
chat = dc_chat_new(chatlist->m_context);
chat_to_delete = chat;
if( !dc_chat_load_from_db__(chat, dc_array_get_id(chatlist->m_chatNlastmsg_ids, index*MR_CHATLIST_IDS_PER_RESULT)) ) {
ret->m_text2 = safe_strdup("ErrCannotReadChat");
ret->m_text2 = dc_strdup("ErrCannotReadChat");
goto cleanup;
}
}
@ -245,7 +245,7 @@ dc_lot_t* dc_chatlist_get_summary(dc_chatlist_t* chatlist, size_t index, dc_chat
if( chat->m_id == DC_CHAT_ID_ARCHIVED_LINK )
{
ret->m_text2 = safe_strdup(NULL);
ret->m_text2 = dc_strdup(NULL);
}
else if( chat->m_draft_timestamp
&& chat->m_draft_text
@ -255,8 +255,8 @@ dc_lot_t* dc_chatlist_get_summary(dc_chatlist_t* chatlist, size_t index, dc_chat
ret->m_text1 = dc_stock_str(DC_STR_DRAFT);
ret->m_text1_meaning = MR_TEXT1_DRAFT;
ret->m_text2 = safe_strdup(chat->m_draft_text);
mr_truncate_n_unwrap_str(ret->m_text2, MR_SUMMARY_CHARACTERS, 1/*unwrap*/);
ret->m_text2 = dc_strdup(chat->m_draft_text);
dc_truncate_n_unwrap_str(ret->m_text2, MR_SUMMARY_CHARACTERS, 1/*unwrap*/);
ret->m_timestamp = chat->m_draft_timestamp;
}
@ -364,8 +364,8 @@ int dc_chatlist_load_from_db__(dc_chatlist_t* ths, int listflags, const char* qu
else
{
/* show chatlist filtered by a search string, this includes archived and unarchived */
query = safe_strdup(query__);
mr_trim(query);
query = dc_strdup(query__);
dc_trim(query);
if( query[0]==0 ) {
success = 1; /*empty result*/
goto cleanup;

64
src/dc_configure.c
View file

@ -108,8 +108,8 @@ static void moz_autoconfigure_text_cb(void* userdata, const char* text, int len)
{
moz_autoconfigure_t* moz_ac = (moz_autoconfigure_t*)userdata;
char* val = safe_strdup(text);
mr_trim(val);
char* val = dc_strdup(text);
dc_trim(val);
dc_str_replace(&val, "%EMAILADDRESS%", moz_ac->m_in->m_addr);
dc_str_replace(&val, "%EMAILLOCALPART%", moz_ac->m_in_emaillocalpart);
dc_str_replace(&val, "%EMAILDOMAIN%", moz_ac->m_in_emaildomain);
@ -175,8 +175,8 @@ static dc_loginparam_t* moz_autoconfigure(dc_context_t* context, const char* url
}
moz_ac.m_in = param_in;
moz_ac.m_in_emaillocalpart = safe_strdup(param_in->m_addr); char* p = strchr(moz_ac.m_in_emaillocalpart, '@'); if( p == NULL ) { goto cleanup; } *p = 0;
moz_ac.m_in_emaildomain = safe_strdup(p+1);
moz_ac.m_in_emaillocalpart = dc_strdup(param_in->m_addr); char* p = strchr(moz_ac.m_in_emaillocalpart, '@'); if( p == NULL ) { goto cleanup; } *p = 0;
moz_ac.m_in_emaildomain = dc_strdup(p+1);
moz_ac.m_out = dc_loginparam_new();
dc_saxparser_t saxparser;
@ -259,8 +259,8 @@ static void outlk_autodiscover_text_cb(void* userdata, const char* text, int len
{
outlk_autodiscover_t* outlk_ad = (outlk_autodiscover_t*)userdata;
char* val = safe_strdup(text);
mr_trim(val);
char* val = dc_strdup(text);
dc_trim(val);
free(outlk_ad->m_config[outlk_ad->m_tag_config]);
outlk_ad->m_config[outlk_ad->m_tag_config] = val;
@ -276,19 +276,19 @@ static void outlk_autodiscover_endtag_cb(void* userdata, const char* tag)
/* copy collected confituration to m_out (we have to delay this as we do not know when the <type> tag appears in the sax-stream) */
if( outlk_ad->m_config[OUTLK_TYPE] )
{
int port = atoi_null_is_0(outlk_ad->m_config[OUTLK_PORT]),
int port = dc_atoi_null_is_0(outlk_ad->m_config[OUTLK_PORT]),
ssl_on = (outlk_ad->m_config[OUTLK_SSL] && strcasecmp(outlk_ad->m_config[OUTLK_SSL], "on" )==0),
ssl_off = (outlk_ad->m_config[OUTLK_SSL] && strcasecmp(outlk_ad->m_config[OUTLK_SSL], "off")==0);
if( strcasecmp(outlk_ad->m_config[OUTLK_TYPE], "imap")==0 && outlk_ad->m_out_imap_set==0 ) {
outlk_ad->m_out->m_mail_server = strdup_keep_null(outlk_ad->m_config[OUTLK_SERVER]);
outlk_ad->m_out->m_mail_server = dc_strdup_keep_null(outlk_ad->m_config[OUTLK_SERVER]);
outlk_ad->m_out->m_mail_port = port;
if( ssl_on ) { outlk_ad->m_out->m_server_flags |= MR_IMAP_SOCKET_SSL; }
else if( ssl_off ) { outlk_ad->m_out->m_server_flags |= MR_IMAP_SOCKET_PLAIN; }
outlk_ad->m_out_imap_set = 1;
}
else if( strcasecmp(outlk_ad->m_config[OUTLK_TYPE], "smtp")==0 && outlk_ad->m_out_smtp_set==0 ) {
outlk_ad->m_out->m_send_server = strdup_keep_null(outlk_ad->m_config[OUTLK_SERVER]);
outlk_ad->m_out->m_send_server = dc_strdup_keep_null(outlk_ad->m_config[OUTLK_SERVER]);
outlk_ad->m_out->m_send_port = port;
if( ssl_on ) { outlk_ad->m_out->m_server_flags |= MR_SMTP_SOCKET_SSL; }
else if( ssl_off ) { outlk_ad->m_out->m_server_flags |= MR_SMTP_SOCKET_PLAIN; }
@ -304,7 +304,7 @@ static void outlk_autodiscover_endtag_cb(void* userdata, const char* tag)
static dc_loginparam_t* outlk_autodiscover(dc_context_t* context, const char* url__, const dc_loginparam_t* param_in)
{
char* xml_raw = NULL, *url = safe_strdup(url__);
char* xml_raw = NULL, *url = dc_strdup(url__);
outlk_autodiscover_t outlk_ad;
int i;
@ -327,7 +327,7 @@ static dc_loginparam_t* outlk_autodiscover(dc_context_t* context, const char* ur
if( outlk_ad.m_config[OUTLK_REDIRECTURL] && outlk_ad.m_config[OUTLK_REDIRECTURL][0] ) {
free(url);
url = safe_strdup(outlk_ad.m_config[OUTLK_REDIRECTURL]);
url = dc_strdup(outlk_ad.m_config[OUTLK_REDIRECTURL]);
dc_loginparam_unref(outlk_ad.m_out);
outlk_clean_config(&outlk_ad);
free(xml_raw); xml_raw = NULL;
@ -384,7 +384,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
ongoing_allocated_here = 1;
#define PROGRESS(p) \
if( mr_shall_stop_ongoing ) { goto cleanup; } \
if( dc_shall_stop_ongoing ) { goto cleanup; } \
context->m_cb(context, DC_EVENT_CONFIGURE_PROGRESS, (p)<1? 1 : ((p)>999? 999 : (p)), 0);
if( !dc_sqlite3_is_open(context->m_sql) ) {
@ -435,7 +435,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
dc_log_error(context, 0, "Please enter the email address.");
goto cleanup;
}
mr_trim(param->m_addr);
dc_trim(param->m_addr);
param_domain = strchr(param->m_addr, '@');
if( param_domain==NULL || param_domain[0]==0 ) {
@ -449,7 +449,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
/* if no password is given, assume an empty password.
(in general, unset values are NULL, not the empty string, this allows to use eg. empty user names or empty passwords) */
if( param->m_mail_pw == NULL ) {
param->m_mail_pw = safe_strdup(NULL);
param->m_mail_pw = dc_strdup(NULL);
}
PROGRESS(200)
@ -511,13 +511,13 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
if( param_autoconfig->m_mail_user ) {
free(param->m_mail_user);
param->m_mail_user= strdup_keep_null(param_autoconfig->m_mail_user);
param->m_mail_user= dc_strdup_keep_null(param_autoconfig->m_mail_user);
}
param->m_mail_server = strdup_keep_null(param_autoconfig->m_mail_server); /* all other values are always NULL when entering autoconfig */
param->m_mail_server = dc_strdup_keep_null(param_autoconfig->m_mail_server); /* all other values are always NULL when entering autoconfig */
param->m_mail_port = param_autoconfig->m_mail_port;
param->m_send_server = strdup_keep_null(param_autoconfig->m_send_server);
param->m_send_server = dc_strdup_keep_null(param_autoconfig->m_send_server);
param->m_send_port = param_autoconfig->m_send_port;
param->m_send_user = strdup_keep_null(param_autoconfig->m_send_user);
param->m_send_user = dc_strdup_keep_null(param_autoconfig->m_send_user);
param->m_server_flags = param_autoconfig->m_server_flags;
/* althoug param_autoconfig's data are no longer needed from, it is important to keep the object as
@ -556,11 +556,11 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
}
if( param->m_mail_user == NULL ) {
param->m_mail_user = safe_strdup(param->m_addr);
param->m_mail_user = dc_strdup(param->m_addr);
}
if( param->m_send_server == NULL && param->m_mail_server ) {
param->m_send_server = safe_strdup(param->m_mail_server);
param->m_send_server = dc_strdup(param->m_mail_server);
if( strncmp(param->m_send_server, "imap.", 5)==0 ) {
memcpy(param->m_send_server, "smtp", 4);
}
@ -572,26 +572,26 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
}
if( param->m_send_user == NULL && param->m_mail_user ) {
param->m_send_user = safe_strdup(param->m_mail_user);
param->m_send_user = dc_strdup(param->m_mail_user);
}
if( param->m_send_pw == NULL && param->m_mail_pw ) {
param->m_send_pw = safe_strdup(param->m_mail_pw);
param->m_send_pw = dc_strdup(param->m_mail_pw);
}
if( !mr_exactly_one_bit_set(param->m_server_flags&MR_AUTH_FLAGS) )
if( !dc_exactly_one_bit_set(param->m_server_flags&MR_AUTH_FLAGS) )
{
param->m_server_flags &= ~MR_AUTH_FLAGS;
param->m_server_flags |= MR_AUTH_NORMAL;
}
if( !mr_exactly_one_bit_set(param->m_server_flags&MR_IMAP_SOCKET_FLAGS) )
if( !dc_exactly_one_bit_set(param->m_server_flags&MR_IMAP_SOCKET_FLAGS) )
{
param->m_server_flags &= ~MR_IMAP_SOCKET_FLAGS;
param->m_server_flags |= (param->m_send_port==TYPICAL_IMAP_STARTTLS_PORT? MR_IMAP_SOCKET_STARTTLS : MR_IMAP_SOCKET_SSL);
}
if( !mr_exactly_one_bit_set(param->m_server_flags&MR_SMTP_SOCKET_FLAGS) )
if( !dc_exactly_one_bit_set(param->m_server_flags&MR_SMTP_SOCKET_FLAGS) )
{
param->m_server_flags &= ~MR_SMTP_SOCKET_FLAGS;
param->m_server_flags |= ( param->m_send_port==TYPICAL_SMTP_STARTTLS_PORT? MR_SMTP_SOCKET_STARTTLS :
@ -770,26 +770,26 @@ int dc_is_configured(dc_context_t* context)
* Returns 0=process started, 1=not started, there is running another process
*/
static int s_ongoing_running = 0;
int mr_shall_stop_ongoing = 1; /* the value 1 avoids dc_stop_ongoing_process() from stopping already stopped threads */
int dc_shall_stop_ongoing = 1; /* the value 1 avoids dc_stop_ongoing_process() from stopping already stopped threads */
int dc_alloc_ongoing(dc_context_t* context)
{
if( context == NULL || context->m_magic != DC_CONTEXT_MAGIC ) {
return 0;
}
if( s_ongoing_running || mr_shall_stop_ongoing == 0 ) {
if( s_ongoing_running || dc_shall_stop_ongoing == 0 ) {
dc_log_warning(context, 0, "There is already another ongoing process running.");
return 0;
}
s_ongoing_running = 1;
mr_shall_stop_ongoing = 0;
dc_shall_stop_ongoing = 0;
return 1;
}
/*
* Frees the process allocated with dc_alloc_ongoing() - independingly of mr_shall_stop_ongoing.
* Frees the process allocated with dc_alloc_ongoing() - independingly of dc_shall_stop_ongoing.
* If dc_alloc_ongoing() fails, this function MUST NOT be called.
*/
void dc_free_ongoing(dc_context_t* context)
@ -799,7 +799,7 @@ void dc_free_ongoing(dc_context_t* context)
}
s_ongoing_running = 0;
mr_shall_stop_ongoing = 1; /* avoids dc_stop_ongoing_process() to stop the thread */
dc_shall_stop_ongoing = 1; /* avoids dc_stop_ongoing_process() to stop the thread */
}
@ -833,10 +833,10 @@ void dc_stop_ongoing_process(dc_context_t* context)
return;
}
if( s_ongoing_running && mr_shall_stop_ongoing==0 )
if( s_ongoing_running && dc_shall_stop_ongoing==0 )
{
dc_log_info(context, 0, "Signaling the ongoing process to stop ASAP.");
mr_shall_stop_ongoing = 1;
dc_shall_stop_ongoing = 1;
}
else
{

54
src/dc_contact.c
View file

@ -141,10 +141,10 @@ uint32_t dc_contact_get_id(const dc_contact_t* contact)
char* dc_contact_get_addr(const dc_contact_t* contact)
{
if( contact == NULL || contact->m_magic != MR_CONTACT_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
return safe_strdup(contact->m_addr);
return dc_strdup(contact->m_addr);
}
@ -165,10 +165,10 @@ char* dc_contact_get_addr(const dc_contact_t* contact)
char* dc_contact_get_name(const dc_contact_t* contact)
{
if( contact == NULL || contact->m_magic != MR_CONTACT_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
return safe_strdup(contact->m_name);
return dc_strdup(contact->m_name);
}
@ -188,14 +188,14 @@ char* dc_contact_get_name(const dc_contact_t* contact)
char* dc_contact_get_display_name(const dc_contact_t* contact)
{
if( contact == NULL || contact->m_magic != MR_CONTACT_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
if( contact->m_name && contact->m_name[0] ) {
return safe_strdup(contact->m_name);
return dc_strdup(contact->m_name);
}
return safe_strdup(contact->m_addr);
return dc_strdup(contact->m_addr);
}
@ -219,14 +219,14 @@ char* dc_contact_get_display_name(const dc_contact_t* contact)
char* dc_contact_get_name_n_addr(const dc_contact_t* contact)
{
if( contact == NULL || contact->m_magic != MR_CONTACT_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
if( contact->m_name && contact->m_name[0] ) {
return dc_mprintf("%s (%s)", contact->m_name, contact->m_addr);
}
return safe_strdup(contact->m_addr);
return dc_strdup(contact->m_addr);
}
@ -244,14 +244,14 @@ char* dc_contact_get_name_n_addr(const dc_contact_t* contact)
char* dc_contact_get_first_name(const dc_contact_t* contact)
{
if( contact == NULL || contact->m_magic != MR_CONTACT_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
if( contact->m_name && contact->m_name[0] ) {
return mr_get_first_name(contact->m_name);
}
return safe_strdup(contact->m_addr);
return dc_strdup(contact->m_addr);
}
@ -350,14 +350,14 @@ cleanup:
*/
char* mr_get_first_name(const char* full_name)
{
char* first_name = safe_strdup(full_name);
char* first_name = dc_strdup(full_name);
char* p1 = strchr(first_name, ' ');
if( p1 ) {
*p1 = 0;
mr_rtrim(first_name);
dc_rtrim(first_name);
if( first_name[0] == 0 ) { /*empty result? use the original string in this case */
free(first_name);
first_name = safe_strdup(full_name);
first_name = dc_strdup(full_name);
}
}
@ -392,7 +392,7 @@ void mr_normalize_name(char* full_name)
return; /* error, however, this can be treated as documented behaviour */
}
mr_trim(full_name); /* remove spaces around possible quotes */
dc_trim(full_name); /* remove spaces around possible quotes */
int len = strlen(full_name);
if( len > 0 ) {
char firstchar = full_name[0], lastchar = full_name[len-1];
@ -407,10 +407,10 @@ void mr_normalize_name(char* full_name)
char* p1 = strchr(full_name, ',');
if( p1 ) {
*p1 = 0;
char* last_name = safe_strdup(full_name);
char* first_name = safe_strdup(p1+1);
mr_trim(last_name);
mr_trim(first_name);
char* last_name = dc_strdup(full_name);
char* first_name = dc_strdup(p1+1);
dc_trim(last_name);
dc_trim(first_name);
strcpy(full_name, first_name);
strcat(full_name, " ");
strcat(full_name, last_name);
@ -418,7 +418,7 @@ void mr_normalize_name(char* full_name)
free(first_name);
}
else {
mr_trim(full_name);
dc_trim(full_name);
}
}
@ -440,13 +440,13 @@ void mr_normalize_name(char* full_name)
*/
char* mr_normalize_addr(const char* email_addr__)
{
char* addr = safe_strdup(email_addr__);
mr_trim(addr);
char* addr = dc_strdup(email_addr__);
dc_trim(addr);
if( strncmp(addr, "mailto:", 7)==0 ) {
char* old = addr;
addr = safe_strdup(&old[7]);
addr = dc_strdup(&old[7]);
free(old);
mr_trim(addr);
dc_trim(addr);
}
return addr;
}
@ -488,11 +488,11 @@ int dc_contact_load_from_db__(dc_contact_t* ths, dc_sqlite3_t* sql, uint32_t con
}
ths->m_id = contact_id;
ths->m_name = safe_strdup((char*)sqlite3_column_text (stmt, 0));
ths->m_addr = safe_strdup((char*)sqlite3_column_text (stmt, 1));
ths->m_name = dc_strdup((char*)sqlite3_column_text (stmt, 0));
ths->m_addr = dc_strdup((char*)sqlite3_column_text (stmt, 1));
ths->m_origin = sqlite3_column_int (stmt, 2);
ths->m_blocked = sqlite3_column_int (stmt, 3);
ths->m_authname = safe_strdup((char*)sqlite3_column_text (stmt, 4));
ths->m_authname = dc_strdup((char*)sqlite3_column_text (stmt, 4));
}
success = 1;

100
src/dc_context.c
View file

@ -115,7 +115,7 @@ dc_context_t* dc_context_new(dc_callback_t cb, void* userdata, const char* os_na
ths->m_userdata = userdata;
ths->m_imap = dc_imap_new(cb_get_config, cb_set_config, cb_receive_imf, (void*)ths, ths);
ths->m_smtp = dc_smtp_new(ths);
ths->m_os_name = strdup_keep_null(os_name);
ths->m_os_name = dc_strdup_keep_null(os_name);
dc_pgp_init(ths);
@ -207,7 +207,7 @@ void* dc_get_userdata(dc_context_t* context)
static void update_config_cache__(dc_context_t* ths, const char* key)
{
if( key==NULL || strcmp(key, "e2ee_enabled")==0 ) {
ths->m_e2ee_enabled = dc_sqlite3_get_config_int__(ths->m_sql, "e2ee_enabled", MR_E2EE_DEFAULT_ENABLED);
ths->m_e2ee_enabled = dc_sqlite3_get_config_int__(ths->m_sql, "e2ee_enabled", DC_E2EE_DEFAULT_ENABLED);
}
}
@ -251,16 +251,16 @@ int dc_open(dc_context_t* context, const char* dbfile, const char* blobdir)
}
/* backup dbfile name */
context->m_dbfile = safe_strdup(dbfile);
context->m_dbfile = dc_strdup(dbfile);
/* set blob-directory
(to avoid double slashed, the given directory should not end with an slash) */
if( blobdir && blobdir[0] ) {
context->m_blobdir = safe_strdup(blobdir);
context->m_blobdir = dc_strdup(blobdir);
}
else {
context->m_blobdir = dc_mprintf("%s-blobs", dbfile);
mr_create_folder(context->m_blobdir, context);
dc_create_folder(context->m_blobdir, context);
}
update_config_cache__(context, NULL);
@ -346,9 +346,9 @@ int dc_is_open(const dc_context_t* context)
char* dc_get_blobdir(dc_context_t* context)
{
if( context == NULL || context->m_magic != DC_CONTEXT_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
return safe_strdup(context->m_blobdir);
return dc_strdup(context->m_blobdir);
}
@ -422,7 +422,7 @@ char* dc_get_config(dc_context_t* ths, const char* key, const char* def)
char* ret;
if( ths == NULL || ths->m_magic != DC_CONTEXT_MAGIC || key == NULL ) { /* "def" may be NULL */
return strdup_keep_null(def);
return dc_strdup_keep_null(def);
}
dc_sqlite3_lock(ths->m_sql);
@ -491,7 +491,7 @@ int32_t dc_get_config_int(dc_context_t* ths, const char* key, int32_t def)
*/
char* dc_get_version_str(void)
{
return safe_strdup(DC_VERSION_STR);
return dc_strdup(DC_VERSION_STR);
}
@ -515,7 +515,7 @@ char* dc_get_info(dc_context_t* context)
dc_strbuilder_init(&ret, 0);
if( context == NULL || context->m_magic != DC_CONTEXT_MAGIC ) {
return safe_strdup("ErrBadPtr");
return dc_strdup("ErrBadPtr");
}
/* read data (all pointers may be NULL!) */
@ -540,7 +540,7 @@ char* dc_get_info(dc_context_t* context)
e2ee_enabled = context->m_e2ee_enabled;
mdns_enabled = dc_sqlite3_get_config_int__(context->m_sql, "mdns_enabled", MR_MDNS_DEFAULT_ENABLED);
mdns_enabled = dc_sqlite3_get_config_int__(context->m_sql, "mdns_enabled", DC_MDNS_DEFAULT_ENABLED);
sqlite3_stmt* stmt = dc_sqlite3_prepare_v2_(context->m_sql, "SELECT COUNT(*) FROM keypairs;");
sqlite3_step(stmt);
@ -556,7 +556,7 @@ char* dc_get_info(dc_context_t* context)
fingerprint_str = dc_key_get_formatted_fingerprint(self_public);
}
else {
fingerprint_str = safe_strdup("<Not yet calculated>");
fingerprint_str = dc_strdup("<Not yet calculated>");
}
dc_sqlite3_unlock(context->m_sql);
@ -599,7 +599,7 @@ char* dc_get_info(dc_context_t* context)
, mdns_enabled
, e2ee_enabled
, MR_E2EE_DEFAULT_ENABLED
, DC_E2EE_DEFAULT_ENABLED
, prv_key_count, pub_key_count, fingerprint_str
, DC_VERSION_STR
@ -1253,7 +1253,7 @@ dc_array_t* dc_get_chat_msgs(dc_context_t* context, uint32_t chat_id, uint32_t f
uint32_t curr_id;
time_t curr_local_timestamp;
int curr_day, last_day = 0;
long cnv_to_local = mr_gm2local_offset();
long cnv_to_local = dc_gm2local_offset();
#define SECONDS_PER_DAY 86400
if( context==NULL || context->m_magic != DC_CONTEXT_MAGIC || ret == NULL ) {
@ -1378,8 +1378,8 @@ dc_array_t* dc_search_msgs(dc_context_t* context, uint32_t chat_id, const char*
goto cleanup;
}
real_query = safe_strdup(query);
mr_trim(real_query);
real_query = dc_strdup(query);
dc_trim(real_query);
if( real_query[0]==0 ) {
success = 1; /*empty result*/
goto cleanup;
@ -1494,7 +1494,7 @@ void dc_set_draft(dc_context_t* context, uint32_t chat_id, const char* msg)
// save draft in object - NULL or empty: clear draft
free(chat->m_draft_text);
chat->m_draft_text = msg? safe_strdup(msg) : NULL;
chat->m_draft_text = msg? dc_strdup(msg) : NULL;
chat->m_draft_timestamp = msg? time(NULL) : 0;
// save draft in database
@ -1945,7 +1945,7 @@ static uint32_t dc_send_msg_i__(dc_context_t* context, dc_chat_t* chat, const dc
dc_log_error(context, 0, "Cannot send message, not configured successfully.");
goto cleanup;
}
rfc724_mid = mr_create_outgoing_rfc724_mid(DC_CHAT_TYPE_IS_MULTI(chat->m_type)? chat->m_grpid : NULL, from);
rfc724_mid = dc_create_outgoing_rfc724_mid(DC_CHAT_TYPE_IS_MULTI(chat->m_type)? chat->m_grpid : NULL, from);
free(from);
}
@ -2128,7 +2128,7 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
if( msg->m_text ) { free(msg->m_text); }
if( msg->m_type == MR_MSG_AUDIO ) {
char* filename = mr_get_filename(pathNfilename);
char* filename = dc_get_filename(pathNfilename);
char* author = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, "");
char* title = dc_param_get(msg->m_param, DC_PARAM_TRACKNAME, "");
msg->m_text = dc_mprintf("%s %s %s", filename, author, title); /* for outgoing messages, also add the mediainfo. For incoming messages, this is not needed as the filename is build from these information */
@ -2137,7 +2137,7 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
free(title);
}
else if( MR_MSG_MAKE_FILENAME_SEARCHABLE(msg->m_type) ) {
msg->m_text = mr_get_filename(pathNfilename);
msg->m_text = dc_get_filename(pathNfilename);
}
else if( MR_MSG_MAKE_SUFFIX_SEARCHABLE(msg->m_type) ) {
msg->m_text = dc_get_filesuffix_lc(pathNfilename);
@ -2167,7 +2167,7 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
{
dc_chat_t* chat = dc_chat_new(context);
if( dc_chat_load_from_db__(chat, chat_id) ) {
msg->m_id = dc_send_msg_i__(context, chat, msg, mr_create_smeared_timestamp__());
msg->m_id = dc_send_msg_i__(context, chat, msg, dc_create_smeared_timestamp__());
if( msg ->m_id == 0 ) {
goto cleanup; /* error already logged */
}
@ -2218,7 +2218,7 @@ uint32_t dc_send_text_msg(dc_context_t* context, uint32_t chat_id, const char* t
}
msg->m_type = MR_MSG_TEXT;
msg->m_text = safe_strdup(text_to_send);
msg->m_text = dc_strdup(text_to_send);
ret = dc_send_msg_object(context, chat_id, msg);
@ -2487,7 +2487,7 @@ uint32_t dc_send_vcard_msg(dc_context_t* context, uint32_t chat_id, uint32_t con
text_to_send = dc_mprintf("%s: %s", contact->m_authname, contact->m_addr);
}
else {
text_to_send = safe_strdup(contact->m_addr);
text_to_send = dc_strdup(contact->m_addr);
}
ret = dc_send_text_msg(context, chat_id, text_to_send);
@ -2545,7 +2545,7 @@ uint32_t dc_add_device_msg(dc_context_t* context, uint32_t chat_id, const char*
dc_sqlite3_lock(context->m_sql);
locked = 1;
dc_add_device_msg__(context, chat_id, text, mr_create_smeared_timestamp__());
dc_add_device_msg__(context, chat_id, text, dc_create_smeared_timestamp__());
dc_sqlite3_unlock(context->m_sql);
locked = 0;
@ -2933,7 +2933,7 @@ int dc_add_contact_to_chat_ex(dc_context_t* context, uint32_t chat_id, uint32_t
goto cleanup; /* we shoud respect this - whatever we send to the group, it gets discarded anyway! */
}
if( (flags&MR_FROM_HANDSHAKE) && dc_param_get_int(chat->m_param, DC_PARAM_UNPROMOTED, 0)==1 ) {
if( (flags&DC_FROM_HANDSHAKE) && dc_param_get_int(chat->m_param, DC_PARAM_UNPROMOTED, 0)==1 ) {
// after a handshake, force sending the `Chat-Group-Member-Added` message
dc_param_set(chat->m_param, DC_PARAM_UNPROMOTED, NULL);
dc_chat_update_param__(chat);
@ -2946,7 +2946,7 @@ int dc_add_contact_to_chat_ex(dc_context_t* context, uint32_t chat_id, uint32_t
if( dc_is_contact_in_chat__(context, chat_id, contact_id) )
{
if( !(flags&MR_FROM_HANDSHAKE) ) {
if( !(flags&DC_FROM_HANDSHAKE) ) {
success = 1;
goto cleanup;
}
@ -3419,7 +3419,7 @@ int dc_add_address_book(dc_context_t* context, const char* adr_book) /* format:
goto cleanup;
}
if( (lines=mr_split_into_lines(adr_book))==NULL ) {
if( (lines=dc_split_into_lines(adr_book))==NULL ) {
goto cleanup;
}
@ -3443,7 +3443,7 @@ int dc_add_address_book(dc_context_t* context, const char* adr_book) /* format:
dc_sqlite3_unlock(context->m_sql);
cleanup:
mr_free_splitted_lines(lines);
dc_free_splitted_lines(lines);
return modify_cnt;
}
@ -3506,7 +3506,7 @@ dc_array_t* dc_get_contacts(dc_context_t* context, uint32_t listflags, const cha
self_name = dc_sqlite3_get_config__(context->m_sql, "displayname", "");
self_name2 = dc_stock_str(DC_STR_SELF);
if( query==NULL || mr_str_contains(self_addr, query) || mr_str_contains(self_name, query) || mr_str_contains(self_name2, query) ) {
if( query==NULL || dc_str_contains(self_addr, query) || dc_str_contains(self_name, query) || dc_str_contains(self_name2, query) ) {
add_self = 1;
}
}
@ -4030,7 +4030,7 @@ size_t dc_get_real_msg_cnt__(dc_context_t* context)
" AND m.chat_id>" DC_STRINGIFY(DC_CHAT_ID_LAST_SPECIAL)
" AND c.blocked=0;");
if( sqlite3_step(stmt) != SQLITE_ROW ) {
dc_sqlite3_log_error(context->m_sql, "mr_get_assigned_msg_cnt_() failed.");
dc_sqlite3_log_error(context->m_sql, "dc_get_real_msg_cnt__() failed.");
return 0;
}
@ -4085,7 +4085,7 @@ uint32_t dc_rfc724_mid_exists__(dc_context_t* context, const char* rfc724_mid, c
return 0;
}
if( ret_server_folder ) { *ret_server_folder = safe_strdup((char*)sqlite3_column_text(stmt, 0)); }
if( ret_server_folder ) { *ret_server_folder = dc_strdup((char*)sqlite3_column_text(stmt, 0)); }
if( ret_server_uid ) { *ret_server_uid = sqlite3_column_int(stmt, 1); /* may be 0 */ }
return sqlite3_column_int(stmt, 2);
}
@ -4193,7 +4193,7 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
goto cleanup;
}
rawtxt = safe_strdup((char*)sqlite3_column_text(stmt, 0));
rawtxt = dc_strdup((char*)sqlite3_column_text(stmt, 0));
#ifdef __ANDROID__
p = strchr(rawtxt, '\n');
@ -4206,7 +4206,7 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
}
#endif
mr_trim(rawtxt);
dc_trim(rawtxt);
dc_truncate_str(rawtxt, MR_MAX_GET_INFO_LEN);
/* add time */
@ -4247,13 +4247,13 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
/* add state */
p = NULL;
switch( msg->m_state ) {
case DC_STATE_IN_FRESH: p = safe_strdup("Fresh"); break;
case DC_STATE_IN_NOTICED: p = safe_strdup("Noticed"); break;
case DC_STATE_IN_SEEN: p = safe_strdup("Seen"); break;
case DC_STATE_OUT_DELIVERED: p = safe_strdup("Delivered"); break;
case DC_STATE_OUT_ERROR: p = safe_strdup("Error"); break;
case DC_STATE_OUT_MDN_RCVD: p = safe_strdup("Read"); break;
case DC_STATE_OUT_PENDING: p = safe_strdup("Pending"); break;
case DC_STATE_IN_FRESH: p = dc_strdup("Fresh"); break;
case DC_STATE_IN_NOTICED: p = dc_strdup("Noticed"); break;
case DC_STATE_IN_SEEN: p = dc_strdup("Seen"); break;
case DC_STATE_OUT_DELIVERED: p = dc_strdup("Delivered"); break;
case DC_STATE_OUT_ERROR: p = dc_strdup("Error"); break;
case DC_STATE_OUT_MDN_RCVD: p = dc_strdup("Read"); break;
case DC_STATE_OUT_PENDING: p = dc_strdup("Pending"); break;
default: p = dc_mprintf("%i", msg->m_state); break;
}
dc_strbuilder_catf(&ret, "State: %s", p);
@ -4263,11 +4263,11 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
int e2ee_errors;
if( (e2ee_errors=dc_param_get_int(msg->m_param, DC_PARAM_ERRONEOUS_E2EE, 0)) ) {
if( e2ee_errors&MRE2EE_NO_VALID_SIGNATURE ) {
p = safe_strdup("Encrypted, no valid signature");
p = dc_strdup("Encrypted, no valid signature");
}
}
else if( dc_param_get_int(msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0) ) {
p = safe_strdup("Encrypted");
p = dc_strdup("Encrypted");
}
if( p ) {
@ -4286,18 +4286,18 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
/* add file info */
char* file = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( file ) {
p = dc_mprintf("\nFile: %s, %i bytes\n", file, (int)mr_get_filebytes(file)); dc_strbuilder_cat(&ret, p); free(p);
p = dc_mprintf("\nFile: %s, %i bytes\n", file, (int)dc_get_filebytes(file)); dc_strbuilder_cat(&ret, p); free(p);
}
if( msg->m_type != MR_MSG_TEXT ) {
p = NULL;
switch( msg->m_type ) {
case MR_MSG_AUDIO: p = safe_strdup("Audio"); break;
case MR_MSG_FILE: p = safe_strdup("File"); break;
case MR_MSG_GIF: p = safe_strdup("GIF"); break;
case MR_MSG_IMAGE: p = safe_strdup("Image"); break;
case MR_MSG_VIDEO: p = safe_strdup("Video"); break;
case MR_MSG_VOICE: p = safe_strdup("Voice"); break;
case MR_MSG_AUDIO: p = dc_strdup("Audio"); break;
case MR_MSG_FILE: p = dc_strdup("File"); break;
case MR_MSG_GIF: p = dc_strdup("GIF"); break;
case MR_MSG_IMAGE: p = dc_strdup("Image"); break;
case MR_MSG_VIDEO: p = dc_strdup("Video"); break;
case MR_MSG_VOICE: p = dc_strdup("Voice"); break;
default: p = dc_mprintf("%i", msg->m_type); break;
}
dc_strbuilder_catf(&ret, "Type: %s\n", p);
@ -4390,7 +4390,7 @@ void dc_forward_msgs(dc_context_t* context, const uint32_t* msg_ids, int msg_cnt
goto cleanup;
}
curr_timestamp = mr_create_smeared_timestamps__(msg_cnt);
curr_timestamp = dc_create_smeared_timestamps__(msg_cnt);
idsstr = dc_arr_to_string(msg_ids, msg_cnt);
q3 = sqlite3_mprintf("SELECT id FROM msgs WHERE id IN(%s) ORDER BY timestamp,id", idsstr);

22
src/dc_context.h
View file

@ -80,11 +80,11 @@ struct _dc_context
int m_smtpidle_condflag;
int m_smtpidle_suspend;
int m_smtpidle_in_idleing;
#define MR_JOBS_NEEDED_AT_ONCE 1
#define MR_JOBS_NEEDED_AVOID_DOS 2
#define DC_JOBS_NEEDED_AT_ONCE 1
#define DC_JOBS_NEEDED_AVOID_DOS 2
int m_perform_smtp_jobs_needed;
mrmailboxcb_t m_cb; /**< Internal */
dc_callback_t m_cb; /**< Internal */
char* m_os_name; /**< Internal, may be NULL */
@ -147,7 +147,7 @@ uint32_t dc_add_device_msg (dc_context_t*, uint3
uint32_t dc_add_device_msg__ (dc_context_t*, uint32_t chat_id, const char* text, time_t timestamp);
void dc_suspend_smtp_thread (dc_context_t*, int suspend);
#define MR_FROM_HANDSHAKE 0x01
#define DC_FROM_HANDSHAKE 0x01
int dc_add_contact_to_chat_ex (dc_context_t*, uint32_t chat_id, uint32_t contact_id, int flags);
uint32_t dc_get_chat_id_by_grpid__ (dc_context_t*, const char* grpid, int* ret_blocked, int* ret_verified);
@ -157,8 +157,8 @@ uint32_t dc_get_chat_id_by_grpid__ (dc_context_t*, const
/* library private: end-to-end-encryption */
#define MR_E2EE_DEFAULT_ENABLED 1
#define MR_MDNS_DEFAULT_ENABLED 1
#define DC_E2EE_DEFAULT_ENABLED 1
#define DC_MDNS_DEFAULT_ENABLED 1
typedef struct dc_e2ee_helper_t {
// encryption
@ -174,14 +174,14 @@ typedef struct dc_e2ee_helper_t {
void dc_e2ee_encrypt (dc_context_t*, const clist* recipients_addr, int force_plaintext, int e2ee_guaranteed, int min_verified, struct mailmime* in_out_message, dc_e2ee_helper_t*);
void dc_e2ee_decrypt (dc_context_t*, struct mailmime* in_out_message, dc_e2ee_helper_t*); /* returns 1 if sth. was decrypted, 0 in other cases */
void dc_e2ee_thanks (dc_e2ee_helper_t*); /* frees data referenced by "mailmime" but not freed by mailmime_free(). After calling mre2ee_unhelp(), in_out_message cannot be used any longer! */
void dc_e2ee_thanks (dc_e2ee_helper_t*); /* frees data referenced by "mailmime" but not freed by mailmime_free(). After calling this function, in_out_message cannot be used any longer! */
int dc_ensure_secret_key_exists (dc_context_t*); /* makes sure, the private key exists, needed only for exporting keys and the case no message was sent before */
char* dc_create_setup_code (dc_context_t*);
char* dc_normalize_setup_code(dc_context_t*, const char* passphrase);
char* dc_render_setup_file (dc_context_t*, const char* passphrase);
char* dc_decrypt_setup_file(dc_context_t*, const char* passphrase, const char* filecontent);
extern int mr_shall_stop_ongoing;
extern int dc_shall_stop_ongoing;
int dc_alloc_ongoing (dc_context_t*);
void dc_free_ongoing (dc_context_t*);
@ -190,13 +190,13 @@ void dc_free_ongoing (dc_context_t*);
/* library private: secure-join */
#define MR_IS_HANDSHAKE_CONTINUE_NORMAL_PROCESSING 1
#define MR_IS_HANDSHAKE_STOP_NORMAL_PROCESSING 2
#define DC_IS_HANDSHAKE_CONTINUE_NORMAL_PROCESSING 1
#define DC_IS_HANDSHAKE_STOP_NORMAL_PROCESSING 2
int dc_handle_securejoin_handshake(dc_context_t*, dc_mimeparser_t*, uint32_t contact_id);
void dc_handle_degrade_event (dc_context_t*, dc_apeerstate_t*);
#define OPENPGP4FPR_SCHEME "OPENPGP4FPR:" /* yes: uppercase */
#define DC_OPENPGP4FPR_SCHEME "OPENPGP4FPR:" /* yes: uppercase */
/* library private: key-history */

6
src/dc_dehtml.c
View file

@ -69,7 +69,7 @@ static void dehtml_starttag_cb(void* userdata, const char* tag, char** attr)
else if( strcmp(tag, "a")==0 )
{
free(dehtml->m_last_href);
dehtml->m_last_href = strdup_keep_null(mrattr_find(attr, "href"));
dehtml->m_last_href = dc_strdup_keep_null(mrattr_find(attr, "href"));
if( dehtml->m_last_href ) {
dc_strbuilder_cat(&dehtml->m_strbuilder, "[");
}
@ -155,9 +155,9 @@ static void dehtml_endtag_cb(void* userdata, const char* tag)
char* dc_dehtml(char* buf_terminated)
{
mr_trim(buf_terminated);
dc_trim(buf_terminated);
if( buf_terminated[0] == 0 ) {
return safe_strdup(""); /* support at least empty HTML-messages; for empty messages, we'll replace the message by the subject later */
return dc_strdup(""); /* support at least empty HTML-messages; for empty messages, we'll replace the message by the subject later */
}
else {
dehtml_t dehtml;

4
src/dc_e2ee.c
View file

@ -846,8 +846,8 @@ void dc_e2ee_decrypt(dc_context_t* mailbox, struct mailmime* in_out_message,
if( field && field->fld_data.fld_orig_date ) {
struct mailimf_orig_date* orig_date = field->fld_data.fld_orig_date;
if( orig_date ) {
message_time = mr_timestamp_from_date(orig_date->dt_date_time); /* is not yet checked against bad times! */
if( message_time != MR_INVALID_TIMESTAMP && message_time > time(NULL) ) {
message_time = dc_timestamp_from_date(orig_date->dt_date_time); /* is not yet checked against bad times! */
if( message_time != DC_INVALID_TIMESTAMP && message_time > time(NULL) ) {
message_time = time(NULL);
}
}

44
src/dc_imap.c
View file

@ -153,7 +153,7 @@ static int get_folder_meaning(const dc_imap_t* ths, struct mailimap_mbx_list_fla
else
{
/* we have no flag list; try some known default names */
lower = mr_strlower(folder_name);
lower = dc_strlower(folder_name);
if( strcmp(lower, "spam") == 0
|| strcmp(lower, "junk") == 0
|| strcmp(lower, "indésirables") == 0 /* fr */
@ -245,10 +245,10 @@ static clist* list_folders__(dc_imap_t* ths)
if( strcasecmp(imap_folder->mb_name, "INBOX")==0 ) {
/* Force upper case INBOX as we also use it directly this way; a unified name is needed as we use the folder name to remember the last uid.
Servers may return any case, however, all variants MUST lead to the same INBOX, see RFC 3501 5.1 */
ret_folder->m_name_to_select = safe_strdup("INBOX");
ret_folder->m_name_to_select = dc_strdup("INBOX");
}
else {
ret_folder->m_name_to_select = safe_strdup(imap_folder->mb_name);
ret_folder->m_name_to_select = dc_strdup(imap_folder->mb_name);
}
ret_folder->m_name_utf8 = dc_decode_modified_utf7(imap_folder->mb_name, 0);
@ -325,14 +325,14 @@ static int init_chat_folders__(dc_imap_t* ths)
for( iter1 = clist_begin(folder_list); iter1 != NULL ; iter1 = clist_next(iter1) ) {
mrimapfolder_t* folder = (struct mrimapfolder_t*)clist_content(iter1);
if( strcmp(folder->m_name_utf8, DC_CHATS_FOLDER)==0 || strcmp(folder->m_name_utf8, fallback_folder)==0 ) {
chats_folder = safe_strdup(folder->m_name_to_select);
chats_folder = dc_strdup(folder->m_name_to_select);
break;
}
else if( folder->m_meaning == MEANING_SENT_OBJECTS ) {
sent_folder = safe_strdup(folder->m_name_to_select);
sent_folder = dc_strdup(folder->m_name_to_select);
}
else if( folder->m_meaning == MEANING_NORMAL && normal_folder == NULL ) {
normal_folder = safe_strdup(folder->m_name_to_select);
normal_folder = dc_strdup(folder->m_name_to_select);
}
}
@ -347,12 +347,12 @@ static int init_chat_folders__(dc_imap_t* ths)
dc_log_warning(ths->m_context, 0, "Cannot create IMAP-folder, using default.");
}
else {
chats_folder = safe_strdup(fallback_folder);
chats_folder = dc_strdup(fallback_folder);
dc_log_info(ths->m_context, 0, "IMAP-folder created (inbox subfolder).");
}
}
else {
chats_folder = safe_strdup(DC_CHATS_FOLDER);
chats_folder = dc_strdup(DC_CHATS_FOLDER);
dc_log_info(ths->m_context, 0, "IMAP-folder created.");
}
}
@ -365,16 +365,16 @@ static int init_chat_folders__(dc_imap_t* ths)
}
if( chats_folder ) {
ths->m_moveto_folder = safe_strdup(chats_folder);
ths->m_sent_folder = safe_strdup(chats_folder);
ths->m_moveto_folder = dc_strdup(chats_folder);
ths->m_sent_folder = dc_strdup(chats_folder);
success = 1;
}
else if( sent_folder ) {
ths->m_sent_folder = safe_strdup(sent_folder);
ths->m_sent_folder = dc_strdup(sent_folder);
success = 1;
}
else if( normal_folder ) {
ths->m_sent_folder = safe_strdup(normal_folder);
ths->m_sent_folder = dc_strdup(normal_folder);
success = 1;
}
@ -424,7 +424,7 @@ static int select_folder__(dc_imap_t* ths, const char* folder /*may be NULL*/)
}
free(ths->m_selected_folder);
ths->m_selected_folder = safe_strdup(folder);
ths->m_selected_folder = dc_strdup(folder);
return 1;
}
@ -499,12 +499,12 @@ static uint32_t peek_uid(struct mailimap_msg_att* msg_att)
static char* unquote_rfc724_mid(const char* in)
{
/* remove < and > from the given message id */
char* out = safe_strdup(in);
char* out = dc_strdup(in);
int out_len = strlen(out);
if( out_len > 2 ) {
if( out[0] == '<' ) { out[0] = ' '; }
if( out[out_len-1] == '>' ) { out[out_len-1] = ' '; }
mr_trim(out);
dc_trim(out);
}
return out;
}
@ -1195,10 +1195,10 @@ int dc_imap_connect(dc_imap_t* ths, const dc_loginparam_t* lp)
goto cleanup;
}
ths->m_imap_server = safe_strdup(lp->m_mail_server);
ths->m_imap_server = dc_strdup(lp->m_mail_server);
ths->m_imap_port = lp->m_mail_port;
ths->m_imap_user = safe_strdup(lp->m_mail_user);
ths->m_imap_pw = safe_strdup(lp->m_mail_pw);
ths->m_imap_user = dc_strdup(lp->m_mail_user);
ths->m_imap_pw = dc_strdup(lp->m_mail_pw);
ths->m_server_flags = lp->m_server_flags;
if( !setup_handle_if_needed__(ths) ) {
@ -1379,7 +1379,7 @@ int dc_imap_append_msg(dc_imap_t* ths, time_t timestamp, const char* data_not_te
flag_list = mailimap_flag_list_new_empty();
mailimap_flag_list_add(flag_list, mailimap_flag_new_seen());
imap_date = mr_timestamp_to_mailimap_date_time(timestamp);
imap_date = dc_timestamp_to_mailimap_date_time(timestamp);
if( imap_date == NULL ) {
dc_log_error(ths->m_context, 0, "Bad date.");
goto cleanup;
@ -1391,7 +1391,7 @@ int dc_imap_append_msg(dc_imap_t* ths, time_t timestamp, const char* data_not_te
goto cleanup;
}
*ret_server_folder = safe_strdup(ths->m_sent_folder);
*ret_server_folder = dc_strdup(ths->m_sent_folder);
dc_log_info(ths->m_context, 0, "Message appended to \"%s\".", ths->m_sent_folder);
@ -1511,7 +1511,7 @@ int dc_imap_markseen_msg(dc_imap_t* ths, const char* folder, uint32_t server_uid
clistiter* cur=clist_begin(fetch_result);
if( cur ) {
if( !peek_flag_keyword((struct mailimap_msg_att*)clist_content(cur), "$MDNSent") ) {
add_flag__(ths, server_uid, mailimap_flag_new_flag_keyword(safe_strdup("$MDNSent")));
add_flag__(ths, server_uid, mailimap_flag_new_flag_keyword(dc_strdup("$MDNSent")));
*ret_ms_flags |= MR_MS_MDNSent_JUST_SET;
}
}
@ -1574,7 +1574,7 @@ int dc_imap_markseen_msg(dc_imap_t* ths, const char* folder, uint32_t server_uid
struct mailimap_set_item* item;
item = clist_content(cur);
*ret_server_uid = item->set_first;
*ret_server_folder = safe_strdup(ths->m_moveto_folder);
*ret_server_folder = dc_strdup(ths->m_moveto_folder);
}
mailimap_set_free(res_setdest);
}

28
src/dc_imex.c
View file

@ -320,7 +320,7 @@ char* dc_decrypt_setup_file(dc_context_t* context, const char* passphrase, const
char* payload = NULL;
/* extract base64 from filecontent */
fc_buf = safe_strdup(filecontent);
fc_buf = dc_strdup(filecontent);
if( !dc_split_armored_data(fc_buf, &fc_headerline, NULL, NULL, &fc_base64)
|| fc_headerline==NULL || strcmp(fc_headerline, "-----BEGIN PGP MESSAGE-----")!=0 || fc_base64==NULL ) {
goto cleanup;
@ -483,7 +483,7 @@ char* dc_initiate_key_transfer(dc_context_t* context)
if( !dc_alloc_ongoing(context) ) {
return 0; /* no cleanup as this would call dc_free_ongoing() */
}
#define CHECK_EXIT if( mr_shall_stop_ongoing ) { goto cleanup; }
#define CHECK_EXIT if( dc_shall_stop_ongoing ) { goto cleanup; }
if( (setup_code=dc_create_setup_code(context)) == NULL ) { /* this may require a keypair to be created. this may take a second ... */
goto cleanup;
@ -564,7 +564,7 @@ static int set_self_key(dc_context_t* context, const char* armored, int set_defa
sqlite3_stmt* stmt = NULL;
char* self_addr = NULL;
buf = safe_strdup(armored);
buf = dc_strdup(armored);
if( !dc_split_armored_data(buf, &buf_headerline, NULL, &buf_preferencrypt, &buf_base64)
|| strcmp(buf_headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----")!=0 || buf_base64 == NULL ) {
dc_log_warning(context, 0, "File does not contain a private key."); /* do not log as error - this is quite normal after entering the bad setup code */
@ -713,7 +713,7 @@ static void export_key_to_asc_file(dc_context_t* context, const char* dir, int i
file_name = dc_mprintf("%s/%s-key-%i.asc", dir, key->m_type==DC_KEY_PUBLIC? "public" : "private", id);
}
dc_log_info(context, 0, "Exporting key %s", file_name);
mr_delete_file(file_name, context);
dc_delete_file(file_name, context);
if( dc_key_render_asc_to_file(key, file_name, context) ) {
context->m_cb(context, DC_EVENT_IMEX_FILE_WRITTEN, (uintptr_t)file_name, 0);
dc_log_error(context, 0, "Cannot write key to %s", file_name);
@ -813,7 +813,7 @@ static int import_self_keys(dc_context_t* context, const char* dir_name)
private_key = buf;
free(buf2);
buf2 = safe_strdup(buf);
buf2 = dc_strdup(buf);
if( dc_split_armored_data(buf2, &buf2_headerline, NULL, NULL, NULL)
&& strcmp(buf2_headerline, "-----BEGIN PGP PUBLIC KEY BLOCK-----")==0 ) {
/* This file starts with a Public Key.
@ -906,7 +906,7 @@ static int export_backup(dc_context_t* context, const char* dir)
/* copy file to backup directory */
dc_log_info(context, 0, "Backup \"%s\" to \"%s\".", context->m_dbfile, dest_pathNfilename);
if( !mr_copy_file(context->m_dbfile, dest_pathNfilename, context) ) {
if( !dc_copy_file(context->m_dbfile, dest_pathNfilename, context) ) {
goto cleanup; /* error already logged */
}
@ -953,7 +953,7 @@ static int export_backup(dc_context_t* context, const char* dir)
stmt = dc_sqlite3_prepare_v2_(dest_sql, "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);");
while( (dir_entry=readdir(dir_handle))!=NULL )
{
if( mr_shall_stop_ongoing ) {
if( dc_shall_stop_ongoing ) {
delete_dest_file = 1;
goto cleanup;
}
@ -1006,7 +1006,7 @@ cleanup:
sqlite3_finalize(stmt);
dc_sqlite3_close__(dest_sql);
dc_sqlite3_unref(dest_sql);
if( delete_dest_file ) { mr_delete_file(dest_pathNfilename, context); }
if( delete_dest_file ) { dc_delete_file(dest_pathNfilename, context); }
free(dest_pathNfilename);
free(curr_pathNfilename);
@ -1061,15 +1061,15 @@ static int import_backup(dc_context_t* context, const char* backup_to_import)
dc_sqlite3_close__(context->m_sql);
}
mr_delete_file(context->m_dbfile, context);
dc_delete_file(context->m_dbfile, context);
if( mr_file_exist(context->m_dbfile) ) {
if( dc_file_exist(context->m_dbfile) ) {
dc_log_error(context, 0, "Cannot import backups: Cannot delete the old file.");
goto cleanup;
}
/* copy the database file */
if( !mr_copy_file(backup_to_import, context->m_dbfile, context) ) {
if( !dc_copy_file(backup_to_import, context->m_dbfile, context) ) {
goto cleanup; /* error already logged */
}
@ -1088,7 +1088,7 @@ static int import_backup(dc_context_t* context, const char* backup_to_import)
stmt = dc_sqlite3_prepare_v2_(context->m_sql, "SELECT file_name, file_content FROM backup_blobs ORDER BY id;");
while( sqlite3_step(stmt) == SQLITE_ROW )
{
if( mr_shall_stop_ongoing ) {
if( dc_shall_stop_ongoing ) {
goto cleanup;
}
@ -1121,7 +1121,7 @@ static int import_backup(dc_context_t* context, const char* backup_to_import)
if( repl_from && strlen(repl_from)>1 && context->m_blobdir && strlen(context->m_blobdir)>1 )
{
ensure_no_slash(repl_from);
repl_to = safe_strdup(context->m_blobdir);
repl_to = dc_strdup(context->m_blobdir);
ensure_no_slash(repl_to);
dc_log_info(context, 0, "Rewriting paths from '%s' to '%s' ...", repl_from, repl_to);
@ -1235,7 +1235,7 @@ int dc_imex(dc_context_t* context, int what, const char* param1, const char* par
goto cleanup;
}
/* also make sure, the directory for exporting exists */
mr_create_folder(param1, context);
dc_create_folder(param1, context);
}
switch( what )

20
src/dc_job.c
View file

@ -194,21 +194,21 @@ static void dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(dc_context_t* mailbox, dc_job_t*
if( !file_used_by_other_msgs )
{
mr_delete_file(pathNfilename, mailbox);
dc_delete_file(pathNfilename, mailbox);
char* increation_file = dc_mprintf("%s.increation", pathNfilename);
mr_delete_file(increation_file, mailbox);
dc_delete_file(increation_file, mailbox);
free(increation_file);
char* filenameOnly = mr_get_filename(pathNfilename);
char* filenameOnly = dc_get_filename(pathNfilename);
if( msg->m_type==MR_MSG_VOICE ) {
char* waveform_file = dc_mprintf("%s/%s.waveform", mailbox->m_blobdir, filenameOnly);
mr_delete_file(waveform_file, mailbox);
dc_delete_file(waveform_file, mailbox);
free(waveform_file);
}
else if( msg->m_type==MR_MSG_VIDEO ) {
char* preview_file = dc_mprintf("%s/%s-preview.jpg", mailbox->m_blobdir, filenameOnly);
mr_delete_file(preview_file, mailbox);
dc_delete_file(preview_file, mailbox);
free(preview_file);
}
free(filenameOnly);
@ -251,7 +251,7 @@ static void dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(dc_context_t* mailbox, dc_job_
/* add an additional job for sending the MDN (here in a thread for fast ui resonses) (an extra job as the MDN has a lower priority) */
if( dc_param_get_int(msg->m_param, DC_PARAM_WANTS_MDN, 0) /* DC_PARAM_WANTS_MDN is set only for one part of a multipart-message */
&& dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", MR_MDNS_DEFAULT_ENABLED) ) {
&& dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", DC_MDNS_DEFAULT_ENABLED) ) {
in_ms_flags |= MR_MS_SET_MDNSent_FLAG;
}
@ -642,7 +642,7 @@ static void dc_job_perform(dc_context_t* mailbox, int thread)
&& dc_is_online(mailbox) )
{
pthread_mutex_lock(&mailbox->m_smtpidle_condmutex);
mailbox->m_perform_smtp_jobs_needed = MR_JOBS_NEEDED_AVOID_DOS;
mailbox->m_perform_smtp_jobs_needed = DC_JOBS_NEEDED_AVOID_DOS;
pthread_mutex_unlock(&mailbox->m_smtpidle_condmutex);
}
}
@ -865,7 +865,7 @@ void dc_perform_smtp_idle(dc_context_t* context)
pthread_mutex_lock(&context->m_smtpidle_condmutex);
if( context->m_perform_smtp_jobs_needed == MR_JOBS_NEEDED_AT_ONCE )
if( context->m_perform_smtp_jobs_needed == DC_JOBS_NEEDED_AT_ONCE )
{
dc_log_info(context, 0, "SMTP-idle will not be started because of waiting jobs.");
}
@ -876,7 +876,7 @@ void dc_perform_smtp_idle(dc_context_t* context)
do {
int r = 0;
struct timespec timeToWait;
timeToWait.tv_sec = time(NULL) + ((context->m_perform_smtp_jobs_needed==MR_JOBS_NEEDED_AVOID_DOS)? 1 : MR_SMTP_IDLE_SEC);
timeToWait.tv_sec = time(NULL) + ((context->m_perform_smtp_jobs_needed==DC_JOBS_NEEDED_AVOID_DOS)? 1 : MR_SMTP_IDLE_SEC);
timeToWait.tv_nsec = 0;
while (context->m_smtpidle_condflag==0 && r==0) {
r = pthread_cond_timedwait(&context->m_smtpidle_cond, &context->m_smtpidle_condmutex, &timeToWait); // unlock mutex -> wait -> lock mutex
@ -939,7 +939,7 @@ void dc_interrupt_smtp_idle(dc_context_t* context)
// when this function is called, it might be that the smtp-thread is in
// perform_smtp_jobs(). if so, added jobs will be performed after the _next_ idle-jobs loop.
// setting the flag perform_smtp_jobs_needed makes sure, idle() returns immediately in this case.
context->m_perform_smtp_jobs_needed = MR_JOBS_NEEDED_AT_ONCE;
context->m_perform_smtp_jobs_needed = DC_JOBS_NEEDED_AT_ONCE;
context->m_smtpidle_condflag = 1;
pthread_cond_signal(&context->m_smtpidle_cond);

4
src/dc_key.c
View file

@ -489,11 +489,11 @@ char* dc_key_get_fingerprint(const dc_key_t* key)
goto cleanup;
}
fingerprint_hex = mr_binary_to_uc_hex(fingerprint_buf, fingerprint_bytes);
fingerprint_hex = dc_binary_to_uc_hex(fingerprint_buf, fingerprint_bytes);
cleanup:
free(fingerprint_buf);
return fingerprint_hex? fingerprint_hex : safe_strdup(NULL);
return fingerprint_hex? fingerprint_hex : dc_strdup(NULL);
}

2
src/dc_log.c
View file

@ -61,7 +61,7 @@ static void log_vprintf(dc_context_t* mailbox, int event, int code, const char*
#define BUFSIZE 1024
char tempbuf[BUFSIZE+1];
vsnprintf(tempbuf, BUFSIZE, msg_format, va);
msg = safe_strdup(tempbuf);
msg = dc_strdup(tempbuf);
}
/* if we have still no message, create one based upon the code */

4
src/dc_loginparam.c
View file

@ -151,7 +151,7 @@ static char* get_readable_flags(int flags)
}
if( strbuilder.m_buf[0]==0 ) { dc_strbuilder_cat(&strbuilder, "0"); }
mr_trim(strbuilder.m_buf);
dc_trim(strbuilder.m_buf);
return strbuilder.m_buf;
}
@ -162,7 +162,7 @@ char* dc_loginparam_get_readable(const dc_loginparam_t* ths)
const char* pw = "***";
if( ths==NULL ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
char* flags_readable = get_readable_flags(ths->m_server_flags);

4
src/dc_lot.c
View file

@ -107,7 +107,7 @@ char* dc_lot_get_text1(dc_lot_t* lot)
if( lot == NULL || lot->m_magic != MR_LOT_MAGIC ) {
return NULL;
}
return strdup_keep_null(lot->m_text1);
return dc_strdup_keep_null(lot->m_text1);
}
@ -125,7 +125,7 @@ char* dc_lot_get_text2(dc_lot_t* lot)
if( lot == NULL || lot->m_magic != MR_LOT_MAGIC ) {
return NULL;
}
return strdup_keep_null(lot->m_text2);
return dc_strdup_keep_null(lot->m_text2);
}

60
src/dc_mimefactory.c
View file

@ -130,8 +130,8 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
if( dc_chat_is_self_talk(factory->m_chat) )
{
clist_append(factory->m_recipients_names, (void*)strdup_keep_null(factory->m_from_displayname));
clist_append(factory->m_recipients_addr, (void*)safe_strdup(factory->m_from_addr));
clist_append(factory->m_recipients_names, (void*)dc_strdup_keep_null(factory->m_from_displayname));
clist_append(factory->m_recipients_addr, (void*)dc_strdup(factory->m_from_addr));
}
else
{
@ -147,8 +147,8 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
const char* addr = (const char*)sqlite3_column_text(stmt, 1);
if( clist_search_string_nocase(factory->m_recipients_addr, addr)==0 )
{
clist_append(factory->m_recipients_names, (void*)((authname&&authname[0])? safe_strdup(authname) : NULL));
clist_append(factory->m_recipients_addr, (void*)safe_strdup(addr));
clist_append(factory->m_recipients_names, (void*)((authname&&authname[0])? dc_strdup(authname) : NULL));
clist_append(factory->m_recipients_addr, (void*)dc_strdup(addr));
}
}
@ -169,7 +169,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
if( command!=DC_CMD_AUTOCRYPT_SETUP_MESSAGE
&& command!=DC_CMD_SECUREJOIN_MESSAGE
&& dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", MR_MDNS_DEFAULT_ENABLED) ) {
&& dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", DC_MDNS_DEFAULT_ENABLED) ) {
factory->m_req_mdn = 1;
}
}
@ -191,7 +191,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
sqlite3_bind_int (stmt, 1, factory->m_msg->m_chat_id);
sqlite3_bind_int (stmt, 2, DC_CONTACT_ID_SELF);
if( sqlite3_step(stmt) == SQLITE_ROW ) {
factory->m_predecessor = strdup_keep_null((const char*)sqlite3_column_text(stmt, 0));
factory->m_predecessor = dc_strdup_keep_null((const char*)sqlite3_column_text(stmt, 0));
}
/* get a References:-header: either the same as the last one or a random one.
@ -216,7 +216,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
}
if( factory->m_references == NULL ) {
factory->m_references = mr_create_dummy_references_mid();
factory->m_references = dc_create_dummy_references_mid();
dc_param_set(factory->m_chat->m_param, DC_PARAM_REFERENCES, factory->m_references);
dc_chat_update_param__(factory->m_chat);
}
@ -224,7 +224,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
success = 1;
factory->m_loaded = DC_MF_MSG_LOADED;
factory->m_timestamp = factory->m_msg->m_timestamp;
factory->m_rfc724_mid = safe_strdup(factory->m_msg->m_rfc724_mid);
factory->m_rfc724_mid = dc_strdup(factory->m_msg->m_rfc724_mid);
}
if( success ) {
@ -258,7 +258,7 @@ int dc_mimefactory_load_mdn(dc_mimefactory_t* factory, uint32_t msg_id)
dc_sqlite3_lock(mailbox->m_sql);
locked = 1;
if( !dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", MR_MDNS_DEFAULT_ENABLED) ) {
if( !dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", DC_MDNS_DEFAULT_ENABLED) ) {
goto cleanup; /* MDNs not enabled - check this is late, in the job. the use may have changed its choice while offline ... */
}
@ -276,13 +276,13 @@ int dc_mimefactory_load_mdn(dc_mimefactory_t* factory, uint32_t msg_id)
goto cleanup;
}
clist_append(factory->m_recipients_names, (void*)((contact->m_authname&&contact->m_authname[0])? safe_strdup(contact->m_authname) : NULL));
clist_append(factory->m_recipients_addr, (void*)safe_strdup(contact->m_addr));
clist_append(factory->m_recipients_names, (void*)((contact->m_authname&&contact->m_authname[0])? dc_strdup(contact->m_authname) : NULL));
clist_append(factory->m_recipients_addr, (void*)dc_strdup(contact->m_addr));
load_from__(factory);
factory->m_timestamp = mr_create_smeared_timestamp__();
factory->m_rfc724_mid = mr_create_outgoing_rfc724_mid(NULL, factory->m_from_addr);
factory->m_timestamp = dc_create_smeared_timestamp__();
factory->m_rfc724_mid = dc_create_outgoing_rfc724_mid(NULL, factory->m_from_addr);
dc_sqlite3_unlock(mailbox->m_sql);
locked = 0;
@ -351,7 +351,7 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
filename_to_send = dc_mprintf("%s - %s.%s", author, title, suffix); /* the separator ` - ` is used on the receiver's side to construct the information; we avoid using ID3-scanners for security purposes */
}
else {
filename_to_send = mr_get_filename(pathNfilename);
filename_to_send = dc_get_filename(pathNfilename);
}
free(author);
free(title);
@ -366,22 +366,22 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
filename_to_send = dc_mprintf("video.%s", suffix? suffix : "dat");
}
else {
filename_to_send = mr_get_filename(pathNfilename);
filename_to_send = dc_get_filename(pathNfilename);
}
/* check mimetype */
if( mimetype == NULL && suffix != NULL ) {
if( strcmp(suffix, "png")==0 ) {
mimetype = safe_strdup("image/png");
mimetype = dc_strdup("image/png");
}
else if( strcmp(suffix, "jpg")==0 || strcmp(suffix, "jpeg")==0 || strcmp(suffix, "jpe")==0 ) {
mimetype = safe_strdup("image/jpeg");
mimetype = dc_strdup("image/jpeg");
}
else if( strcmp(suffix, "gif")==0 ) {
mimetype = safe_strdup("image/gif");
mimetype = dc_strdup("image/gif");
}
else {
mimetype = safe_strdup("application/octet-stream");
mimetype = dc_strdup("application/octet-stream");
}
}
@ -395,7 +395,7 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
int needs_ext = dc_needs_ext_header(filename_to_send);
mime_fields = mailmime_fields_new_filename(MAILMIME_DISPOSITION_TYPE_ATTACHMENT,
needs_ext? NULL : safe_strdup(filename_to_send), MAILMIME_MECHANISM_BASE64);
needs_ext? NULL : dc_strdup(filename_to_send), MAILMIME_MECHANISM_BASE64);
if( needs_ext ) {
for( clistiter* cur1 = clist_begin(mime_fields->fld_list); cur1 != NULL; cur1 = clist_next(cur1) ) {
@ -424,10 +424,10 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
mime_sub = mailmime_new_empty(content, mime_fields);
mailmime_set_body_file(mime_sub, safe_strdup(pathNfilename));
mailmime_set_body_file(mime_sub, dc_strdup(pathNfilename));
if( ret_file_name_as_sent ) {
*ret_file_name_as_sent = safe_strdup(filename_to_send);
*ret_file_name_as_sent = dc_strdup(filename_to_send);
}
cleanup:
@ -492,7 +492,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
{
struct mailimf_mailbox_list* from = mailimf_mailbox_list_new_empty();
mailimf_mailbox_list_add(from, mailimf_mailbox_new(factory->m_from_displayname? dc_encode_header_words(factory->m_from_displayname) : NULL, safe_strdup(factory->m_from_addr)));
mailimf_mailbox_list_add(from, mailimf_mailbox_new(factory->m_from_displayname? dc_encode_header_words(factory->m_from_displayname) : NULL, dc_strdup(factory->m_from_addr)));
struct mailimf_address_list* to = NULL;
if( factory->m_recipients_names && factory->m_recipients_addr && clist_count(factory->m_recipients_addr)>0 ) {
@ -501,19 +501,19 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
for( iter1=clist_begin(factory->m_recipients_names),iter2=clist_begin(factory->m_recipients_addr); iter1!=NULL&&iter2!=NULL; iter1=clist_next(iter1),iter2=clist_next(iter2)) {
const char* name = clist_content(iter1);
const char* addr = clist_content(iter2);
mailimf_address_list_add(to, mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mailimf_mailbox_new(name? dc_encode_header_words(name) : NULL, safe_strdup(addr)), NULL));
mailimf_address_list_add(to, mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mailimf_mailbox_new(name? dc_encode_header_words(name) : NULL, dc_strdup(addr)), NULL));
}
}
clist* references_list = NULL;
if( factory->m_references ) {
references_list = clist_new();
clist_append(references_list, (void*)safe_strdup(factory->m_references));
clist_append(references_list, (void*)dc_strdup(factory->m_references));
}
imf_fields = mailimf_fields_new_with_data_all(mailimf_get_date(factory->m_timestamp), from,
NULL /* sender */, NULL /* reply-to */,
to, NULL /* cc */, NULL /* bcc */, safe_strdup(factory->m_rfc724_mid), NULL /* in-reply-to */,
to, NULL /* cc */, NULL /* bcc */, dc_strdup(factory->m_rfc724_mid), NULL /* in-reply-to */,
references_list /* references */,
NULL /* subject set later */);
@ -566,7 +566,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
int command = dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0);
if( DC_CHAT_TYPE_IS_MULTI(chat->m_type) )
{
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-ID"), safe_strdup(chat->m_grpid)));
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-ID"), dc_strdup(chat->m_grpid)));
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Name"), dc_encode_header_words(chat->m_name)));
@ -585,7 +585,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
grpimage = dc_param_get(chat->m_param, DC_PARAM_PROFILE_IMAGE, NULL);
}
if( dc_param_get_int(msg->m_param, DC_PARAM_CMD_ARG2, 0)&MR_FROM_HANDSHAKE ) {
if( dc_param_get_int(msg->m_param, DC_PARAM_CMD_ARG2, 0)&DC_FROM_HANDSHAKE ) {
dc_log_info(msg->m_context, 0, "sending secure-join message '%s' >>>>>>>>>>>>>>>>>>>>>>>>>", "vg-member-added");
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Secure-Join"), strdup("vg-member-added")));
}
@ -598,7 +598,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
{
grpimage = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( grpimage==NULL ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Image"), safe_strdup("0")));
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Image"), dc_strdup("0")));
}
}
}
@ -669,7 +669,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
afwd_email = dc_param_exists(msg->m_param, DC_PARAM_FORWARDED);
char* fwdhint = NULL;
if( afwd_email ) {
fwdhint = safe_strdup("---------- Forwarded message ----------" LINEEND "From: Delta Chat" LINEEND LINEEND); /* do not chage this! expected this way in the simplifier to detect forwarding! */
fwdhint = dc_strdup("---------- Forwarded message ----------" LINEEND "From: Delta Chat" LINEEND LINEEND); /* do not chage this! expected this way in the simplifier to detect forwarding! */
}
const char* final_text = NULL;

10
src/dc_mimeparser.c
View file

@ -978,7 +978,7 @@ static void do_add_single_file_part(dc_mimeparser_t* parser, int msg_type, int m
part->m_bytes = decoded_data_bytes;
dc_param_set(part->m_param, DC_PARAM_FILE, pathNfilename);
if( MR_MSG_MAKE_FILENAME_SEARCHABLE(msg_type) ) {
part->m_msg = mr_get_filename(pathNfilename);
part->m_msg = dc_get_filename(pathNfilename);
}
else if( MR_MSG_MAKE_SUFFIX_SEARCHABLE(msg_type) ) {
part->m_msg = dc_get_filesuffix_lc(pathNfilename);
@ -1182,7 +1182,7 @@ static int dc_mimeparser_add_single_part_if_known(dc_mimeparser_t* ths, struct m
if( desired_filename==NULL ) {
struct mailmime_parameter* param = mailmime_find_ct_parameter(mime, "name");
if( param && param->pa_value && param->pa_value[0] ) {
desired_filename = safe_strdup(param->pa_value);// is already decoded, see #162
desired_filename = dc_strdup(param->pa_value);// is already decoded, see #162
}
}
@ -1563,12 +1563,12 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
if( prepend_subject )
{
char* subj = safe_strdup(ths->m_subject);
char* subj = dc_strdup(ths->m_subject);
char* p = strchr(subj, '['); /* do not add any tags as "[checked by XYZ]" */
if( p ) {
*p = 0;
}
mr_trim(subj);
dc_trim(subj);
if( subj[0] ) {
int i, icnt = carray_count(ths->m_parts); /* should be at least one - maybe empty - part */
for( i = 0; i < icnt; i++ ) {
@ -1680,7 +1680,7 @@ cleanup:
if( !dc_mimeparser_has_nonmeta(ths) && carray_count(ths->m_reports)==0 ) {
dc_mimepart_t* part = mrmimepart_new();
part->m_type = MR_MSG_TEXT;
part->m_msg = safe_strdup(ths->m_subject? ths->m_subject : "Empty message");
part->m_msg = dc_strdup(ths->m_subject? ths->m_subject : "Empty message");
carray_add(ths->m_parts, (void*)part, NULL);
}
}

56
src/dc_msg.c
View file

@ -286,10 +286,10 @@ char* dc_msg_get_text(const dc_msg_t* msg)
char* ret;
if( msg == NULL || msg->m_magic != MR_MSG_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
ret = safe_strdup(msg->m_text);
ret = dc_strdup(msg->m_text);
dc_truncate_str(ret, MR_MAX_GET_TEXT_LEN); /* we do not do this on load: (1) for speed reasons (2) we may decide to process the full text on other places */
return ret;
}
@ -321,7 +321,7 @@ char* dc_msg_get_file(const dc_msg_t* msg)
ret = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
cleanup:
return ret? ret : safe_strdup(NULL);
return ret? ret : dc_strdup(NULL);
}
@ -350,11 +350,11 @@ char* dc_msg_get_filename(const dc_msg_t* msg)
goto cleanup;
}
ret = mr_get_filename(pathNfilename);
ret = dc_get_filename(pathNfilename);
cleanup:
free(pathNfilename);
return ret? ret : safe_strdup(NULL);
return ret? ret : dc_strdup(NULL);
}
@ -387,13 +387,13 @@ char* dc_msg_get_filemime(const dc_msg_t* msg)
dc_msg_guess_msgtype_from_suffix(file, NULL, &ret);
if( ret == NULL ) {
ret = safe_strdup("application/octet-stream");
ret = dc_strdup("application/octet-stream");
}
}
cleanup:
free(file);
return ret? ret : safe_strdup(NULL);
return ret? ret : dc_strdup(NULL);
}
@ -423,7 +423,7 @@ uint64_t dc_msg_get_filebytes(const dc_msg_t* msg)
goto cleanup;
}
ret = mr_get_filebytes(file);
ret = dc_get_filebytes(file);
cleanup:
free(file);
@ -466,7 +466,7 @@ dc_lot_t* dc_msg_get_mediainfo(const dc_msg_t* msg)
if( (contact = dc_get_contact(msg->m_context, msg->m_from_id))==NULL ) {
goto cleanup;
}
ret->m_text1 = safe_strdup((contact->m_name&&contact->m_name[0])? contact->m_name : contact->m_addr);
ret->m_text1 = dc_strdup((contact->m_name&&contact->m_name[0])? contact->m_name : contact->m_addr);
ret->m_text2 = dc_stock_str(DC_STR_VOICEMESSAGE);
}
else
@ -680,7 +680,7 @@ cleanup:
char* dc_msg_get_summarytext(const dc_msg_t* msg, int approx_characters)
{
if( msg==NULL || msg->m_magic != MR_MSG_MAGIC ) {
return safe_strdup(NULL);
return dc_strdup(NULL);
}
return dc_msg_get_summarytext_by_raw(msg->m_type, msg->m_text, msg->m_param, approx_characters);
@ -862,12 +862,12 @@ char* dc_msg_get_setupcodebegin(const dc_msg_t* msg)
goto cleanup;
}
ret = safe_strdup(buf_setupcodebegin); /* we need to make a copy as buf_setupcodebegin just points inside buf (which will be free()'d on cleanup) */
ret = dc_strdup(buf_setupcodebegin); /* we need to make a copy as buf_setupcodebegin just points inside buf (which will be free()'d on cleanup) */
cleanup:
free(filename);
free(buf);
return ret? ret : safe_strdup(NULL);
return ret? ret : dc_strdup(NULL);
}
@ -886,8 +886,8 @@ static int dc_msg_set_from_stmt__(dc_msg_t* ths, sqlite3_stmt* row, int row_offs
dc_msg_empty(ths);
ths->m_id = (uint32_t)sqlite3_column_int (row, row_offset++);
ths->m_rfc724_mid = safe_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_server_folder= safe_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_rfc724_mid = dc_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_server_folder= dc_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_server_uid = (uint32_t)sqlite3_column_int (row, row_offset++);
ths->m_chat_id = (uint32_t)sqlite3_column_int (row, row_offset++);
@ -900,7 +900,7 @@ static int dc_msg_set_from_stmt__(dc_msg_t* ths, sqlite3_stmt* row, int row_offs
ths->m_type = sqlite3_column_int (row, row_offset++);
ths->m_state = sqlite3_column_int (row, row_offset++);
ths->m_is_msgrmsg = sqlite3_column_int (row, row_offset++);
ths->m_text = safe_strdup((char*)sqlite3_column_text (row, row_offset++));
ths->m_text = dc_strdup((char*)sqlite3_column_text (row, row_offset++));
dc_param_set_packed( ths->m_param, (char*)sqlite3_column_text (row, row_offset++));
ths->m_starred = sqlite3_column_int (row, row_offset++);
@ -908,7 +908,7 @@ static int dc_msg_set_from_stmt__(dc_msg_t* ths, sqlite3_stmt* row, int row_offs
ths->m_chat_blocked = sqlite3_column_int (row, row_offset++);
if( ths->m_chat_blocked == 2 ) {
mr_truncate_n_unwrap_str(ths->m_text, 256 /* 256 characters is about a half screen on a 5" smartphone display */,
dc_truncate_n_unwrap_str(ths->m_text, 256 /* 256 characters is about a half screen on a 5" smartphone display */,
0/*unwrap*/);
}
@ -988,23 +988,23 @@ void dc_msg_guess_msgtype_from_suffix(const char* pathNfilename, int* ret_msgtyp
if( strcmp(suffix, "mp3")==0 ) {
*ret_msgtype = MR_MSG_AUDIO;
*ret_mime = safe_strdup("audio/mpeg");
*ret_mime = dc_strdup("audio/mpeg");
}
else if( strcmp(suffix, "mp4")==0 ) {
*ret_msgtype = MR_MSG_VIDEO;
*ret_mime = safe_strdup("video/mp4");
*ret_mime = dc_strdup("video/mp4");
}
else if( strcmp(suffix, "jpg")==0 || strcmp(suffix, "jpeg")==0 ) {
*ret_msgtype = MR_MSG_IMAGE;
*ret_mime = safe_strdup("image/jpeg");
*ret_mime = dc_strdup("image/jpeg");
}
else if( strcmp(suffix, "png")==0 ) {
*ret_msgtype = MR_MSG_IMAGE;
*ret_mime = safe_strdup("image/png");
*ret_mime = dc_strdup("image/png");
}
else if( strcmp(suffix, "gif")==0 ) {
*ret_msgtype = MR_MSG_GIF;
*ret_mime = safe_strdup("image/gif");
*ret_mime = dc_strdup("image/gif");
}
cleanup:
@ -1018,12 +1018,12 @@ void dc_msg_get_authorNtitle_from_filename(const char* pathNfilename, char** ret
/* function extracts AUTHOR and TITLE from a path given as `/path/other folder/AUTHOR - TITLE.mp3`
if the mark ` - ` is not preset, the whole name (without suffix) is used as the title and the author is NULL. */
char *author = NULL, *title = NULL, *p;
mr_split_filename(pathNfilename, &title, NULL);
dc_split_filename(pathNfilename, &title, NULL);
p = strstr(title, " - ");
if( p ) {
*p = 0;
author = title;
title = safe_strdup(&p[3]);
title = dc_strdup(&p[3]);
}
if( ret_author ) { *ret_author = author; } else { free(author); }
@ -1069,7 +1069,7 @@ char* dc_msg_get_summarytext_by_raw(int type, const char* text, dc_param_t* para
}
else {
pathNfilename = dc_param_get(param, DC_PARAM_FILE, "ErrFilename");
value = mr_get_filename(pathNfilename);
value = dc_get_filename(pathNfilename);
label = dc_stock_str(DC_STR_FILE);
ret = dc_mprintf("%s: %s", label, value);
}
@ -1077,8 +1077,8 @@ char* dc_msg_get_summarytext_by_raw(int type, const char* text, dc_param_t* para
default:
if( text ) {
ret = safe_strdup(text);
mr_truncate_n_unwrap_str(ret, approx_characters, 1/*unwrap*/);
ret = dc_strdup(text);
dc_truncate_n_unwrap_str(ret, approx_characters, 1/*unwrap*/);
}
break;
}
@ -1088,7 +1088,7 @@ char* dc_msg_get_summarytext_by_raw(int type, const char* text, dc_param_t* para
free(label);
free(value);
if( ret == NULL ) {
ret = safe_strdup(NULL);
ret = dc_strdup(NULL);
}
return ret;
}
@ -1102,7 +1102,7 @@ int dc_msg_is_increation__(const dc_msg_t* msg)
char* pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( pathNfilename ) {
char* totest = dc_mprintf("%s.increation", pathNfilename);
if( mr_file_exist(totest) ) {
if( dc_file_exist(totest) ) {
is_increation = 1;
}
free(totest);

16
src/dc_param.c
View file

@ -142,7 +142,7 @@ void dc_param_set_packed(dc_param_t* param, const char* packed)
if( packed ) {
free(param->m_packed);
param->m_packed = safe_strdup(packed);
param->m_packed = dc_strdup(packed);
}
}
@ -161,7 +161,7 @@ void dc_param_set_urlencoded(dc_param_t* param, const char* urlencoded)
if( urlencoded ) {
free(param->m_packed);
param->m_packed = safe_strdup(urlencoded);
param->m_packed = dc_strdup(urlencoded);
dc_str_replace(&param->m_packed, "&", "\n");
}
}
@ -208,20 +208,20 @@ char* dc_param_get(dc_param_t* param, int key, const char* def)
char *p1, *p2, bak, *ret;
if( param == NULL || key == 0 ) {
return def? safe_strdup(def) : NULL;
return def? dc_strdup(def) : NULL;
}
p1 = find_param(param->m_packed, key, &p2);
if( p1 == NULL ) {
return def? safe_strdup(def) : NULL;
return def? dc_strdup(def) : NULL;
}
p1 += 2; /* skip key and "=" (safe as find_param checks for its existance) */
bak = *p2;
*p2 = 0;
ret = safe_strdup(p1);
mr_rtrim(ret); /* to be safe with '\r' characters ... */
ret = dc_strdup(p1);
dc_rtrim(ret); /* to be safe with '\r' characters ... */
*p2 = bak;
return ret;
}
@ -294,8 +294,8 @@ void dc_param_set(dc_param_t* param, int key, const char* value)
}
}
mr_rtrim(old1); /* trim functions are null-pointer-safe */
mr_ltrim(old2);
dc_rtrim(old1); /* trim functions are null-pointer-safe */
dc_ltrim(old2);
if( old1 && old1[0]==0 ) { old1 = NULL; }
if( old2 && old2[0]==0 ) { old2 = NULL; }

14
src/dc_pgp.c
View file

@ -108,14 +108,14 @@ int dc_split_armored_data(char* buf, const char** ret_headerline, const char** r
goto cleanup;
}
mr_remove_cr_chars(buf);
dc_remove_cr_chars(buf);
while( *p1 ) {
if( *p1 == '\n' ) {
/* line found ... */
line[line_chars] = 0;
if( headerline == NULL ) {
/* ... headerline */
mr_trim(line);
dc_trim(line);
if( strncmp(line, "-----BEGIN ", 11)==0 && strncmp(&line[strlen(line)-5], "-----", 5)==0 ) {
headerline = line;
if( ret_headerline ) {
@ -137,17 +137,17 @@ int dc_split_armored_data(char* buf, const char** ret_headerline, const char** r
else {
/* header line */
*p2 = 0;
mr_trim(line);
dc_trim(line);
if( strcasecmp(line, "Passphrase-Begin")==0 ) {
p2++;
mr_trim(p2);
dc_trim(p2);
if( ret_setupcodebegin ) {
*ret_setupcodebegin = p2;
}
}
else if( strcasecmp(line, "Autocrypt-Prefer-Encrypt")==0 ) {
p2++;
mr_trim(p2);
dc_trim(p2);
if( ret_preferencrypt ) {
*ret_preferencrypt = p2;
}
@ -176,7 +176,7 @@ int dc_split_armored_data(char* buf, const char** ret_headerline, const char** r
}
*p1 = 0;
mr_trim(base64);
dc_trim(base64);
if( ret_base64 ) {
*ret_base64 = base64;
@ -698,7 +698,7 @@ int dc_pgp_pk_decrypt( dc_context_t* mailbox,
goto cleanup;
}
char* fingerprint_hex = mr_binary_to_uc_hex(key0->pubkeyfpr.fingerprint, key0->pubkeyfpr.length);
char* fingerprint_hex = dc_binary_to_uc_hex(key0->pubkeyfpr.fingerprint, key0->pubkeyfpr.length);
if( fingerprint_hex ) {
dc_hash_insert(ret_signature_fingerprints, fingerprint_hex, strlen(fingerprint_hex), (void*)1);
}

44
src/dc_qr.c
View file

@ -71,12 +71,12 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
/* split parameters from the qr code
------------------------------------ */
if( strncasecmp(qr, OPENPGP4FPR_SCHEME, strlen(OPENPGP4FPR_SCHEME)) == 0 )
if( strncasecmp(qr, DC_OPENPGP4FPR_SCHEME, strlen(DC_OPENPGP4FPR_SCHEME)) == 0 )
{
/* scheme: OPENPGP4FPR:FINGERPRINT#a=ADDR&n=NAME&i=INVITENUMBER&s=AUTH
or: OPENPGP4FPR:FINGERPRINT#a=ADDR&g=GROUPNAME&x=GROUPID&i=INVITENUMBER&s=AUTH */
payload = safe_strdup(&qr[strlen(OPENPGP4FPR_SCHEME)]);
payload = dc_strdup(&qr[strlen(DC_OPENPGP4FPR_SCHEME)]);
char* fragment = strchr(payload, '#'); /* must not be freed, only a pointer inside payload */
if( fragment )
{
@ -116,44 +116,44 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
else if( strncasecmp(qr, MAILTO_SCHEME, strlen(MAILTO_SCHEME)) == 0 )
{
/* scheme: mailto:addr...?subject=...&body=... */
payload = safe_strdup(&qr[strlen(MAILTO_SCHEME)]);
payload = dc_strdup(&qr[strlen(MAILTO_SCHEME)]);
char* query = strchr(payload, '?'); /* must not be freed, only a pointer inside payload */
if( query ) {
*query = 0;
}
addr = safe_strdup(payload);
addr = dc_strdup(payload);
}
else if( strncasecmp(qr, SMTP_SCHEME, strlen(SMTP_SCHEME)) == 0 )
{
/* scheme: `SMTP:addr...:subject...:body...` */
payload = safe_strdup(&qr[strlen(SMTP_SCHEME)]);
payload = dc_strdup(&qr[strlen(SMTP_SCHEME)]);
char* colon = strchr(payload, ':'); /* must not be freed, only a pointer inside payload */
if( colon ) {
*colon = 0;
}
addr = safe_strdup(payload);
addr = dc_strdup(payload);
}
else if( strncasecmp(qr, MATMSG_SCHEME, strlen(MATMSG_SCHEME)) == 0 )
{
/* scheme: `MATMSG:TO:addr...;SUB:subject...;BODY:body...;` - there may or may not be linebreaks after the fields */
char* to = strstr(qr, "TO:"); /* does not work when the text `TO:` is used in subject/body _and_ TO: is not the first field. we ignore this case. */
if( to ) {
addr = safe_strdup(&to[3]);
addr = dc_strdup(&to[3]);
char* semicolon = strchr(addr, ';');
if( semicolon ) { *semicolon = 0; }
}
else {
qr_parsed->m_state = MR_QR_ERROR;
qr_parsed->m_text1 = safe_strdup("Bad e-mail address.");
qr_parsed->m_text1 = dc_strdup("Bad e-mail address.");
goto cleanup;
}
}
else if( strncasecmp(qr, VCARD_BEGIN, strlen(VCARD_BEGIN)) == 0 )
{
/* scheme: `VCARD:BEGIN\nN:last name;first name;...;\nEMAIL:addr...;` */
carray* lines = mr_split_into_lines(qr);
carray* lines = dc_split_into_lines(qr);
for( int i = 0; i < carray_count(lines); i++ ) {
char* key = (char*)carray_get(lines, i); mr_trim(key);
char* key = (char*)carray_get(lines, i); dc_trim(key);
char* value = strchr(key, ':');
if( value ) {
*value = 0;
@ -161,17 +161,17 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
char* semicolon = strchr(key, ';'); if( semicolon ) { *semicolon = 0; } /* handle `EMAIL;type=work:` stuff */
if( strcasecmp(key, "EMAIL") == 0 ) {
semicolon = strchr(value, ';'); if( semicolon ) { *semicolon = 0; } /* use the first EMAIL */
addr = safe_strdup(value);
addr = dc_strdup(value);
}
else if( strcasecmp(key, "N") == 0 ) {
semicolon = strchr(value, ';'); if( semicolon ) { semicolon = strchr(semicolon+1, ';'); if( semicolon ) { *semicolon = 0; } } /* the N format is `lastname;prename;wtf;title` - skip everything after the second semicolon */
name = safe_strdup(value);
name = dc_strdup(value);
dc_str_replace(&name, ";", ","); /* the format "lastname,prename" is handled by mr_normalize_name() */
mr_normalize_name(name);
}
}
}
mr_free_splitted_lines(lines);
dc_free_splitted_lines(lines);
}
/* check the paramters
@ -183,7 +183,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
if( strlen(addr) < 3 || strchr(addr, '@')==NULL || strchr(addr, '.')==NULL ) {
qr_parsed->m_state = MR_QR_ERROR;
qr_parsed->m_text1 = safe_strdup("Bad e-mail address.");
qr_parsed->m_text1 = dc_strdup("Bad e-mail address.");
goto cleanup;
}
}
@ -191,7 +191,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
if( fingerprint ) {
if( strlen(fingerprint) != 40 ) {
qr_parsed->m_state = MR_QR_ERROR;
qr_parsed->m_text1 = safe_strdup("Bad fingerprint length in QR code.");
qr_parsed->m_text1 = dc_strdup("Bad fingerprint length in QR code.");
goto cleanup;
}
}
@ -235,17 +235,17 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
if( grpid && grpname ) {
qr_parsed->m_state = MR_QR_ASK_VERIFYGROUP;
qr_parsed->m_text1 = safe_strdup(grpname);
qr_parsed->m_text2 = safe_strdup(grpid);
qr_parsed->m_text1 = dc_strdup(grpname);
qr_parsed->m_text2 = dc_strdup(grpid);
}
else {
qr_parsed->m_state = MR_QR_ASK_VERIFYCONTACT;
}
qr_parsed->m_id = dc_add_or_lookup_contact__(context, name, addr, DC_ORIGIN_UNHANDLED_QR_SCAN, NULL);
qr_parsed->m_fingerprint = safe_strdup(fingerprint);
qr_parsed->m_invitenumber = safe_strdup(invitenumber);
qr_parsed->m_auth = safe_strdup(auth);
qr_parsed->m_fingerprint = dc_strdup(fingerprint);
qr_parsed->m_invitenumber = dc_strdup(invitenumber);
qr_parsed->m_auth = dc_strdup(auth);
dc_sqlite3_unlock(context->m_sql);
@ -260,12 +260,12 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
else if( strstr(qr, "http://")==qr || strstr(qr, "https://")==qr )
{
qr_parsed->m_state = MR_QR_URL;
qr_parsed->m_text1 = safe_strdup(qr);
qr_parsed->m_text1 = dc_strdup(qr);
}
else
{
qr_parsed->m_state = MR_QR_TEXT;
qr_parsed->m_text1 = safe_strdup(qr);
qr_parsed->m_text1 = dc_strdup(qr);
}
if( device_msg ) {

40
src/dc_receive_imf.c
View file

@ -317,8 +317,8 @@ static void dc_calc_timestamps__(dc_context_t* mailbox, uint32_t chat_id, uint32
}
/* use the (smeared) current time as the MAXIMUM */
if( *sort_timestamp >= mr_smeared_time__() ) {
*sort_timestamp = mr_create_smeared_timestamp__();
if( *sort_timestamp >= dc_smeared_time__() ) {
*sort_timestamp = dc_create_smeared_timestamp__();
}
}
@ -429,11 +429,11 @@ static char* create_adhoc_grp_id__(dc_context_t* mailbox, dc_array_t* member_ids
q3 = sqlite3_mprintf("SELECT addr FROM contacts WHERE id IN(%s) AND id!=" DC_STRINGIFY(DC_CONTACT_ID_SELF), member_ids_str);
stmt = dc_sqlite3_prepare_v2_(mailbox->m_sql, q3);
addr = dc_sqlite3_get_config__(mailbox->m_sql, "configured_addr", "no-self");
mr_strlower_in_place(addr);
dc_strlower_in_place(addr);
dc_array_add_ptr(member_addrs, addr);
while( sqlite3_step(stmt)==SQLITE_ROW ) {
addr = safe_strdup((const char*)sqlite3_column_text(stmt, 0));
mr_strlower_in_place(addr);
addr = dc_strdup((const char*)sqlite3_column_text(stmt, 0));
dc_strlower_in_place(addr);
dc_array_add_ptr(member_addrs, addr);
}
dc_array_sort_strings(member_addrs);
@ -455,7 +455,7 @@ static char* create_adhoc_grp_id__(dc_context_t* mailbox, dc_array_t* member_ids
hasher.finish(&hasher, binary_hash);
}
/* output the first 8 bytes as 16 hex-characters - CAVE: if the lenght changes here, also adapt mr_extract_grpid_from_rfc724_mid() */
/* output the first 8 bytes as 16 hex-characters - CAVE: if the lenght changes here, also adapt dc_extract_grpid_from_rfc724_mid() */
ret = calloc(1, 256);
for( i = 0; i < 8; i++ ) {
sprintf(&ret[i*2], "%02x", (int)binary_hash[i]);
@ -556,7 +556,7 @@ static void create_or_lookup_adhoc_group__(dc_context_t* mailbox, dc_mimeparser_
/* use subject as initial chat name */
if( mime_parser->m_subject && mime_parser->m_subject[0] ) {
grpname = safe_strdup(mime_parser->m_subject);
grpname = dc_strdup(mime_parser->m_subject);
}
else {
grpname = dc_stock_str_repl_pl(DC_STR_MEMBER, dc_array_get_cnt(member_ids));
@ -706,7 +706,7 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
struct mailimf_optional_field* optional_field = NULL;
if( (optional_field=dc_mimeparser_lookup_optional_field2(mime_parser, "Chat-Group-ID", "X-MrGrpId"))!=NULL ) {
grpid = safe_strdup(optional_field->fld_value);
grpid = dc_strdup(optional_field->fld_value);
}
if( grpid == NULL )
@ -714,7 +714,7 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
if( (field=dc_mimeparser_lookup_field(mime_parser, "Message-ID"))!=NULL && field->fld_type==MAILIMF_FIELD_MESSAGE_ID ) {
struct mailimf_message_id* fld_message_id = field->fld_data.fld_message_id;
if( fld_message_id ) {
grpid = mr_extract_grpid_from_rfc724_mid(fld_message_id->mid_value);
grpid = dc_extract_grpid_from_rfc724_mid(fld_message_id->mid_value);
}
}
@ -723,7 +723,7 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
if( (field=dc_mimeparser_lookup_field(mime_parser, "In-Reply-To"))!=NULL && field->fld_type==MAILIMF_FIELD_IN_REPLY_TO ) {
struct mailimf_in_reply_to* fld_in_reply_to = field->fld_data.fld_in_reply_to;
if( fld_in_reply_to ) {
grpid = mr_extract_grpid_from_rfc724_mid_list(fld_in_reply_to->mid_list);
grpid = dc_extract_grpid_from_rfc724_mid_list(fld_in_reply_to->mid_list);
}
}
@ -732,7 +732,7 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
if( (field=dc_mimeparser_lookup_field(mime_parser, "References"))!=NULL && field->fld_type==MAILIMF_FIELD_REFERENCES ) {
struct mailimf_references* fld_references = field->fld_data.fld_references;
if( fld_references ) {
grpid = mr_extract_grpid_from_rfc724_mid_list(fld_references->mid_list);
grpid = dc_extract_grpid_from_rfc724_mid_list(fld_references->mid_list);
}
}
@ -958,9 +958,9 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
size_t i, icnt;
uint32_t first_dblocal_id = 0;
char* rfc724_mid = NULL; /* Message-ID from the header */
time_t sort_timestamp = MR_INVALID_TIMESTAMP;
time_t sent_timestamp = MR_INVALID_TIMESTAMP;
time_t rcvd_timestamp = MR_INVALID_TIMESTAMP;
time_t sort_timestamp = DC_INVALID_TIMESTAMP;
time_t sent_timestamp = DC_INVALID_TIMESTAMP;
time_t rcvd_timestamp = DC_INVALID_TIMESTAMP;
dc_mimeparser_t* mime_parser = dc_mimeparser_new(mailbox->m_blobdir, mailbox);
int db_locked = 0;
int transaction_pending = 0;
@ -1012,7 +1012,7 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
if( (field=dc_mimeparser_lookup_field(mime_parser, "Date"))!=NULL && field->fld_type==MAILIMF_FIELD_ORIG_DATE ) {
struct mailimf_orig_date* orig_date = field->fld_data.fld_orig_date;
if( orig_date ) {
sent_timestamp = mr_timestamp_from_date(orig_date->dt_date_time); // is not yet checked against bad times! we do this later if we have the database information.
sent_timestamp = dc_timestamp_from_date(orig_date->dt_date_time); // is not yet checked against bad times! we do this later if we have the database information.
}
}
@ -1090,12 +1090,12 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
if( (field=dc_mimeparser_lookup_field(mime_parser, "Message-ID"))!=NULL && field->fld_type==MAILIMF_FIELD_MESSAGE_ID ) {
struct mailimf_message_id* fld_message_id = field->fld_data.fld_message_id;
if( fld_message_id ) {
rfc724_mid = safe_strdup(fld_message_id->mid_value);
rfc724_mid = dc_strdup(fld_message_id->mid_value);
}
}
if( rfc724_mid == NULL ) {
rfc724_mid = mr_create_incoming_rfc724_mid(sort_timestamp, from_id, to_ids);
rfc724_mid = dc_create_incoming_rfc724_mid(sort_timestamp, from_id, to_ids);
if( rfc724_mid == NULL ) {
dc_log_info(mailbox, 0, "Cannot create Message-ID.");
goto cleanup;
@ -1133,7 +1133,7 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
if( dc_mimeparser_lookup_field(mime_parser, "Secure-Join") ) {
dc_sqlite3_commit__(mailbox->m_sql);
dc_sqlite3_unlock(mailbox->m_sql);
if( dc_handle_securejoin_handshake(mailbox, mime_parser, from_id) == MR_IS_HANDSHAKE_STOP_NORMAL_PROCESSING ) {
if( dc_handle_securejoin_handshake(mailbox, mime_parser, from_id) == DC_IS_HANDSHAKE_STOP_NORMAL_PROCESSING ) {
hidden = 1;
state = DC_STATE_IN_SEEN;
}
@ -1189,7 +1189,7 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
else if( dc_is_reply_to_known_message__(mailbox, mime_parser) ) {
dc_scaleup_contact_origin__(mailbox, from_id, DC_ORIGIN_INCOMING_REPLY_TO); /* we do not want any chat to be created implicitly. Because of the origin-scale-up, the contact requests will pop up and this should be just fine. */
dc_log_info(mailbox, 0, "Message is a reply to a known message, mark sender as known.");
incoming_origin = MR_MAX(incoming_origin, DC_ORIGIN_INCOMING_REPLY_TO);
incoming_origin = DC_MAX(incoming_origin, DC_ORIGIN_INCOMING_REPLY_TO);
}
}
}
@ -1369,7 +1369,7 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
* Handle reports (mainly MDNs)
*****************************************************************/
int mdns_enabled = dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", MR_MDNS_DEFAULT_ENABLED);
int mdns_enabled = dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", DC_MDNS_DEFAULT_ENABLED);
icnt = carray_count(mime_parser->m_reports);
for( i = 0; i < icnt; i++ )
{

14
src/dc_saxparser.c
View file

@ -333,7 +333,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
return;
}
buf_start = safe_strdup(buf_start__); /* we make a copy as we can easily null-terminate tag names and attributes "in place" */
buf_start = dc_strdup(buf_start__); /* we make a copy as we can easily null-terminate tag names and attributes "in place" */
last_text_start = buf_start;
p = buf_start;
while( *p )
@ -414,7 +414,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
{
bak = *p;
*p = '\0'; /* null-terminate tag name temporary, eg. a covered `>` may get important downwards */
mr_strlower_in_place(beg_tag_name);
dc_strlower_in_place(beg_tag_name);
ths->m_endtag_cb(ths->m_userdata, beg_tag_name);
*p = bak;
}
@ -470,7 +470,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
p += strcspn(p, XML_WS "/>"); /* get end of attribute value */
bak = *p;
*p = '\0';
char* temp = safe_strdup(beg_attr_value);
char* temp = dc_strdup(beg_attr_value);
beg_attr_value_new = xml_decode(temp, ' ');
if( beg_attr_value_new!=temp ) { free(temp); }
*p = bak;
@ -478,7 +478,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
}
else
{
beg_attr_value_new = safe_strdup(NULL);
beg_attr_value_new = dc_strdup(NULL);
}
/* add attribute */
@ -490,7 +490,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
/* take care not to overwrite the current pointer (happens eg. for `<tag attrWithoutValue>` */
bak = *after_attr_name;
*after_attr_name = '\0';
beg_attr_name_new = safe_strdup(beg_attr_name);
beg_attr_name_new = dc_strdup(beg_attr_name);
*after_attr_name = bak;
free_bits |= FREE_KEY;
}
@ -498,7 +498,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
*after_attr_name = '\0';
}
mr_strlower_in_place(beg_attr_name_new);
dc_strlower_in_place(beg_attr_name_new);
attr[attr_index] = beg_attr_name_new;
attr[attr_index+1] = beg_attr_value_new;
attr[attr_index+2] = NULL; /* null-terminate list */
@ -511,7 +511,7 @@ void dc_saxparser_parse(dc_saxparser_t* ths, const char* buf_start__)
char bak = *after_tag_name; /* backup the character as it may be `/` or `>` which gets important downwards */
*after_tag_name = 0;
mr_strlower_in_place(beg_tag_name);
dc_strlower_in_place(beg_tag_name);
ths->m_starttag_cb(ths->m_userdata, beg_tag_name, attr);
*after_tag_name = bak;

26
src/dc_securejoin.c
View file

@ -420,12 +420,12 @@ char* dc_get_securejoin_qr(dc_context_t* context, uint32_t group_chat_id)
}
group_name = dc_chat_get_name(chat);
group_name_urlencoded = dc_urlencode(group_name);
qr = dc_mprintf(OPENPGP4FPR_SCHEME "%s#a=%s&g=%s&x=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, group_name_urlencoded, chat->m_grpid, invitenumber, auth);
qr = dc_mprintf(DC_OPENPGP4FPR_SCHEME "%s#a=%s&g=%s&x=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, group_name_urlencoded, chat->m_grpid, invitenumber, auth);
}
else
{
// parameters used: a=n=i=s=
qr = dc_mprintf(OPENPGP4FPR_SCHEME "%s#a=%s&n=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, self_name_urlencoded, invitenumber, auth);
qr = dc_mprintf(DC_OPENPGP4FPR_SCHEME "%s#a=%s&n=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, self_name_urlencoded, invitenumber, auth);
}
cleanup:
@ -440,7 +440,7 @@ cleanup:
dc_chat_unref(chat);
free(group_name);
free(group_name_urlencoded);
return qr? qr : safe_strdup(NULL);
return qr? qr : dc_strdup(NULL);
}
@ -478,7 +478,7 @@ uint32_t dc_join_securejoin(dc_context_t* context, const char* qr)
int ret_chat_id = 0;
int ongoing_allocated = 0;
#define CHECK_EXIT if( mr_shall_stop_ongoing ) { goto cleanup; }
#define CHECK_EXIT if( dc_shall_stop_ongoing ) { goto cleanup; }
uint32_t contact_chat_id = 0;
dc_lot_t* qr_scan = NULL;
int join_vg = 0;
@ -595,7 +595,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
}
UNLOCK
ret = MR_IS_HANDSHAKE_STOP_NORMAL_PROCESSING;
ret = DC_IS_HANDSHAKE_STOP_NORMAL_PROCESSING;
if( strcmp(step, "vg-request")==0 || strcmp(step, "vc-request")==0 )
{
@ -643,10 +643,10 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
dc_log_warning(context, 0, "auth-required message out of sync.");
goto cleanup; // no error, just aborted somehow or a mail from another handshake
}
scanned_fingerprint_of_alice = safe_strdup(s_bobs_qr_scan->m_fingerprint);
auth = safe_strdup(s_bobs_qr_scan->m_auth);
scanned_fingerprint_of_alice = dc_strdup(s_bobs_qr_scan->m_fingerprint);
auth = dc_strdup(s_bobs_qr_scan->m_auth);
if( join_vg ) {
grpid = safe_strdup(s_bobs_qr_scan->m_text2);
grpid = dc_strdup(s_bobs_qr_scan->m_text2);
}
UNLOCK
@ -735,7 +735,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
if( join_vg ) {
// the vg-member-added message is special: this is a normal Chat-Group-Member-Added message with an additional Secure-Join header
grpid = safe_strdup(lookup_field(mimeparser, "Secure-Join-Group"));
grpid = dc_strdup(lookup_field(mimeparser, "Secure-Join-Group"));
int is_verified = 0;
LOCK
uint32_t verified_chat_id = dc_get_chat_id_by_grpid__(context, grpid, NULL, &is_verified);
@ -745,7 +745,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
goto cleanup;
}
dc_add_contact_to_chat_ex(context, verified_chat_id, contact_id, MR_FROM_HANDSHAKE); // Alice -> Bob and all members
dc_add_contact_to_chat_ex(context, verified_chat_id, contact_id, DC_FROM_HANDSHAKE); // Alice -> Bob and all members
}
else {
send_handshake_msg(context, contact_chat_id, "vc-contact-confirm",
@ -761,7 +761,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
if( join_vg ) {
// vg-member-added is just part of a Chat-Group-Member-Added which should be kept in any way, eg. for multi-client
ret = MR_IS_HANDSHAKE_CONTINUE_NORMAL_PROCESSING;
ret = DC_IS_HANDSHAKE_CONTINUE_NORMAL_PROCESSING;
}
if( s_bob_expects != VC_CONTACT_CONFIRM ) {
@ -779,7 +779,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
dc_log_warning(context, 0, "Message out of sync or belongs to a different handshake.");
goto cleanup;
}
scanned_fingerprint_of_alice = safe_strdup(s_bobs_qr_scan->m_fingerprint);
scanned_fingerprint_of_alice = dc_strdup(s_bobs_qr_scan->m_fingerprint);
UNLOCK
if( !encrypted_and_signed(mimeparser, scanned_fingerprint_of_alice) ) {
@ -809,7 +809,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
// delete the message, as SMTP and IMAP is done in separate threads it should be okay to delete the message just now.
// for errors, we do not the corresponding message at all, it may come eg. from another device or may be useful to find out what was going wrong.
if( ret == MR_IS_HANDSHAKE_STOP_NORMAL_PROCESSING ) {
if( ret == DC_IS_HANDSHAKE_STOP_NORMAL_PROCESSING ) {
struct mailimf_field* field;
if( (field=dc_mimeparser_lookup_field(mimeparser, "Message-ID"))!=NULL && field->fld_type==MAILIMF_FIELD_MESSAGE_ID ) {
struct mailimf_message_id* fld_message_id = field->fld_data.fld_message_id;

12
src/dc_simplify.c
View file

@ -124,7 +124,7 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* ths, const char* buf
however, this adds some additional complexity and seems not to be needed currently */
/* split the given buffer into lines */
carray* lines = mr_split_into_lines(buf_terminated);
carray* lines = dc_split_into_lines(buf_terminated);
int l, l_first = 0, l_last = carray_count(lines)-1; /* if l_last is -1, there are no lines */
char* line;
@ -289,7 +289,7 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* ths, const char* buf
dc_strbuilder_cat(&ret, " " DC_EDITORIAL_ELLIPSE);
}
mr_free_splitted_lines(lines);
dc_free_splitted_lines(lines);
return ret.m_buf;
}
@ -306,7 +306,7 @@ char* dc_simplify_simplify(dc_simplify_t* ths, const char* in_unterminated, int
char* out = NULL, *temp = NULL;
if( ths == NULL || in_unterminated == NULL || in_bytes <= 0 ) {
return safe_strdup("");
return dc_strdup("");
}
ths->m_is_forwarded = 0;
@ -315,7 +315,7 @@ char* dc_simplify_simplify(dc_simplify_t* ths, const char* in_unterminated, int
out = strndup((char*)in_unterminated, in_bytes); /* strndup() makes sure, the string is null-terminated */
if( out == NULL ) {
return safe_strdup("");
return dc_strdup("");
}
/* convert HTML to text, if needed */
@ -327,14 +327,14 @@ char* dc_simplify_simplify(dc_simplify_t* ths, const char* in_unterminated, int
}
/* simplify the text in the buffer (characters to remove may be marked by `\r`) */
mr_remove_cr_chars(out); /* make comparisons easier, eg. for line `-- ` */
dc_remove_cr_chars(out); /* make comparisons easier, eg. for line `-- ` */
if( (temp = dc_simplify_simplify_plain_text(ths, out)) != NULL ) {
free(out);
out = temp;
}
/* remove all `\r` from string */
mr_remove_cr_chars(out);
dc_remove_cr_chars(out);
return out;
}

2
src/dc_smtp.c
View file

@ -117,7 +117,7 @@ int dc_smtp_connect(dc_smtp_t* ths, const dc_loginparam_t* lp)
}
free(ths->m_from);
ths->m_from = safe_strdup(lp->m_addr);
ths->m_from = dc_strdup(lp->m_addr);
ths->m_hEtpan = mailsmtp_new(0, NULL);
if( ths->m_hEtpan == NULL ) {

6
src/dc_sqlite3.c
View file

@ -647,7 +647,7 @@ char* dc_sqlite3_get_config__(dc_sqlite3_t* ths, const char* key, const char* de
sqlite3_stmt* stmt;
if( !dc_sqlite3_is_open(ths) || key == NULL ) {
return strdup_keep_null(def);
return dc_strdup_keep_null(def);
}
stmt = dc_sqlite3_predefine__(ths, SELECT_v_FROM_config_k, SELECT_v_FROM_config_k_STATEMENT);
@ -658,12 +658,12 @@ char* dc_sqlite3_get_config__(dc_sqlite3_t* ths, const char* key, const char* de
if( ptr )
{
/* success, fall through below to free objects */
return safe_strdup((const char*)ptr);
return dc_strdup((const char*)ptr);
}
}
/* return the default value */
return strdup_keep_null(def);
return dc_strdup_keep_null(def);
}

70
src/dc_stock.c
View file

@ -39,44 +39,44 @@ dc_context_t* s_localize_mb_obj = NULL;
static char* default_string(int id, int qty)
{
switch( id ) {
case DC_STR_NOMESSAGES: return safe_strdup("No messages.");
case DC_STR_SELF: return safe_strdup("Me");
case DC_STR_DRAFT: return safe_strdup("Draft");
case DC_STR_NOMESSAGES: return dc_strdup("No messages.");
case DC_STR_SELF: return dc_strdup("Me");
case DC_STR_DRAFT: return dc_strdup("Draft");
case DC_STR_MEMBER: return dc_mprintf("%i member(s)", qty);
case DC_STR_CONTACT: return dc_mprintf("%i contact(s)", qty);
case DC_STR_VOICEMESSAGE: return safe_strdup("Voice message");
case DC_STR_DEADDROP: return safe_strdup("Mailbox");
case DC_STR_IMAGE: return safe_strdup("Image");
case DC_STR_GIF: return safe_strdup("GIF");
case DC_STR_VIDEO: return safe_strdup("Video");
case DC_STR_AUDIO: return safe_strdup("Audio");
case DC_STR_FILE: return safe_strdup("File");
case DC_STR_ENCRYPTEDMSG: return safe_strdup("Encrypted message");
case DC_STR_STATUSLINE: return safe_strdup("Sent with my Delta Chat Messenger: https://delta.chat");
case DC_STR_NEWGROUPDRAFT: return safe_strdup("Hello, I've just created the group \"%1$s\" for us.");
case DC_STR_MSGGRPNAME: return safe_strdup("Group name changed from \"%1$s\" to \"%2$s\".");
case DC_STR_MSGGRPIMGCHANGED: return safe_strdup("Group image changed.");
case DC_STR_MSGADDMEMBER: return safe_strdup("Member %1$s added.");
case DC_STR_MSGDELMEMBER: return safe_strdup("Member %1$s removed.");
case DC_STR_MSGGROUPLEFT: return safe_strdup("Group left.");
case DC_STR_SELFNOTINGRP: return safe_strdup("You must be a member of the group to perform this action.");
case DC_STR_NONETWORK: return safe_strdup("No network available.");
case DC_STR_E2E_AVAILABLE: return safe_strdup("End-to-end encryption available.");
case DC_STR_ENCR_TRANSP: return safe_strdup("Transport-encryption.");
case DC_STR_ENCR_NONE: return safe_strdup("No encryption.");
case DC_STR_FINGERPRINTS: return safe_strdup("Fingerprints");
case DC_STR_READRCPT: return safe_strdup("Return receipt");
case DC_STR_READRCPT_MAILBODY: return safe_strdup("This is a return receipt for the message \"%1$s\".");
case DC_STR_MSGGRPIMGDELETED: return safe_strdup("Group image deleted.");
case DC_STR_E2E_PREFERRED: return safe_strdup("End-to-end encryption preferred.");
case DC_STR_ARCHIVEDCHATS: return safe_strdup("Archived chats");
case DC_STR_STARREDMSGS: return safe_strdup("Starred messages");
case DC_STR_AC_SETUP_MSG_SUBJECT: return safe_strdup("Autocrypt Setup Message");
case DC_STR_AC_SETUP_MSG_BODY: return safe_strdup("This is the Autocrypt Setup Message used to transfer your key between clients.\n\nTo decrypt and use your key, open the message in an Autocrypt-compliant client and enter the setup code presented on the generating device.");
case DC_STR_SELFTALK_SUBTITLE: return safe_strdup("Messages I sent to myself");
case DC_STR_CANTDECRYPT_MSG_BODY: return safe_strdup("This message was encrypted for another setup.");
case DC_STR_VOICEMESSAGE: return dc_strdup("Voice message");
case DC_STR_DEADDROP: return dc_strdup("Mailbox");
case DC_STR_IMAGE: return dc_strdup("Image");
case DC_STR_GIF: return dc_strdup("GIF");
case DC_STR_VIDEO: return dc_strdup("Video");
case DC_STR_AUDIO: return dc_strdup("Audio");
case DC_STR_FILE: return dc_strdup("File");
case DC_STR_ENCRYPTEDMSG: return dc_strdup("Encrypted message");
case DC_STR_STATUSLINE: return dc_strdup("Sent with my Delta Chat Messenger: https://delta.chat");
case DC_STR_NEWGROUPDRAFT: return dc_strdup("Hello, I've just created the group \"%1$s\" for us.");
case DC_STR_MSGGRPNAME: return dc_strdup("Group name changed from \"%1$s\" to \"%2$s\".");
case DC_STR_MSGGRPIMGCHANGED: return dc_strdup("Group image changed.");
case DC_STR_MSGADDMEMBER: return dc_strdup("Member %1$s added.");
case DC_STR_MSGDELMEMBER: return dc_strdup("Member %1$s removed.");
case DC_STR_MSGGROUPLEFT: return dc_strdup("Group left.");
case DC_STR_SELFNOTINGRP: return dc_strdup("You must be a member of the group to perform this action.");
case DC_STR_NONETWORK: return dc_strdup("No network available.");
case DC_STR_E2E_AVAILABLE: return dc_strdup("End-to-end encryption available.");
case DC_STR_ENCR_TRANSP: return dc_strdup("Transport-encryption.");
case DC_STR_ENCR_NONE: return dc_strdup("No encryption.");
case DC_STR_FINGERPRINTS: return dc_strdup("Fingerprints");
case DC_STR_READRCPT: return dc_strdup("Return receipt");
case DC_STR_READRCPT_MAILBODY: return dc_strdup("This is a return receipt for the message \"%1$s\".");
case DC_STR_MSGGRPIMGDELETED: return dc_strdup("Group image deleted.");
case DC_STR_E2E_PREFERRED: return dc_strdup("End-to-end encryption preferred.");
case DC_STR_ARCHIVEDCHATS: return dc_strdup("Archived chats");
case DC_STR_STARREDMSGS: return dc_strdup("Starred messages");
case DC_STR_AC_SETUP_MSG_SUBJECT: return dc_strdup("Autocrypt Setup Message");
case DC_STR_AC_SETUP_MSG_BODY: return dc_strdup("This is the Autocrypt Setup Message used to transfer your key between clients.\n\nTo decrypt and use your key, open the message in an Autocrypt-compliant client and enter the setup code presented on the generating device.");
case DC_STR_SELFTALK_SUBTITLE: return dc_strdup("Messages I sent to myself");
case DC_STR_CANTDECRYPT_MSG_BODY: return dc_strdup("This message was encrypted for another setup.");
}
return safe_strdup("ErrStr");
return dc_strdup("ErrStr");
}

4
src/dc_strbuilder.c
View file

@ -50,7 +50,7 @@ void dc_strbuilder_init(dc_strbuilder_t* strbuilder, int init_bytes)
return;
}
strbuilder->m_allocated = MR_MAX(init_bytes, 128); /* use a small default minimum, we may use _many_ of these objects at the same time */
strbuilder->m_allocated = DC_MAX(init_bytes, 128); /* use a small default minimum, we may use _many_ of these objects at the same time */
strbuilder->m_buf = malloc(strbuilder->m_allocated);
if( strbuilder->m_buf==NULL ) {
@ -89,7 +89,7 @@ char* dc_strbuilder_cat(dc_strbuilder_t* strbuilder, const char* text)
int len = strlen(text);
if( len > strbuilder->m_free ) {
int add_bytes = MR_MAX(len, strbuilder->m_allocated);
int add_bytes = DC_MAX(len, strbuilder->m_allocated);
int old_offset = (int)(strbuilder->m_eos - strbuilder->m_buf);
strbuilder->m_allocated = strbuilder->m_allocated + add_bytes;

14
src/dc_strencode.c
View file

@ -66,7 +66,7 @@ char* dc_urlencode(const char *to_encode)
const char *pstr = to_encode;
if( to_encode == NULL ) {
return safe_strdup("");
return dc_strdup("");
}
char *buf = malloc(strlen(to_encode) * 3 + 1), *pbuf = buf;
@ -112,7 +112,7 @@ char* dc_urldecode(const char* to_decode)
const char *pstr = to_decode;
if( to_decode == NULL ) {
return safe_strdup("");
return dc_strdup("");
}
char *buf = malloc(strlen(to_decode) + 1), *pbuf = buf;
@ -465,7 +465,7 @@ char* dc_decode_header_words(const char* in)
size_t cur_token = 0;
int r = mailmime_encoded_phrase_parse(DEF_INCOMING_CHARSET, in, strlen(in), &cur_token, DEF_DISPLAY_CHARSET, &out);
if( r != MAILIMF_NO_ERROR || out == NULL ) {
out = safe_strdup(in); /* error, make a copy of the original string (as we free it later) */
out = dc_strdup(in); /* error, make a copy of the original string (as we free it later) */
}
return out; /* must be free()'d by the caller */
@ -513,7 +513,7 @@ char* dc_encode_modified_utf7(const char* to_encode, int change_spaces)
char *dst, *res;
if (!to_encode) {
return safe_strdup("");
return dc_strdup("");
}
res = (char*)malloc(2*strlen(to_encode)+1);
@ -650,7 +650,7 @@ char* dc_decode_modified_utf7(const char *to_decode, int change_spaces)
char *dst, *res;
if( to_decode == NULL ) {
return safe_strdup("");
return dc_strdup("");
}
res = (char*)malloc(4*strlen(to_decode)+1);
@ -794,7 +794,7 @@ char* dc_encode_ext_header(const char* to_encode)
const char *pstr = to_encode;
if( to_encode == NULL ) {
return safe_strdup(PREFIX);
return dc_strdup(PREFIX);
}
char *buf = malloc(strlen(PREFIX) + strlen(to_encode) * 3 + 1);
@ -876,5 +876,5 @@ char* dc_decode_ext_header(const char* to_decode)
cleanup:
free(charset);
return decoded? decoded : safe_strdup(to_decode);
return decoded? decoded : dc_strdup(to_decode);
}

2
src/dc_token.c
View file

@ -60,7 +60,7 @@ char* mrtoken_lookup__(dc_context_t* mailbox, mrtokennamespc_t namespc, uint32_t
sqlite3_bind_int (stmt, 2, (int)foreign_id);
sqlite3_step(stmt);
token = strdup_keep_null((char*)sqlite3_column_text(stmt, 0));
token = dc_strdup_keep_null((char*)sqlite3_column_text(stmt, 0));
cleanup:
sqlite3_finalize(stmt);

128
src/dc_tools.c
View file

@ -38,7 +38,7 @@
******************************************************************************/
int mr_exactly_one_bit_set(int v)
int dc_exactly_one_bit_set(int v)
{
return (v && !(v & (v - 1))); /* via http://www.graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
}
@ -49,7 +49,7 @@ int mr_exactly_one_bit_set(int v)
******************************************************************************/
char* safe_strdup(const char* s) /* strdup(NULL) is undefined, save_strdup(NULL) returns an empty string in this case */
char* dc_strdup(const char* s) /* strdup(NULL) is undefined, save_strdup(NULL) returns an empty string in this case */
{
char* ret;
if( s ) {
@ -66,19 +66,19 @@ char* safe_strdup(const char* s) /* strdup(NULL) is undefined, save_strdup(NULL)
}
char* strdup_keep_null(const char* s) /* strdup(NULL) is undefined, safe_strdup_keep_null(NULL) returns NULL in this case */
char* dc_strdup_keep_null(const char* s) /* strdup(NULL) is undefined, safe_strdup_keep_null(NULL) returns NULL in this case */
{
return s? safe_strdup(s) : NULL;
return s? dc_strdup(s) : NULL;
}
int atoi_null_is_0(const char* s)
int dc_atoi_null_is_0(const char* s)
{
return s? atoi(s) : 0;
}
void mr_ltrim(char* buf)
void dc_ltrim(char* buf)
{
size_t len;
const unsigned char* cur;
@ -98,7 +98,7 @@ void mr_ltrim(char* buf)
}
void mr_rtrim(char* buf)
void dc_rtrim(char* buf)
{
size_t len;
unsigned char* cur;
@ -116,14 +116,14 @@ void mr_rtrim(char* buf)
}
void mr_trim(char* buf)
void dc_trim(char* buf)
{
mr_ltrim(buf);
mr_rtrim(buf);
dc_ltrim(buf);
dc_rtrim(buf);
}
void mr_strlower_in_place(char* in)
void dc_strlower_in_place(char* in)
{
char* p = in;
for ( ; *p; p++) {
@ -132,9 +132,9 @@ void mr_strlower_in_place(char* in)
}
char* mr_strlower(const char* in) /* the result must be free()'d */
char* dc_strlower(const char* in) /* the result must be free()'d */
{
char* out = safe_strdup(in);
char* out = dc_strdup(in);
char* p = out;
for ( ; *p; p++) {
@ -176,7 +176,7 @@ int dc_str_replace(char** haystack, const char* needle, const char* replacement)
}
int mr_str_contains(const char* haystack, const const char* needle)
int dc_str_contains(const char* haystack, const const char* needle)
{
/* case-insensitive search of needle in haystack, return 1 if found, 0 if not */
if( haystack==NULL || needle == NULL ) {
@ -187,8 +187,8 @@ int mr_str_contains(const char* haystack, const const char* needle)
return 1;
}
char* haystack_lower = mr_strlower(haystack);
char* needle_lower = mr_strlower(needle);
char* haystack_lower = dc_strlower(haystack);
char* needle_lower = dc_strlower(needle);
int ret = strstr(haystack_lower, needle_lower)? 1 : 0;
@ -242,7 +242,7 @@ char* dc_null_terminate(const char* in, int bytes) /* the result must be free()'
* @return Returns a null-terminated string, must be free()'d when no longer
* needed. For errors, NULL is returned.
*/
char* mr_binary_to_uc_hex(const uint8_t* buf, size_t bytes)
char* dc_binary_to_uc_hex(const uint8_t* buf, size_t bytes)
{
char* hex = NULL;
int i;
@ -279,13 +279,13 @@ char* dc_mprintf(const char* format, ...)
va_end(argp);
if( char_cnt_without_zero < 0) {
va_end(argp_copy);
return safe_strdup("ErrFmt");
return dc_strdup("ErrFmt");
}
buf = malloc(char_cnt_without_zero+2 /* +1 would be enough, however, protect against off-by-one-errors */);
if( buf == NULL ) {
va_end(argp_copy);
return safe_strdup("ErrMem");
return dc_strdup("ErrMem");
}
vsnprintf(buf, char_cnt_without_zero+1, format, argp_copy);
@ -301,11 +301,11 @@ char* dc_mprintf(const char* format, ...)
va_end(argp);
if( sqlite_str == NULL ) {
return safe_strdup("ErrFmt"); /* error - the result must be free()'d */
return dc_strdup("ErrFmt"); /* error - the result must be free()'d */
}
/* as sqlite-strings must be freed using sqlite3_free() instead of a simple free(), convert it to a normal c-string */
c_string = safe_strdup(sqlite_str); /* exists on errors */
c_string = dc_strdup(sqlite_str); /* exists on errors */
sqlite3_free(sqlite_str);
return c_string; /* success - the result must be free()'d */
#endif /* /old implementation based upon sqlite3 */
@ -321,7 +321,7 @@ char* dc_mprintf(const char* format, ...)
*
* @return None.
*/
void mr_remove_cr_chars(char* buf)
void dc_remove_cr_chars(char* buf)
{
const char* p1 = buf; /* search for first `\r` */
while( *p1 ) {
@ -358,11 +358,11 @@ void mr_remove_cr_chars(char* buf)
*
* @return None.
*/
void mr_unify_lineends(char* buf)
void dc_unify_lineends(char* buf)
{
// this function may be extended to do more linefeed unification, do not mess up
// with mr_remove_cr_chars() which does only exactly removing CR.
mr_remove_cr_chars(buf);
// with dc_remove_cr_chars() which does only exactly removing CR.
dc_remove_cr_chars(buf);
}
@ -435,7 +435,7 @@ static size_t mr_utf8_strnlen(const char* s, size_t n)
}
void mr_truncate_n_unwrap_str(char* buf, int approx_characters, int do_unwrap)
void dc_truncate_n_unwrap_str(char* buf, int approx_characters, int do_unwrap)
{
/* Function unwraps the given string and removes unnecessary whitespace.
Function stops processing after approx_characters are processed.
@ -473,7 +473,7 @@ void mr_truncate_n_unwrap_str(char* buf, int approx_characters, int do_unwrap)
}
if( do_unwrap ) {
mr_remove_cr_chars(buf);
dc_remove_cr_chars(buf);
}
}
@ -497,7 +497,7 @@ void dc_truncate_str(char* buf, int approx_chars)
}
carray* mr_split_into_lines(const char* buf_terminated)
carray* dc_split_into_lines(const char* buf_terminated)
{
carray* lines = carray_new(1024);
@ -519,11 +519,11 @@ carray* mr_split_into_lines(const char* buf_terminated)
}
carray_add(lines, (void*)strndup(line_start, line_chars), &l_indx);
return lines; /* should be freed using mr_free_splitted_lines() */
return lines; /* should be freed using dc_free_splitted_lines() */
}
void mr_free_splitted_lines(carray* lines)
void dc_free_splitted_lines(carray* lines)
{
if( lines ) {
int i, cnt = carray_count(lines);
@ -541,7 +541,7 @@ char* dc_insert_breaks(const char* in, int break_every, const char* break_chars)
this is useful to allow lines being wrapped according to RFC 5322 (adds linebreaks before spaces) */
if( in == NULL || break_every <= 0 || break_chars == NULL ) {
return safe_strdup(in);
return dc_strdup(in);
}
int out_len = strlen(in), chars_added = 0;
@ -642,7 +642,7 @@ static time_t mkgmtime(struct tm * tmp) /* from mailcore2 */
dir = tmcomp(&mytm, &yourtm);
if (dir != 0) {
if (bits-- < 0) {
return MR_INVALID_TIMESTAMP;
return DC_INVALID_TIMESTAMP;
}
if (bits < 0)
--t;
@ -658,7 +658,7 @@ static time_t mkgmtime(struct tm * tmp) /* from mailcore2 */
}
time_t mr_timestamp_from_date(struct mailimf_date_time * date_time) /* from mailcore2 */
time_t dc_timestamp_from_date(struct mailimf_date_time * date_time) /* from mailcore2 */
{
struct tm tmval;
time_t timeval;
@ -694,7 +694,7 @@ time_t mr_timestamp_from_date(struct mailimf_date_time * date_time) /* from mail
}
long mr_gm2local_offset(void)
long dc_gm2local_offset(void)
{
/* returns the offset that must be _added_ to an UTC/GMT-time to create the localtime.
the function may return nagative values. */
@ -723,7 +723,7 @@ char* dc_timestamp_to_str(time_t wanted)
}
struct mailimap_date_time* mr_timestamp_to_mailimap_date_time(time_t timeval)
struct mailimap_date_time* dc_timestamp_to_mailimap_date_time(time_t timeval)
{
struct tm gmt;
struct tm lt;
@ -767,7 +767,7 @@ static time_t s_last_smeared_timestamp = 0;
#define MR_MAX_SECONDS_TO_LEND_FROM_FUTURE 5
time_t mr_create_smeared_timestamp__(void)
time_t dc_create_smeared_timestamp__(void)
{
time_t now = time(NULL);
time_t ret = now;
@ -782,19 +782,19 @@ time_t mr_create_smeared_timestamp__(void)
}
time_t mr_create_smeared_timestamps__(int count)
time_t dc_create_smeared_timestamps__(int count)
{
/* get a range to timestamps that can be used uniquely */
time_t now = time(NULL);
time_t start = now + MR_MIN(count, MR_MAX_SECONDS_TO_LEND_FROM_FUTURE) - count;
start = MR_MAX(s_last_smeared_timestamp+1, start);
time_t start = now + DC_MIN(count, MR_MAX_SECONDS_TO_LEND_FROM_FUTURE) - count;
start = DC_MAX(s_last_smeared_timestamp+1, start);
s_last_smeared_timestamp = start+(count-1);
return start;
}
time_t mr_smeared_time__(void)
time_t dc_smeared_time__(void)
{
/* function returns a corrected time(NULL) */
time_t now = time(NULL);
@ -854,7 +854,7 @@ char* dc_create_id(void)
}
char* mr_create_dummy_references_mid()
char* dc_create_dummy_references_mid()
{
char* msgid = dc_create_id(), *ret = NULL;
ret = dc_mprintf("Rf.%s@mr.thread", msgid);
@ -863,7 +863,7 @@ char* mr_create_dummy_references_mid()
}
char* mr_create_outgoing_rfc724_mid(const char* grpid, const char* from_addr)
char* dc_create_outgoing_rfc724_mid(const char* grpid, const char* from_addr)
{
/* Function generates a Message-ID that can be used for a new outgoing message.
- this function is called for all outgoing messages.
@ -894,7 +894,7 @@ char* mr_create_outgoing_rfc724_mid(const char* grpid, const char* from_addr)
}
char* mr_create_incoming_rfc724_mid(time_t message_timestamp, uint32_t contact_id_from, dc_array_t* contact_ids_to)
char* dc_create_incoming_rfc724_mid(time_t message_timestamp, uint32_t contact_id_from, dc_array_t* contact_ids_to)
{
/* Function generates a Message-ID for incoming messages that lacks one.
- normally, this function is not needed as incoming messages already have an ID
@ -902,7 +902,7 @@ char* mr_create_incoming_rfc724_mid(time_t message_timestamp, uint32_t contact_i
- when fetching the same message again, this function should generate the same Message-ID
*/
if( message_timestamp == MR_INVALID_TIMESTAMP || contact_ids_to == NULL || dc_array_get_cnt(contact_ids_to)==0 ) {
if( message_timestamp == DC_INVALID_TIMESTAMP || contact_ids_to == NULL || dc_array_get_cnt(contact_ids_to)==0 ) {
return NULL;
}
@ -922,7 +922,7 @@ char* mr_create_incoming_rfc724_mid(time_t message_timestamp, uint32_t contact_i
}
char* mr_extract_grpid_from_rfc724_mid(const char* mid)
char* dc_extract_grpid_from_rfc724_mid(const char* mid)
{
/* extract our group ID from Message-IDs as `Gr.12345678901.morerandom@domain.de`; "12345678901" is the wanted ID in this example. */
int success = 0;
@ -933,7 +933,7 @@ char* mr_extract_grpid_from_rfc724_mid(const char* mid)
goto cleanup;
}
grpid = safe_strdup(&mid[3]);
grpid = dc_strdup(&mid[3]);
p1 = strchr(grpid, '.');
if( p1 == NULL ) {
@ -955,13 +955,13 @@ cleanup:
}
char* mr_extract_grpid_from_rfc724_mid_list(const clist* list)
char* dc_extract_grpid_from_rfc724_mid_list(const clist* list)
{
clistiter* cur;
if( list ) {
for( cur = clist_begin(list); cur!=NULL ; cur=clist_next(cur) ) {
const char* mid = clist_content(cur);
char* grpid = mr_extract_grpid_from_rfc724_mid(mid);
char* grpid = dc_extract_grpid_from_rfc724_mid(mid);
if( grpid ) {
return grpid;
}
@ -977,7 +977,7 @@ char* mr_extract_grpid_from_rfc724_mid_list(const clist* list)
******************************************************************************/
int mr_file_exist(const char* pathNfilename)
int dc_file_exist(const char* pathNfilename)
{
struct stat st;
if( stat(pathNfilename, &st) == 0 ) {
@ -989,7 +989,7 @@ int mr_file_exist(const char* pathNfilename)
}
uint64_t mr_get_filebytes(const char* pathNfilename)
uint64_t dc_get_filebytes(const char* pathNfilename)
{
struct stat st;
if( stat(pathNfilename, &st) == 0 ) {
@ -1001,7 +1001,7 @@ uint64_t mr_get_filebytes(const char* pathNfilename)
}
char* mr_get_filename(const char* pathNfilename)
char* dc_get_filename(const char* pathNfilename)
{
const char* p = strrchr(pathNfilename, '/');
if( p==NULL ) {
@ -1010,15 +1010,15 @@ char* mr_get_filename(const char* pathNfilename)
if( p ) {
p++;
return safe_strdup(p);
return dc_strdup(p);
}
else {
return safe_strdup(pathNfilename);
return dc_strdup(pathNfilename);
}
}
int mr_delete_file(const char* pathNfilename, dc_context_t* log/*may be NULL*/)
int dc_delete_file(const char* pathNfilename, dc_context_t* log/*may be NULL*/)
{
if( pathNfilename==NULL ) {
return 0;
@ -1033,7 +1033,7 @@ int mr_delete_file(const char* pathNfilename, dc_context_t* log/*may be NULL*/)
}
int mr_copy_file(const char* src, const char* dest, dc_context_t* log/*may be NULL*/)
int dc_copy_file(const char* src, const char* dest, dc_context_t* log/*may be NULL*/)
{
int success = 0, fd_src = -1, fd_dest = -1;
#define MR_COPY_BUF_SIZE 4096
@ -1066,7 +1066,7 @@ int mr_copy_file(const char* src, const char* dest, dc_context_t* log/*may be NU
/* not a single byte copied -> check if the source is empty, too */
close(fd_src);
fd_src = -1;
if( mr_get_filebytes(src)!=0 ) {
if( dc_get_filebytes(src)!=0 ) {
dc_log_error(log, 0, "Different size information for \"%s\".", bytes_read, dest);
goto cleanup;
}
@ -1081,7 +1081,7 @@ cleanup:
}
int mr_create_folder(const char* pathNfilename, dc_context_t* log)
int dc_create_folder(const char* pathNfilename, dc_context_t* log)
{
struct stat st;
if (stat(pathNfilename, &st) == -1) {
@ -1100,28 +1100,28 @@ char* dc_get_filesuffix_lc(const char* pathNfilename)
const char* p = strrchr(pathNfilename, '.'); /* use the last point, we're interesting the "main" type */
if( p ) {
p++;
return mr_strlower(p); /* in contrast to mr_split_filename() we return the lowercase suffix */
return dc_strlower(p); /* in contrast to dc_split_filename() we return the lowercase suffix */
}
}
return NULL;
}
void mr_split_filename(const char* pathNfilename, char** ret_basename, char** ret_all_suffixes_incl_dot)
void dc_split_filename(const char* pathNfilename, char** ret_basename, char** ret_all_suffixes_incl_dot)
{
/* splits a filename into basename and all suffixes, eg. "/path/foo.tar.gz" is split into "foo.tar" and ".gz",
(we use the _last_ dot which allows the usage inside the filename which are very usual;
maybe the detection could be more intelligent, however, for the moment, it is just file)
- if there is no suffix, the returned suffix string is empty, eg. "/path/foobar" is split into "foobar" and ""
- the case of the returned suffix is preserved; this is to allow reconstruction of (similar) names */
char* basename = mr_get_filename(pathNfilename), *suffix;
char* basename = dc_get_filename(pathNfilename), *suffix;
char* p1 = strrchr(basename, '.');
if( p1 ) {
suffix = safe_strdup(p1);
suffix = dc_strdup(p1);
*p1 = 0;
}
else {
suffix = safe_strdup(NULL);
suffix = dc_strdup(NULL);
}
/* return the given values */
@ -1151,9 +1151,9 @@ char* dc_get_fine_pathNfilename(const char* folder, const char* desired_filename
struct stat st;
int i;
filenameNsuffix = safe_strdup(desired_filenameNsuffix__);
filenameNsuffix = dc_strdup(desired_filenameNsuffix__);
mr_validate_filename(filenameNsuffix);
mr_split_filename(filenameNsuffix, &basename, &dotNSuffix);
dc_split_filename(filenameNsuffix, &basename, &dotNSuffix);
for( i = 0; i < 1000 /*no deadlocks, please*/; i++ ) {
if( i ) {

87
src/dc_tools.h
View file

@ -24,8 +24,8 @@
no references to dc_context_t and other "larger" classes here. */
#ifndef __MRTOOLS_H__
#define __MRTOOLS_H__
#ifndef __DC_TOOLS_H__
#define __DC_TOOLS_H__
#ifdef __cplusplus
extern "C" {
#endif
@ -37,85 +37,86 @@ extern "C" {
/*** library-private **********************************************************/
/* math tools */
int mr_exactly_one_bit_set (int v);
int dc_exactly_one_bit_set (int v);
/* string tools */
#define DC_EDITORIAL_OPEN "["
#define DC_EDITORIAL_CLOSE "]"
#define DC_EDITORIAL_ELLIPSE DC_EDITORIAL_OPEN "..." DC_EDITORIAL_CLOSE
char* safe_strdup (const char*); /* safe_strdup() returns empty string if NULL is given, never returns NULL (exists on errors) */
char* strdup_keep_null (const char*); /* strdup(NULL) is undefined, safe_strdup_keep_null(NULL) returns NULL in this case */
int atoi_null_is_0 (const char*);
void mr_ltrim (char*);
void mr_rtrim (char*);
void mr_trim (char*);
char* mr_strlower (const char*); /* the result must be free()'d */
void mr_strlower_in_place (char*);
char* dc_strdup (const char*); /* dc_strdup() returns empty string if NULL is given, never returns NULL (exits on errors) */
char* dc_strdup_keep_null (const char*); /* strdup(NULL) is undefined, safe_strdup_keep_null(NULL) returns NULL in this case */
int dc_atoi_null_is_0 (const char*);
void dc_ltrim (char*);
void dc_rtrim (char*);
void dc_trim (char*);
char* dc_strlower (const char*); /* the result must be free()'d */
void dc_strlower_in_place (char*);
int dc_str_replace (char** haystack, const char* needle, const char* replacement);
int mr_str_contains (const char* haystack, const char* needle);
int dc_str_contains (const char* haystack, const char* needle);
char* dc_null_terminate (const char*, int bytes); /* the result must be free()'d */
char* dc_mprintf (const char* format, ...); /* The result must be free()'d. */
char* mr_binary_to_uc_hex (const uint8_t* buf, size_t bytes);
void mr_remove_cr_chars (char*); /* remove all \r characters from string */
void mr_unify_lineends (char*);
char* dc_binary_to_uc_hex (const uint8_t* buf, size_t bytes);
void dc_remove_cr_chars (char*); /* remove all \r characters from string */
void dc_unify_lineends (char*);
void dc_replace_bad_utf8_chars (char*); /* replace bad UTF-8 characters by sequences of `_` (to avoid problems in filenames, we do not use eg. `?`) the function is useful if strings are unexpectingly encoded eg. as ISO-8859-1 */
void dc_truncate_str (char*, int approx_characters);
void mr_truncate_n_unwrap_str (char*, int approx_characters, int do_unwrap);
carray* mr_split_into_lines (const char* buf_terminated); /* split string into lines*/
void mr_free_splitted_lines (carray* lines);
void dc_truncate_n_unwrap_str (char*, int approx_characters, int do_unwrap);
carray* dc_split_into_lines (const char* buf_terminated); /* split string into lines*/
void dc_free_splitted_lines (carray* lines);
char* dc_insert_breaks (const char*, int break_every, const char* break_chars); /* insert a break every n characters, the return must be free()'d */
char* encode_base64 (const char * in, int len); /* prototype, from libetpan/src/data-types/base64.h which cannot be included without adding libetpan/src/... to the include-search-paths, which would result in double-file-name-errors */
// from libetpan/src/data-types/base64.h (which cannot be included without adding libetpan/src/... to the include-search-paths, which would result in double-file-name-errors, so, for now, we use this hack)
char* encode_base64 (const char * in, int len);
/* clist tools */
void clist_free_content (const clist*); /* calls free() for each item content */
int clist_search_string_nocase (const clist*, const char* str);
/* date/time tools */
#define MR_INVALID_TIMESTAMP (-1)
time_t mr_timestamp_from_date (struct mailimf_date_time * date_time); /* the result is UTC or MR_INVALID_TIMESTAMP */
#define DC_INVALID_TIMESTAMP (-1)
time_t dc_timestamp_from_date (struct mailimf_date_time * date_time); /* the result is UTC or DC_INVALID_TIMESTAMP */
char* dc_timestamp_to_str (time_t); /* the return value must be free()'d */
struct mailimap_date_time* mr_timestamp_to_mailimap_date_time (time_t);
long mr_gm2local_offset (void);
struct mailimap_date_time* dc_timestamp_to_mailimap_date_time (time_t);
long dc_gm2local_offset (void);
/* timesmearing */
time_t mr_smeared_time__ (void);
time_t mr_create_smeared_timestamp__ (void);
time_t mr_create_smeared_timestamps__(int count);
time_t dc_smeared_time__ (void);
time_t dc_create_smeared_timestamp__ (void);
time_t dc_create_smeared_timestamps__(int count);
/* Message-ID tools */
#define DC_CREATE_ID_LEN 11
char* dc_create_id (void);
char* mr_create_dummy_references_mid (void);
char* mr_create_incoming_rfc724_mid (time_t message_timestamp, uint32_t contact_id_from, dc_array_t* contact_ids_to);
char* mr_create_outgoing_rfc724_mid (const char* grpid, const char* addr);
char* mr_extract_grpid_from_rfc724_mid (const char* rfc724_mid);
char* mr_extract_grpid_from_rfc724_mid_list(const clist* rfc724_mid_list);
char* dc_create_dummy_references_mid (void);
char* dc_create_incoming_rfc724_mid (time_t message_timestamp, uint32_t contact_id_from, dc_array_t* contact_ids_to);
char* dc_create_outgoing_rfc724_mid (const char* grpid, const char* addr);
char* dc_extract_grpid_from_rfc724_mid (const char* rfc724_mid);
char* dc_extract_grpid_from_rfc724_mid_list(const clist* rfc724_mid_list);
/* file tools */
int mr_file_exist (const char* pathNfilename);
uint64_t mr_get_filebytes (const char* pathNfilename);
char* mr_get_filename (const char* pathNfilename); /* the return value must be free()'d */
int mr_delete_file (const char* pathNFilename, dc_context_t* log);
int mr_copy_file (const char* src_pathNFilename, const char* dest_pathNFilename, dc_context_t* log);
int mr_create_folder (const char* pathNfilename, dc_context_t* log);
int dc_file_exist (const char* pathNfilename);
uint64_t dc_get_filebytes (const char* pathNfilename);
char* dc_get_filename (const char* pathNfilename); /* the return value must be free()'d */
int dc_delete_file (const char* pathNFilename, dc_context_t* log);
int dc_copy_file (const char* src_pathNFilename, const char* dest_pathNFilename, dc_context_t* log);
int dc_create_folder (const char* pathNfilename, dc_context_t* log);
int dc_write_file (const char* pathNfilename, const void* buf, size_t buf_bytes, dc_context_t* log);
int dc_read_file (const char* pathNfilename, void** buf, size_t* buf_bytes, dc_context_t* log);
char* dc_get_filesuffix_lc (const char* pathNfilename); /* the returned suffix is lower-case */
void mr_split_filename (const char* pathNfilename, char** ret_basename, char** ret_all_suffixes_incl_dot); /* the case of the suffix is preserved! */
void dc_split_filename (const char* pathNfilename, char** ret_basename, char** ret_all_suffixes_incl_dot); /* the case of the suffix is preserved! */
int dc_get_filemeta (const void* buf, size_t buf_bytes, uint32_t* ret_width, uint32_t *ret_height);
char* dc_get_fine_pathNfilename (const char* folder, const char* desired_name);
/* macros */
#define MR_QUOTEHELPER(name) #name
#define DC_STRINGIFY(macro) MR_QUOTEHELPER(macro)
#define MR_MIN(X, Y) (((X) < (Y))? (X) : (Y))
#define MR_MAX(X, Y) (((X) > (Y))? (X) : (Y))
#define DC_QUOTEHELPER(name) #name
#define DC_STRINGIFY(macro) DC_QUOTEHELPER(macro)
#define DC_MIN(X, Y) (((X) < (Y))? (X) : (Y))
#define DC_MAX(X, Y) (((X) > (Y))? (X) : (Y))
#ifdef __cplusplus
} /* /extern "C" */
#endif
#endif /* __MRTOOLS_H__ */
#endif /* __DC_TOOLS_H__ */