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

refactor hash, constants

Browse source
This commit is contained in:
B. Petersen 2018-06-25 18:20:08 +02:00
parent a15a50b383
commit 41037ef714
19 changed files with 135 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

10
cmdline/stress.c
View file

@ -302,7 +302,7 @@ void stress_functions(dc_context_t* context)
str = strdup("this is a little test string");
dc_truncate_str(str, 16);
assert( strcmp(str, "this is a " MR_EDITORIAL_ELLIPSE)==0 );
assert( strcmp(str, "this is a " DC_EDITORIAL_ELLIPSE)==0 );
free(str);
str = strdup("1234");
@ -371,10 +371,10 @@ void stress_functions(dc_context_t* context)
assert( strcmp("self=" DC_STRINGIFY(DC_CONTACT_ID_SELF), "self=1")==0 );
assert( strcmp("spcl_contact=" DC_STRINGIFY(DC_CONTACT_ID_LAST_SPECIAL), "spcl_contact=9")==0 );
assert( strcmp("grpimg=" DC_STRINGIFY(MR_CMD_GROUPIMAGE_CHANGED), "grpimg=3")==0 );
assert( strcmp("grpimg=" DC_STRINGIFY(DC_CMD_GROUPIMAGE_CHANGED), "grpimg=3")==0 );
assert( strcmp("notverified=" DC_STRINGIFY(MRV_NOT_VERIFIED), "notverified=0")==0 );
assert( strcmp("bidirectional=" DC_STRINGIFY(MRV_BIDIRECTIONAL), "bidirectional=2")==0 );
assert( strcmp("notverified=" DC_STRINGIFY(DC_NOT_VERIFIED), "notverified=0")==0 );
assert( strcmp("bidirectional=" DC_STRINGIFY(DC_BIDIRECT_VERIFIED), "bidirectional=2")==0 );
assert( strcmp("public=" DC_STRINGIFY(DC_KEY_PUBLIC), "public=0")==0 );
assert( strcmp("private=" DC_STRINGIFY(DC_KEY_PRIVATE), "private=1")==0 );
@ -812,7 +812,7 @@ void stress_functions(dc_context_t* context)
void* plain = NULL;
dc_hash_t valid_signatures;
dc_hash_init(&valid_signatures, MRHASH_STRING, 1/*copy key*/);
dc_hash_init(&valid_signatures, DC_HASH_STRING, 1/*copy key*/);
int ok;
ok = dc_pgp_pk_decrypt(context, ctext_signed, ctext_signed_bytes, keyring, public_keyring/*for validate*/, 1, &plain, &plain_bytes, &valid_signatures);

44
src/dc_apeerstate.c
View file

@ -182,7 +182,7 @@ int dc_apeerstate_save_to_db__(const dc_apeerstate_t* ths, dc_sqlite3_t* sql, in
sqlite3_step(stmt);
}
if( (ths->m_to_save&MRA_SAVE_ALL) || create )
if( (ths->m_to_save&DC_SAVE_ALL) || create )
{
stmt = dc_sqlite3_predefine__(sql, UPDATE_acpeerstates_SET_lcpp_WHERE_a,
"UPDATE acpeerstates "
@ -204,7 +204,7 @@ int dc_apeerstate_save_to_db__(const dc_apeerstate_t* ths, dc_sqlite3_t* sql, in
goto cleanup;
}
}
else if( ths->m_to_save&MRA_SAVE_TIMESTAMPS )
else if( ths->m_to_save&DC_SAVE_TIMESTAMPS )
{
stmt = dc_sqlite3_predefine__(sql, UPDATE_acpeerstates_SET_l_WHERE_a,
"UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? WHERE addr=?;");
@ -301,8 +301,8 @@ cleanup:
*
* @param peerstate The peerstate object.
* @param min_verified The minimal verification criterion the key should match.
* Typically either MRV_NOT_VERIFIED (0) if there is no need for the key being verified
* or MRV_BIDIRECTIONAL (2) for bidirectional verification requirement.
* Typically either DC_NOT_VERIFIED (0) if there is no need for the key being verified
* or DC_BIDIRECT_VERIFIED (2) for bidirectional verification requirement.
*
* @return m_public_key or m_gossip_key, NULL if nothing is available.
* the returned pointer MUST NOT be unref()'d.
@ -345,7 +345,7 @@ int dc_apeerstate_init_from_header(dc_apeerstate_t* ths, const dc_aheader_t* hea
ths->m_addr = safe_strdup(header->m_addr);
ths->m_last_seen = message_time;
ths->m_last_seen_autocrypt = message_time;
ths->m_to_save = MRA_SAVE_ALL;
ths->m_to_save = DC_SAVE_ALL;
ths->m_prefer_encrypt = header->m_prefer_encrypt;
ths->m_public_key = dc_key_new();
@ -365,7 +365,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_gossip_timestamp = message_time;
peerstate->m_to_save = MRA_SAVE_ALL;
peerstate->m_to_save = DC_SAVE_ALL;
peerstate->m_gossip_key = dc_key_new();
dc_key_set_from_key(peerstate->m_gossip_key, gossip_header->m_public_key);
@ -382,12 +382,12 @@ int dc_apeerstate_degrade_encryption(dc_apeerstate_t* ths, time_t message_time)
}
if( ths->m_prefer_encrypt == DC_PE_MUTUAL ) {
ths->m_degrade_event |= MRA_DE_ENCRYPTION_PAUSED;
ths->m_degrade_event |= DC_DE_ENCRYPTION_PAUSED;
}
ths->m_prefer_encrypt = DC_PE_RESET;
ths->m_last_seen = message_time; /*last_seen_autocrypt is not updated as there was not Autocrypt:-header seen*/
ths->m_to_save = MRA_SAVE_ALL;
ths->m_to_save = DC_SAVE_ALL;
return 1;
}
@ -406,17 +406,17 @@ void dc_apeerstate_apply_header(dc_apeerstate_t* ths, const dc_aheader_t* header
{
ths->m_last_seen = message_time;
ths->m_last_seen_autocrypt = message_time;
ths->m_to_save |= MRA_SAVE_TIMESTAMPS;
ths->m_to_save |= DC_SAVE_TIMESTAMPS;
if( (header->m_prefer_encrypt==DC_PE_MUTUAL || header->m_prefer_encrypt==DC_PE_NOPREFERENCE) /*this also switches from DC_PE_RESET to DC_PE_NOPREFERENCE, which is just fine as the function is only called _if_ the Autocrypt:-header is preset at all */
&& header->m_prefer_encrypt != ths->m_prefer_encrypt )
{
if( ths->m_prefer_encrypt == DC_PE_MUTUAL && header->m_prefer_encrypt != DC_PE_MUTUAL ) {
ths->m_degrade_event |= MRA_DE_ENCRYPTION_PAUSED;
ths->m_degrade_event |= DC_DE_ENCRYPTION_PAUSED;
}
ths->m_prefer_encrypt = header->m_prefer_encrypt;
ths->m_to_save |= MRA_SAVE_ALL;
ths->m_to_save |= DC_SAVE_ALL;
}
if( ths->m_public_key == NULL ) {
@ -427,7 +427,7 @@ void dc_apeerstate_apply_header(dc_apeerstate_t* ths, const dc_aheader_t* header
{
dc_key_set_from_key(ths->m_public_key, header->m_public_key);
dc_apeerstate_recalc_fingerprint(ths);
ths->m_to_save |= MRA_SAVE_ALL;
ths->m_to_save |= DC_SAVE_ALL;
}
}
}
@ -445,7 +445,7 @@ void dc_apeerstate_apply_gossip(dc_apeerstate_t* peerstate, const dc_aheader_t*
if( message_time > peerstate->m_gossip_timestamp )
{
peerstate->m_gossip_timestamp = message_time;
peerstate->m_to_save |= MRA_SAVE_TIMESTAMPS;
peerstate->m_to_save |= DC_SAVE_TIMESTAMPS;
if( peerstate->m_gossip_key == NULL ) {
peerstate->m_gossip_key = dc_key_new();
@ -455,7 +455,7 @@ void dc_apeerstate_apply_gossip(dc_apeerstate_t* peerstate, const dc_aheader_t*
{
dc_key_set_from_key(peerstate->m_gossip_key, gossip_header->m_public_key);
dc_apeerstate_recalc_fingerprint(peerstate);
peerstate->m_to_save |= MRA_SAVE_ALL;
peerstate->m_to_save |= DC_SAVE_ALL;
}
}
}
@ -490,10 +490,10 @@ int dc_apeerstate_recalc_fingerprint(dc_apeerstate_t* peerstate)
|| peerstate->m_public_key_fingerprint[0] == 0
|| strcasecmp(old_public_fingerprint, peerstate->m_public_key_fingerprint) != 0 )
{
peerstate->m_to_save |= MRA_SAVE_ALL;
peerstate->m_to_save |= DC_SAVE_ALL;
if( old_public_fingerprint && old_public_fingerprint[0] ) { // no degrade event when we recveive just the initial fingerprint
peerstate->m_degrade_event |= MRA_DE_FINGERPRINT_CHANGED;
peerstate->m_degrade_event |= DC_DE_FINGERPRINT_CHANGED;
}
}
}
@ -509,10 +509,10 @@ int dc_apeerstate_recalc_fingerprint(dc_apeerstate_t* peerstate)
|| peerstate->m_gossip_key_fingerprint[0] == 0
|| strcasecmp(old_gossip_fingerprint, peerstate->m_gossip_key_fingerprint) != 0 )
{
peerstate->m_to_save |= MRA_SAVE_ALL;
peerstate->m_to_save |= DC_SAVE_ALL;
if( old_gossip_fingerprint && old_gossip_fingerprint[0] ) { // no degrade event when we recveive just the initial fingerprint
peerstate->m_degrade_event |= MRA_DE_FINGERPRINT_CHANGED;
peerstate->m_degrade_event |= DC_DE_FINGERPRINT_CHANGED;
}
}
}
@ -538,7 +538,7 @@ cleanup:
* @param peerstate The peerstate object.
* @param which_key Which key should be marked as being verified? MRA_GOSSIP_KEY (1) or MRA_PUBLIC_KEY (2)
* @param fingerprint Fingerprint expected in the object
* @param verified MRV_BIDIRECTIONAL (2): contact verfied in both directions
* @param verified DC_BIDIRECT_VERIFIED (2): contact verfied in both directions
*
* @return 1=the given fingerprint is equal to the peer's fingerprint and
* the verified-state is set; you should call dc_apeerstate_save_to_db__()
@ -552,7 +552,7 @@ int dc_apeerstate_set_verified(dc_apeerstate_t* peerstate, int which_key, const
if( peerstate == NULL
|| (which_key!=MRA_GOSSIP_KEY && which_key!=MRA_PUBLIC_KEY)
|| (verified!=MRV_BIDIRECTIONAL) ) {
|| (verified!=DC_BIDIRECT_VERIFIED) ) {
goto cleanup;
}
@ -562,7 +562,7 @@ int dc_apeerstate_set_verified(dc_apeerstate_t* peerstate, int which_key, const
&& fingerprint[0] != 0
&& strcasecmp(peerstate->m_public_key_fingerprint, fingerprint) == 0 )
{
peerstate->m_to_save |= MRA_SAVE_ALL;
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);
success = 1;
@ -574,7 +574,7 @@ int dc_apeerstate_set_verified(dc_apeerstate_t* peerstate, int which_key, const
&& fingerprint[0] != 0
&& strcasecmp(peerstate->m_gossip_key_fingerprint, fingerprint) == 0 )
{
peerstate->m_to_save |= MRA_SAVE_ALL;
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);
success = 1;

20
src/dc_apeerstate.h
View file

@ -44,7 +44,7 @@ typedef struct dc_aheader_t dc_aheader_t;
typedef struct dc_apeerstate_t
{
/** @privatesection */
dc_context_t* m_context;
dc_context_t* m_context;
char* m_addr;
time_t m_last_seen; /* may be 0 if the peer was created by gossipping */
@ -52,25 +52,25 @@ typedef struct dc_apeerstate_t
time_t m_last_seen_autocrypt;
int m_prefer_encrypt;
#define MRV_NOT_VERIFIED 0
#define MRV_BIDIRECTIONAL 2
#define DC_NOT_VERIFIED 0
#define DC_BIDIRECT_VERIFIED 2
dc_key_t* m_public_key; /* may be NULL, however, in the database, either public_key or gossip_key is set */
dc_key_t* m_public_key; /* may be NULL, however, in the database, either public_key or gossip_key is set */
char* m_public_key_fingerprint;
dc_key_t* m_gossip_key; /* may be NULL */
dc_key_t* m_gossip_key; /* may be NULL */
time_t m_gossip_timestamp;
char* m_gossip_key_fingerprint;
dc_key_t* m_verified_key; // may be NULL
dc_key_t* m_verified_key; // may be NULL
char* m_verified_key_fingerprint;
#define MRA_SAVE_TIMESTAMPS 0x01
#define MRA_SAVE_ALL 0x02
#define DC_SAVE_TIMESTAMPS 0x01
#define DC_SAVE_ALL 0x02
int m_to_save;
#define MRA_DE_ENCRYPTION_PAUSED 0x01 // recoverable by an incoming encrypted mail
#define MRA_DE_FINGERPRINT_CHANGED 0x02 // recoverable by a new verify
#define DC_DE_ENCRYPTION_PAUSED 0x01 // recoverable by an incoming encrypted mail
#define DC_DE_FINGERPRINT_CHANGED 0x02 // recoverable by a new verify
int m_degrade_event;
} dc_apeerstate_t;

8
src/dc_contact.c
View file

@ -277,18 +277,18 @@ int dc_contact_is_blocked(const dc_contact_t* contact)
int dc_contact_is_verified__(const dc_contact_t* contact, const dc_apeerstate_t* peerstate)
{
int contact_verified = MRV_NOT_VERIFIED;
int contact_verified = DC_NOT_VERIFIED;
if( contact == NULL || contact->m_magic != MR_CONTACT_MAGIC ) {
goto cleanup;
}
if( contact->m_id == MR_CONTACT_ID_SELF ) {
contact_verified = MRV_BIDIRECTIONAL;
contact_verified = DC_BIDIRECT_VERIFIED;
goto cleanup; // we're always sort of secured-verified as we could verify the key on this device any time with the key on this device
}
contact_verified = peerstate->m_verified_key? MRV_BIDIRECTIONAL : 0;
contact_verified = peerstate->m_verified_key? DC_BIDIRECT_VERIFIED : 0;
cleanup:
return contact_verified;
@ -310,7 +310,7 @@ cleanup:
*/
int dc_contact_is_verified(const dc_contact_t* contact)
{
int contact_verified = MRV_NOT_VERIFIED;
int contact_verified = DC_NOT_VERIFIED;
int locked = 0;
dc_apeerstate_t* peerstate = NULL;

16
src/dc_context.c
View file

@ -2759,7 +2759,7 @@ int dc_set_chat_name(dc_context_t* context, uint32_t chat_id, const char* new_na
{
msg->m_type = MR_MSG_TEXT;
msg->m_text = mrstock_str_repl_string2(MR_STR_MSGGRPNAME, chat->m_name, new_name);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_GROUPNAME_CHANGED);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, DC_CMD_GROUPNAME_CHANGED);
msg->m_id = dc_send_msg_object(context, chat_id, msg);
context->m_cb(context, DC_EVENT_MSGS_CHANGED, chat_id, msg->m_id);
}
@ -2831,7 +2831,7 @@ int dc_set_chat_profile_image(dc_context_t* context, uint32_t chat_id, const cha
/* send a status mail to all group members, also needed for outself to allow multi-client */
if( DO_SEND_STATUS_MAILS )
{
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_GROUPIMAGE_CHANGED);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, DC_CMD_GROUPIMAGE_CHANGED);
dc_param_set (msg->m_param, DC_PARAM_CMD_ARG, new_image);
msg->m_type = MR_MSG_TEXT;
msg->m_text = mrstock_str(new_image? MR_STR_MSGGRPIMGCHANGED : MR_STR_MSGGRPIMGDELETED);
@ -2957,7 +2957,7 @@ int dc_add_contact_to_chat_ex(dc_context_t* context, uint32_t chat_id, uint32_t
if( chat->m_type == MR_CHAT_TYPE_VERIFIED_GROUP )
{
if( !dc_apeerstate_load_by_addr__(peerstate, context->m_sql, contact->m_addr)
|| dc_contact_is_verified__(contact, peerstate) != MRV_BIDIRECTIONAL ) {
|| dc_contact_is_verified__(contact, peerstate) != DC_BIDIRECT_VERIFIED ) {
dc_log_error(context, 0, "Only bidirectional verified contacts can be added to verfied groups.");
goto cleanup;
}
@ -2976,7 +2976,7 @@ int dc_add_contact_to_chat_ex(dc_context_t* context, uint32_t chat_id, uint32_t
{
msg->m_type = MR_MSG_TEXT;
msg->m_text = mrstock_str_repl_string(MR_STR_MSGADDMEMBER, (contact->m_authname&&contact->m_authname[0])? contact->m_authname : contact->m_addr);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_MEMBER_ADDED_TO_GROUP);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, DC_CMD_MEMBER_ADDED_TO_GROUP);
dc_param_set (msg->m_param, DC_PARAM_CMD_ARG ,contact->m_addr);
dc_param_set_int(msg->m_param, DC_PARAM_CMD_ARG2,flags); // combine the Secure-Join protocol headers with the Chat-Group-Member-Added header
msg->m_id = dc_send_msg_object(context, chat_id, msg);
@ -3083,7 +3083,7 @@ int dc_remove_contact_from_chat(dc_context_t* context, uint32_t chat_id, uint32_
else {
msg->m_text = mrstock_str_repl_string(MR_STR_MSGDELMEMBER, (contact->m_authname&&contact->m_authname[0])? contact->m_authname : contact->m_addr);
}
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_MEMBER_REMOVED_FROM_GROUP);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, DC_CMD_MEMBER_REMOVED_FROM_GROUP);
dc_param_set (msg->m_param, DC_PARAM_CMD_ARG, contact->m_addr);
msg->m_id = dc_send_msg_object(context, chat_id, msg);
context->m_cb(context, DC_EVENT_MSGS_CHANGED, chat_id, msg->m_id);
@ -3851,7 +3851,7 @@ char* dc_get_contact_encrinfo(dc_context_t* context, uint32_t contact_id)
dc_sqlite3_unlock(context->m_sql);
locked = 0;
if( dc_apeerstate_peek_key(peerstate, MRV_NOT_VERIFIED) )
if( dc_apeerstate_peek_key(peerstate, DC_NOT_VERIFIED) )
{
// E2E available :)
p = mrstock_str(peerstate->m_prefer_encrypt == DC_PE_MUTUAL? MR_STR_E2E_PREFERRED : MR_STR_E2E_AVAILABLE); dc_strbuilder_cat(&ret, p); free(p);
@ -3871,8 +3871,8 @@ char* dc_get_contact_encrinfo(dc_context_t* context, uint32_t contact_id)
dc_strbuilder_cat(&ret, ":");
fingerprint_self = dc_key_get_formatted_fingerprint(self_key);
fingerprint_other_verified = dc_key_get_formatted_fingerprint(dc_apeerstate_peek_key(peerstate, MRV_BIDIRECTIONAL));
fingerprint_other_unverified = dc_key_get_formatted_fingerprint(dc_apeerstate_peek_key(peerstate, MRV_NOT_VERIFIED));
fingerprint_other_verified = dc_key_get_formatted_fingerprint(dc_apeerstate_peek_key(peerstate, DC_BIDIRECT_VERIFIED));
fingerprint_other_unverified = dc_key_get_formatted_fingerprint(dc_apeerstate_peek_key(peerstate, DC_NOT_VERIFIED));
if( strcmp(loginparam->m_addr, peerstate->m_addr)<0 ) {
cat_fingerprint(&ret, loginparam->m_addr, fingerprint_self, NULL);

4
src/dc_e2ee.c
View file

@ -786,7 +786,7 @@ static dc_hash_t* update_gossip_peerstates(dc_context_t* mailbox, time_t message
// verified when used in a verified group by a verified sender
if( gossipped_addr == NULL ) {
gossipped_addr = malloc(sizeof(dc_hash_t));
dc_hash_init(gossipped_addr, MRHASH_STRING, 1/*copy key*/);
dc_hash_init(gossipped_addr, DC_HASH_STRING, 1/*copy key*/);
}
dc_hash_insert(gossipped_addr, gossip_header->m_addr, strlen(gossip_header->m_addr), (void*)1);
}
@ -917,7 +917,7 @@ void dc_e2ee_decrypt(dc_context_t* mailbox, struct mailmime* in_out_message,
/* finally, decrypt. If sth. was decrypted, decrypt_recursive() returns "true" and we start over to decrypt maybe just added parts. */
helper->m_signatures = malloc(sizeof(dc_hash_t));
dc_hash_init(helper->m_signatures, MRHASH_STRING, 1/*copy key*/);
dc_hash_init(helper->m_signatures, DC_HASH_STRING, 1/*copy key*/);
int iterations = 0;
while( iterations < 10 ) {

20
src/dc_hash.c
View file

@ -113,10 +113,10 @@ static int sjhashNoCase(const char *z, int n)
void dc_hash_init(dc_hash_t *pNew, int keyClass, int copyKey)
{
assert( pNew!=0 );
assert( keyClass>=MRHASH_INT && keyClass<=MRHASH_BINARY );
assert( keyClass>=DC_HASH_INT && keyClass<=DC_HASH_BINARY );
pNew->keyClass = keyClass;
if( keyClass==MRHASH_POINTER || keyClass==MRHASH_INT ) copyKey = 0;
if( keyClass==DC_HASH_POINTER || keyClass==DC_HASH_INT ) copyKey = 0;
pNew->copyKey = copyKey;
pNew->first = 0;
@ -239,10 +239,10 @@ static int (*hashFunction(int keyClass))(const void*,int)
{
switch( keyClass )
{
case MRHASH_INT: return &intHash;
case MRHASH_POINTER:return &ptrHash;
case MRHASH_STRING: return &strHash;
case MRHASH_BINARY: return &binHash;;
case DC_HASH_INT: return &intHash;
case DC_HASH_POINTER:return &ptrHash;
case DC_HASH_STRING: return &strHash;
case DC_HASH_BINARY: return &binHash;;
default: break;
}
return 0;
@ -256,10 +256,10 @@ static int (*compareFunction(int keyClass))(const void*,int,const void*,int)
{
switch( keyClass )
{
case MRHASH_INT: return &intCompare;
case MRHASH_POINTER: return &ptrCompare;
case MRHASH_STRING: return &strCompare;
case MRHASH_BINARY: return &binCompare;
case DC_HASH_INT: return &intCompare;
case DC_HASH_POINTER: return &ptrCompare;
case DC_HASH_STRING: return &strCompare;
case DC_HASH_BINARY: return &binCompare;
default: break;
}
return 0;

24
src/dc_hash.h
View file

@ -20,8 +20,8 @@
******************************************************************************/
#ifndef __MRHASH_H__
#define __MRHASH_H__
#ifndef __DC_HASH_H__
#define __DC_HASH_H__
#ifdef __cplusplus
extern "C"
{
@ -74,24 +74,24 @@ typedef struct mrhashelem_t
/*
* There are 4 different modes of operation for a hash table:
*
* MRHASH_INT nKey is used as the key and pKey is ignored.
* DC_HASH_INT nKey is used as the key and pKey is ignored.
*
* MRHASH_POINTER pKey is used as the key and nKey is ignored.
* DC_HASH_POINTER pKey is used as the key and nKey is ignored.
*
* MRHASH_STRING pKey points to a string that is nKey bytes long
* DC_HASH_STRING pKey points to a string that is nKey bytes long
* (including the null-terminator, if any). Case
* is ignored in comparisons.
*
* MRHASH_BINARY pKey points to binary data nKey bytes long.
* DC_HASH_BINARY pKey points to binary data nKey bytes long.
* memcmp() is used to compare keys.
*
* A copy of the key is made for MRHASH_STRING and MRHASH_BINARY
* A copy of the key is made for DC_HASH_STRING and DC_HASH_BINARY
* if the copyKey parameter to dc_hash_init() is 1.
*/
#define MRHASH_INT 1
#define MRHASH_POINTER 2
#define MRHASH_STRING 3
#define MRHASH_BINARY 4
#define DC_HASH_INT 1
#define DC_HASH_POINTER 2
#define DC_HASH_STRING 3
#define DC_HASH_BINARY 4
/*
@ -133,4 +133,4 @@ void dc_hash_clear (dc_hash_t*);
#ifdef __cplusplus
}; /* /extern "C" */
#endif
#endif /* __MRHASH_H__ */
#endif /* __DC_HASH_H__ */

2
src/dc_imex.c
View file

@ -510,7 +510,7 @@ char* dc_initiate_key_transfer(dc_context_t* context)
msg->m_type = MR_MSG_FILE;
dc_param_set (msg->m_param, DC_PARAM_FILE, setup_file_name);
dc_param_set (msg->m_param, DC_PARAM_MIMETYPE, "application/autocrypt-setup");
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_AUTOCRYPT_SETUP_MESSAGE);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, DC_CMD_AUTOCRYPT_SETUP_MESSAGE);
dc_param_set_int(msg->m_param, DC_PARAM_FORCE_PLAINTEXT, MRFP_NO_AUTOCRYPT_HEADER);
CHECK_EXIT

2
src/dc_job.c
View file

@ -421,7 +421,7 @@ static void dc_job_do_DC_JOB_SEND_MSG_TO_SMTP(dc_context_t* mailbox, dc_job_t* j
if( (mailbox->m_imap->m_server_flags&MR_NO_EXTRA_IMAP_UPLOAD)==0
&& dc_param_get(mimefactory.m_chat->m_param, DC_PARAM_SELFTALK, 0)==0
&& dc_param_get_int(mimefactory.m_msg->m_param, DC_PARAM_CMD, 0)!=MR_CMD_SECUREJOIN_MESSAGE ) {
&& dc_param_get_int(mimefactory.m_msg->m_param, DC_PARAM_CMD, 0)!=DC_CMD_SECUREJOIN_MESSAGE ) {
dc_job_add(mailbox, DC_JOB_SEND_MSG_TO_IMAP, mimefactory.m_msg->m_id, NULL, 0); /* send message to IMAP in another job */
}

38
src/dc_mimefactory.c
View file

@ -83,7 +83,7 @@ void dc_mimefactory_empty(dc_mimefactory_t* factory)
factory->m_out = NULL;
}
factory->m_out_encrypted = 0;
factory->m_loaded = MR_MF_NOTHING_LOADED;
factory->m_loaded = DC_MF_NOTHING_LOADED;
factory->m_timestamp = 0;
}
@ -153,7 +153,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
}
int command = dc_param_get_int(factory->m_msg->m_param, DC_PARAM_CMD, 0);
if( command==MR_CMD_MEMBER_REMOVED_FROM_GROUP /* for added members, the list is just fine */) {
if( command==DC_CMD_MEMBER_REMOVED_FROM_GROUP /* for added members, the list is just fine */) {
char* email_to_remove = dc_param_get(factory->m_msg->m_param, DC_PARAM_CMD_ARG, NULL);
char* self_addr = dc_sqlite3_get_config__(mailbox->m_sql, "configured_addr", "");
if( email_to_remove && strcasecmp(email_to_remove, self_addr)!=0 )
@ -167,8 +167,8 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
free(self_addr);
}
if( command!=MR_CMD_AUTOCRYPT_SETUP_MESSAGE
&& command!=MR_CMD_SECUREJOIN_MESSAGE
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) ) {
factory->m_req_mdn = 1;
}
@ -222,7 +222,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
}
success = 1;
factory->m_loaded = MR_MF_MSG_LOADED;
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);
}
@ -288,7 +288,7 @@ int dc_mimefactory_load_mdn(dc_mimefactory_t* factory, uint32_t msg_id)
locked = 0;
success = 1;
factory->m_loaded = MR_MF_MDN_LOADED;
factory->m_loaded = DC_MF_MDN_LOADED;
cleanup:
if( locked ) { dc_sqlite3_unlock(mailbox->m_sql); }
@ -445,7 +445,7 @@ static char* get_subject(const dc_chat_t* chat, const dc_msg_t* msg, int afwd_em
char *ret, *raw_subject = dc_msg_get_summarytext_by_raw(msg->m_type, msg->m_text, msg->m_param, APPROX_SUBJECT_CHARS);
const char* fwd = afwd_email? "Fwd: " : "";
if( dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0) == MR_CMD_AUTOCRYPT_SETUP_MESSAGE )
if( dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0) == DC_CMD_AUTOCRYPT_SETUP_MESSAGE )
{
ret = mrstock_str(MR_STR_AC_SETUP_MSG_SUBJECT); /* do not add the "Chat:" prefix for setup messages */
}
@ -466,7 +466,7 @@ static char* get_subject(const dc_chat_t* chat, const dc_msg_t* msg, int afwd_em
int dc_mimefactory_render(dc_mimefactory_t* factory)
{
if( factory == NULL
|| factory->m_loaded == MR_MF_NOTHING_LOADED
|| factory->m_loaded == DC_MF_NOTHING_LOADED
|| factory->m_out/*call empty() before*/ ) {
return 0;
}
@ -480,7 +480,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
int parts = 0;
dc_e2ee_helper_t e2ee_helper;
int e2ee_guaranteed = 0;
int min_verified = MRV_NOT_VERIFIED;
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;
@ -539,7 +539,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
mailmime_set_imf_fields(message, imf_fields);
}
if( factory->m_loaded == MR_MF_MSG_LOADED )
if( factory->m_loaded == DC_MF_MSG_LOADED )
{
/* Render a normal message
*********************************************************************/
@ -554,7 +554,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Verified"), strdup("1")));
force_plaintext = 0;
e2ee_guaranteed = 1;
min_verified = MRV_BIDIRECTIONAL;
min_verified = DC_BIDIRECT_VERIFIED;
}
else {
if( (force_plaintext = dc_param_get_int(factory->m_msg->m_param, DC_PARAM_FORCE_PLAINTEXT, 0)) == 0 ) {
@ -570,14 +570,14 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Name"), dc_encode_header_words(chat->m_name)));
if( command == MR_CMD_MEMBER_REMOVED_FROM_GROUP )
if( command == DC_CMD_MEMBER_REMOVED_FROM_GROUP )
{
char* email_to_remove = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( email_to_remove ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Member-Removed"), email_to_remove));
}
}
else if( command == MR_CMD_MEMBER_ADDED_TO_GROUP )
else if( command == DC_CMD_MEMBER_ADDED_TO_GROUP )
{
char* email_to_add = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( email_to_add ) {
@ -590,11 +590,11 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Secure-Join"), strdup("vg-member-added")));
}
}
else if( command == MR_CMD_GROUPNAME_CHANGED )
else if( command == DC_CMD_GROUPNAME_CHANGED )
{
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Name-Changed"), strdup("1")));
}
else if( command == MR_CMD_GROUPIMAGE_CHANGED )
else if( command == DC_CMD_GROUPIMAGE_CHANGED )
{
grpimage = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( grpimage==NULL ) {
@ -603,12 +603,12 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
}
}
if( command == MR_CMD_AUTOCRYPT_SETUP_MESSAGE ) {
if( command == DC_CMD_AUTOCRYPT_SETUP_MESSAGE ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Autocrypt-Setup-Message"), strdup("v1")));
placeholdertext = mrstock_str(MR_STR_AC_SETUP_MSG_BODY);
}
if( command == MR_CMD_SECUREJOIN_MESSAGE ) {
if( command == DC_CMD_SECUREJOIN_MESSAGE ) {
char* step = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( step ) {
dc_log_info(msg->m_context, 0, "sending secure-join message '%s' >>>>>>>>>>>>>>>>>>>>>>>>>", step);
@ -712,7 +712,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
parts++;
}
}
else if( factory->m_loaded == MR_MF_MDN_LOADED )
else if( factory->m_loaded == DC_MF_MDN_LOADED )
{
/* Render a MDN
*********************************************************************/
@ -777,7 +777,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
/* Encrypt the message
*************************************************************************/
if( factory->m_loaded==MR_MF_MDN_LOADED ) {
if( factory->m_loaded==DC_MF_MDN_LOADED ) {
char* e = mrstock_str(MR_STR_READRCPT); subject_str = dc_mprintf(MR_CHAT_PREFIX " %s", e); free(e);
}
else {

24
src/dc_mimefactory.h
View file

@ -20,26 +20,26 @@
******************************************************************************/
#ifndef __MRMIMEFACTORY_H__
#define __MRMIMEFACTORY_H__
#ifndef __DC_MIMEFACTORY_H__
#define __DC_MIMEFACTORY_H__
#ifdef __cplusplus
extern "C" {
#endif
#define MR_CMD_GROUPNAME_CHANGED 2
#define MR_CMD_GROUPIMAGE_CHANGED 3
#define MR_CMD_MEMBER_ADDED_TO_GROUP 4
#define MR_CMD_MEMBER_REMOVED_FROM_GROUP 5
#define MR_CMD_AUTOCRYPT_SETUP_MESSAGE 6
#define MR_CMD_SECUREJOIN_MESSAGE 7
#define DC_CMD_GROUPNAME_CHANGED 2
#define DC_CMD_GROUPIMAGE_CHANGED 3
#define DC_CMD_MEMBER_ADDED_TO_GROUP 4
#define DC_CMD_MEMBER_REMOVED_FROM_GROUP 5
#define DC_CMD_AUTOCRYPT_SETUP_MESSAGE 6
#define DC_CMD_SECUREJOIN_MESSAGE 7
typedef enum {
MR_MF_NOTHING_LOADED = 0,
MR_MF_MSG_LOADED,
MR_MF_MDN_LOADED
DC_MF_NOTHING_LOADED = 0,
DC_MF_MSG_LOADED,
DC_MF_MDN_LOADED
} dc_mimefactory_loaded_t;
@ -89,5 +89,5 @@ int dc_mimefactory_render (dc_mimefactory_t*);
#ifdef __cplusplus
} /* /extern "C" */
#endif
#endif /* __MRMIMEFACTORY_H__ */
#endif /* __DC_MIMEFACTORY_H__ */

10
src/dc_mimeparser.c
View file

@ -426,7 +426,7 @@ dc_hash_t* mailimf_get_recipients(struct mailimf_fields* imffields)
{
/* the returned value must be dc_hash_clear()'d and free()'d. returned addresses are normalized. */
dc_hash_t* recipients = malloc(sizeof(dc_hash_t));
dc_hash_init(recipients, MRHASH_STRING, 1/*copy key*/);
dc_hash_init(recipients, DC_HASH_STRING, 1/*copy key*/);
clistiter* cur1;
for( cur1 = clist_begin(imffields->fld_list); cur1!=NULL ; cur1=clist_next(cur1) )
@ -849,7 +849,7 @@ dc_mimeparser_t* dc_mimeparser_new(const char* blobdir, dc_context_t* mailbox)
ths->m_reports = carray_new(16);
ths->m_e2ee_helper = calloc(1, sizeof(dc_e2ee_helper_t));
dc_hash_init(&ths->m_header, MRHASH_STRING, 0/* do not copy key */);
dc_hash_init(&ths->m_header, DC_HASH_STRING, 0/* do not copy key */);
return ths;
}
@ -1307,7 +1307,7 @@ static int dc_mimeparser_parse_mime_recursive(dc_mimeparser_t* ths, struct mailm
part->m_type = MR_MSG_TEXT;
char* msg_body = mrstock_str(MR_STR_CANTDECRYPT_MSG_BODY);
part->m_msg = dc_mprintf(MR_EDITORIAL_OPEN "%s" MR_EDITORIAL_CLOSE, msg_body);
part->m_msg = dc_mprintf(DC_EDITORIAL_OPEN "%s" DC_EDITORIAL_CLOSE, msg_body);
free(msg_body);
carray_add(ths->m_parts, (void*)part, NULL);
@ -1533,7 +1533,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
}
if( has_setup_file ) {
/* delete all parts but the application/autocrypt-setup part */
ths->m_is_system_message = MR_CMD_AUTOCRYPT_SETUP_MESSAGE;
ths->m_is_system_message = DC_CMD_AUTOCRYPT_SETUP_MESSAGE;
for( i = 0; i < carray_count(ths->m_parts); i++ ) {
dc_mimepart_t* part = (dc_mimepart_t*)carray_get(ths->m_parts, i);
if( part->m_int_mimetype!=MR_MIMETYPE_AC_SETUP_FILE ) {
@ -1626,7 +1626,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
&& carray_count(ths->m_parts)>=1 ) {
dc_mimepart_t* textpart = (dc_mimepart_t*)carray_get(ths->m_parts, 0);
if( textpart->m_type == MR_MSG_TEXT ) {
dc_param_set_int(textpart->m_param, DC_PARAM_CMD, MR_CMD_GROUPIMAGE_CHANGED);
dc_param_set_int(textpart->m_param, DC_PARAM_CMD, DC_CMD_GROUPIMAGE_CHANGED);
if( carray_count(ths->m_parts)>=2 ) {
dc_mimepart_t* imgpart = (dc_mimepart_t*)carray_get(ths->m_parts, 1);
if( imgpart->m_type == MR_MSG_IMAGE ) {

6
src/dc_msg.c
View file

@ -786,7 +786,7 @@ int dc_msg_is_info(const dc_msg_t* msg)
if( msg->m_from_id == MR_CONTACT_ID_DEVICE
|| msg->m_to_id == MR_CONTACT_ID_DEVICE
|| (cmd && cmd != MR_CMD_AUTOCRYPT_SETUP_MESSAGE) ) {
|| (cmd && cmd != DC_CMD_AUTOCRYPT_SETUP_MESSAGE) ) {
return 1;
}
@ -816,7 +816,7 @@ int dc_msg_is_setupmessage(const dc_msg_t* msg)
return 0;
}
return dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0)==MR_CMD_AUTOCRYPT_SETUP_MESSAGE? 1 : 0;
return dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0)==DC_CMD_AUTOCRYPT_SETUP_MESSAGE? 1 : 0;
}
@ -1064,7 +1064,7 @@ char* dc_msg_get_summarytext_by_raw(int type, const char* text, dc_param_t* para
break;
case MR_MSG_FILE:
if( dc_param_get_int(param, DC_PARAM_CMD, 0)==MR_CMD_AUTOCRYPT_SETUP_MESSAGE ) {
if( dc_param_get_int(param, DC_PARAM_CMD, 0)==DC_CMD_AUTOCRYPT_SETUP_MESSAGE ) {
ret = mrstock_str(MR_STR_AC_SETUP_MSG_SUBJECT);
}
else {

12
src/dc_receive_imf.c
View file

@ -597,7 +597,7 @@ static int check_verified_properties__(dc_context_t* mailbox, dc_mimeparser_t* m
// ensure, the contact is verified
if( !dc_contact_load_from_db__(contact, mailbox->m_sql, from_id)
|| !dc_apeerstate_load_by_addr__(peerstate, mailbox->m_sql, contact->m_addr)
|| dc_contact_is_verified__(contact, peerstate) < MRV_BIDIRECTIONAL ) {
|| dc_contact_is_verified__(contact, peerstate) < DC_BIDIRECT_VERIFIED ) {
dc_log_warning(mailbox, 0, "Cannot verifiy group; sender is not verified.");
goto cleanup;
}
@ -641,7 +641,7 @@ static int check_verified_properties__(dc_context_t* mailbox, dc_mimeparser_t* m
&& strcmp(peerstate->m_verified_key_fingerprint, peerstate->m_gossip_key_fingerprint)!=0) )
{
dc_log_info(mailbox, 0, "Marking gossipped key %s as verified due to verified %s.", to_addr, contact->m_addr);
dc_apeerstate_set_verified(peerstate, MRA_GOSSIP_KEY, peerstate->m_gossip_key_fingerprint, MRV_BIDIRECTIONAL);
dc_apeerstate_set_verified(peerstate, MRA_GOSSIP_KEY, peerstate->m_gossip_key_fingerprint, DC_BIDIRECT_VERIFIED);
dc_apeerstate_save_to_db__(peerstate, mailbox->m_sql, 0);
is_verified = 1;
}
@ -751,19 +751,19 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
if( (optional_field=dc_mimeparser_lookup_optional_field2(mime_parser, "Chat-Group-Member-Removed", "X-MrRemoveFromGrp"))!=NULL ) {
X_MrRemoveFromGrp = optional_field->fld_value;
mime_parser->m_is_system_message = MR_CMD_MEMBER_REMOVED_FROM_GROUP;
mime_parser->m_is_system_message = DC_CMD_MEMBER_REMOVED_FROM_GROUP;
}
else if( (optional_field=dc_mimeparser_lookup_optional_field2(mime_parser, "Chat-Group-Member-Added", "X-MrAddToGrp"))!=NULL ) {
X_MrAddToGrp = optional_field->fld_value;
mime_parser->m_is_system_message = MR_CMD_MEMBER_ADDED_TO_GROUP;
mime_parser->m_is_system_message = DC_CMD_MEMBER_ADDED_TO_GROUP;
}
else if( (optional_field=dc_mimeparser_lookup_optional_field2(mime_parser, "Chat-Group-Name-Changed", "X-MrGrpNameChanged"))!=NULL ) {
X_MrGrpNameChanged = 1;
mime_parser->m_is_system_message = MR_CMD_GROUPNAME_CHANGED;
mime_parser->m_is_system_message = DC_CMD_GROUPNAME_CHANGED;
}
else if( (optional_field=dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Image"))!=NULL ) {
X_MrGrpImageChanged = 1;
mime_parser->m_is_system_message = MR_CMD_GROUPIMAGE_CHANGED;
mime_parser->m_is_system_message = DC_CMD_GROUPIMAGE_CHANGED;
}
}

14
src/dc_securejoin.c
View file

@ -51,13 +51,13 @@ void dc_handle_degrade_event(dc_context_t* context, dc_apeerstate_t* peerstate)
goto cleanup;
}
// - we do not issue an warning for MRA_DE_ENCRYPTION_PAUSED as this is quite normal
// - currently, we do not issue an extra warning for MRA_DE_VERIFICATION_LOST - this always comes
// together with MRA_DE_FINGERPRINT_CHANGED which is logged, the idea is not to bother
// - we do not issue an warning for DC_DE_ENCRYPTION_PAUSED as this is quite normal
// - currently, we do not issue an extra warning for DC_DE_VERIFICATION_LOST - this always comes
// together with DC_DE_FINGERPRINT_CHANGED which is logged, the idea is not to bother
// with things they cannot fix, so the user is just kicked from the verified group
// (and he will know this and can fix this)
if( peerstate->m_degrade_event & MRA_DE_FINGERPRINT_CHANGED )
if( peerstate->m_degrade_event & DC_DE_FINGERPRINT_CHANGED )
{
LOCK
@ -212,7 +212,7 @@ static int mark_peer_as_verified__(dc_context_t* context, const char* fingerprin
goto cleanup;
}
if( !dc_apeerstate_set_verified(peerstate, MRA_PUBLIC_KEY, fingerprint, MRV_BIDIRECTIONAL) ) {
if( !dc_apeerstate_set_verified(peerstate, MRA_PUBLIC_KEY, fingerprint, DC_BIDIRECT_VERIFIED) ) {
goto cleanup;
}
@ -220,7 +220,7 @@ static int mark_peer_as_verified__(dc_context_t* context, const char* fingerprin
// the state may be corrected by the Autocrypt headers as usual later;
// maybe it is a good idea to add the prefer-encrypt-state to the QR code.
peerstate->m_prefer_encrypt = DC_PE_MUTUAL;
peerstate->m_to_save |= MRA_SAVE_ALL;
peerstate->m_to_save |= DC_SAVE_ALL;
dc_apeerstate_save_to_db__(peerstate, context->m_sql, 0);
success = 1;
@ -250,7 +250,7 @@ static void send_handshake_msg(dc_context_t* context, uint32_t contact_chat_id,
msg->m_type = MR_MSG_TEXT;
msg->m_text = dc_mprintf("Secure-Join: %s", step);
msg->m_hidden = 1;
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_SECUREJOIN_MESSAGE);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, DC_CMD_SECUREJOIN_MESSAGE);
dc_param_set (msg->m_param, DC_PARAM_CMD_ARG, step);
if( param2 ) {

4
src/dc_simplify.c
View file

@ -253,7 +253,7 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* ths, const char* buf
dc_strbuilder_init(&ret, strlen(buf_terminated));
if( ths->m_is_cut_at_begin ) {
dc_strbuilder_cat(&ret, MR_EDITORIAL_ELLIPSE " ");
dc_strbuilder_cat(&ret, DC_EDITORIAL_ELLIPSE " ");
}
int pending_linebreaks = 0; /* we write empty lines only in case and non-empty line follows */
@ -286,7 +286,7 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* ths, const char* buf
if( ths->m_is_cut_at_end
&& (!ths->m_is_cut_at_begin || content_lines_added) /* avoid two `[...]` without content */ ) {
dc_strbuilder_cat(&ret, " " MR_EDITORIAL_ELLIPSE);
dc_strbuilder_cat(&ret, " " DC_EDITORIAL_ELLIPSE);
}
mr_free_splitted_lines(lines);

6
src/dc_tools.c
View file

@ -440,7 +440,7 @@ void mr_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.
(as we're using UTF-8, for simplicity, we cut the string only at whitespaces). */
const char* ellipse_utf8 = do_unwrap? " ..." : " " MR_EDITORIAL_ELLIPSE; /* a single line is truncated `...` instead of `[...]` (the former is typically also used by the UI to fit strings in a rectangle) */
const char* ellipse_utf8 = do_unwrap? " ..." : " " DC_EDITORIAL_ELLIPSE; /* a single line is truncated `...` instead of `[...]` (the former is typically also used by the UI to fit strings in a rectangle) */
int lastIsCharacter = 0;
unsigned char* p1 = (unsigned char*)buf; /* force unsigned - otherwise the `> ' '` comparison will fail */
while( *p1 ) {
@ -480,7 +480,7 @@ void mr_truncate_n_unwrap_str(char* buf, int approx_characters, int do_unwrap)
void dc_truncate_str(char* buf, int approx_chars)
{
if( approx_chars > 0 && strlen(buf) > approx_chars+strlen(MR_EDITORIAL_ELLIPSE) )
if( approx_chars > 0 && strlen(buf) > approx_chars+strlen(DC_EDITORIAL_ELLIPSE) )
{
char* p = &buf[approx_chars]; /* null-terminate string at the desired length */
*p = 0;
@ -492,7 +492,7 @@ void dc_truncate_str(char* buf, int approx_chars)
}
}
strcat(p, MR_EDITORIAL_ELLIPSE);
strcat(p, DC_EDITORIAL_ELLIPSE);
}
}

6
src/dc_tools.h
View file

@ -40,9 +40,9 @@ extern "C" {
int mr_exactly_one_bit_set (int v);
/* string tools */
#define MR_EDITORIAL_OPEN "["
#define MR_EDITORIAL_CLOSE "]"
#define MR_EDITORIAL_ELLIPSE MR_EDITORIAL_OPEN "..." MR_EDITORIAL_CLOSE
#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*);