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

resilience: initialize all parameters to zero

Browse source
This commit is contained in:
B. Petersen 2018-07-06 14:45:54 +02:00
parent e6eb4eff3e
commit bc1fda3050
27 changed files with 558 additions and 445 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/dc_aheader.c
View file

@ -168,8 +168,11 @@ int dc_aheader_set_from_string(dc_aheader_t* aheader, const char* header_str__)
(b) for the key, non-base64-characters are ignored and
(c) for parsing, we ignore `\r\n` as well as tabs for spaces */
#define AHEADER_WS "\t\r\n "
char *header_str = NULL;
char *p, *beg_attr_name, *after_attr_name, *beg_attr_value;
char* header_str = NULL;
char* p = NULL;
char* beg_attr_name = NULL;
char* after_attr_name = NULL;
char* beg_attr_value = NULL;
int success = 0;
dc_aheader_empty(aheader);
@ -271,7 +274,7 @@ void dc_aheader_unref(dc_aheader_t* aheader)
*/
dc_aheader_t* dc_aheader_new_from_imffields(const char* wanted_from, const struct mailimf_fields* header)
{
clistiter* cur;
clistiter* cur = NULL;
dc_aheader_t* fine_header = NULL;
if (wanted_from == NULL || header == NULL) {

3
src/dc_apeerstate.c
View file

@ -482,7 +482,8 @@ void dc_apeerstate_apply_gossip(dc_apeerstate_t* peerstate, const dc_aheader_t*
int dc_apeerstate_recalc_fingerprint(dc_apeerstate_t* peerstate)
{
int success = 0;
char* old_public_fingerprint = NULL, *old_gossip_fingerprint = NULL;
char* old_public_fingerprint = NULL;
char* old_gossip_fingerprint = NULL;
if (peerstate == NULL) {
goto cleanup;

9
src/dc_array.c
View file

@ -38,7 +38,7 @@
*/
dc_array_t* dc_array_new(dc_context_t* context, size_t initsize)
{
dc_array_t* array;
dc_array_t* array = NULL;
array = (dc_array_t*) malloc(sizeof(dc_array_t));
if (array==NULL) {
@ -93,13 +93,11 @@ void dc_array_unref(dc_array_t* array)
*/
void dc_array_free_ptr(dc_array_t* array)
{
size_t i;
if (array==NULL || array->magic != DC_ARRAY_MAGIC) {
return;
}
for (i = 0; i < array->count; i++) {
for (size_t i = 0; i < array->count; i++) {
free((void*)array->array[i]);
array->array[i] = 0;
}
@ -135,7 +133,8 @@ dc_array_t* dc_array_duplicate(const dc_array_t* array)
static int cmp_intptr_t(const void* p1, const void* p2)
{
uintptr_t v1 = *(uintptr_t*)p1, v2 = *(uintptr_t*)p2;
uintptr_t v1 = *(uintptr_t*)p1;
uintptr_t v2 = *(uintptr_t*)p2;
return (v1<v2)? -1 : ((v1>v2)? 1 : 0); /* CAVE: do not use v1-v2 as the uintptr_t may be 64bit and the return value may be 32bit only... */
}

3
src/dc_chatlist.c
View file

@ -301,7 +301,8 @@ int dc_chatlist_load_from_db(dc_chatlist_t* chatlist, int listflags, const char*
int success = 0;
int add_archived_link_item = 0;
sqlite3_stmt* stmt = NULL;
char* strLikeCmd = NULL, *query = NULL;
char* strLikeCmd = NULL;
char* query = NULL;
if (chatlist == NULL || chatlist->magic != DC_CHATLIST_MAGIC || chatlist->context == NULL) {
goto cleanup;

166
src/dc_configure.c
View file

@ -40,7 +40,7 @@ static char* read_autoconf_file(dc_context_t* context, const char* url)
char* filecontent = NULL;
dc_log_info(context, 0, "Testing %s ...", url);
filecontent = (char*)context->cb(context, DC_EVENT_HTTP_GET, (uintptr_t)url, 0);
if (filecontent == NULL) {
if (filecontent==NULL) {
dc_log_info(context, 0, "Can't read file."); /* this is not a warning or an error, we're just testing */
return NULL;
}
@ -88,7 +88,7 @@ typedef struct moz_autoconfigure_t
static void moz_autoconfigure_starttag_cb(void* userdata, const char* tag, char** attr)
{
moz_autoconfigure_t* moz_ac = (moz_autoconfigure_t*)userdata;
const char* p1;
const char* p1 = NULL;
if (strcmp(tag, "incomingserver")==0) {
moz_ac->tag_server = (moz_ac->out_imap_set==0 && (p1=dc_attr_find(attr, "type"))!=NULL && strcasecmp(p1, "imap")==0)? MOZ_SERVER_IMAP : 0;
@ -98,16 +98,24 @@ static void moz_autoconfigure_starttag_cb(void* userdata, const char* tag, char*
moz_ac->tag_server = moz_ac->out_smtp_set==0? MOZ_SERVER_SMTP : 0;
moz_ac->tag_config = 0;
}
else if (strcmp(tag, "hostname")==0) { moz_ac->tag_config = MOZ_HOSTNAME; }
else if (strcmp(tag, "port")==0 ) { moz_ac->tag_config = MOZ_PORT; }
else if (strcmp(tag, "sockettype")==0) { moz_ac->tag_config = MOZ_SOCKETTYPE; }
else if (strcmp(tag, "username")==0) { moz_ac->tag_config = MOZ_USERNAME; }
else if (strcmp(tag, "hostname")==0) {
moz_ac->tag_config = MOZ_HOSTNAME;
}
else if (strcmp(tag, "port")==0 ) {
moz_ac->tag_config = MOZ_PORT;
}
else if (strcmp(tag, "sockettype")==0) {
moz_ac->tag_config = MOZ_SOCKETTYPE;
}
else if (strcmp(tag, "username")==0) {
moz_ac->tag_config = MOZ_USERNAME;
}
}
static void moz_autoconfigure_text_cb(void* userdata, const char* text, int len)
{
moz_autoconfigure_t* moz_ac = (moz_autoconfigure_t*)userdata;
moz_autoconfigure_t* moz_ac = (moz_autoconfigure_t*)userdata;
char* val = dc_strdup(text);
dc_trim(val);
@ -115,11 +123,25 @@ static void moz_autoconfigure_text_cb(void* userdata, const char* text, int len)
dc_str_replace(&val, "%EMAILLOCALPART%", moz_ac->in_emaillocalpart);
dc_str_replace(&val, "%EMAILDOMAIN%", moz_ac->in_emaildomain);
if (moz_ac->tag_server == MOZ_SERVER_IMAP) {
if (moz_ac->tag_server==MOZ_SERVER_IMAP)
{
switch (moz_ac->tag_config) {
case MOZ_HOSTNAME: free(moz_ac->out->mail_server); moz_ac->out->mail_server = val; val = NULL; break;
case MOZ_PORT: moz_ac->out->mail_port = atoi(val); break;
case MOZ_USERNAME: free(moz_ac->out->mail_user); moz_ac->out->mail_user = val; val = NULL; break;
case MOZ_HOSTNAME:
free(moz_ac->out->mail_server);
moz_ac->out->mail_server = val;
val = NULL;
break;
case MOZ_PORT:
moz_ac->out->mail_port = atoi(val);
break;
case MOZ_USERNAME:
free(moz_ac->out->mail_user);
moz_ac->out->mail_user = val;
val = NULL;
break;
case MOZ_SOCKETTYPE:
if (strcasecmp(val, "ssl")==0) { moz_ac->out->server_flags |=DC_LP_IMAP_SOCKET_SSL; }
if (strcasecmp(val, "starttls")==0) { moz_ac->out->server_flags |=DC_LP_IMAP_SOCKET_STARTTLS; }
@ -127,11 +149,25 @@ static void moz_autoconfigure_text_cb(void* userdata, const char* text, int len)
break;
}
}
else if (moz_ac->tag_server == MOZ_SERVER_SMTP) {
else if (moz_ac->tag_server==MOZ_SERVER_SMTP)
{
switch (moz_ac->tag_config) {
case MOZ_HOSTNAME: free(moz_ac->out->send_server); moz_ac->out->send_server = val; val = NULL; break;
case MOZ_PORT: moz_ac->out->send_port = atoi(val); break;
case MOZ_USERNAME: free(moz_ac->out->send_user); moz_ac->out->send_user = val; val = NULL; break;
case MOZ_HOSTNAME:
free(moz_ac->out->send_server);
moz_ac->out->send_server = val;
val = NULL;
break;
case MOZ_PORT:
moz_ac->out->send_port = atoi(val);
break;
case MOZ_USERNAME:
free(moz_ac->out->send_user);
moz_ac->out->send_user = val;
val = NULL;
break;
case MOZ_SOCKETTYPE:
if (strcasecmp(val, "ssl")==0) { moz_ac->out->server_flags |=DC_LP_SMTP_SOCKET_SSL; }
if (strcasecmp(val, "starttls")==0) { moz_ac->out->server_flags |=DC_LP_SMTP_SOCKET_STARTTLS; }
@ -176,7 +212,7 @@ static dc_loginparam_t* moz_autoconfigure(dc_context_t* context, const char* url
}
moz_ac.in = param_in;
moz_ac.in_emaillocalpart = dc_strdup(param_in->addr); char* p = strchr(moz_ac.in_emaillocalpart, '@'); if (p == NULL) { goto cleanup; } *p = 0;
moz_ac.in_emaillocalpart = dc_strdup(param_in->addr); char* p = strchr(moz_ac.in_emaillocalpart, '@'); if (p==NULL) { goto cleanup; } *p = 0;
moz_ac.in_emaildomain = dc_strdup(p+1);
moz_ac.out = dc_loginparam_new();
@ -186,10 +222,10 @@ static dc_loginparam_t* moz_autoconfigure(dc_context_t* context, const char* url
dc_saxparser_set_text_handler(&saxparser, moz_autoconfigure_text_cb);
dc_saxparser_parse (&saxparser, xml_raw);
if (moz_ac.out->mail_server == NULL
|| moz_ac.out->mail_port == 0
|| moz_ac.out->send_server == NULL
|| moz_ac.out->send_port == 0)
if (moz_ac.out->mail_server==NULL
|| moz_ac.out->mail_port ==0
|| moz_ac.out->send_server==NULL
|| moz_ac.out->send_port ==0)
{
{ char* r = dc_loginparam_get_readable(moz_ac.out); dc_log_warning(context, 0, "Bad or incomplete autoconfig: %s", r); free(r); }
@ -282,17 +318,19 @@ static void outlk_autodiscover_endtag_cb(void* userdata, const char* tag)
ssl_on = (outlk_ad->config[OUTLK_SSL] && strcasecmp(outlk_ad->config[OUTLK_SSL], "on")==0),
ssl_off = (outlk_ad->config[OUTLK_SSL] && strcasecmp(outlk_ad->config[OUTLK_SSL], "off")==0);
if (strcasecmp(outlk_ad->config[OUTLK_TYPE], "imap")==0 && outlk_ad->out_imap_set==0) {
if (strcasecmp(outlk_ad->config[OUTLK_TYPE], "imap")==0 && outlk_ad->out_imap_set==0)
{
outlk_ad->out->mail_server = dc_strdup_keep_null(outlk_ad->config[OUTLK_SERVER]);
outlk_ad->out->mail_port = port;
if (ssl_on) { outlk_ad->out->server_flags |= DC_LP_IMAP_SOCKET_SSL; }
if (ssl_on) { outlk_ad->out->server_flags |= DC_LP_IMAP_SOCKET_SSL; }
else if (ssl_off) { outlk_ad->out->server_flags |= DC_LP_IMAP_SOCKET_PLAIN; }
outlk_ad->out_imap_set = 1;
}
else if (strcasecmp(outlk_ad->config[OUTLK_TYPE], "smtp")==0 && outlk_ad->out_smtp_set==0) {
else if (strcasecmp(outlk_ad->config[OUTLK_TYPE], "smtp")==0 && outlk_ad->out_smtp_set==0)
{
outlk_ad->out->send_server = dc_strdup_keep_null(outlk_ad->config[OUTLK_SERVER]);
outlk_ad->out->send_port = port;
if (ssl_on) { outlk_ad->out->server_flags |= DC_LP_SMTP_SOCKET_SSL; }
if (ssl_on) { outlk_ad->out->server_flags |= DC_LP_SMTP_SOCKET_SSL; }
else if (ssl_off) { outlk_ad->out->server_flags |= DC_LP_SMTP_SOCKET_PLAIN; }
outlk_ad->out_smtp_set = 1;
}
@ -333,17 +371,18 @@ static dc_loginparam_t* outlk_autodiscover(dc_context_t* context, const char* ur
url = dc_strdup(outlk_ad.config[OUTLK_REDIRECTURL]);
dc_loginparam_unref(outlk_ad.out);
outlk_clean_config(&outlk_ad);
free(xml_raw); xml_raw = NULL;
free(xml_raw);
xml_raw = NULL;
}
else {
break;
}
}
if (outlk_ad.out->mail_server == NULL
|| outlk_ad.out->mail_port == 0
|| outlk_ad.out->send_server == NULL
|| outlk_ad.out->send_port == 0)
if (outlk_ad.out->mail_server==NULL
|| outlk_ad.out->mail_port ==0
|| outlk_ad.out->send_server==NULL
|| outlk_ad.out->send_port ==0)
{
{ char* r = dc_loginparam_get_readable(outlk_ad.out); dc_log_warning(context, 0, "Bad or incomplete autoconfig: %s", r); free(r); }
dc_loginparam_unref(outlk_ad.out); /* autoconfig failed for the given URL */
@ -366,7 +405,8 @@ cleanup:
void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
{
int success = 0, i;
int success = 0;
int i = 0;
int imap_connected_here = 0;
int smtp_connected_here = 0;
int ongoing_allocated_here = 0;
@ -376,7 +416,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
char* param_addr_urlencoded = NULL;
dc_loginparam_t* param_autoconfig = NULL;
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
goto cleanup;
}
@ -419,7 +459,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
dc_loginparam_read(param, context->sql, "");
if (param->addr == NULL) {
if (param->addr==NULL) {
dc_log_error(context, 0, "Please enter the email address.");
goto cleanup;
}
@ -436,7 +476,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->mail_pw == NULL) {
if (param->mail_pw==NULL) {
param->mail_pw = dc_strdup(NULL);
}
@ -446,14 +486,14 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
/* 2. Autoconfig
**************************************************************************/
if (param->mail_server == NULL
&& param->mail_port == 0
/*&&param->mail_user == NULL -- the user can enter a loginname which is used by autoconfig then */
&& param->send_server == NULL
&& param->send_port == 0
&& param->send_user == NULL
/*&&param->send_pw == NULL -- the password cannot be auto-configured and is no criterion for autoconfig or not */
&& param->server_flags == 0)
if (param->mail_server ==NULL
&& param->mail_port ==0
/*&&param->mail_user ==NULL -- the user can enter a loginname which is used by autoconfig then */
&& param->send_server ==NULL
&& param->send_port ==0
&& param->send_user ==NULL
/*&&param->send_pw ==NULL -- the password cannot be auto-configured and is no criterion for autoconfig or not */
&& param->server_flags==0)
{
/* A. Search configurations from the domain used in the email-address */
for (i = 0; i <= 1; i++) {
@ -535,35 +575,35 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
#define TYPICAL_SMTP_STARTTLS_PORT 587 /* also used very often, SSL:STARTTLS is maybe 50:50 */
#define TYPICAL_SMTP_PLAIN_PORT 25
if (param->mail_server == NULL) {
if (param->mail_server==NULL) {
param->mail_server = dc_mprintf("imap.%s", param_domain);
}
if (param->mail_port == 0) {
if (param->mail_port==0) {
param->mail_port = (param->server_flags&(DC_LP_IMAP_SOCKET_STARTTLS|DC_LP_IMAP_SOCKET_PLAIN))? TYPICAL_IMAP_STARTTLS_PORT : TYPICAL_IMAP_SSL_PORT;
}
if (param->mail_user == NULL) {
if (param->mail_user==NULL) {
param->mail_user = dc_strdup(param->addr);
}
if (param->send_server == NULL && param->mail_server) {
if (param->send_server==NULL && param->mail_server) {
param->send_server = dc_strdup(param->mail_server);
if (strncmp(param->send_server, "imap.", 5)==0) {
memcpy(param->send_server, "smtp", 4);
}
}
if (param->send_port == 0) {
if (param->send_port==0) {
param->send_port = (param->server_flags&DC_LP_SMTP_SOCKET_STARTTLS)? TYPICAL_SMTP_STARTTLS_PORT :
((param->server_flags&DC_LP_SMTP_SOCKET_PLAIN)? TYPICAL_SMTP_PLAIN_PORT : TYPICAL_SMTP_SSL_PORT);
}
if (param->send_user == NULL && param->mail_user) {
if (param->send_user==NULL && param->mail_user) {
param->send_user = dc_strdup(param->mail_user);
}
if (param->send_pw == NULL && param->mail_pw) {
if (param->send_pw==NULL && param->mail_pw) {
param->send_pw = dc_strdup(param->mail_pw);
}
@ -588,16 +628,16 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
/* do we have a complete configuration? */
if (param->addr == NULL
|| param->mail_server == NULL
|| param->mail_port == 0
|| param->mail_user == NULL
|| param->mail_pw == NULL
|| param->send_server == NULL
|| param->send_port == 0
|| param->send_user == NULL
|| param->send_pw == NULL
|| param->server_flags == 0)
if (param->addr ==NULL
|| param->mail_server ==NULL
|| param->mail_port ==0
|| param->mail_user ==NULL
|| param->mail_pw ==NULL
|| param->send_server ==NULL
|| param->send_port ==0
|| param->send_user ==NULL
|| param->send_pw ==NULL
|| param->server_flags==0)
{
dc_log_error(context, 0, "Account settings incomplete.");
goto cleanup;
@ -726,7 +766,7 @@ void dc_configure(dc_context_t* context)
*/
int dc_is_configured(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
return 0;
}
@ -744,11 +784,11 @@ int dc_is_configured(dc_context_t* context)
*/
int dc_alloc_ongoing(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
return 0;
}
if (context->ongoing_running || context->shall_stop_ongoing == 0) {
if (context->ongoing_running || context->shall_stop_ongoing==0) {
dc_log_warning(context, 0, "There is already another ongoing process running.");
return 0;
}
@ -765,7 +805,7 @@ int dc_alloc_ongoing(dc_context_t* context)
*/
void dc_free_ongoing(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
return;
}
@ -800,7 +840,7 @@ void dc_free_ongoing(dc_context_t* context)
*/
void dc_stop_ongoing_process(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
return;
}

45
src/dc_e2ee.c
View file

@ -278,24 +278,24 @@ int dc_ensure_secret_key_exists(dc_context_t* context)
{
/* normally, the key is generated as soon as the first mail is send
(this is to gain some extra-random-seed by the message content and the timespan between program start and message sending) */
int success = 0;
int success = 0;
dc_key_t* public_key = dc_key_new();
char* self_addr = NULL;
char* self_addr = NULL;
if (context==NULL || context->magic != DC_CONTEXT_MAGIC || public_key==NULL) {
goto cleanup;
}
if ((self_addr=dc_sqlite3_get_config(context->sql, "configured_addr", NULL))==NULL) {
dc_log_warning(context, 0, "Cannot ensure secret key if context is not configured.");
goto cleanup;
}
if ((self_addr=dc_sqlite3_get_config(context->sql, "configured_addr", NULL))==NULL) {
dc_log_warning(context, 0, "Cannot ensure secret key if context is not configured.");
goto cleanup;
}
if (!load_or_generate_self_public_key(context, public_key, self_addr, NULL/*no random text data for seeding available*/)) {
goto cleanup;
}
if (!load_or_generate_self_public_key(context, public_key, self_addr, NULL/*no random text data for seeding available*/)) {
goto cleanup;
}
success = 1;
success = 1;
cleanup:
dc_key_unref(public_key);
@ -315,14 +315,15 @@ void dc_e2ee_encrypt(dc_context_t* context, const clist* recipients_addr,
int min_verified,
struct mailmime* in_out_message, dc_e2ee_helper_t* helper)
{
int col = 0, do_encrypt = 0;
int col = 0;
int do_encrypt = 0;
dc_aheader_t* autocryptheader = dc_aheader_new();
struct mailimf_fields* imffields_unprotected = NULL; /*just a pointer into mailmime structure, must not be freed*/
struct mailimf_fields* imffields_unprotected = NULL; /*just a pointer into mailmime structure, must not be freed*/
dc_keyring_t* keyring = dc_keyring_new();
dc_key_t* sign_key = dc_key_new();
MMAPString* plain = mmap_string_new("");
char* ctext = NULL;
size_t ctext_bytes = 0;
MMAPString* plain = mmap_string_new("");
char* ctext = NULL;
size_t ctext_bytes = 0;
dc_array_t* peerstates = dc_array_new(NULL, 10);
if (helper) { memset(helper, 0, sizeof(dc_e2ee_helper_t)); }
@ -536,7 +537,8 @@ void dc_e2ee_thanks(dc_e2ee_helper_t* helper)
static int has_decrypted_pgp_armor(const char* str__, int str_bytes)
{
const unsigned char *str_end = (const unsigned char*)str__+str_bytes, *p=(const unsigned char*)str__;
const unsigned char* str_end = (const unsigned char*)str__+str_bytes;
const unsigned char* p=(const unsigned char*)str__;
while (p < str_end) {
if (*p > ' ') {
break;
@ -558,7 +560,7 @@ static int decrypt_part(dc_context_t* context,
dc_hash_t* ret_valid_signatures,
struct mailmime** ret_decrypted_mime)
{
struct mailmime_data* mime_data;
struct mailmime_data* mime_data = NULL;
int mime_transfer_encoding = MAILMIME_MECHANISM_BINARY;
char* transfer_decoding_buffer = NULL; /* mmap_string_unref()'d if set */
const char* decoded_data = NULL; /* must not be free()'d */
@ -663,8 +665,8 @@ static int decrypt_recursive(dc_context_t* context,
struct mailimf_fields** ret_gossip_headers,
int* ret_has_unencrypted_parts)
{
struct mailmime_content* ct;
clistiter* cur;
struct mailmime_content* ct = NULL;
clistiter* cur = NULL;
if (context == NULL || mime == NULL) {
return 0;
@ -725,7 +727,7 @@ static int decrypt_recursive(dc_context_t* context,
static dc_hash_t* update_gossip_peerstates(dc_context_t* context, time_t message_time, struct mailimf_fields* imffields, const struct mailimf_fields* gossip_headers)
{
clistiter* cur1;
clistiter* cur1 = NULL;
dc_hash_t* recipients = NULL;
dc_hash_t* gossipped_addr = NULL;
@ -801,7 +803,8 @@ void dc_e2ee_decrypt(dc_context_t* context, struct mailmime* in_out_message,
dc_aheader_t* autocryptheader = NULL;
time_t message_time = 0;
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
char* from = NULL, *self_addr = NULL;
char* from = NULL;
char* self_addr = NULL;
dc_keyring_t* private_keyring = dc_keyring_new();
dc_keyring_t* public_keyring_for_validate = dc_keyring_new();
struct mailimf_fields* gossip_headers = NULL;

79
src/dc_imex.c
View file

@ -303,9 +303,11 @@ cleanup:
char* dc_decrypt_setup_file(dc_context_t* context, const char* passphrase, const char* filecontent)
{
char* fc_buf = NULL;
const char *fc_headerline = NULL, *fc_base64 = NULL;
const char* fc_headerline = NULL;
const char* fc_base64 = NULL;
char* binary = NULL;
size_t binary_bytes = 0, indx = 0;
size_t binary_bytes = 0;
size_t indx = 0;
pgp_io_t io;
pgp_memory_t* outmem = NULL;
char* payload = NULL;
@ -357,10 +359,9 @@ cleanup:
char* dc_create_setup_code(dc_context_t* context)
{
#define CODE_ELEMS 9
uint16_t random_val;
int i;
uint16_t random_val = 0;
int i = 0;
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, 0);
for (i = 0; i < CODE_ELEMS; i++)
@ -392,7 +393,7 @@ char* dc_normalize_setup_code(dc_context_t* context, const char* in)
dc_strbuilder_t out;
dc_strbuilder_init(&out, 0);
int outlen;
int outlen = 0;
const char* p1 = in;
while (*p1) {
@ -457,13 +458,13 @@ char* dc_normalize_setup_code(dc_context_t* context, const char* in)
*/
char* dc_initiate_key_transfer(dc_context_t* context)
{
int success = 0;
char* setup_code = NULL;
char* setup_file_content = NULL;
char* setup_file_name = NULL;
uint32_t chat_id = 0;
int success = 0;
char* setup_code = NULL;
char* setup_file_content = NULL;
char* setup_file_name = NULL;
uint32_t chat_id = 0;
dc_msg_t* msg = NULL;
uint32_t msg_id = 0;
uint32_t msg_id = 0;
if (!dc_alloc_ongoing(context)) {
return 0; /* no cleanup as this would call dc_free_ongoing() */
@ -540,13 +541,15 @@ cleanup:
static int set_self_key(dc_context_t* context, const char* armored, int set_default)
{
int success = 0;
char* buf = NULL;
const char* buf_headerline, *buf_preferencrypt, *buf_base64; // pointers inside buf, MUST NOT be free()'d
dc_key_t* private_key = dc_key_new();
dc_key_t* public_key = dc_key_new();
sqlite3_stmt* stmt = NULL;
char* self_addr = NULL;
int success = 0;
char* buf = NULL;
const char* buf_headerline = NULL; // pointer inside buf, MUST NOT be free()'d
const char* buf_preferencrypt = NULL; // - " -
const char* buf_base64 = NULL; // - " -
dc_key_t* private_key = dc_key_new();
dc_key_t* public_key = dc_key_new();
sqlite3_stmt* stmt = NULL;
char* self_addr = NULL;
buf = dc_strdup(armored);
if (!dc_split_armored_data(buf, &buf_headerline, NULL, &buf_preferencrypt, &buf_base64)
@ -624,13 +627,13 @@ cleanup:
*/
int dc_continue_key_transfer(dc_context_t* context, uint32_t msg_id, const char* setup_code)
{
int success = 0;
dc_msg_t* msg = NULL;
char* filename = NULL;
char* filecontent = NULL;
size_t filebytes = 0;
char* armored_key = NULL;
char* norm_sc = NULL;
int success = 0;
dc_msg_t* msg = NULL;
char* filename = NULL;
char* filecontent = NULL;
size_t filebytes = 0;
char* armored_key = NULL;
char* norm_sc = NULL;
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || msg_id <= DC_MSG_ID_LAST_SPECIAL || setup_code == NULL) {
goto cleanup;
@ -701,9 +704,10 @@ static int export_self_keys(dc_context_t* context, const char* dir)
{
int success = 0;
sqlite3_stmt* stmt = NULL;
int id = 0, is_default = 0;
dc_key_t* public_key = dc_key_new();
dc_key_t* private_key = dc_key_new();
int id = 0;
int is_default = 0;
dc_key_t* public_key = dc_key_new();
dc_key_t* private_key = dc_key_new();
if ((stmt=dc_sqlite3_prepare(context->sql, "SELECT id, public_key, private_key, is_default FROM keypairs;"))==NULL) {
goto cleanup;
@ -750,9 +754,9 @@ static int import_self_keys(dc_context_t* context, const char* dir_name)
int set_default = 0;
char* buf = NULL;
size_t buf_bytes = 0;
const char* private_key; // a pointer inside buf, MUST NOT be free()'d
const char* private_key = NULL; // a pointer inside buf, MUST NOT be free()'d
char* buf2 = NULL;
const char* buf2_headerline; // a pointer inside buf2, MUST NOT be free()'d
const char* buf2_headerline = NULL; // a pointer inside buf2, MUST NOT be free()'d
if (context==NULL || context->magic != DC_CONTEXT_MAGIC || dir_name==NULL) {
goto cleanup;
@ -840,19 +844,21 @@ The macro avoids weird values of 0% or 100% while still working. */
static int export_backup(dc_context_t* context, const char* dir)
{
int success = 0, closed = 0;
int success = 0;
int closed = 0;
char* dest_pathNfilename = NULL;
dc_sqlite3_t* dest_sql = NULL;
time_t now = time(NULL);
DIR* dir_handle = NULL;
struct dirent* dir_entry;
struct dirent* dir_entry = NULL;
int prefix_len = strlen(DC_BAK_PREFIX);
int suffix_len = strlen(DC_BAK_SUFFIX);
char* curr_pathNfilename = NULL;
void* buf = NULL;
size_t buf_bytes = 0;
sqlite3_stmt* stmt = NULL;
int total_files_count = 0, processed_files_count = 0;
int total_files_count = 0;
int processed_files_count = 0;
int delete_dest_file = 0;
/* get a fine backup file name (the name includes the date so that multiple backup instances are possible)
@ -1002,7 +1008,8 @@ static int import_backup(dc_context_t* context, const char* backup_to_import)
*/
int success = 0;
int processed_files_count = 0, total_files_count = 0;
int processed_files_count = 0;
int total_files_count = 0;
sqlite3_stmt* stmt = NULL;
char* pathNfilename = NULL;
char* repl_from = NULL;
@ -1324,7 +1331,7 @@ char* dc_imex_has_backup(dc_context_t* context, const char* dir_name)
char* ret = NULL;
time_t ret_backup_time = 0;
DIR* dir_handle = NULL;
struct dirent* dir_entry;
struct dirent* dir_entry = NULL;
int prefix_len = strlen(DC_BAK_PREFIX);
int suffix_len = strlen(DC_BAK_SUFFIX);
char* curr_pathNfilename = NULL;

57
src/dc_job.c
View file

@ -43,7 +43,7 @@ static int connect_to_imap(dc_context_t* context, dc_job_t* job /*may be NULL if
int ret_connected = NOT_CONNECTED;
dc_loginparam_t* param = dc_loginparam_new();
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || context->imap == NULL) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC || context->imap==NULL) {
dc_log_warning(context, 0, "Cannot connect to IMAP: Bad parameters.");
goto cleanup;
}
@ -53,7 +53,7 @@ static int connect_to_imap(dc_context_t* context, dc_job_t* job /*may be NULL if
goto cleanup;
}
if (dc_sqlite3_get_config_int(context->sql, "configured", 0) == 0) {
if (dc_sqlite3_get_config_int(context->sql, "configured", 0)==0) {
dc_log_warning(context, 0, "Not configured, cannot connect."); // this is no error, connect() is called eg. when the screen is switched on, it's okay if the caller does not check all circumstances here
goto cleanup;
}
@ -75,10 +75,9 @@ cleanup:
static void dc_job_do_DC_JOB_SEND_MSG_TO_IMAP(dc_context_t* context, dc_job_t* job)
{
dc_mimefactory_t mimefactory;
char* server_folder = NULL;
uint32_t server_uid = 0;
dc_mimefactory_t mimefactory;
dc_mimefactory_init(&mimefactory, context);
/* connect to IMAP-server */
@ -92,7 +91,7 @@ static void dc_job_do_DC_JOB_SEND_MSG_TO_IMAP(dc_context_t* context, dc_job_t* j
/* create message */
if (dc_mimefactory_load_msg(&mimefactory, job->foreign_id)==0
|| mimefactory.from_addr == NULL) {
|| mimefactory.from_addr==NULL) {
goto cleanup; /* should not happen as we've sent the message to the SMTP server before */
}
@ -121,11 +120,11 @@ static void dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(dc_context_t* context, dc_job_t*
sqlite3_stmt* stmt = NULL;
if (!dc_msg_load_from_db(msg, context, job->foreign_id)
|| msg->rfc724_mid == NULL || msg->rfc724_mid[0] == 0 /* eg. device messages have no Message-ID */) {
|| msg->rfc724_mid==NULL || msg->rfc724_mid[0]==0 /* eg. device messages have no Message-ID */) {
goto cleanup;
}
if (dc_rfc724_mid_cnt(context, msg->rfc724_mid) != 1) {
if (dc_rfc724_mid_cnt(context, msg->rfc724_mid)!=1) {
dc_log_info(context, 0, "The message is deleted from the server when all parts are deleted.");
delete_from_server = 0;
}
@ -242,7 +241,7 @@ static void dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(dc_context_t* context, dc_job_
}
if (dc_imap_markseen_msg(context->imap, msg->server_folder, msg->server_uid,
in_ms_flags, &new_server_folder, &new_server_uid, &out_ms_flags) != 0)
in_ms_flags, &new_server_folder, &new_server_uid, &out_ms_flags)!=0)
{
if ((new_server_folder && new_server_uid) || out_ms_flags&DC_MS_MDNSent_JUST_SET)
{
@ -270,10 +269,10 @@ cleanup:
static void dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(dc_context_t* context, dc_job_t* job)
{
char* server_folder = dc_param_get (job->param, DC_PARAM_SERVER_FOLDER, NULL);
uint32_t server_uid = dc_param_get_int(job->param, DC_PARAM_SERVER_UID, 0);
char* server_folder = dc_param_get(job->param, DC_PARAM_SERVER_FOLDER, NULL);
uint32_t server_uid = dc_param_get_int(job->param, DC_PARAM_SERVER_UID, 0);
char* new_server_folder = NULL;
uint32_t new_server_uid = 0;
uint32_t new_server_uid = 0;
int out_ms_flags = 0;
if (!dc_imap_is_connected(context->imap)) {
@ -284,7 +283,7 @@ static void dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(dc_context_t* context, dc_job_
}
}
if (dc_imap_markseen_msg(context->imap, server_folder, server_uid, DC_MS_ALSO_MOVE, &new_server_folder, &new_server_uid, &out_ms_flags) == 0) {
if (dc_imap_markseen_msg(context->imap, server_folder, server_uid, DC_MS_ALSO_MOVE, &new_server_folder, &new_server_uid, &out_ms_flags)==0) {
dc_job_try_again_later(job, DC_AT_ONCE);
}
@ -329,7 +328,7 @@ static void dc_job_do_DC_JOB_SEND_MSG_TO_SMTP(dc_context_t* context, dc_job_t* j
/* load message data */
if (!dc_mimefactory_load_msg(&mimefactory, job->foreign_id)
|| mimefactory.from_addr == NULL) {
|| mimefactory.from_addr==NULL) {
dc_log_warning(context, 0, "Cannot load data to send, maybe the message is deleted in between.");
goto cleanup; /* no redo, no IMAP - there won't be more recipients next time (as the data does not exist, there is no need in calling mark_as_error()) */
}
@ -408,7 +407,7 @@ static void dc_job_do_DC_JOB_SEND_MDN(dc_context_t* context, dc_job_t* job)
dc_mimefactory_t mimefactory;
dc_mimefactory_init(&mimefactory, context);
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || job == NULL) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC || job==NULL) {
return;
}
@ -476,8 +475,8 @@ static void dc_suspend_smtp_thread(dc_context_t* context, int suspend)
void dc_job_add(dc_context_t* context, int action, int foreign_id, const char* param, int delay_seconds)
{
time_t timestamp = time(NULL);
sqlite3_stmt* stmt;
int thread;
sqlite3_stmt* stmt = NULL;
int thread = 0;
if (action >= DC_IMAP_THREAD && action < DC_IMAP_THREAD+1000) {
thread = DC_IMAP_THREAD;
@ -500,7 +499,7 @@ void dc_job_add(dc_context_t* context, int action, int foreign_id, const char* p
sqlite3_step(stmt);
sqlite3_finalize(stmt);
if (thread == DC_IMAP_THREAD) {
if (thread==DC_IMAP_THREAD) {
dc_interrupt_imap_idle(context);
}
else {
@ -511,7 +510,7 @@ void dc_job_add(dc_context_t* context, int action, int foreign_id, const char* p
void dc_job_try_again_later(dc_job_t* job, int try_again)
{
if (job == NULL) {
if (job==NULL) {
return;
}
@ -521,7 +520,7 @@ void dc_job_try_again_later(dc_job_t* job, int try_again)
void dc_job_kill_actions(dc_context_t* context, int action1, int action2)
{
if (context == NULL) {
if (context==NULL) {
return;
}
@ -544,7 +543,7 @@ static void dc_job_perform(dc_context_t* context, int thread)
memset(&job, 0, sizeof(dc_job_t));
job.param = dc_param_new();
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
goto cleanup;
}
@ -552,7 +551,7 @@ static void dc_job_perform(dc_context_t* context, int thread)
"SELECT id, action, foreign_id, param FROM jobs WHERE thread=? AND desired_timestamp<=? ORDER BY action DESC, added_timestamp;");
sqlite3_bind_int64(select_stmt, 1, thread);
sqlite3_bind_int64(select_stmt, 2, time(NULL));
while (sqlite3_step(select_stmt) == SQLITE_ROW)
while (sqlite3_step(select_stmt)==SQLITE_ROW)
{
job.job_id = sqlite3_column_int (select_stmt, 0);
job.action = sqlite3_column_int (select_stmt, 1);
@ -587,7 +586,7 @@ static void dc_job_perform(dc_context_t* context, int thread)
case DC_JOB_IMEX_IMAP: dc_job_do_DC_JOB_IMEX_IMAP (context, &job); break;
}
if (job.try_again != DC_AT_ONCE) {
if (job.try_again!=DC_AT_ONCE) {
break;
}
}
@ -596,12 +595,12 @@ static void dc_job_perform(dc_context_t* context, int thread)
dc_suspend_smtp_thread(context, 0);
goto cleanup;
}
else if (job.try_again == DC_INCREATION_POLL)
else if (job.try_again==DC_INCREATION_POLL)
{
// just try over next loop unconditionally, the ui typically interrupts idle when the file (video) is ready
dc_log_info(context, 0, "%s-job #%i not yet ready and will be delayed.", THREAD_STR, (int)job.job_id);
}
else if (job.try_again == DC_AT_ONCE || job.try_again == DC_STANDARD_DELAY)
else if (job.try_again==DC_AT_ONCE || job.try_again==DC_STANDARD_DELAY)
{
int tries = dc_param_get_int(job.param, DC_PARAM_TIMES, 0) + 1;
dc_param_set_int(job.param, DC_PARAM_TIMES, tries);
@ -617,7 +616,7 @@ static void dc_job_perform(dc_context_t* context, int thread)
// if the job did not succeeded AND this is a smtp-job AND we're online, try over after a mini-delay of one second.
// if we're not online, the ui calls interrupt idle as soon as we're online again.
// if nothing of this happens, after DC_SMTP_IDLE_SEC (60) we try again.
if (thread == DC_SMTP_THREAD
if (thread==DC_SMTP_THREAD
&& dc_is_online(context))
{
pthread_mutex_lock(&context->smtpidle_condmutex);
@ -774,7 +773,7 @@ void dc_perform_imap_idle(dc_context_t* context)
*/
void dc_interrupt_imap_idle(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || context->imap == NULL) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC || context->imap==NULL) {
dc_log_warning(context, 0, "Interrupt IMAP-IDLE: Bad parameters.");
return;
}
@ -835,7 +834,7 @@ void dc_perform_smtp_jobs(dc_context_t* context)
*/
void dc_perform_smtp_idle(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
dc_log_warning(context, 0, "Cannot perform SMTP-idle: Bad parameters.");
return;
}
@ -844,7 +843,7 @@ void dc_perform_smtp_idle(dc_context_t* context)
pthread_mutex_lock(&context->smtpidle_condmutex);
if (context->perform_smtp_jobs_needed == DC_JOBS_NEEDED_AT_ONCE)
if (context->perform_smtp_jobs_needed==DC_JOBS_NEEDED_AT_ONCE)
{
dc_log_info(context, 0, "SMTP-idle will not be started because of waiting jobs.");
}
@ -906,7 +905,7 @@ void dc_perform_smtp_idle(dc_context_t* context)
*/
void dc_interrupt_smtp_idle(dc_context_t* context)
{
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
dc_log_warning(context, 0, "Interrupt SMTP-idle: Bad parameters.");
return;
}

19
src/dc_key.c
View file

@ -161,10 +161,12 @@ int dc_key_set_from_base64(dc_key_t* key, const char* base64, int type)
int dc_key_set_from_file(dc_key_t* key, const char* pathNfilename, dc_context_t* context)
{
char* buf = NULL;
const char *headerline, *base64; // just pointers inside buf, must not be freed
size_t buf_bytes;
int type = -1, success = 0;
char* buf = NULL;
const char* headerline = NULL; // just pointer inside buf, must not be freed
const char* base64 = NULL; // - " -
size_t buf_bytes = 0;
int type = -1;
int success = 0;
dc_key_empty(key);
@ -319,10 +321,9 @@ static long crc_octets(const unsigned char *octets, size_t len)
#define CRC24_INIT 0xB704CEL
#define CRC24_POLY 0x1864CFBL
long crc = CRC24_INIT;
int i;
while (len--) {
crc ^= (*octets++) << 16;
for (i = 0; i < 8; i++) {
for (int i = 0; i < 8; i++) {
crc <<= 1;
if (crc & 0x1000000)
crc ^= CRC24_POLY;
@ -396,7 +397,8 @@ char* dc_key_render_base64(const dc_key_t* key, int break_every, const char* bre
char* dc_key_render_asc(const dc_key_t* key, const char* add_header_lines /*must be terminated by \r\n*/)
{
/* see RFC 4880, 6.2. Forming ASCII Armor, https://tools.ietf.org/html/rfc4880#section-6.2 */
char *base64 = NULL, *ret = NULL;
char* base64 = NULL;
char* ret = NULL;
if (key==NULL) {
goto cleanup;
@ -446,7 +448,8 @@ cleanup:
/* make a fingerprint human-readable */
char* dc_format_fingerprint(const char* fingerprint)
{
int i = 0, fingerprint_len = strlen(fingerprint);
int i = 0;
int fingerprint_len = strlen(fingerprint);
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, 0);

3
src/dc_keyring.c
View file

@ -45,12 +45,11 @@ dc_keyring_t* dc_keyring_new()
void dc_keyring_unref(dc_keyring_t* keyring)
{
int i;
if (keyring == NULL) {
return;
}
for (i = 0; i < keyring->count; i++) {
for (int i = 0; i < keyring->count; i++) {
dc_key_unref(keyring->keys[i]);
}
free(keyring->keys);

14
src/dc_log.c
View file

@ -43,16 +43,16 @@ static void log_vprintf(dc_context_t* context, int event, int code, const char*
{
char* msg = NULL;
if (context==NULL || context->magic != DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
return;
}
/* format message from variable parameters or translate very comming errors */
if (code == DC_ERROR_SELF_NOT_IN_GROUP)
if (code==DC_ERROR_SELF_NOT_IN_GROUP)
{
msg = dc_stock_str(context, DC_STR_SELFNOTINGRP);
}
else if (code == DC_ERROR_NO_NETWORK)
else if (code==DC_ERROR_NO_NETWORK)
{
msg = dc_stock_str(context, DC_STR_NONETWORK);
}
@ -65,9 +65,9 @@ static void log_vprintf(dc_context_t* context, int event, int code, const char*
}
/* if we have still no message, create one based upon the code */
if (msg == NULL) {
if (event == DC_EVENT_INFO) { msg = dc_mprintf("Info: %i", (int)code); }
else if (event == DC_EVENT_WARNING) { msg = dc_mprintf("Warning: %i", (int)code); }
if (msg==NULL) {
if (event==DC_EVENT_INFO) { msg = dc_mprintf("Info: %i", (int)code); }
else if (event==DC_EVENT_WARNING) { msg = dc_mprintf("Warning: %i", (int)code); }
else { msg = dc_mprintf("Error: %i", (int)code); }
}
@ -114,7 +114,7 @@ void dc_log_error(dc_context_t* context, int code, const char* msg, ...)
void dc_log_error_if(int* condition, dc_context_t* context, int code, const char* msg, ...)
{
if (condition == NULL || context==NULL || context->magic != DC_CONTEXT_MAGIC) {
if (condition==NULL || context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
return;
}

26
src/dc_mimefactory.c
View file

@ -244,7 +244,7 @@ cleanup:
int dc_mimefactory_load_mdn(dc_mimefactory_t* factory, uint32_t msg_id)
{
int success = 0;
dc_contact_t* contact = dc_contact_new(factory->context);
dc_contact_t* contact = dc_contact_new(factory->context);
if (factory == NULL) {
goto cleanup;
@ -297,9 +297,9 @@ cleanup:
static struct mailmime* build_body_text(char* text)
{
struct mailmime_fields* mime_fields;
struct mailmime* message_part;
struct mailmime_content* content;
struct mailmime_fields* mime_fields = NULL;
struct mailmime* message_part = NULL;
struct mailmime_content* content = NULL;
content = mailmime_content_new_with_str("text/plain");
clist_append(content->ct_parameters, mailmime_param_new_with_data("charset", "utf-8")); /* format=flowed currently does not really affect us, see https://www.ietf.org/rfc/rfc3676.txt */
@ -315,9 +315,9 @@ static struct mailmime* build_body_text(char* text)
static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_name, char** ret_file_name_as_sent)
{
struct mailmime_fields* mime_fields;
struct mailmime_fields* mime_fields = NULL;
struct mailmime* mime_sub = NULL;
struct mailmime_content* content;
struct mailmime_content* content = NULL;
char* pathNfilename = dc_param_get(msg->param, DC_PARAM_FILE, NULL);
char* mimetype = dc_param_get(msg->param, DC_PARAM_MIMETYPE, NULL);
@ -437,8 +437,9 @@ cleanup:
static char* get_subject(const dc_chat_t* chat, const dc_msg_t* msg, int afwd_email)
{
dc_context_t* context = chat? chat->context : NULL;
char *ret, *raw_subject = dc_msg_get_summarytext_by_raw(msg->type, msg->text, msg->param, DC_APPROX_SUBJECT_CHARS, context);
const char* fwd = afwd_email? "Fwd: " : "";
char* ret = NULL;
char* raw_subject = dc_msg_get_summarytext_by_raw(msg->type, msg->text, msg->param, DC_APPROX_SUBJECT_CHARS, context);
const char* fwd = afwd_email? "Fwd: " : "";
if (dc_param_get_int(msg->param, DC_PARAM_CMD, 0) == DC_CMD_AUTOCRYPT_SETUP_MESSAGE)
{
@ -466,19 +467,20 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
return 0;
}
struct mailimf_fields* imf_fields;
struct mailimf_fields* imf_fields = NULL;
struct mailmime* message = NULL;
char* message_text = NULL, *message_text2 = NULL, *subject_str = NULL;
char* message_text = NULL;
char* message_text2 = NULL;
char* subject_str = NULL;
int afwd_email = 0;
int col = 0;
int success = 0;
int parts = 0;
dc_e2ee_helper_t e2ee_helper;
int e2ee_guaranteed = 0;
int min_verified = DC_NOT_VERIFIED;
int force_plaintext = 0; // 1=add Autocrypt-header (needed eg. for handshaking), 2=no Autocrypte-header (used for MDN)
char* grpimage = NULL;
dc_e2ee_helper_t e2ee_helper;
memset(&e2ee_helper, 0, sizeof(dc_e2ee_helper_t));

17
src/dc_mimeparser.c
View file

@ -577,13 +577,11 @@ struct mailimf_fields* mailmime_find_mailimf_fields(struct mailmime* mime)
char* mailimf_find_first_addr(const struct mailimf_mailbox_list* mb_list)
{
clistiter* cur;
if (mb_list == NULL) {
return NULL;
}
for (cur = clist_begin(mb_list->mb_list); cur!=NULL ; cur=clist_next(cur)) {
for (clistiter* cur = clist_begin(mb_list->mb_list); cur!=NULL ; cur=clist_next(cur)) {
struct mailimf_mailbox* mb = (struct mailimf_mailbox*)clist_content(cur);
if (mb && mb->mb_addr_spec) {
return dc_addr_normalize(mb->mb_addr_spec);
@ -599,8 +597,7 @@ struct mailimf_field* mailimf_find_field(struct mailimf_fields* header, int want
return NULL;
}
clistiter* cur1;
for (cur1 = clist_begin(header->fld_list); cur1!=NULL ; cur1=clist_next(cur1))
for (clistiter* cur1 = clist_begin(header->fld_list); cur1!=NULL ; cur1=clist_next(cur1))
{
struct mailimf_field* field = (struct mailimf_field*)clist_content(cur1);
if (field)
@ -622,8 +619,7 @@ struct mailimf_optional_field* mailimf_find_optional_field(struct mailimf_fields
return NULL;
}
clistiter* cur1;
for (cur1 = clist_begin(header->fld_list); cur1!=NULL ; cur1=clist_next(cur1))
for (clistiter* cur1 = clist_begin(header->fld_list); cur1!=NULL ; cur1=clist_next(cur1))
{
struct mailimf_field* field = (struct mailimf_field*)clist_content(cur1);
if (field && field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD)
@ -642,8 +638,7 @@ struct mailimf_optional_field* mailimf_find_optional_field(struct mailimf_fields
static int mailmime_is_attachment_disposition(struct mailmime* mime)
{
if (mime->mm_mime_fields != NULL) {
clistiter* cur;
for (cur = clist_begin(mime->mm_mime_fields->fld_list); cur != NULL; cur = clist_next(cur)) {
for (clistiter* cur = clist_begin(mime->mm_mime_fields->fld_list); cur != NULL; cur = clist_next(cur)) {
struct mailmime_field* field = (struct mailmime_field*)clist_content(cur);
if (field && field->fld_type == MAILMIME_FIELD_DISPOSITION && field->fld_data.fld_disposition) {
if (field->fld_data.fld_disposition->dsp_type
@ -676,7 +671,7 @@ static int mailmime_get_mime_type(struct mailmime* mime, int* msg_type)
#define DC_MIMETYPE_AC_SETUP_FILE 111
struct mailmime_content* c = mime->mm_content_type;
int dummy; if (msg_type == NULL) { msg_type = &dummy; }
int dummy = 0; if (msg_type == NULL) { msg_type = &dummy; }
*msg_type = DC_MSG_UNDEFINED;
if (c == NULL || c->ct_type == NULL) {
@ -1858,7 +1853,7 @@ int dc_mimeparser_sender_equals_recipient(dc_mimeparser_t* mimeparser)
const struct mailimf_from* fld_from = NULL;
struct mailimf_mailbox* mb = NULL;
char* from_addr_norm = NULL;
dc_hash_t* recipients = NULL;
dc_hash_t* recipients = NULL;
if (mimeparser == NULL || mimeparser->header_root == NULL) {
goto cleanup;

20
src/dc_msg.c
View file

@ -264,7 +264,7 @@ time_t dc_msg_get_timestamp(const dc_msg_t* msg)
*/
char* dc_msg_get_text(const dc_msg_t* msg)
{
char* ret;
char* ret = NULL;
if (msg == NULL || msg->magic != DC_MSG_MAGIC) {
return dc_strdup(NULL);
@ -316,7 +316,8 @@ cleanup:
*/
char* dc_msg_get_filename(const dc_msg_t* msg)
{
char* ret = NULL, *pathNfilename = NULL;
char* ret = NULL;
char* pathNfilename = NULL;
if (msg == NULL || msg->magic != DC_MSG_MAGIC) {
goto cleanup;
@ -423,8 +424,8 @@ cleanup:
*/
dc_lot_t* dc_msg_get_mediainfo(const dc_msg_t* msg)
{
dc_lot_t* ret = dc_lot_new();
char* pathNfilename = NULL;
dc_lot_t* ret = dc_lot_new();
char* pathNfilename = NULL;
dc_contact_t* contact = NULL;
if (msg == NULL || msg->magic != DC_MSG_MAGIC || msg->context == NULL) {
@ -957,7 +958,10 @@ 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;
char* author = NULL;
char* title = NULL;
char* p = NULL;
dc_split_filename(pathNfilename, &title, NULL);
p = strstr(title, " - ");
if (p) {
@ -967,7 +971,7 @@ void dc_msg_get_authorNtitle_from_filename(const char* pathNfilename, char** ret
}
if (ret_author) { *ret_author = author; } else { free(author); }
if (ret_title) { *ret_title = title; } else { free(title); }
if (ret_title) { *ret_title = title; } else { free(title); }
}
@ -975,7 +979,9 @@ char* dc_msg_get_summarytext_by_raw(int type, const char* text, dc_param_t* para
{
/* get a summary text, result must be free()'d, never returns NULL. */
char* ret = NULL;
char* pathNfilename = NULL, *label = NULL, *value = NULL;
char* pathNfilename = NULL;
char* label = NULL;
char* value = NULL;
switch (type) {
case DC_MSG_IMAGE:

16
src/dc_param.c
View file

@ -29,7 +29,8 @@
static char* find_param(char* haystack, int key, char** ret_p2)
{
char *p1, *p2;
char* p1 = NULL;
char* p2 = NULL;
/* let p1 point to the start of the */
p1 = haystack;
@ -68,7 +69,7 @@ static char* find_param(char* haystack, int key, char** ret_p2)
*/
dc_param_t* dc_param_new()
{
dc_param_t* param;
dc_param_t* param = NULL;
if ((param=calloc(1, sizeof(dc_param_t)))==NULL) {
exit(28); /* cannot allocate little memory, unrecoverable error */
@ -171,7 +172,7 @@ void dc_param_set_urlencoded(dc_param_t* param, const char* urlencoded)
*/
int dc_param_exists(dc_param_t* param, int key)
{
char *p2;
char *p2 = NULL;
if (param == NULL || key == 0) {
return 0;
@ -192,7 +193,10 @@ int dc_param_exists(dc_param_t* param, int key)
*/
char* dc_param_get(dc_param_t* param, int key, const char* def)
{
char *p1, *p2, bak, *ret;
char* p1 = NULL;
char* p2 = NULL;
char bak = 0;
char* ret = NULL;
if (param == NULL || key == 0) {
return def? dc_strdup(def) : NULL;
@ -250,7 +254,9 @@ int32_t dc_param_get_int(dc_param_t* param, int key, int32_t def)
*/
void dc_param_set(dc_param_t* param, int key, const char* value)
{
char *old1, *old2, *new1 = NULL;
char* old1 = NULL;
char* old2 = NULL;
char* new1 = NULL;
if (param == NULL || key == 0) {
return;

29
src/dc_pgp.c
View file

@ -88,7 +88,8 @@ int dc_split_armored_data(char* buf, const char** ret_headerline, const char** r
int success = 0;
size_t line_chars = 0;
char* line = buf;
char* p1 = buf, *p2;
char* p1 = buf;
char* p2 = NULL;
char* headerline = NULL;
char* base64 = NULL;
#define PGP_WS "\t\r\n "
@ -218,10 +219,10 @@ static unsigned add_key_prefs(pgp_create_sig_t *sig)
static void add_selfsigned_userid(pgp_key_t *skey, pgp_key_t *pkey, const uint8_t *userid, time_t key_expiry)
{
/* similar to pgp_add_selfsigned_userid() which, however, uses different key flags */
pgp_create_sig_t *sig;
pgp_subpacket_t sigpacket;
pgp_memory_t *mem_sig = NULL;
pgp_output_t *sigoutput = NULL;
pgp_create_sig_t* sig = NULL;
pgp_subpacket_t sigpacket;
pgp_memory_t* mem_sig = NULL;
pgp_output_t* sigoutput = NULL;
/* create sig for this pkt */
sig = pgp_create_sig_new();
@ -261,7 +262,7 @@ static void add_selfsigned_userid(pgp_key_t *skey, pgp_key_t *pkey, const uint8_
static void add_subkey_binding_signature(pgp_subkeysig_t* p, pgp_key_t* primarykey, pgp_key_t* subkey, pgp_key_t* seckey)
{
/*add "0x18: Subkey Binding Signature" packet, PGP_SIG_SUBKEY */
pgp_create_sig_t* sig;
pgp_create_sig_t* sig = NULL;
pgp_output_t* sigoutput = NULL;
pgp_memory_t* mem_sig = NULL;
@ -293,11 +294,15 @@ static void add_subkey_binding_signature(pgp_subkeysig_t* p, pgp_key_t* primaryk
int dc_pgp_create_keypair(dc_context_t* context, const char* addr, dc_key_t* ret_public_key, dc_key_t* ret_private_key)
{
int success = 0;
pgp_key_t seckey, pubkey, subkey;
pgp_key_t seckey;
pgp_key_t pubkey;
pgp_key_t subkey;
uint8_t subkeyid[PGP_KEY_ID_SIZE];
uint8_t* user_id = NULL;
pgp_memory_t *pubmem = pgp_memory_new(), *secmem = pgp_memory_new();
pgp_output_t *pubout = pgp_output_new(), *secout = pgp_output_new();
pgp_memory_t* pubmem = pgp_memory_new();
pgp_memory_t* secmem = pgp_memory_new();
pgp_output_t* pubout = pgp_output_new();
pgp_output_t* secout = pgp_output_new();
memset(&seckey, 0, sizeof(pgp_key_t));
memset(&pubkey, 0, sizeof(pgp_key_t));
@ -542,7 +547,8 @@ int dc_pgp_pk_encrypt( dc_context_t* context,
pgp_keyring_t* dummy_keys = calloc(1, sizeof(pgp_keyring_t));
pgp_memory_t* keysmem = pgp_memory_new();
pgp_memory_t* signedmem = NULL;
int i, success = 0;
int i = 0;
int success = 0;
if (context==NULL || plain_text==NULL || plain_bytes==0 || ret_ctext==NULL || ret_ctext_bytes==NULL
|| raw_public_keys_for_encryption==NULL || raw_public_keys_for_encryption->count<=0
@ -636,7 +642,8 @@ int dc_pgp_pk_decrypt( dc_context_t* context,
key_id_t* recipients_key_ids = NULL;
unsigned recipients_count = 0;
pgp_memory_t* keysmem = pgp_memory_new();
int i, success = 0;
int i = 0;
int success = 0;
if (context==NULL || ctext==NULL || ctext_bytes==0 || ret_plain==NULL || ret_plain_bytes==NULL
|| raw_private_keys_for_decryption==NULL || raw_private_keys_for_decryption->count<=0

40
src/dc_qr.c
View file

@ -44,18 +44,18 @@
*/
dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
{
char* payload = NULL;
char* addr = NULL; /* must be normalized, if set */
char* fingerprint = NULL; /* must be normalized, if set */
char* name = NULL;
char* invitenumber = NULL;
char* auth = NULL;
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
dc_lot_t* qr_parsed = dc_lot_new();
uint32_t chat_id = 0;
char* device_msg = NULL;
char* grpid = NULL;
char* grpname = NULL;
char* payload = NULL;
char* addr = NULL; // must be normalized, if set
char* fingerprint = NULL; // must be normalized, if set
char* name = NULL;
char* invitenumber = NULL;
char* auth = NULL;
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
dc_lot_t* qr_parsed = dc_lot_new();
uint32_t chat_id = 0;
char* device_msg = NULL;
char* grpid = NULL;
char* grpname = NULL;
qr_parsed->state = 0;
@ -68,7 +68,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
/* split parameters from the qr code
------------------------------------ */
if (strncasecmp(qr, DC_OPENPGP4FPR_SCHEME, strlen(DC_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 */
@ -110,7 +110,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
fingerprint = dc_normalize_fingerprint(payload);
}
else if (strncasecmp(qr, MAILTO_SCHEME, strlen(MAILTO_SCHEME)) == 0)
else if (strncasecmp(qr, MAILTO_SCHEME, strlen(MAILTO_SCHEME))==0)
{
/* scheme: mailto:addr...?subject=...&body=... */
payload = dc_strdup(&qr[strlen(MAILTO_SCHEME)]);
@ -120,7 +120,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
}
addr = dc_strdup(payload);
}
else if (strncasecmp(qr, SMTP_SCHEME, strlen(SMTP_SCHEME)) == 0)
else if (strncasecmp(qr, SMTP_SCHEME, strlen(SMTP_SCHEME))==0)
{
/* scheme: `SMTP:addr...:subject...:body...` */
payload = dc_strdup(&qr[strlen(SMTP_SCHEME)]);
@ -130,7 +130,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
}
addr = dc_strdup(payload);
}
else if (strncasecmp(qr, MATMSG_SCHEME, strlen(MATMSG_SCHEME)) == 0)
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. */
@ -145,7 +145,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
goto cleanup;
}
}
else if (strncasecmp(qr, VCARD_BEGIN, strlen(VCARD_BEGIN)) == 0)
else if (strncasecmp(qr, VCARD_BEGIN, strlen(VCARD_BEGIN))==0)
{
/* scheme: `VCARD:BEGIN\nN:last name;first name;...;\nEMAIL:addr...;` */
carray* lines = dc_split_into_lines(qr);
@ -156,11 +156,11 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
*value = 0;
value++;
char* semicolon = strchr(key, ';'); if (semicolon) { *semicolon = 0; } /* handle `EMAIL;type=work:` stuff */
if (strcasecmp(key, "EMAIL") == 0) {
if (strcasecmp(key, "EMAIL")==0) {
semicolon = strchr(value, ';'); if (semicolon) { *semicolon = 0; } /* use the first EMAIL */
addr = dc_strdup(value);
}
else if (strcasecmp(key, "N") == 0) {
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 = dc_strdup(value);
dc_str_replace(&name, ";", ","); /* the format "lastname,prename" is handled by dc_normalize_name() */
@ -200,7 +200,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
{
/* fingerprint set ... */
if (addr == NULL || invitenumber == NULL || auth == NULL)
if (addr==NULL || invitenumber==NULL || auth==NULL)
{
// _only_ fingerprint set ...
// (we could also do this before/instead of a secure-join, however, this may require complicated questions in the ui)

102
src/dc_receive_imf.c
View file

@ -39,7 +39,7 @@
static void add_or_lookup_contact_by_addr(dc_context_t* context, const char* display_name_enc, const char* addr_spec, int origin, dc_array_t* ids, int* check_self)
{
/* is addr_spec equal to SELF? */
int dummy;
int dummy = 0;
if (check_self == NULL) { check_self = &dummy; }
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || addr_spec == NULL) {
@ -79,13 +79,11 @@ static void add_or_lookup_contact_by_addr(dc_context_t* context, const char* dis
static void dc_add_or_lookup_contacts_by_mailbox_list(dc_context_t* context, const struct mailimf_mailbox_list* mb_list, int origin, dc_array_t* ids, int* check_self)
{
clistiter* cur;
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || mb_list == NULL) {
return;
}
for (cur = clist_begin(mb_list->mb_list); cur!=NULL ; cur=clist_next(cur)) {
for (clistiter* cur = clist_begin(mb_list->mb_list); cur!=NULL ; cur=clist_next(cur)) {
struct mailimf_mailbox* mb = (struct mailimf_mailbox*)clist_content(cur);
if (mb) {
add_or_lookup_contact_by_addr(context, mb->mb_display_name, mb->mb_addr_spec, origin, ids, check_self);
@ -96,13 +94,11 @@ static void dc_add_or_lookup_contacts_by_mailbox_list(dc_context_t* context, con
static void dc_add_or_lookup_contacts_by_address_list(dc_context_t* context, const struct mailimf_address_list* adr_list, int origin, dc_array_t* ids, int* check_self)
{
clistiter* cur;
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || adr_list == NULL /*may be NULL eg. if bcc is given as `Bcc: \n` in the header */) {
return;
}
for (cur = clist_begin(adr_list->ad_list); cur!=NULL ; cur=clist_next(cur)) {
for (clistiter* cur = clist_begin(adr_list->ad_list); cur!=NULL ; cur=clist_next(cur)) {
struct mailimf_address* adr = (struct mailimf_address*)clist_content(cur);
if (adr) {
if (adr->ad_type == MAILIMF_ADDRESS_MAILBOX) {
@ -167,7 +163,7 @@ static int dc_is_reply_to_known_message(dc_context_t* context, dc_mimeparser_t*
/* check if the message is a reply to a known message; the replies are identified by the Message-ID from
`In-Reply-To`/`References:` (to support non-Delta-Clients) or from `Chat-Predecessor:` (Delta clients, see comment in dc_chat.c) */
struct mailimf_optional_field* optional_field;
struct mailimf_optional_field* optional_field = NULL;
if ((optional_field=dc_mimeparser_lookup_optional_field2(mime_parser, "Chat-Predecessor", "X-MrPredecessor")) != NULL)
{
if (is_known_rfc724_mid(context, optional_field->fld_value)) {
@ -175,7 +171,7 @@ static int dc_is_reply_to_known_message(dc_context_t* context, dc_mimeparser_t*
}
}
struct mailimf_field* field;
struct mailimf_field* field = NULL;
if ((field=dc_mimeparser_lookup_field(mime_parser, "In-Reply-To"))!=NULL
&& field->fld_type == MAILIMF_FIELD_IN_REPLY_TO)
{
@ -229,8 +225,7 @@ static int is_msgrmsg_rfc724_mid(dc_context_t* context, const char* rfc724_mid)
static int is_msgrmsg_rfc724_mid_in_list(dc_context_t* context, const clist* mid_list)
{
if (mid_list) {
clistiter* cur;
for (cur = clist_begin(mid_list); cur!=NULL ; cur=clist_next(cur)) {
for (clistiter* cur = clist_begin(mid_list); cur!=NULL ; cur=clist_next(cur)) {
if (is_msgrmsg_rfc724_mid(context, clist_content(cur))) {
return 1;
}
@ -250,7 +245,7 @@ static int dc_is_reply_to_messenger_message(dc_context_t* context, dc_mimeparser
- it is okay, if the referenced messages are moved to trash here
- no check for the Chat-* headers (function is only called if it is no messenger message itself) */
struct mailimf_field* field;
struct mailimf_field* field = NULL;
if ((field=dc_mimeparser_lookup_field(mime_parser, "In-Reply-To"))!=NULL
&& field->fld_type==MAILIMF_FIELD_IN_REPLY_TO)
{
@ -329,9 +324,10 @@ static dc_array_t* search_chat_ids_by_contact_ids(dc_context_t* context, const d
{
/* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
sqlite3_stmt* stmt = NULL;
dc_array_t* contact_ids = dc_array_new(context, 23);
char* contact_ids_str = NULL, *q3 = NULL;
dc_array_t* chat_ids = dc_array_new(context, 23);
dc_array_t* contact_ids = dc_array_new(context, 23);
char* contact_ids_str = NULL;
char* q3 = NULL;
dc_array_t* chat_ids = dc_array_new(context, 23);
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
goto cleanup;
@ -418,13 +414,14 @@ static char* create_adhoc_grp_id(dc_context_t* context, dc_array_t* member_ids /
*/
dc_array_t* member_addrs = dc_array_new(context, 23);
char* member_ids_str = dc_array_get_string(member_ids, ",");
dc_strbuilder_t member_cs;
sqlite3_stmt* stmt = NULL;
char* q3 = NULL, *addr;
int i, iCnt;
char* q3 = NULL;
char* addr = NULL;
int i = 0;
int iCnt = 0;
uint8_t* binary_hash = NULL;
char* ret = NULL;
dc_strbuilder_t member_cs;
dc_strbuilder_init(&member_cs, 0);
/* collect all addresses and sort them */
@ -508,14 +505,16 @@ static void create_or_lookup_adhoc_group(dc_context_t* context, dc_mimeparser_t*
{
/* if we're here, no grpid was found, check there is an existing ad-hoc
group matching the to-list or if we can create one */
dc_array_t* member_ids = NULL;
uint32_t chat_id = 0;
int chat_id_blocked = 0, i;
dc_array_t* chat_ids = NULL;
char* chat_ids_str = NULL, *q3 = NULL;
sqlite3_stmt* stmt = NULL;
char* grpid = NULL;
char* grpname = NULL;
dc_array_t* member_ids = NULL;
uint32_t chat_id = 0;
int chat_id_blocked = 0;
int i = 0;
dc_array_t* chat_ids = NULL;
char* chat_ids_str = NULL;
char* q3 = NULL;
sqlite3_stmt* stmt = NULL;
char* grpid = NULL;
char* grpname = NULL;
/* build member list from the given ids */
if (dc_array_get_cnt(to_ids)==0 || dc_mimeparser_is_mailinglist_message(mime_parser)) {
@ -590,11 +589,11 @@ static int check_verified_properties(dc_context_t* context, dc_mimeparser_t* mim
uint32_t from_id, const dc_array_t* to_ids)
{
int everythings_okay = 0;
dc_contact_t* contact = dc_contact_new(context);
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
char* to_ids_str = NULL;
char* q3 = NULL;
sqlite3_stmt* stmt = NULL;
dc_contact_t* contact = dc_contact_new(context);
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
char* to_ids_str = NULL;
char* q3 = NULL;
sqlite3_stmt* stmt = NULL;
// ensure, the contact is verified
if (!dc_contact_load_from_db(contact, context->sql, from_id)
@ -686,21 +685,21 @@ static void create_or_lookup_group(dc_context_t* context, dc_mimeparser_t* mime_
int32_t from_id, const dc_array_t* to_ids,
uint32_t* ret_chat_id, int* ret_chat_id_blocked)
{
uint32_t chat_id = 0;
int chat_id_blocked = 0;
int chat_id_verified = 0;
char* grpid = NULL;
char* grpname = NULL;
sqlite3_stmt* stmt;
int i, to_ids_cnt = dc_array_get_cnt(to_ids);
char* self_addr = NULL;
int recreate_member_list = 0;
int send_EVENT_CHAT_MODIFIED = 0;
char* X_MrRemoveFromGrp = NULL; /* pointer somewhere into mime_parser, must not be freed */
char* X_MrAddToGrp = NULL; /* pointer somewhere into mime_parser, must not be freed */
int X_MrGrpNameChanged = 0;
int X_MrGrpImageChanged = 0;
uint32_t chat_id = 0;
int chat_id_blocked = 0;
int chat_id_verified = 0;
char* grpid = NULL;
char* grpname = NULL;
sqlite3_stmt* stmt;
int i = 0;
int to_ids_cnt = dc_array_get_cnt(to_ids);
char* self_addr = NULL;
int recreate_member_list = 0;
int send_EVENT_CHAT_MODIFIED = 0;
char* X_MrRemoveFromGrp = NULL; /* pointer somewhere into mime_parser, must not be freed */
char* X_MrAddToGrp = NULL; /* pointer somewhere into mime_parser, must not be freed */
int X_MrGrpNameChanged = 0;
int X_MrGrpImageChanged = 0;
/* search the grpid in the header */
{
@ -927,7 +926,7 @@ cleanup:
free(grpid);
free(grpname);
free(self_addr);
if (ret_chat_id) { *ret_chat_id = chat_id; }
if (ret_chat_id) { *ret_chat_id = chat_id; }
if (ret_chat_id_blocked) { *ret_chat_id_blocked = chat_id? chat_id_blocked : 0; }
}
@ -950,15 +949,16 @@ void dc_receive_imf(dc_context_t* context, const char* imf_raw_not_terminated, s
uint32_t from_id = 0;
int from_id_blocked = 0;
uint32_t to_id = 0;
uint32_t to_id = 0;
uint32_t chat_id = 0;
int chat_id_blocked = 0;
int state = DC_STATE_UNDEFINED;
int state = DC_STATE_UNDEFINED;
int hidden = 0;
int add_delete_job = 0;
sqlite3_stmt* stmt = NULL;
size_t i, icnt;
size_t i = 0;
size_t icnt = 0;
uint32_t first_dblocal_id = 0;
char* rfc724_mid = NULL; /* Message-ID from the header */
time_t sort_timestamp = DC_INVALID_TIMESTAMP;

15
src/dc_saxparser.c
View file

@ -143,9 +143,13 @@ Function based upon ezxml_decode() from the "ezxml" parser which is
Copyright 2004-2006 Aaron Voisine <aaron@voisine.org> */
static char* xml_decode(char* s, char type)
{
char *e, *r = s;
char* e = NULL;
char* r = s;
const char* original_buf = s;
long b, c, d, l;
long b = 0;
long c = 0;
long d = 0;
long l = 0;
for (; *s; s++) { /* normalize line endings */
while (*s == '\r') {
@ -263,7 +267,7 @@ static void do_free_attr(char** attr, int* free_attr)
#define FREE_VALUE 0x02
int i = 0;
while (attr[i]) {
if (free_attr[i>>1]&FREE_KEY && attr[i] ) { free(attr[i]); }
if (free_attr[i>>1]&FREE_KEY && attr[i]) { free(attr[i]); }
if (free_attr[i>>1]&FREE_VALUE && attr[i+1]) { free(attr[i+1]); }
i += 2;
}
@ -324,7 +328,10 @@ void dc_saxparser_set_text_handler (dc_saxparser_t* saxparser, dc_saxparser_text
void dc_saxparser_parse(dc_saxparser_t* saxparser, const char* buf_start__)
{
char bak, *buf_start, *last_text_start, *p;
char bak = 0;
char* buf_start = NULL;
char* last_text_start = NULL;
char* p = NULL;
#define MAX_ATTR 100 /* attributes per tag - a fixed border here is a security feature, not a limit */
char* attr[(MAX_ATTR+1)*2]; /* attributes as key/value pairs, +1 for terminating the list */

134
src/dc_securejoin.c
View file

@ -38,11 +38,11 @@
void dc_handle_degrade_event(dc_context_t* context, dc_apeerstate_t* peerstate)
{
sqlite3_stmt* stmt = NULL;
uint32_t contact_id = 0;
sqlite3_stmt* stmt = NULL;
uint32_t contact_id = 0;
uint32_t contact_chat_id = 0;
if (context == NULL || peerstate == NULL) {
if (context==NULL || peerstate==NULL) {
goto cleanup;
}
@ -60,7 +60,7 @@ void dc_handle_degrade_event(dc_context_t* context, dc_apeerstate_t* peerstate)
contact_id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
if (contact_id == 0) {
if (contact_id==0) {
goto cleanup;
}
@ -94,12 +94,12 @@ static int encrypted_and_signed(dc_mimeparser_t* mimeparser, const char* expecte
return 0;
}
if (expected_fingerprint == NULL) {
if (expected_fingerprint==NULL) {
dc_log_warning(mimeparser->context, 0, "Fingerprint for comparison missing.");
return 0;
}
if (dc_hash_find_str(mimeparser->e2ee_helper->signatures, expected_fingerprint) == NULL) {
if (dc_hash_find_str(mimeparser->e2ee_helper->signatures, expected_fingerprint)==NULL) {
dc_log_warning(mimeparser->context, 0, "Message does not match expected fingerprint %s.", expected_fingerprint);
return 0;
}
@ -110,16 +110,16 @@ static int encrypted_and_signed(dc_mimeparser_t* mimeparser, const char* expecte
static char* get_self_fingerprint(dc_context_t* context)
{
char* self_addr = NULL;
dc_key_t* self_key = dc_key_new();
char* self_addr = NULL;
dc_key_t* self_key = dc_key_new();
char* fingerprint = NULL;
if ((self_addr = dc_sqlite3_get_config(context->sql, "configured_addr", NULL)) == NULL
if ((self_addr = dc_sqlite3_get_config(context->sql, "configured_addr", NULL))==NULL
|| !dc_key_load_self_public(self_key, self_addr, context->sql)) {
goto cleanup;
}
if ((fingerprint=dc_key_get_fingerprint(self_key)) == NULL) {
if ((fingerprint=dc_key_get_fingerprint(self_key))==NULL) {
goto cleanup;
}
@ -135,7 +135,7 @@ static uint32_t chat_id_2_contact_id(dc_context_t* context, uint32_t contact_cha
uint32_t contact_id = 0;
dc_array_t* contacts = dc_get_chat_contacts(context, contact_chat_id);
if (dc_array_get_cnt(contacts) != 1) {
if (dc_array_get_cnt(contacts)!=1) {
goto cleanup;
}
@ -149,13 +149,13 @@ cleanup:
static int fingerprint_equals_sender(dc_context_t* context, const char* fingerprint, uint32_t contact_chat_id)
{
int fingerprint_equal = 0;
dc_array_t* contacts = dc_get_chat_contacts(context, contact_chat_id);
dc_contact_t* contact = dc_contact_new(context);
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
int fingerprint_equal = 0;
dc_array_t* contacts = dc_get_chat_contacts(context, contact_chat_id);
dc_contact_t* contact = dc_contact_new(context);
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
char* fingerprint_normalized = NULL;
if (dc_array_get_cnt(contacts) != 1) {
if (dc_array_get_cnt(contacts)!=1) {
goto cleanup;
}
@ -166,7 +166,7 @@ static int fingerprint_equals_sender(dc_context_t* context, const char* fingerpr
fingerprint_normalized = dc_normalize_fingerprint(fingerprint);
if (strcasecmp(fingerprint_normalized, peerstate->public_key_fingerprint) == 0) {
if (strcasecmp(fingerprint_normalized, peerstate->public_key_fingerprint)==0) {
fingerprint_equal = 1;
}
@ -180,7 +180,7 @@ cleanup:
static int mark_peer_as_verified(dc_context_t* context, const char* fingerprint)
{
int success = 0;
int success = 0;
dc_apeerstate_t* peerstate = dc_apeerstate_new(context);
if (!dc_apeerstate_load_by_fingerprint(peerstate, context->sql, fingerprint)) {
@ -210,8 +210,8 @@ static const char* lookup_field(dc_mimeparser_t* mimeparser, const char* key)
{
const char* value = NULL;
struct mailimf_field* field = dc_mimeparser_lookup_field(mimeparser, key);
if (field == NULL || field->fld_type != MAILIMF_FIELD_OPTIONAL_FIELD
|| field->fld_data.fld_optional_field == NULL || (value=field->fld_data.fld_optional_field->fld_value) == NULL) {
if (field==NULL || field->fld_type!=MAILIMF_FIELD_OPTIONAL_FIELD
|| field->fld_data.fld_optional_field==NULL || (value=field->fld_data.fld_optional_field->fld_value)==NULL) {
return NULL;
}
return value;
@ -256,8 +256,8 @@ static void send_handshake_msg(dc_context_t* context, uint32_t contact_chat_id,
static void could_not_establish_secure_connection(dc_context_t* context, uint32_t contact_chat_id, const char* details)
{
uint32_t contact_id = chat_id_2_contact_id(context, contact_chat_id);
dc_contact_t* contact = dc_get_contact(context, contact_id);
char* msg = dc_mprintf("Could not establish secure connection to %s.", contact? contact->addr : "?");
dc_contact_t* contact = dc_get_contact(context, contact_id);
char* msg = dc_mprintf("Could not establish secure connection to %s.", contact? contact->addr : "?");
dc_add_device_msg(context, contact_chat_id, msg);
@ -271,8 +271,8 @@ static void could_not_establish_secure_connection(dc_context_t* context, uint32_
static void secure_connection_established(dc_context_t* context, uint32_t contact_chat_id)
{
uint32_t contact_id = chat_id_2_contact_id(context, contact_chat_id);
dc_contact_t* contact = dc_get_contact(context, contact_id);
char* msg = dc_mprintf("Secure connection to %s established.", contact? contact->addr : "?");
dc_contact_t* contact = dc_get_contact(context, contact_id);
char* msg = dc_mprintf("Secure connection to %s established.", contact? contact->addr : "?");
dc_add_device_msg(context, contact_chat_id, msg);
@ -319,19 +319,19 @@ char* dc_get_securejoin_qr(dc_context_t* context, uint32_t group_chat_id)
==== Step 1 in "Setup verified contact" protocol ====
========================================================= */
char* qr = NULL;
char* self_addr = NULL;
char* qr = NULL;
char* self_addr = NULL;
char* self_addr_urlencoded = NULL;
char* self_name = NULL;
char* self_name = NULL;
char* self_name_urlencoded = NULL;
char* fingerprint = NULL;
char* invitenumber = NULL;
char* auth = NULL;
dc_chat_t* chat = NULL;
char* group_name = NULL;
char* fingerprint = NULL;
char* invitenumber = NULL;
char* auth = NULL;
dc_chat_t* chat = NULL;
char* group_name = NULL;
char* group_name_urlencoded= NULL;
if (context == NULL || context->magic!=DC_CONTEXT_MAGIC) {
if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
goto cleanup;
}
@ -339,25 +339,25 @@ char* dc_get_securejoin_qr(dc_context_t* context, uint32_t group_chat_id)
// invitenumber will be used to allow starting the handshake, auth will be used to verify the fingerprint
invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id);
if (invitenumber == NULL) {
if (invitenumber==NULL) {
invitenumber = dc_create_id();
dc_token_save(context, DC_TOKEN_INVITENUMBER, group_chat_id, invitenumber);
}
auth = dc_token_lookup(context, DC_TOKEN_AUTH, group_chat_id);
if (auth == NULL) {
if (auth==NULL) {
auth = dc_create_id();
dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth);
}
if ((self_addr = dc_sqlite3_get_config(context->sql, "configured_addr", NULL)) == NULL) {
if ((self_addr = dc_sqlite3_get_config(context->sql, "configured_addr", NULL))==NULL) {
dc_log_error(context, 0, "Not configured, cannot generate QR code.");
goto cleanup;
}
self_name = dc_sqlite3_get_config(context->sql, "displayname", "");
if ((fingerprint=get_self_fingerprint(context)) == NULL) {
if ((fingerprint=get_self_fingerprint(context))==NULL) {
goto cleanup;
}
@ -368,7 +368,7 @@ char* dc_get_securejoin_qr(dc_context_t* context, uint32_t group_chat_id)
{
// parameters used: a=g=x=i=s=
chat = dc_get_chat(context, group_chat_id);
if (chat == NULL || chat->type != DC_CHAT_TYPE_VERIFIED_GROUP) {
if (chat==NULL || chat->type!=DC_CHAT_TYPE_VERIFIED_GROUP) {
dc_log_error(context, 0, "Secure join is only available for verified groups.");
goto cleanup;
}
@ -422,21 +422,21 @@ uint32_t dc_join_securejoin(dc_context_t* context, const char* qr)
==== Step 2 in "Setup verified contact" protocol =====
========================================================== */
int ret_chat_id = 0;
int ret_chat_id = 0;
int ongoing_allocated = 0;
uint32_t contact_chat_id = 0;
int join_vg = 0;
dc_lot_t* qr_scan = NULL;
int qr_locked = 0;
#define LOCK_QR { pthread_mutex_lock(&context->bobs_qr_critical); qr_locked = 1; }
#define UNLOCK_QR if (qr_locked) { pthread_mutex_unlock(&context->bobs_qr_critical); qr_locked = 0; }
#define CHECK_EXIT if (context->shall_stop_ongoing) { goto cleanup; }
uint32_t contact_chat_id = 0;
int join_vg = 0;
dc_lot_t* qr_scan = NULL;
int qr_locked = 0;
#define LOCK_QR { pthread_mutex_lock(&context->bobs_qr_critical); qr_locked = 1; }
#define UNLOCK_QR if (qr_locked) { pthread_mutex_unlock(&context->bobs_qr_critical); qr_locked = 0; }
#define CHECK_EXIT if (context->shall_stop_ongoing) { goto cleanup; }
dc_log_info(context, 0, "Requesting secure-join ...");
dc_ensure_secret_key_exists(context);
if ((ongoing_allocated=dc_alloc_ongoing(context)) == 0) {
if ((ongoing_allocated=dc_alloc_ongoing(context))==0) {
goto cleanup;
}
@ -446,7 +446,7 @@ uint32_t dc_join_securejoin(dc_context_t* context, const char* qr)
goto cleanup;
}
if ((contact_chat_id=dc_create_chat_by_contact_id(context, qr_scan->id)) == 0) {
if ((contact_chat_id=dc_create_chat_by_contact_id(context, qr_scan->id))==0) {
dc_log_error(context, 0, "Unknown contact.");
goto cleanup;
}
@ -492,7 +492,7 @@ uint32_t dc_join_securejoin(dc_context_t* context, const char* qr)
cleanup:
context->bob_expects = 0;
if (context->bobs_status == DC_BOB_SUCCESS) {
if (context->bobs_status==DC_BOB_SUCCESS) {
if (join_vg) {
ret_chat_id = dc_get_chat_id_by_grpid(context, qr_scan->text2, NULL, NULL);
}
@ -525,23 +525,23 @@ cleanup:
*/
int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimeparser, uint32_t contact_id)
{
int qr_locked = 0;
const char* step = NULL;
int join_vg = 0;
int qr_locked = 0;
const char* step = NULL;
int join_vg = 0;
char* scanned_fingerprint_of_alice = NULL;
char* auth = NULL;
char* own_fingerprint = NULL;
uint32_t contact_chat_id = 0;
int contact_chat_id_blocked = 0;
char* grpid = NULL;
int ret = 0;
dc_contact_t* contact = NULL;
char* auth = NULL;
char* own_fingerprint = NULL;
uint32_t contact_chat_id = 0;
int contact_chat_id_blocked = 0;
char* grpid = NULL;
int ret = 0;
dc_contact_t* contact = NULL;
if (context == NULL || mimeparser == NULL || contact_id <= DC_CONTACT_ID_LAST_SPECIAL) {
if (context==NULL || mimeparser==NULL || contact_id <= DC_CONTACT_ID_LAST_SPECIAL) {
goto cleanup;
}
if ((step=lookup_field(mimeparser, "Secure-Join")) == NULL) {
if ((step=lookup_field(mimeparser, "Secure-Join"))==NULL) {
goto cleanup;
}
dc_log_info(context, 0, ">>>>>>>>>>>>>>>>>>>>>>>>> secure-join message '%s' received", step);
@ -568,12 +568,12 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
// verify that the `Secure-Join-Invitenumber:`-header matches invitenumber written to the QR code
const char* invitenumber = NULL;
if ((invitenumber=lookup_field(mimeparser, "Secure-Join-Invitenumber")) == NULL) {
if ((invitenumber=lookup_field(mimeparser, "Secure-Join-Invitenumber"))==NULL) {
dc_log_warning(context, 0, "Secure-join denied (invitenumber missing)."); // do not raise an error, this might just be spam or come from an old request
goto cleanup;
}
if (dc_token_exists(context, DC_TOKEN_INVITENUMBER, invitenumber) == 0) {
if (dc_token_exists(context, DC_TOKEN_INVITENUMBER, invitenumber)==0) {
dc_log_warning(context, 0, "Secure-join denied (bad invitenumber)."); // do not raise an error, this might just be spam or come from an old request
goto cleanup;
}
@ -640,7 +640,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
// verify that Secure-Join-Fingerprint:-header matches the fingerprint of Bob
const char* fingerprint = NULL;
if ((fingerprint=lookup_field(mimeparser, "Secure-Join-Fingerprint")) == NULL) {
if ((fingerprint=lookup_field(mimeparser, "Secure-Join-Fingerprint"))==NULL) {
could_not_establish_secure_connection(context, contact_chat_id, "Fingerprint not provided.");
goto cleanup;
}
@ -660,12 +660,12 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
// verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code
const char* auth = NULL;
if ((auth=lookup_field(mimeparser, "Secure-Join-Auth")) == NULL) {
if ((auth=lookup_field(mimeparser, "Secure-Join-Auth"))==NULL) {
could_not_establish_secure_connection(context, contact_chat_id, "Auth not provided.");
goto cleanup;
}
if (dc_token_exists(context, DC_TOKEN_AUTH, auth) == 0) {
if (dc_token_exists(context, DC_TOKEN_AUTH, auth)==0) {
could_not_establish_secure_connection(context, contact_chat_id, "Auth invalid.");
goto cleanup;
}
@ -688,7 +688,7 @@ int dc_handle_securejoin_handshake(dc_context_t* context, dc_mimeparser_t* mimep
grpid = dc_strdup(lookup_field(mimeparser, "Secure-Join-Group"));
int is_verified = 0;
uint32_t verified_chat_id = dc_get_chat_id_by_grpid(context, grpid, NULL, &is_verified);
if (verified_chat_id == 0 || !is_verified) {
if (verified_chat_id==0 || !is_verified) {
dc_log_error(context, 0, "Verified chat not found.");
goto cleanup;
}

9
src/dc_simplify.c
View file

@ -125,8 +125,10 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* simplify, const char
/* split the given buffer into lines */
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;
int l = 0;
int l_first = 0;
int l_last = carray_count(lines)-1; /* if l_last is -1, there are no lines */
char* line = NULL;
/* search for the line `-- ` and ignore this and all following lines
If the line contains more characters, it is _not_ treated as the footer start mark (hi, Thorsten) */
@ -303,7 +305,8 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* simplify, const char
char* dc_simplify_simplify(dc_simplify_t* simplify, const char* in_unterminated, int in_bytes, int is_html)
{
/* create a copy of the given buffer */
char* out = NULL, *temp = NULL;
char* out = NULL;
char* temp = NULL;
if (simplify == NULL || in_unterminated == NULL || in_bytes <= 0) {
return dc_strdup("");

2
src/dc_smtp.c
View file

@ -256,7 +256,7 @@ void dc_smtp_disconnect(dc_smtp_t* smtp)
int dc_smtp_send_msg(dc_smtp_t* smtp, const clist* recipients, const char* data_not_terminated, size_t data_bytes)
{
int success = 0;
int success = 0;
int r = 0;
clistiter* iter = NULL;

13
src/dc_sqlite3.c
View file

@ -54,10 +54,9 @@ safe. However, there are some points to keep in mind:
void dc_sqlite3_log_error(dc_sqlite3_t* sql, const char* msg_format, ...)
{
char* msg;
char* msg = NULL;
const char* notSetUp = "SQLite object not set up.";
va_list va;
va_start(va, msg_format);
msg = sqlite3_vmprintf(msg_format, va); if (msg == NULL) { dc_log_error(sql->context, 0, "Bad log format string \"%s\".", msg_format); }
dc_log_error(sql->context, 0, "%s SQLite says: %s", msg, sql->cobj? sqlite3_errmsg(sql->cobj) : notSetUp);
@ -92,7 +91,7 @@ int dc_sqlite3_execute(dc_sqlite3_t* sql, const char* querystr)
{
int success = 0;
sqlite3_stmt* stmt = NULL;
int sqlState;
int sqlState = 0;
stmt = dc_sqlite3_prepare(sql, querystr);
if (stmt == NULL) {
@ -513,7 +512,7 @@ int dc_sqlite3_table_exists(dc_sqlite3_t* sql, const char* name)
int ret = 0;
char* querystr = NULL;
sqlite3_stmt* stmt = NULL;
int sqlState;
int sqlState = 0;
if ((querystr=sqlite3_mprintf("PRAGMA table_info(%s)", name)) == NULL) { /* this statement cannot be used with binded variables */
dc_log_error(sql->context, 0, "dc_sqlite3_table_exists_(): Out of memory.");
@ -553,8 +552,8 @@ cleanup:
int dc_sqlite3_set_config(dc_sqlite3_t* sql, const char* key, const char* value)
{
int state;
sqlite3_stmt* stmt;
int state = 0;
sqlite3_stmt* stmt = NULL;
if (key == NULL) {
dc_log_error(sql->context, 0, "dc_sqlite3_set_config(): Bad parameter.");
@ -614,7 +613,7 @@ int dc_sqlite3_set_config(dc_sqlite3_t* sql, const char* key, const char* value)
char* dc_sqlite3_get_config(dc_sqlite3_t* sql, const char* key, const char* def) /* the returned string must be free()'d, NULL is only returned if def is NULL */
{
sqlite3_stmt* stmt;
sqlite3_stmt* stmt = NULL;
if (!dc_sqlite3_is_open(sql) || key == NULL) {
return dc_strdup_keep_null(def);

4
src/dc_strbuilder.c
View file

@ -124,8 +124,8 @@ char* dc_strbuilder_cat(dc_strbuilder_t* strbuilder, const char* text)
void dc_strbuilder_catf(dc_strbuilder_t* strbuilder, const char* format, ...)
{
char testbuf[1];
char* buf;
int char_cnt_without_zero;
char* buf = NULL;
int char_cnt_without_zero = 0;
va_list argp;
va_list argp_copy;

41
src/dc_strencode.c
View file

@ -155,7 +155,7 @@ char* dc_urldecode(const char* to_decode)
static int to_be_quoted(const char * word, size_t size)
{
const char* cur = word;
size_t i;
size_t i = 0;
for (i = 0; i < size; i++)
{
@ -198,10 +198,10 @@ static int to_be_quoted(const char * word, size_t size)
static int quote_word(const char* display_charset, MMAPString* mmapstr, const char* word, size_t size)
{
const char * cur;
size_t i;
char hex[4];
int col;
const char* cur = NULL;
size_t i = 0;
char hex[4];
int col = 0;
if (mmap_string_append(mmapstr, "=?") == NULL) {
return 0;
@ -502,9 +502,16 @@ char* dc_encode_modified_utf7(const char* to_encode, int change_spaces)
#define UTF16LOEND 0xDFFFUL
#define UNDEFINED 64
unsigned int utf8pos, utf8total, c, utf7mode, bitstogo, utf16flag;
unsigned long ucs4 = 0, bitbuf = 0;
char *dst, *res;
unsigned int utf8pos = 0;
unsigned int utf8total = 0;
unsigned int c = 0;
unsigned int utf7mode = 0;
unsigned int bitstogo = 0;
unsigned int utf16flag = 0;
unsigned long ucs4 = 0;
unsigned long bitbuf = 0;
char* dst = NULL;
char* res = NULL;
if (!to_encode) {
return dc_strdup("");
@ -635,11 +642,16 @@ char* dc_encode_modified_utf7(const char* to_encode, int change_spaces)
*/
char* dc_decode_modified_utf7(const char *to_decode, int change_spaces)
{
unsigned c, i, bitcount;
unsigned long ucs4, utf16, bitbuf;
unsigned c = 0;
unsigned i = 0;
unsigned bitcount = 0;
unsigned long ucs4 = 0;
unsigned long utf16 = 0;
unsigned long bitbuf = 0;
unsigned char base64[256];
const char *src;
char *dst, *res;
const char* src = NULL;
char* dst = NULL;
char* res = NULL;
if (to_decode == NULL) {
return dc_strdup("");
@ -825,8 +837,9 @@ char* dc_encode_ext_header(const char* to_encode)
*/
char* dc_decode_ext_header(const char* to_decode)
{
char *decoded = NULL, *charset = NULL;
const char *p2 = NULL;
char* decoded = NULL;
char* charset = NULL;
const char* p2 = NULL;
if (to_decode == NULL) {
goto cleanup;

4
src/dc_token.c
View file

@ -48,7 +48,7 @@ cleanup:
char* dc_token_lookup(dc_context_t* context, dc_tokennamespc_t namespc, uint32_t foreign_id)
{
char* token = NULL;
sqlite3_stmt* stmt = NULL;
sqlite3_stmt* stmt = NULL;
if (context == NULL || context->magic != DC_CONTEXT_MAGIC) {
goto cleanup;
@ -71,7 +71,7 @@ cleanup:
int dc_token_exists(dc_context_t* context, dc_tokennamespc_t namespc, const char* token)
{
int exists = 0;
sqlite3_stmt* stmt = NULL;
sqlite3_stmt* stmt = NULL;
if (context == NULL || context->magic != DC_CONTEXT_MAGIC || token == NULL) {
goto cleanup;

124
src/dc_tools.c
View file

@ -51,7 +51,7 @@ int dc_exactly_one_bit_set(int v)
char* dc_strdup(const char* s) /* strdup(NULL) is undefined, save_strdup(NULL) returns an empty string in this case */
{
char* ret;
char* ret = NULL;
if (s) {
if ((ret=strdup(s)) == NULL) {
exit(16); /* cannot allocate (little) memory, unrecoverable error */
@ -80,8 +80,8 @@ int dc_atoi_null_is_0(const char* s)
void dc_ltrim(char* buf)
{
size_t len;
const unsigned char* cur;
size_t len = 0;
const unsigned char* cur = NULL;
if (buf && *buf) {
len = strlen(buf);
@ -100,8 +100,8 @@ void dc_ltrim(char* buf)
void dc_rtrim(char* buf)
{
size_t len;
unsigned char* cur;
size_t len = 0;
unsigned char* cur = NULL;
if (buf && *buf) {
len = strlen(buf);
@ -150,7 +150,10 @@ char* dc_strlower(const char* in) /* the result must be free()'d */
*/
int dc_str_replace(char** haystack, const char* needle, const char* replacement)
{
int replacements = 0, start_search_pos = 0, needle_len, replacement_len;
int replacements = 0;
int start_search_pos = 0;
int needle_len = 0;
int replacement_len = 0;
if (haystack==NULL || *haystack==NULL || needle == NULL || needle[0]==0) {
return 0;
@ -242,7 +245,7 @@ char* dc_null_terminate(const char* in, int bytes) /* the result must be free()'
char* dc_binary_to_uc_hex(const uint8_t* buf, size_t bytes)
{
char* hex = NULL;
int i;
int i = 0;
if (buf == NULL || bytes <= 0) {
goto cleanup;
@ -264,8 +267,8 @@ cleanup:
char* dc_mprintf(const char* format, ...)
{
char testbuf[1];
char* buf;
int char_cnt_without_zero;
char* buf = NULL;
int char_cnt_without_zero = 0;
va_list argp;
va_list argp_copy;
@ -369,14 +372,19 @@ void dc_replace_bad_utf8_chars(char* buf)
unsigned char* p1 = (unsigned char*)buf; /* force unsigned - otherwise the `> ' '` comparison will fail */
int p1len = strlen(buf);
int c, i, ix, n, j;
int c = 0;
int i = 0;
int ix = 0;
int n = 0;
int j = 0;
for (i=0, ix=p1len; i < ix; i++)
{
c = p1[i];
if (c > 0 && c <= 0x7f) { n=0; } /* 0bbbbbbb */
else if ((c & 0xE0) == 0xC0) { n=1; } /* 110bbbbb */
if (c > 0 && c <= 0x7f) { n=0; } /* 0bbbbbbb */
else if ((c & 0xE0) == 0xC0) { n=1; } /* 110bbbbb */
else if (c==0xed && i<(ix-1) && (p1[i+1] & 0xa0)==0xa0) { goto error; } /* U+d800 to U+dfff */
else if ((c & 0xF0) == 0xE0) { n=2; } /* 1110bbbb */
else if ((c & 0xF0) == 0xE0) { n=2; } /* 1110bbbb */
else if ((c & 0xF8) == 0xF0) { n=3; } /* 11110bbb */
//else if ((c & 0xFC) == 0xF8) { n=4; } /* 111110bb - not valid in https://tools.ietf.org/html/rfc3629 */
//else if ((c & 0xFE) == 0xFC) { n=5; } /* 1111110b - not valid in https://tools.ietf.org/html/rfc3629 */
@ -407,7 +415,8 @@ error:
#if 0 /* not needed at the moment */
static size_t dc_utf8_strlen(const char* s)
{
size_t i = 0, j = 0;
size_t i = 0;
size_t j = 0;
while (s[i]) {
if ((s[i]&0xC0) != 0x80)
j++;
@ -420,7 +429,8 @@ static size_t dc_utf8_strlen(const char* s)
static size_t dc_utf8_strnlen(const char* s, size_t n)
{
size_t i = 0, j = 0;
size_t i = 0;
size_t j = 0;
while (i < n) {
if ((s[i]&0xC0) != 0x80)
j++;
@ -494,12 +504,12 @@ void dc_truncate_str(char* buf, int approx_chars)
carray* dc_split_into_lines(const char* buf_terminated)
{
carray* lines = carray_new(1024);
carray* lines = carray_new(1024);
size_t line_chars = 0;
const char* p1 = buf_terminated;
const char* line_start = p1;
unsigned int l_indx = 0;
size_t line_chars = 0;
const char* p1 = buf_terminated;
const char* line_start = p1;
unsigned int l_indx;
while (*p1) {
if (*p1 == '\n') {
carray_add(lines, (void*)strndup(line_start, line_chars), &l_indx);
@ -539,8 +549,10 @@ char* dc_insert_breaks(const char* in, int break_every, const char* break_chars)
return dc_strdup(in);
}
int out_len = strlen(in), chars_added = 0;
int out_len = strlen(in);
int chars_added = 0;
int break_chars_len = strlen(break_chars);
out_len += (out_len/break_every+1)*break_chars_len + 1/*nullbyte*/;
char* out = malloc(out_len);
@ -569,8 +581,7 @@ char* dc_insert_breaks(const char* in, int break_every, const char* break_chars)
void clist_free_content(const clist* haystack)
{
clistiter* iter;
for (iter=clist_begin(haystack); iter!=NULL; iter=clist_next(iter)) {
for (clistiter* iter=clist_begin(haystack); iter!=NULL; iter=clist_next(iter)) {
free(iter->data);
iter->data = NULL;
}
@ -579,8 +590,7 @@ void clist_free_content(const clist* haystack)
int clist_search_string_nocase(const clist* haystack, const char* needle)
{
clistiter* iter;
for (iter=clist_begin(haystack); iter!=NULL; iter=clist_next(iter)) {
for (clistiter* iter=clist_begin(haystack); iter!=NULL; iter=clist_next(iter)) {
if (strcasecmp((const char*)iter->data, needle)==0) {
return 1;
}
@ -596,7 +606,7 @@ int clist_search_string_nocase(const clist* haystack, const char* needle)
static int tmcomp(struct tm * atmp, struct tm * btmp) /* from mailcore2 */
{
int result;
int result = 0;
if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
@ -610,11 +620,12 @@ static int tmcomp(struct tm * atmp, struct tm * btmp) /* from mailcore2 */
static time_t mkgmtime(struct tm * tmp) /* from mailcore2 */
{
int dir;
int bits;
int saved_seconds;
time_t t;
struct tm yourtm, mytm;
int dir = 0;
int bits = 0;
int saved_seconds = 0;
time_t t = 0;
struct tm yourtm;
struct tm mytm;
yourtm = *tmp;
saved_seconds = yourtm.tm_sec;
@ -656,9 +667,9 @@ static time_t mkgmtime(struct tm * tmp) /* from mailcore2 */
time_t dc_timestamp_from_date(struct mailimf_date_time * date_time) /* from mailcore2 */
{
struct tm tmval;
time_t timeval;
int zone_min;
int zone_hour;
time_t timeval = 0;
int zone_min = 0;
int zone_hour = 0;
tmval.tm_sec = date_time->dt_sec;
tmval.tm_min = date_time->dt_min;
@ -693,7 +704,7 @@ 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. */
time_t gmtime = time(NULL);
time_t gmtime = time(NULL);
struct tm timeinfo = {0};
localtime_r(&gmtime, &timeinfo);
return timeinfo.tm_gmtoff;
@ -720,13 +731,13 @@ char* dc_timestamp_to_str(time_t wanted)
struct mailimap_date_time* dc_timestamp_to_mailimap_date_time(time_t timeval)
{
struct tm gmt;
struct tm lt;
int off;
struct mailimap_date_time * date_time;
int sign;
int hour;
int min;
struct tm gmt;
struct tm lt;
int off = 0;
struct mailimap_date_time* date_time;
int sign = 0;
int hour = 0;
int min = 0;
gmtime_r(&timeval, &gmt);
localtime_r(&timeval, &lt);
@ -911,8 +922,10 @@ char* dc_create_incoming_rfc724_mid(time_t message_timestamp, uint32_t contact_i
}
/* find out the largest receiver ID (we could also take the smallest, but it should be unique) */
size_t i, icnt = dc_array_get_cnt(contact_ids_to);
size_t i = 0;
size_t icnt = dc_array_get_cnt(contact_ids_to);
uint32_t largest_id_to = 0;
for (i = 0; i < icnt; i++) {
uint32_t cur_id = dc_array_get_id(contact_ids_to, i);
if (cur_id > largest_id_to) {
@ -930,8 +943,9 @@ 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;
char* grpid = NULL, *p1;
int grpid_len;
char* grpid = NULL;
char* p1 = NULL;
int grpid_len = 0;
if (mid == NULL || strlen(mid)<8 || mid[0]!='G' || mid[1]!='r' || mid[2]!='.') {
goto cleanup;
@ -961,9 +975,8 @@ cleanup:
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)) {
for (clistiter* cur = clist_begin(list); cur!=NULL ; cur=clist_next(cur)) {
const char* mid = clist_content(cur);
char* grpid = dc_extract_grpid_from_rfc724_mid(mid);
if (grpid) {
@ -1039,10 +1052,12 @@ int dc_delete_file(const char* pathNfilename, 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;
int success = 0;
int fd_src = -1;
int fd_dest = -1;
#define DC_COPY_BUF_SIZE 4096
char buf[DC_COPY_BUF_SIZE];
size_t bytes_read;
size_t bytes_read = 0;
int anything_copied = 0;
if (src==NULL || dest==NULL) {
@ -1118,8 +1133,10 @@ void dc_split_filename(const char* pathNfilename, char** ret_basename, char** re
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 = dc_get_filename(pathNfilename), *suffix;
char* basename = dc_get_filename(pathNfilename);
char* suffix = NULL;
char* p1 = strrchr(basename, '.');
if (p1) {
suffix = dc_strdup(p1);
*p1 = 0;
@ -1150,10 +1167,13 @@ void dc_validate_filename(char* filename)
char* dc_get_fine_pathNfilename(const char* folder, const char* desired_filenameNsuffix__)
{
char* ret = NULL, *filenameNsuffix, *basename = NULL, *dotNSuffix = NULL;
char* ret = NULL;
char* filenameNsuffix = NULL;
char* basename = NULL;
char* dotNSuffix = NULL;
time_t now = time(NULL);
struct stat st;
int i;
int i = 0;
filenameNsuffix = dc_strdup(desired_filenameNsuffix__);
dc_validate_filename(filenameNsuffix);