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

refactor cmdline, strbuilder, tools

Browse source
This commit is contained in:
B. Petersen 2018-06-25 17:04:15 +02:00
parent a44ba1abf7
commit a15a50b383
46 changed files with 1070 additions and 1073 deletions
Download patch file Download diff file Expand all files Collapse all files

442
cmdline/cmdline.c
View file

File diff suppressed because it is too large Load diff

20
cmdline/cmdline.h
View file

@ -20,8 +20,8 @@
******************************************************************************/
#ifndef __MRCMDLINE_H__
#define __MRCMDLINE_H__
#ifndef __DC_CMDLINE_H__
#define __DC_CMDLINE_H__
#ifdef __cplusplus
extern "C" {
#endif
@ -32,20 +32,20 @@ extern "C" {
to give users some special power to the database and to the connection.
- For security reasons, the first command must be `auth <password>`; once authorized, this is
is valid for _all_ exising and future mailbox objects. You can skip the authorisation process
by calling mrmailbox_cmdline_skip_auth()
by calling dc_cmdline_skip_auth()
- The returned result may contain multiple lines separated by `\n` and must be
free()'d if no longer needed.
- some commands may use mrmailbox_log_info() for additional output.
- some commands may use dc_log_info() for additional output.
- The command `help` gives an overview */
char* mrmailbox_cmdline (mrmailbox_t*, const char* cmd);
char* dc_cmdline (dc_context_t*, const char* cmd);
/* If the command line authorisation (see mrmailbox_cmdline()) is not desired, eg. for a command line client,
you can skip this using mrmailbox_cmdline_skip_auth().*/
void mrmailbox_cmdline_skip_auth ();
/* If the command line authorisation (see dc_cmdline()) is not desired, eg. for a command line client,
you can skip this using dc_cmdline_skip_auth().*/
void dc_cmdline_skip_auth ();
#ifdef __cplusplus
} /* /extern "C" */
} // /extern "C"
#endif
#endif /* __MRCMDLINE_H__ */
#endif // __DC_CMDLINE_H__

76
cmdline/main.c
View file

@ -47,73 +47,73 @@ static int s_do_log_info = 1;
#define ANSI_NORMAL "\e[0m"
static uintptr_t receive_event(mrmailbox_t* mailbox, int event, uintptr_t data1, uintptr_t data2)
static uintptr_t receive_event(dc_context_t* mailbox, int event, uintptr_t data1, uintptr_t data2)
{
switch( event )
{
case MR_EVENT_GET_STRING:
case MR_EVENT_GET_QUANTITY_STRING:
case DC_EVENT_GET_STRING:
case DC_EVENT_GET_QUANTITY_STRING:
break; /* do not show the event as this would fill the screen */
case MR_EVENT_INFO:
case DC_EVENT_INFO:
if( s_do_log_info ) {
printf("%s\n", (char*)data2);
}
break;
case MR_EVENT_WARNING:
case DC_EVENT_WARNING:
printf("[Warning] %s\n", (char*)data2);
break;
case MR_EVENT_ERROR:
case DC_EVENT_ERROR:
printf(ANSI_RED "[ERROR #%i] %s" ANSI_NORMAL "\n", (int)data1, (char*)data2);
break;
case MR_EVENT_HTTP_GET:
case DC_EVENT_HTTP_GET:
{
char* ret = NULL;
char* tempFile = mr_get_fine_pathNfilename(mailbox->m_blobdir, "curl.result");
char* cmd = mr_mprintf("curl --silent --location --fail --insecure %s > %s", (char*)data1, tempFile); /* --location = follow redirects */
char* tempFile = dc_get_fine_pathNfilename(mailbox->m_blobdir, "curl.result");
char* cmd = dc_mprintf("curl --silent --location --fail --insecure %s > %s", (char*)data1, tempFile); /* --location = follow redirects */
int error = system(cmd);
if( error == 0 ) { /* -1=system() error, !0=curl errors forced by -f, 0=curl success */
size_t bytes = 0;
mr_read_file(tempFile, (void**)&ret, &bytes, mailbox);
dc_read_file(tempFile, (void**)&ret, &bytes, mailbox);
}
free(cmd);
free(tempFile);
return (uintptr_t)ret;
}
case MR_EVENT_IS_OFFLINE:
printf(ANSI_YELLOW "{{Received MR_EVENT_IS_OFFLINE()}}\n" ANSI_NORMAL);
case DC_EVENT_IS_OFFLINE:
printf(ANSI_YELLOW "{{Received DC_EVENT_IS_OFFLINE()}}\n" ANSI_NORMAL);
break;
case MR_EVENT_MSGS_CHANGED:
printf(ANSI_YELLOW "{{Received MR_EVENT_MSGS_CHANGED(%i, %i)}}\n" ANSI_NORMAL, (int)data1, (int)data2);
case DC_EVENT_MSGS_CHANGED:
printf(ANSI_YELLOW "{{Received DC_EVENT_MSGS_CHANGED(%i, %i)}}\n" ANSI_NORMAL, (int)data1, (int)data2);
break;
case MR_EVENT_CONTACTS_CHANGED:
printf(ANSI_YELLOW "{{Received MR_EVENT_CONTACTS_CHANGED()}}\n" ANSI_NORMAL);
case DC_EVENT_CONTACTS_CHANGED:
printf(ANSI_YELLOW "{{Received DC_EVENT_CONTACTS_CHANGED()}}\n" ANSI_NORMAL);
break;
case MR_EVENT_CONFIGURE_PROGRESS:
printf(ANSI_YELLOW "{{Received MR_EVENT_CONFIGURE_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
case DC_EVENT_CONFIGURE_PROGRESS:
printf(ANSI_YELLOW "{{Received DC_EVENT_CONFIGURE_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
break;
case MR_EVENT_IMEX_PROGRESS:
printf(ANSI_YELLOW "{{Received MR_EVENT_IMEX_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
case DC_EVENT_IMEX_PROGRESS:
printf(ANSI_YELLOW "{{Received DC_EVENT_IMEX_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
break;
case MR_EVENT_IMEX_FILE_WRITTEN:
printf(ANSI_YELLOW "{{Received MR_EVENT_IMEX_FILE_WRITTEN(%s)}}\n" ANSI_NORMAL, (char*)data1);
case DC_EVENT_IMEX_FILE_WRITTEN:
printf(ANSI_YELLOW "{{Received DC_EVENT_IMEX_FILE_WRITTEN(%s)}}\n" ANSI_NORMAL, (char*)data1);
break;
case MR_EVENT_CHAT_MODIFIED:
printf(ANSI_YELLOW "{{Received MR_EVENT_CHAT_MODIFIED(%i)}}\n" ANSI_NORMAL, (int)data1);
case DC_EVENT_CHAT_MODIFIED:
printf(ANSI_YELLOW "{{Received DC_EVENT_CHAT_MODIFIED(%i)}}\n" ANSI_NORMAL, (int)data1);
break;
default:
printf(ANSI_YELLOW "{{Received MR_EVENT_%i(%i, %i)}}\n" ANSI_NORMAL, (int)event, (int)data1, (int)data2);
printf(ANSI_YELLOW "{{Received DC_EVENT_%i(%i, %i)}}\n" ANSI_NORMAL, (int)event, (int)data1, (int)data2);
break;
}
return 0;
@ -129,7 +129,7 @@ static pthread_t imap_thread = 0;
static int imap_foreground = 1;
static void* imap_thread_entry_point (void* entry_arg)
{
mrmailbox_t* mailbox = (mrmailbox_t*)entry_arg;
dc_context_t* mailbox = (dc_context_t*)entry_arg;
while( 1 ) {
// perform_jobs(), fetch() and idle()
@ -152,7 +152,7 @@ static void* imap_thread_entry_point (void* entry_arg)
static pthread_t smtp_thread = 0;
static void* smtp_thread_entry_point (void* entry_arg)
{
mrmailbox_t* mailbox = (mrmailbox_t*)entry_arg;
dc_context_t* mailbox = (dc_context_t*)entry_arg;
while( 1 ) {
dc_perform_smtp_jobs(mailbox);
@ -169,7 +169,7 @@ static void* smtp_thread_entry_point (void* entry_arg)
}
static void start_threads(mrmailbox_t* mailbox)
static void start_threads(dc_context_t* mailbox)
{
if( !imap_thread ) {
pthread_create(&imap_thread, NULL, imap_thread_entry_point, mailbox);
@ -181,7 +181,7 @@ static void start_threads(mrmailbox_t* mailbox)
}
static void stop_threads(mrmailbox_t* mailbox)
static void stop_threads(dc_context_t* mailbox)
{
imap_foreground = 0;
dc_interrupt_imap_idle(mailbox);
@ -213,14 +213,14 @@ static char* read_cmd(void)
int main(int argc, char ** argv)
{
char* cmd = NULL;
mrmailbox_t* mailbox = mrmailbox_new(receive_event, NULL, "CLI");
dc_context_t* mailbox = dc_context_new(receive_event, NULL, "CLI");
mrmailbox_cmdline_skip_auth(mailbox); /* disable the need to enter the command `auth <password>` for all mailboxes. */
dc_cmdline_skip_auth(mailbox); /* disable the need to enter the command `auth <password>` for all mailboxes. */
/* open database from the commandline (if omitted, it can be opened using the `open`-command) */
if( argc == 2 ) {
printf("Opening %s ...\n", argv[1]);
if( !mrmailbox_open(mailbox, argv[1], NULL) ) {
if( !dc_open(mailbox, argv[1], NULL) ) {
printf("ERROR: Cannot open mailbox.\n");
}
}
@ -261,7 +261,7 @@ int main(int argc, char ** argv)
{
imap_foreground = 1;
start_threads(mailbox);
mrmailbox_configure(mailbox);
dc_configure(mailbox);
}
else if( strcmp(cmd, "clear")==0 )
{
@ -272,13 +272,13 @@ int main(int argc, char ** argv)
{
imap_foreground = 1;
start_threads(mailbox);
char* qrstr = mrmailbox_get_securejoin_qr(mailbox, arg1? atoi(arg1) : 0);
char* qrstr = dc_get_securejoin_qr(mailbox, arg1? atoi(arg1) : 0);
if( qrstr && qrstr[0] ) {
if( strcmp(cmd, "getbadqr")==0 && strlen(qrstr)>40 ) {
for( int i = 12; i < 22; i++ ) { qrstr[i] = '0'; }
}
printf("%s\n", qrstr);
char* syscmd = mr_mprintf("qrencode -t ansiutf8 \"%s\" -o -", qrstr); /* `-t ansiutf8`=use back/write, `-t utf8`=use terminal colors */
char* syscmd = dc_mprintf("qrencode -t ansiutf8 \"%s\" -o -", qrstr); /* `-t ansiutf8`=use back/write, `-t utf8`=use terminal colors */
system(syscmd);
free(syscmd);
}
@ -294,7 +294,7 @@ int main(int argc, char ** argv)
}
else
{
char* execute_result = mrmailbox_cmdline(mailbox, cmdline);
char* execute_result = dc_cmdline(mailbox, cmdline);
if( execute_result ) {
printf("%s\n", execute_result);
free(execute_result);
@ -304,8 +304,8 @@ int main(int argc, char ** argv)
free(cmd);
stop_threads(mailbox);
mrmailbox_close(mailbox);
mrmailbox_unref(mailbox);
dc_close(mailbox);
dc_context_unref(mailbox);
mailbox = NULL;
return 0;
}

233
cmdline/stress.c
View file

@ -174,7 +174,7 @@ static const char* s_em_setupfile =
void stress_functions(dc_context_t* context)
{
/* test mrsimplify and mrsaxparser (indirectly used by mrsimplify)
/* test dc_simplify_t and dc_saxparser_t (indirectly used by dc_simplify_t)
**************************************************************************/
{
@ -233,7 +233,7 @@ void stress_functions(dc_context_t* context)
mailmime_free(mime);
}
/* test mrmimeparser_t
/* test dc_mimeparser_t
**************************************************************************/
{
@ -286,7 +286,7 @@ void stress_functions(dc_context_t* context)
dc_msg_guess_msgtype_from_suffix("foo/bar-sth.mp3", NULL, &mime);
assert( strcmp(mime, "audio/mpeg")==0 );
dc_msg_guess_msgtype_from_suffix("foo/bar-sth.mp3", &type, NULL);
assert( type == MR_MSG_AUDIO );
assert( type == DC_MSG_AUDIO );
free(mime);
}
@ -295,214 +295,217 @@ void stress_functions(dc_context_t* context)
{
char* str = strdup("aaa");
int replacements = mr_str_replace(&str, "a", "ab"); /* no endless recursion here! */
int replacements = dc_str_replace(&str, "a", "ab"); /* no endless recursion here! */
assert( strcmp(str, "ababab")==0 );
assert( replacements == 3 );
free(str);
str = strdup("this is a little test string");
mr_truncate_str(str, 16);
dc_truncate_str(str, 16);
assert( strcmp(str, "this is a " MR_EDITORIAL_ELLIPSE)==0 );
free(str);
str = strdup("1234");
mr_truncate_str(str, 2);
dc_truncate_str(str, 2);
assert( strcmp(str, "1234")==0 );
free(str);
str = strdup("1234567");
mr_truncate_str(str, 1);
dc_truncate_str(str, 1);
assert( strcmp(str, "1[...]")==0 );
free(str);
str = strdup("123456");
mr_truncate_str(str, 4);
dc_truncate_str(str, 4);
assert( strcmp(str, "123456")==0 );
free(str);
str = mr_insert_breaks("just1234test", 4, " ");
str = dc_insert_breaks("just1234test", 4, " ");
assert( strcmp(str, "just 1234 test")==0 );
free(str);
str = mr_insert_breaks("just1234tes", 4, "--");
str = dc_insert_breaks("just1234tes", 4, "--");
assert( strcmp(str, "just--1234--tes")==0 );
free(str);
str = mr_insert_breaks("just1234t", 4, "");
str = dc_insert_breaks("just1234t", 4, "");
assert( strcmp(str, "just1234t")==0 );
free(str);
str = mr_insert_breaks("", 4, "---");
str = dc_insert_breaks("", 4, "---");
assert( strcmp(str, "")==0 );
free(str);
str = mr_null_terminate("abcxyz", 3);
str = dc_null_terminate("abcxyz", 3);
assert( strcmp(str, "abc")==0 );
free(str);
str = mr_null_terminate("abcxyz", 0);
str = dc_null_terminate("abcxyz", 0);
assert( strcmp(str, "")==0 );
free(str);
str = mr_null_terminate(NULL, 0);
str = dc_null_terminate(NULL, 0);
assert( strcmp(str, "")==0 );
free(str);
assert( strcmp("fresh=" MR_STRINGIFY(MR_STATE_IN_FRESH), "fresh=10")==0 ); /* these asserts check the values, the existance of the macros and also MR_STRINGIFY() */
assert( strcmp("noticed=" MR_STRINGIFY(MR_STATE_IN_NOTICED), "noticed=13")==0 );
assert( strcmp("seen=" MR_STRINGIFY(MR_STATE_IN_SEEN), "seen=16")==0 );
assert( strcmp("pending=" MR_STRINGIFY(MR_STATE_OUT_PENDING), "pending=20")==0 );
assert( strcmp("error=" MR_STRINGIFY(MR_STATE_OUT_ERROR), "error=24")==0 );
assert( strcmp("delivered=" MR_STRINGIFY(MR_STATE_OUT_DELIVERED), "delivered=26")==0 );
assert( strcmp("mdn_rcvd=" MR_STRINGIFY(MR_STATE_OUT_MDN_RCVD), "mdn_rcvd=28")==0 );
assert( strcmp("fresh=" DC_STRINGIFY(DC_STATE_IN_FRESH), "fresh=10")==0 ); /* these asserts check the values, the existance of the macros and also DC_STRINGIFY() */
assert( strcmp("noticed=" DC_STRINGIFY(DC_STATE_IN_NOTICED), "noticed=13")==0 );
assert( strcmp("seen=" DC_STRINGIFY(DC_STATE_IN_SEEN), "seen=16")==0 );
assert( strcmp("pending=" DC_STRINGIFY(DC_STATE_OUT_PENDING), "pending=20")==0 );
assert( strcmp("error=" DC_STRINGIFY(DC_STATE_OUT_ERROR), "error=24")==0 );
assert( strcmp("delivered=" DC_STRINGIFY(DC_STATE_OUT_DELIVERED), "delivered=26")==0 );
assert( strcmp("mdn_rcvd=" DC_STRINGIFY(DC_STATE_OUT_MDN_RCVD), "mdn_rcvd=28")==0 );
assert( strcmp("undefined=" MR_STRINGIFY(MR_CHAT_TYPE_UNDEFINED), "undefined=0")==0 );
assert( strcmp("single=" MR_STRINGIFY(MR_CHAT_TYPE_SINGLE), "single=100")==0 );
assert( strcmp("group=" MR_STRINGIFY(MR_CHAT_TYPE_GROUP), "group=120")==0 );
assert( strcmp("vgroup=" MR_STRINGIFY(MR_CHAT_TYPE_VERIFIED_GROUP), "vgroup=130")==0 );
assert( strcmp("undefined=" DC_STRINGIFY(DC_CHAT_TYPE_UNDEFINED), "undefined=0")==0 );
assert( strcmp("single=" DC_STRINGIFY(DC_CHAT_TYPE_SINGLE), "single=100")==0 );
assert( strcmp("group=" DC_STRINGIFY(DC_CHAT_TYPE_GROUP), "group=120")==0 );
assert( strcmp("vgroup=" DC_STRINGIFY(DC_CHAT_TYPE_VERIFIED_GROUP), "vgroup=130")==0 );
assert( strcmp("deaddrop=" MR_STRINGIFY(MR_CHAT_ID_DEADDROP), "deaddrop=1")==0 );
assert( strcmp("trash=" MR_STRINGIFY(MR_CHAT_ID_TRASH), "trash=3")==0 );
assert( strcmp("in_creation=" MR_STRINGIFY(MR_CHAT_ID_MSGS_IN_CREATION), "in_creation=4")==0 );
assert( strcmp("starred=" MR_STRINGIFY(MR_CHAT_ID_STARRED), "starred=5")==0 );
assert( strcmp("archivedlink=" MR_STRINGIFY(MR_CHAT_ID_ARCHIVED_LINK), "archivedlink=6")==0 );
assert( strcmp("spcl_chat=" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL), "spcl_chat=9")==0 );
assert( strcmp("deaddrop=" DC_STRINGIFY(DC_CHAT_ID_DEADDROP), "deaddrop=1")==0 );
assert( strcmp("trash=" DC_STRINGIFY(DC_CHAT_ID_TRASH), "trash=3")==0 );
assert( strcmp("in_creation=" DC_STRINGIFY(DC_CHAT_ID_MSGS_IN_CREATION), "in_creation=4")==0 );
assert( strcmp("starred=" DC_STRINGIFY(DC_CHAT_ID_STARRED), "starred=5")==0 );
assert( strcmp("archivedlink=" DC_STRINGIFY(DC_CHAT_ID_ARCHIVED_LINK), "archivedlink=6")==0 );
assert( strcmp("spcl_chat=" DC_STRINGIFY(DC_CHAT_ID_LAST_SPECIAL), "spcl_chat=9")==0 );
assert( strcmp("self=" MR_STRINGIFY(MR_CONTACT_ID_SELF), "self=1")==0 );
assert( strcmp("spcl_contact=" MR_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL), "spcl_contact=9")==0 );
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=" MR_STRINGIFY(MR_CMD_GROUPIMAGE_CHANGED), "grpimg=3")==0 );
assert( strcmp("grpimg=" DC_STRINGIFY(MR_CMD_GROUPIMAGE_CHANGED), "grpimg=3")==0 );
assert( strcmp("notverified=" MR_STRINGIFY(MRV_NOT_VERIFIED), "notverified=0")==0 );
assert( strcmp("bidirectional=" MR_STRINGIFY(MRV_BIDIRECTIONAL), "bidirectional=2")==0 );
assert( strcmp("notverified=" DC_STRINGIFY(MRV_NOT_VERIFIED), "notverified=0")==0 );
assert( strcmp("bidirectional=" DC_STRINGIFY(MRV_BIDIRECTIONAL), "bidirectional=2")==0 );
assert( MRP_FILE == 'f' );
assert( MRP_WIDTH == 'w' );
assert( MRP_HEIGHT == 'h' );
assert( MRP_DURATION == 'd' );
assert( MRP_MIMETYPE == 'm' );
assert( MRP_AUTHORNAME == 'N' );
assert( MRP_TRACKNAME == 'n' );
assert( MRP_FORWARDED == 'a' );
assert( MRP_UNPROMOTED == 'U' );
assert( strcmp("public=" DC_STRINGIFY(DC_KEY_PUBLIC), "public=0")==0 );
assert( strcmp("private=" DC_STRINGIFY(DC_KEY_PRIVATE), "private=1")==0 );
assert( DC_PARAM_FILE == 'f' );
assert( DC_PARAM_WIDTH == 'w' );
assert( DC_PARAM_HEIGHT == 'h' );
assert( DC_PARAM_DURATION == 'd' );
assert( DC_PARAM_MIMETYPE == 'm' );
assert( DC_PARAM_AUTHORNAME == 'N' );
assert( DC_PARAM_TRACKNAME == 'n' );
assert( DC_PARAM_FORWARDED == 'a' );
assert( DC_PARAM_UNPROMOTED == 'U' );
char* buf1 = strdup("ol\xc3\xa1 mundo <>\"'& äÄöÖüÜß fooÆçÇ ♦&noent;"); char* buf2 = strdup(buf1);
mr_replace_bad_utf8_chars(buf2);
dc_replace_bad_utf8_chars(buf2);
assert( strcmp(buf1, buf2)==0 );
free(buf1); free(buf2);
buf1 = strdup("ISO-String with Ae: \xC4"); buf2 = strdup(buf1);
mr_replace_bad_utf8_chars(buf2);
dc_replace_bad_utf8_chars(buf2);
assert( strcmp("ISO-String with Ae: _", buf2)==0 );
free(buf1); free(buf2);
buf1 = strdup(""); buf2 = strdup(buf1);
mr_replace_bad_utf8_chars(buf2);
dc_replace_bad_utf8_chars(buf2);
assert( buf2[0]==0 );
free(buf1); free(buf2);
mr_replace_bad_utf8_chars(NULL); /* should do nothing */
dc_replace_bad_utf8_chars(NULL); /* should do nothing */
buf1 = mr_urlencode("Björn Petersen");
buf1 = dc_urlencode("Björn Petersen");
assert( strcmp(buf1, "Bj%C3%B6rn+Petersen") == 0 );
buf2 = mr_urldecode(buf1);
buf2 = dc_urldecode(buf1);
assert( strcmp(buf2, "Björn Petersen") == 0 );
free(buf1); free(buf2);
buf1 = mr_create_id();
assert( strlen(buf1) == MR_CREATE_ID_LEN );
buf1 = dc_create_id();
assert( strlen(buf1) == DC_CREATE_ID_LEN );
free(buf1);
buf1 = mr_decode_header_words("=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?=");
buf1 = dc_decode_header_words("=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?=");
assert( strcmp(buf1, "testäöü.txt")==0 );
free(buf1);
buf1 = mr_decode_header_words("just ascii test");
buf1 = dc_decode_header_words("just ascii test");
assert( strcmp(buf1, "just ascii test")==0 );
free(buf1);
buf1 = mr_encode_header_words("abcdef");
buf1 = dc_encode_header_words("abcdef");
assert( strcmp(buf1, "abcdef")==0 );
free(buf1);
buf1 = mr_encode_header_words("testäöü.txt");
buf1 = dc_encode_header_words("testäöü.txt");
assert( strncmp(buf1, "=?utf-8", 7)==0 );
buf2 = mr_decode_header_words(buf1);
buf2 = dc_decode_header_words(buf1);
assert( strcmp("testäöü.txt", buf2)==0 );
free(buf1);
free(buf2);
buf1 = mr_decode_header_words("=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?=");
buf1 = dc_decode_header_words("=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?=");
assert( strcmp(buf1, "attachment;\r\n filename=\"testäöü.txt\";\r\n size=39")==0 );
free(buf1);
buf1 = mr_encode_ext_header("Björn Petersen");
buf1 = dc_encode_ext_header("Björn Petersen");
assert( strcmp(buf1, "utf-8''Bj%C3%B6rn%20Petersen") == 0 );
buf2 = mr_decode_ext_header(buf1);
buf2 = dc_decode_ext_header(buf1);
assert( strcmp(buf2, "Björn Petersen") == 0 );
free(buf1);
free(buf2);
buf1 = mr_decode_ext_header("iso-8859-1'en'%A3%20rates");
buf1 = dc_decode_ext_header("iso-8859-1'en'%A3%20rates");
assert( strcmp(buf1, "£ rates") == 0 );
assert( strcmp(buf1, "\xC2\xA3 rates") == 0 );
free(buf1);
buf1 = mr_decode_ext_header("wrong'format"); // bad format -> should return given string
buf1 = dc_decode_ext_header("wrong'format"); // bad format -> should return given string
assert( strcmp(buf1, "wrong'format") == 0 );
free(buf1);
buf1 = mr_decode_ext_header("''"); // empty charset -> should return given string
buf1 = dc_decode_ext_header("''"); // empty charset -> should return given string
assert( strcmp(buf1, "''") == 0 );
free(buf1);
buf1 = mr_decode_ext_header("x''"); // charset given -> return empty encoded string
buf1 = dc_decode_ext_header("x''"); // charset given -> return empty encoded string
assert( strcmp(buf1, "") == 0 );
free(buf1);
buf1 = mr_decode_ext_header("'"); // bad format -> should return given string
buf1 = dc_decode_ext_header("'"); // bad format -> should return given string
assert( strcmp(buf1, "'") == 0 );
free(buf1);
buf1 = mr_decode_ext_header(""); // bad format -> should return given string - empty in this case
buf1 = dc_decode_ext_header(""); // bad format -> should return given string - empty in this case
assert( strcmp(buf1, "") == 0 );
free(buf1);
assert( mr_needs_ext_header("Björn") );
assert( !mr_needs_ext_header("Bjoern") );
assert( !mr_needs_ext_header("") );
assert( mr_needs_ext_header(" ") );
assert( mr_needs_ext_header("a b") );
assert( !mr_needs_ext_header(NULL) );
assert( dc_needs_ext_header("Björn") );
assert( !dc_needs_ext_header("Bjoern") );
assert( !dc_needs_ext_header("") );
assert( dc_needs_ext_header(" ") );
assert( dc_needs_ext_header("a b") );
assert( !dc_needs_ext_header(NULL) );
buf1 = mr_encode_modified_utf7("Björn Petersen", 1);
buf1 = dc_encode_modified_utf7("Björn Petersen", 1);
assert( strcmp(buf1, "Bj&APY-rn_Petersen")==0 );
buf2 = mr_decode_modified_utf7(buf1, 1);
buf2 = dc_decode_modified_utf7(buf1, 1);
assert( strcmp(buf2, "Björn Petersen")==0 );
free(buf1);
free(buf2);
}
/* test mrarray_t
/* test dc_array_t
**************************************************************************/
{
#define TEST_CNT 1000
mrarray_t* arr = mrarray_new(NULL, 7);
assert( mrarray_get_cnt(arr) == 0 );
dc_array_t* arr = dc_array_new(NULL, 7);
assert( dc_array_get_cnt(arr) == 0 );
int i;
for( i = 0; i < TEST_CNT; i++ ) {
mrarray_add_id(arr, i+1*2);
dc_array_add_id(arr, i+1*2);
}
assert( mrarray_get_cnt(arr) == TEST_CNT );
assert( dc_array_get_cnt(arr) == TEST_CNT );
for( i = 0; i< TEST_CNT; i++ ) {
assert( mrarray_get_id(arr, i) == i+1*2 );
assert( dc_array_get_id(arr, i) == i+1*2 );
}
assert( mrarray_get_id(arr, -1) == 0 ); /* test out-of-range access */
assert( mrarray_get_id(arr, TEST_CNT) == 0 ); /* test out-of-range access */
assert( mrarray_get_id(arr, TEST_CNT+1) == 0 ); /* test out-of-range access */
assert( dc_array_get_id(arr, -1) == 0 ); /* test out-of-range access */
assert( dc_array_get_id(arr, TEST_CNT) == 0 ); /* test out-of-range access */
assert( dc_array_get_id(arr, TEST_CNT+1) == 0 ); /* test out-of-range access */
dc_array_empty(arr);
assert( dc_array_get_cnt(arr) == 0 );
@ -520,10 +523,10 @@ void stress_functions(dc_context_t* context)
free(str);
const uint32_t arr2[] = { 0, 12, 133, 1999999 };
str = mr_arr_to_string(arr2, 4);
str = dc_arr_to_string(arr2, 4);
assert( strcmp(str, "0,12,133,1999999")==0 );
free(str);
mrarray_empty(arr);
dc_array_empty(arr);
dc_array_add_ptr(arr, "XX");
dc_array_add_ptr(arr, "item1");
@ -538,37 +541,37 @@ void stress_functions(dc_context_t* context)
dc_array_unref(arr);
}
/* test mrparam
/* test dc_param
**************************************************************************/
{
mrparam_t* p1 = mrparam_new();
dc_param_t* p1 = dc_param_new();
mrparam_set_packed(p1, "\r\n\r\na=1\nb=2\n\nc = 3 ");
dc_param_set_packed(p1, "\r\n\r\na=1\nb=2\n\nc = 3 ");
assert( mrparam_get_int(p1, 'a', 0)==1 );
assert( mrparam_get_int(p1, 'b', 0)==2 );
assert( mrparam_get_int(p1, 'c', 0)==0 ); /* c is not accepted, spaces and weird characters are not allowed in param, were very strict there */
assert( mrparam_exists (p1, 'c')==0 );
assert( dc_param_get_int(p1, 'a', 0)==1 );
assert( dc_param_get_int(p1, 'b', 0)==2 );
assert( dc_param_get_int(p1, 'c', 0)==0 ); /* c is not accepted, spaces and weird characters are not allowed in param, were very strict there */
assert( dc_param_exists (p1, 'c')==0 );
mrparam_set_int(p1, 'd', 4);
assert( mrparam_get_int(p1, 'd', 0)==4 );
dc_param_set_int(p1, 'd', 4);
assert( dc_param_get_int(p1, 'd', 0)==4 );
mrparam_empty(p1);
mrparam_set (p1, 'a', "foo");
mrparam_set_int(p1, 'b', 2);
mrparam_set (p1, 'c', NULL);
mrparam_set_int(p1, 'd', 4);
dc_param_empty(p1);
dc_param_set (p1, 'a', "foo");
dc_param_set_int(p1, 'b', 2);
dc_param_set (p1, 'c', NULL);
dc_param_set_int(p1, 'd', 4);
assert( strcmp(p1->m_packed, "a=foo\nb=2\nd=4")==0 );
mrparam_set (p1, 'b', NULL);
dc_param_set (p1, 'b', NULL);
assert( strcmp(p1->m_packed, "a=foo\nd=4")==0 );
mrparam_set (p1, 'a', NULL);
mrparam_set (p1, 'd', NULL);
dc_param_set (p1, 'a', NULL);
dc_param_set (p1, 'd', NULL);
assert( strcmp(p1->m_packed, "")==0 );
mrparam_unref(p1);
dc_param_unref(p1);
}
/* test Autocrypt header parsing functions
@ -583,7 +586,7 @@ void stress_functions(dc_context_t* context)
assert( ah_ok == 1 );
assert( ah->m_addr && strcmp(ah->m_addr, "a@b.example.org")==0 );
assert( ah->m_public_key->m_bytes==10 && strncmp((char*)ah->m_public_key->m_binary, "Delta Chat", 10)==0 );
assert( ah->m_prefer_encrypt==MRA_PE_MUTUAL );
assert( ah->m_prefer_encrypt==DC_PE_MUTUAL );
rendered = dc_aheader_render(ah);
assert( rendered && strcmp(rendered, "addr=a@b.example.org; prefer-encrypt=mutual; keydata= RGVsdGEgQ2hhdA==")==0 );
@ -592,13 +595,13 @@ void stress_functions(dc_context_t* context)
assert( ah_ok == 1 );
assert( ah->m_addr && strcmp(ah->m_addr, "a@b.example.org")==0 );
assert( ah->m_public_key->m_bytes==10 && strncmp((char*)ah->m_public_key->m_binary, "Delta Chat", 10)==0 );
assert( ah->m_prefer_encrypt==MRA_PE_MUTUAL );
assert( ah->m_prefer_encrypt==DC_PE_MUTUAL );
ah_ok = dc_aheader_set_from_string(ah, "addr=a@b.example.org; prefer-encrypt=ignoreUnknownValues; keydata=RGVsdGEgQ2hhdA==");
assert( ah_ok == 1 ); /* only "yes" or "no" are valid for prefer-encrypt ... */
ah_ok = dc_aheader_set_from_string(ah, "addr=a@b.example.org; keydata=RGVsdGEgQ2hhdA==");
assert( ah_ok == 1 && ah->m_prefer_encrypt==MRA_PE_NOPREFERENCE ); /* ... "nopreference" is use if the attribute is missing (see Autocrypt-Level0) */
assert( ah_ok == 1 && ah->m_prefer_encrypt==DC_PE_NOPREFERENCE ); /* ... "nopreference" is use if the attribute is missing (see Autocrypt-Level0) */
ah_ok = dc_aheader_set_from_string(ah, "");
assert( ah_ok == 0 );
@ -749,7 +752,7 @@ void stress_functions(dc_context_t* context)
bad_data[i] = (unsigned char)(i&0xFF);
}
for( int j = 0; j < BAD_DATA_BYTES/40; j++ ) {
dc_key_set_from_binary(bad_key, &bad_data[j], BAD_DATA_BYTES/2 + j, (j&1)? MR_PUBLIC : MR_PRIVATE);
dc_key_set_from_binary(bad_key, &bad_data[j], BAD_DATA_BYTES/2 + j, (j&1)? DC_KEY_PUBLIC : DC_KEY_PRIVATE);
assert( !dc_pgp_is_valid_key(context, bad_key) );
}
dc_key_unref(bad_key);
@ -760,8 +763,8 @@ void stress_functions(dc_context_t* context)
dc_pgp_create_keypair(context, "foo@bar.de", public_key, private_key);
assert( dc_pgp_is_valid_key(context, public_key) );
assert( dc_pgp_is_valid_key(context, private_key) );
//{char *t1=dc_key_render_asc(public_key); printf("%s",t1);mr_write_file("/home/bpetersen/temp/stress-public.asc", t1,strlen(t1),mailbox);mr_write_file("/home/bpetersen/temp/stress-public.der", public_key->m_binary, public_key->m_bytes, mailbox);free(t1);}
//{char *t1=dc_key_render_asc(private_key);printf("%s",t1);mr_write_file("/home/bpetersen/temp/stress-private.asc",t1,strlen(t1),mailbox);mr_write_file("/home/bpetersen/temp/stress-private.der",private_key->m_binary,private_key->m_bytes,mailbox);free(t1);}
//{char *t1=dc_key_render_asc(public_key); printf("%s",t1);dc_write_file("/home/bpetersen/temp/stress-public.asc", t1,strlen(t1),mailbox);dc_write_file("/home/bpetersen/temp/stress-public.der", public_key->m_binary, public_key->m_bytes, mailbox);free(t1);}
//{char *t1=dc_key_render_asc(private_key);printf("%s",t1);dc_write_file("/home/bpetersen/temp/stress-private.asc",t1,strlen(t1),mailbox);dc_write_file("/home/bpetersen/temp/stress-private.der",private_key->m_binary,private_key->m_bytes,mailbox);free(t1);}
{
dc_key_t *test_key = dc_key_new();
@ -787,7 +790,7 @@ void stress_functions(dc_context_t* context)
assert( ok && ctext_signed && ctext_signed_bytes>0 );
assert( strncmp((char*)ctext_signed, "-----BEGIN PGP MESSAGE-----", 27)==0 );
assert( ((char*)ctext_signed)[ctext_signed_bytes-1]!=0 ); /*armored strings are not null-terminated!*/
//{char* t3 = mr_null_terminate((char*)ctext,ctext_bytes);printf("\n%i ENCRYPTED BYTES: {\n%s\n}\n",(int)ctext_bytes,t3);free(t3);}
//{char* t3 = dc_null_terminate((char*)ctext,ctext_bytes);printf("\n%i ENCRYPTED BYTES: {\n%s\n}\n",(int)ctext_bytes,t3);free(t3);}
ok = dc_pgp_pk_encrypt(context, original_text, strlen(original_text), keyring, NULL, 1, (void**)&ctext_unsigned, &ctext_unsigned_bytes);
assert( ok && ctext_unsigned && ctext_unsigned_bytes>0 );
@ -883,7 +886,7 @@ void stress_functions(dc_context_t* context)
**************************************************************************/
{
char* fingerprint = mr_normalize_fingerprint(" 1234 567890 \n AbcD abcdef ABCDEF ");
char* fingerprint = dc_normalize_fingerprint(" 1234 567890 \n AbcD abcdef ABCDEF ");
assert( fingerprint );
assert( strcmp(fingerprint, "1234567890ABCDABCDEFABCDEF") == 0 );
}
@ -895,14 +898,14 @@ void stress_functions(dc_context_t* context)
dc_lot_t* res = dc_check_qr(context, qr);
assert( res );
assert( res->m_state == MR_QR_ASK_VERIFYCONTACT || res->m_state == MR_QR_FPR_MISMATCH || res->m_state == MR_QR_FPR_WITHOUT_ADDR );
assert( res->m_state == DC_QR_ASK_VERIFYCONTACT || res->m_state == DC_QR_FPR_MISMATCH || res->m_state == DC_QR_FPR_WITHOUT_ADDR );
dc_lot_unref(res);
free(qr);
res = dc_check_qr(context, "BEGIN:VCARD\nVERSION:3.0\nN:Last;First\nEMAIL;TYPE=INTERNET:stress@test.local\nEND:VCARD");
assert( res );
assert( res->m_state == MR_QR_ADDR );
assert( res->m_state == DC_QR_ADDR );
assert( res->m_id != 0 );
dc_lot_unref(res);
}

26
src/dc_aheader.c
View file

@ -66,22 +66,22 @@ char* dc_aheader_render(const dc_aheader_t* ths)
{
int success = 0;
char* keybase64_wrapped = NULL;
mrstrbuilder_t ret;
mrstrbuilder_init(&ret, 0);
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, 0);
if( ths==NULL || ths->m_addr==NULL || ths->m_public_key->m_binary==NULL || ths->m_public_key->m_type!=MR_PUBLIC ) {
if( ths==NULL || ths->m_addr==NULL || ths->m_public_key->m_binary==NULL || ths->m_public_key->m_type!=DC_KEY_PUBLIC ) {
goto cleanup;
}
mrstrbuilder_cat(&ret, "addr=");
mrstrbuilder_cat(&ret, ths->m_addr);
mrstrbuilder_cat(&ret, "; ");
dc_strbuilder_cat(&ret, "addr=");
dc_strbuilder_cat(&ret, ths->m_addr);
dc_strbuilder_cat(&ret, "; ");
if( ths->m_prefer_encrypt==MRA_PE_MUTUAL ) {
mrstrbuilder_cat(&ret, "prefer-encrypt=mutual; ");
if( ths->m_prefer_encrypt==DC_PE_MUTUAL ) {
dc_strbuilder_cat(&ret, "prefer-encrypt=mutual; ");
}
mrstrbuilder_cat(&ret, "keydata= "); /* the trailing space together with mr_insert_breaks() allows a proper transport */
dc_strbuilder_cat(&ret, "keydata= "); /* the trailing space together with dc_insert_breaks() allows a proper transport */
/* adds a whitespace every 78 characters, this allows libEtPan to wrap the lines according to RFC 5322
(which may insert a linebreak before every whitespace) */
@ -89,7 +89,7 @@ char* dc_aheader_render(const dc_aheader_t* ths)
goto cleanup;
}
mrstrbuilder_cat(&ret, keybase64_wrapped);
dc_strbuilder_cat(&ret, keybase64_wrapped);
success = 1;
@ -133,7 +133,7 @@ static int add_attribute(dc_aheader_t* ths, const char* name, const char* value
else if( strcasecmp(name, "prefer-encrypt")==0 )
{
if( value && strcasecmp(value, "mutual")==0 ) {
ths->m_prefer_encrypt = MRA_PE_MUTUAL;
ths->m_prefer_encrypt = DC_PE_MUTUAL;
return 1;
}
return 1; /* An Autocrypt level 0 client that sees the attribute with any other value (or that does not see the attribute at all) should interpret the value as nopreference.*/
@ -144,7 +144,7 @@ static int add_attribute(dc_aheader_t* ths, const char* name, const char* value
|| ths->m_public_key->m_binary || ths->m_public_key->m_bytes ) {
return 0; /* there is already a k*/
}
return dc_key_set_from_base64(ths->m_public_key, value, MR_PUBLIC);
return dc_key_set_from_base64(ths->m_public_key, value, DC_KEY_PUBLIC);
}
else if( name[0]=='_' )
{
@ -178,7 +178,7 @@ int dc_aheader_set_from_string(dc_aheader_t* ths, const char* header_str__)
goto cleanup;
}
ths->m_prefer_encrypt = MRA_PE_NOPREFERENCE; /* value to use if the prefer-encrypted header is missing */
ths->m_prefer_encrypt = DC_PE_NOPREFERENCE; /* value to use if the prefer-encrypted header is missing */
header_str = safe_strdup(header_str__);
p = header_str;

16
src/dc_apeerstate.c
View file

@ -92,17 +92,17 @@ static void dc_apeerstate_set_from_stmt__(dc_apeerstate_t* peerstate, sqlite3_st
if( sqlite3_column_type(stmt, PUBLIC_KEY_COL)!=SQLITE_NULL ) {
peerstate->m_public_key = dc_key_new();
dc_key_set_from_stmt(peerstate->m_public_key, stmt, PUBLIC_KEY_COL, MR_PUBLIC);
dc_key_set_from_stmt(peerstate->m_public_key, stmt, PUBLIC_KEY_COL, DC_KEY_PUBLIC);
}
if( sqlite3_column_type(stmt, GOSSIP_KEY_COL)!=SQLITE_NULL ) {
peerstate->m_gossip_key = dc_key_new();
dc_key_set_from_stmt(peerstate->m_gossip_key, stmt, GOSSIP_KEY_COL, MR_PUBLIC);
dc_key_set_from_stmt(peerstate->m_gossip_key, stmt, GOSSIP_KEY_COL, DC_KEY_PUBLIC);
}
if( sqlite3_column_type(stmt, VERIFIED_KEY_COL)!=SQLITE_NULL ) {
peerstate->m_verified_key = dc_key_new();
dc_key_set_from_stmt(peerstate->m_verified_key, stmt, VERIFIED_KEY_COL, MR_PUBLIC);
dc_key_set_from_stmt(peerstate->m_verified_key, stmt, VERIFIED_KEY_COL, DC_KEY_PUBLIC);
}
}
@ -277,7 +277,7 @@ char* dc_apeerstate_render_gossip_header(const dc_apeerstate_t* peerstate, int m
goto cleanup;
}
autocryptheader->m_prefer_encrypt = MRA_PE_NOPREFERENCE; /* the spec says, we SHOULD NOT gossip this flag */
autocryptheader->m_prefer_encrypt = DC_PE_NOPREFERENCE; /* the spec says, we SHOULD NOT gossip this flag */
autocryptheader->m_addr = safe_strdup(peerstate->m_addr);
autocryptheader->m_public_key = dc_key_ref(dc_apeerstate_peek_key(peerstate, min_verified)); /* may be NULL */
@ -381,11 +381,11 @@ int dc_apeerstate_degrade_encryption(dc_apeerstate_t* ths, time_t message_time)
return 0;
}
if( ths->m_prefer_encrypt == MRA_PE_MUTUAL ) {
if( ths->m_prefer_encrypt == DC_PE_MUTUAL ) {
ths->m_degrade_event |= MRA_DE_ENCRYPTION_PAUSED;
}
ths->m_prefer_encrypt = MRA_PE_RESET;
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;
@ -408,10 +408,10 @@ void dc_apeerstate_apply_header(dc_apeerstate_t* ths, const dc_aheader_t* header
ths->m_last_seen_autocrypt = message_time;
ths->m_to_save |= MRA_SAVE_TIMESTAMPS;
if( (header->m_prefer_encrypt==MRA_PE_MUTUAL || header->m_prefer_encrypt==MRA_PE_NOPREFERENCE) /*this also switches from MRA_PE_RESET to MRA_PE_NOPREFERENCE, which is just fine as the function is only called _if_ the Autocrypt:-header is preset at all */
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 == MRA_PE_MUTUAL && header->m_prefer_encrypt != MRA_PE_MUTUAL ) {
if( ths->m_prefer_encrypt == DC_PE_MUTUAL && header->m_prefer_encrypt != DC_PE_MUTUAL ) {
ths->m_degrade_event |= MRA_DE_ENCRYPTION_PAUSED;
}

6
src/dc_apeerstate.h
View file

@ -33,9 +33,9 @@ extern "C" {
typedef struct dc_aheader_t dc_aheader_t;
#define MRA_PE_NOPREFERENCE 0 /* prefer-encrypt states */
#define MRA_PE_MUTUAL 1
#define MRA_PE_RESET 20
#define DC_PE_NOPREFERENCE 0 /* prefer-encrypt states */
#define DC_PE_MUTUAL 1
#define DC_PE_RESET 20
/**

2
src/dc_array.c
View file

@ -401,7 +401,7 @@ const uintptr_t* dc_array_get_raw(const dc_array_t* array)
}
char* mr_arr_to_string(const uint32_t* arr, int cnt)
char* dc_arr_to_string(const uint32_t* arr, int cnt)
{
/* return comma-separated value-string from integer array */
char* ret = NULL;

2
src/dc_array.h
View file

@ -45,7 +45,7 @@ dc_array_t* dc_array_duplicate (const dc_array_t*);
void dc_array_sort_ids (dc_array_t*);
void dc_array_sort_strings (dc_array_t*);
char* dc_array_get_string (const dc_array_t*, const char* sep);
char* mr_arr_to_string (const uint32_t* arr, int cnt);
char* dc_arr_to_string (const uint32_t* arr, int cnt);
#ifdef __cplusplus

20
src/dc_chat.c
View file

@ -50,7 +50,7 @@ dc_chat_t* dc_chat_new(dc_context_t* mailbox)
ths->m_magic = MR_CHAT_MAGIC;
ths->m_context = mailbox;
ths->m_type = MR_CHAT_TYPE_UNDEFINED;
ths->m_param = mrparam_new();
ths->m_param = dc_param_new();
return ths;
}
@ -72,7 +72,7 @@ void dc_chat_unref(dc_chat_t* chat)
}
dc_chat_empty(chat);
mrparam_unref(chat->m_param);
dc_param_unref(chat->m_param);
chat->m_magic = 0;
free(chat);
}
@ -109,7 +109,7 @@ void dc_chat_empty(dc_chat_t* chat)
chat->m_blocked = 0;
mrparam_set_packed(chat->m_param, NULL);
dc_param_set_packed(chat->m_param, NULL);
}
@ -221,7 +221,7 @@ char* dc_chat_get_subtitle(dc_chat_t* chat)
return safe_strdup("Err");
}
if( chat->m_type == MR_CHAT_TYPE_SINGLE && mrparam_exists(chat->m_param, MRP_SELFTALK) )
if( chat->m_type == MR_CHAT_TYPE_SINGLE && dc_param_exists(chat->m_param, DC_PARAM_SELFTALK) )
{
ret = mrstock_str(MR_STR_SELFTALK_SUBTITLE);
}
@ -283,7 +283,7 @@ char* dc_chat_get_profile_image(dc_chat_t* chat)
return NULL;
}
return mrparam_get(chat->m_param, MRP_PROFILE_IMAGE, NULL);
return dc_param_get(chat->m_param, DC_PARAM_PROFILE_IMAGE, NULL);
}
@ -376,7 +376,7 @@ int dc_chat_is_unpromoted(dc_chat_t* chat)
if( chat == NULL || chat->m_magic != MR_CHAT_MAGIC ) {
return 0;
}
return mrparam_get_int(chat->m_param, MRP_UNPROMOTED, 0);
return dc_param_get_int(chat->m_param, DC_PARAM_UNPROMOTED, 0);
}
@ -453,7 +453,7 @@ int dc_chat_is_self_talk(dc_chat_t* chat)
if( chat == NULL || chat->m_magic != MR_CHAT_MAGIC ) {
return 0;
}
return mrparam_exists(chat->m_param, MRP_SELFTALK);
return dc_param_exists(chat->m_param, DC_PARAM_SELFTALK);
}
@ -492,7 +492,7 @@ static int dc_chat_set_from_stmt__(dc_chat_t* ths, sqlite3_stmt* row)
ths->m_draft_timestamp = sqlite3_column_int64(row, row_offset++);
draft_text = (const char*)sqlite3_column_text (row, row_offset++);
ths->m_grpid = safe_strdup((char*)sqlite3_column_text (row, row_offset++));
mrparam_set_packed(ths->m_param, (char*)sqlite3_column_text (row, row_offset++));
dc_param_set_packed(ths->m_param, (char*)sqlite3_column_text (row, row_offset++));
ths->m_archived = sqlite3_column_int (row, row_offset++);
ths->m_blocked = sqlite3_column_int (row, row_offset++);
@ -513,14 +513,14 @@ static int dc_chat_set_from_stmt__(dc_chat_t* ths, sqlite3_stmt* row)
else if( ths->m_id == MR_CHAT_ID_ARCHIVED_LINK ) {
free(ths->m_name);
char* tempname = mrstock_str(MR_STR_ARCHIVEDCHATS);
ths->m_name = mr_mprintf("%s (%i)", tempname, dc_get_archived_count__(ths->m_context));
ths->m_name = dc_mprintf("%s (%i)", tempname, dc_get_archived_count__(ths->m_context));
free(tempname);
}
else if( ths->m_id == MR_CHAT_ID_STARRED ) {
free(ths->m_name);
ths->m_name = mrstock_str(MR_STR_STARREDMSGS);
}
else if( mrparam_exists(ths->m_param, MRP_SELFTALK) ) {
else if( dc_param_exists(ths->m_param, DC_PARAM_SELFTALK) ) {
free(ths->m_name);
ths->m_name = mrstock_str(MR_STR_SELF);
}

2
src/dc_chat.h
View file

@ -47,7 +47,7 @@ struct _dc_chat
dc_context_t* m_context; /**< The mailbox object the chat belongs to. */
char* m_grpid; /**< Group ID that is used by all clients. Only used if the chat is a group. NULL if unset */
int m_blocked; /**< One of MR_CHAT_*_BLOCKED */
mrparam_t* m_param; /**< Additional parameters for a chat. Should not be used directly. */
dc_param_t* m_param; /**< Additional parameters for a chat. Should not be used directly. */
};

4
src/dc_chatlist.c
View file

@ -323,7 +323,7 @@ int dc_chatlist_load_from_db__(dc_chatlist_t* ths, int listflags, const char* qu
/* select example with left join and minimum: http://stackoverflow.com/questions/7588142/mysql-left-join-min */
#define QUR1 "SELECT c.id, m.id FROM chats c " \
" LEFT JOIN msgs m ON (c.id=m.chat_id AND m.hidden=0 AND m.timestamp=(SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND hidden=0)) " /* not: `m.hidden` which would refer the outer select and takes lot of time*/ \
" WHERE c.id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) " AND c.blocked=0"
" WHERE c.id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) " AND c.blocked=0"
#define QUR2 " GROUP BY c.id " /* GROUP BY is needed as there may be several messages with the same timestamp */ \
" ORDER BY MAX(c.draft_timestamp, IFNULL(m.timestamp,0)) DESC,m.id DESC;" /* the list starts with the newest chats */
@ -370,7 +370,7 @@ int dc_chatlist_load_from_db__(dc_chatlist_t* ths, int listflags, const char* qu
success = 1; /*empty result*/
goto cleanup;
}
strLikeCmd = mr_mprintf("%%%s%%", query);
strLikeCmd = dc_mprintf("%%%s%%", query);
stmt = dc_sqlite3_predefine__(ths->m_context->m_sql, SELECT_ii_FROM_chats_LEFT_JOIN_msgs_WHERE_query,
QUR1 " AND c.name LIKE ? " QUR2);
sqlite3_bind_text(stmt, 1, strLikeCmd, -1, SQLITE_STATIC);

18
src/dc_configure.c
View file

@ -110,9 +110,9 @@ static void moz_autoconfigure_text_cb(void* userdata, const char* text, int len)
char* val = safe_strdup(text);
mr_trim(val);
mr_str_replace(&val, "%EMAILADDRESS%", moz_ac->m_in->m_addr);
mr_str_replace(&val, "%EMAILLOCALPART%", moz_ac->m_in_emaillocalpart);
mr_str_replace(&val, "%EMAILDOMAIN%", moz_ac->m_in_emaildomain);
dc_str_replace(&val, "%EMAILADDRESS%", moz_ac->m_in->m_addr);
dc_str_replace(&val, "%EMAILLOCALPART%", moz_ac->m_in_emaillocalpart);
dc_str_replace(&val, "%EMAILDOMAIN%", moz_ac->m_in_emaildomain);
if( moz_ac->m_tag_server == MOZ_SERVER_IMAP ) {
switch( moz_ac->m_tag_config ) {
@ -444,7 +444,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
}
param_domain++;
param_addr_urlencoded = mr_urlencode(param->m_addr);
param_addr_urlencoded = dc_urlencode(param->m_addr);
/* 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) */
@ -470,7 +470,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
/* A. Search configurations from the domain used in the email-address */
for( i = 0; i <= 1; i++ ) {
if( param_autoconfig==NULL ) {
char* url = mr_mprintf("%s://autoconfig.%s/mail/config-v1.1.xml?emailaddress=%s", i==0?"https":"http", param_domain, param_addr_urlencoded); /* Thunderbird may or may not use SSL */
char* url = dc_mprintf("%s://autoconfig.%s/mail/config-v1.1.xml?emailaddress=%s", i==0?"https":"http", param_domain, param_addr_urlencoded); /* Thunderbird may or may not use SSL */
param_autoconfig = moz_autoconfigure(context, url, param);
free(url);
PROGRESS(300+i*20)
@ -479,7 +479,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
for( i = 0; i <= 1; i++ ) {
if( param_autoconfig==NULL ) {
char* url = mr_mprintf("%s://%s/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress=%s", i==0?"https":"http", param_domain, param_addr_urlencoded); // the doc does not mention `emailaddress=`, however, Thunderbird adds it, see https://releases.mozilla.org/pub/thunderbird/ , which makes some sense
char* url = dc_mprintf("%s://%s/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress=%s", i==0?"https":"http", param_domain, param_addr_urlencoded); // the doc does not mention `emailaddress=`, however, Thunderbird adds it, see https://releases.mozilla.org/pub/thunderbird/ , which makes some sense
param_autoconfig = moz_autoconfigure(context, url, param);
free(url);
PROGRESS(340+i*30)
@ -488,7 +488,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
for( i = 0; i <= 1; i++ ) {
if( param_autoconfig==NULL ) {
char* url = mr_mprintf("https://%s%s/autodiscover/autodiscover.xml", i==0?"":"autodiscover.", param_domain); /* Outlook uses always SSL but different domains */
char* url = dc_mprintf("https://%s%s/autodiscover/autodiscover.xml", i==0?"":"autodiscover.", param_domain); /* Outlook uses always SSL but different domains */
param_autoconfig = outlk_autodiscover(context, url, param);
free(url);
PROGRESS(400+i*50)
@ -498,7 +498,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
/* B. If we have no configuration yet, search configuration in Thunderbird's centeral database */
if( param_autoconfig==NULL )
{
char* url = mr_mprintf("https://autoconfig.thunderbird.net/v1.1/%s", param_domain); /* always SSL for Thunderbird's database */
char* url = dc_mprintf("https://autoconfig.thunderbird.net/v1.1/%s", param_domain); /* always SSL for Thunderbird's database */
param_autoconfig = moz_autoconfigure(context, url, param);
free(url);
PROGRESS(500)
@ -548,7 +548,7 @@ void dc_job_do_DC_JOB_CONFIGURE_IMAP(dc_context_t* context, dc_job_t* job)
#define TYPICAL_SMTP_PLAIN_PORT 25
if( param->m_mail_server == NULL ) {
param->m_mail_server = mr_mprintf("imap.%s", param_domain);
param->m_mail_server = dc_mprintf("imap.%s", param_domain);
}
if( param->m_mail_port == 0 ) {

2
src/dc_contact.c
View file

@ -223,7 +223,7 @@ char* dc_contact_get_name_n_addr(const dc_contact_t* contact)
}
if( contact->m_name && contact->m_name[0] ) {
return mr_mprintf("%s (%s)", contact->m_name, contact->m_addr);
return dc_mprintf("%s (%s)", contact->m_name, contact->m_addr);
}
return safe_strdup(contact->m_addr);

288
src/dc_context.c
View file

@ -259,7 +259,7 @@ int dc_open(dc_context_t* context, const char* dbfile, const char* blobdir)
context->m_blobdir = safe_strdup(blobdir);
}
else {
context->m_blobdir = mr_mprintf("%s-blobs", dbfile);
context->m_blobdir = dc_mprintf("%s-blobs", dbfile);
mr_create_folder(context->m_blobdir, context);
}
@ -511,8 +511,8 @@ char* dc_get_info(dc_context_t* context)
int contacts, chats, real_msgs, deaddrop_msgs, is_configured, dbversion, mdns_enabled, e2ee_enabled, prv_key_count, pub_key_count;
dc_key_t* self_public = dc_key_new();
mrstrbuilder_t ret;
mrstrbuilder_init(&ret, 0);
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, 0);
if( context == NULL || context->m_magic != DC_CONTEXT_MAGIC ) {
return safe_strdup("ErrBadPtr");
@ -569,7 +569,7 @@ char* dc_get_info(dc_context_t* context)
- we do not display the password here; in the cli-utility, you can see it using `get mail_pw`
- use neutral speach; the Delta Chat Core is not directly related to any front end or end-product
- contributors: You're welcome to add your names here */
temp = mr_mprintf(
temp = dc_mprintf(
"Chats: %i\n"
"Chat messages: %i\n"
"Messages in context requests: %i\n"
@ -608,7 +608,7 @@ char* dc_get_info(dc_context_t* context)
, sizeof(void*)*8
);
mrstrbuilder_cat(&ret, temp);
dc_strbuilder_cat(&ret, temp);
free(temp);
/* add log excerpt */
@ -618,9 +618,9 @@ char* dc_get_info(dc_context_t* context)
if( context->m_log_ringbuf[j] ) {
struct tm wanted_struct;
memcpy(&wanted_struct, localtime(&context->m_log_ringbuf_times[j]), sizeof(struct tm));
temp = mr_mprintf("\n%02i:%02i:%02i ", (int)wanted_struct.tm_hour, (int)wanted_struct.tm_min, (int)wanted_struct.tm_sec);
mrstrbuilder_cat(&ret, temp);
mrstrbuilder_cat(&ret, context->m_log_ringbuf[j]);
temp = dc_mprintf("\n%02i:%02i:%02i ", (int)wanted_struct.tm_hour, (int)wanted_struct.tm_min, (int)wanted_struct.tm_sec);
dc_strbuilder_cat(&ret, temp);
dc_strbuilder_cat(&ret, context->m_log_ringbuf[j]);
free(temp);
}
}
@ -787,7 +787,7 @@ void dc_marknoticed_chat(dc_context_t* context, uint32_t chat_id)
dc_sqlite3_lock(context->m_sql);
stmt = dc_sqlite3_predefine__(context->m_sql, UPDATE_msgs_SET_state_WHERE_chat_id_AND_state,
"UPDATE msgs SET state=" MR_STRINGIFY(MR_STATE_IN_NOTICED) " WHERE chat_id=? AND state=" MR_STRINGIFY(MR_STATE_IN_FRESH) ";");
"UPDATE msgs SET state=" DC_STRINGIFY(MR_STATE_IN_NOTICED) " WHERE chat_id=? AND state=" DC_STRINGIFY(MR_STATE_IN_FRESH) ";");
sqlite3_bind_int(stmt, 1, chat_id);
sqlite3_step(stmt);
@ -1195,7 +1195,7 @@ dc_array_t* dc_get_fresh_msgs(dc_context_t* context)
" FROM msgs m"
" LEFT JOIN contacts ct ON m.from_id=ct.id"
" LEFT JOIN chats c ON m.chat_id=c.id"
" WHERE m.state=" MR_STRINGIFY(MR_STATE_IN_FRESH) " AND ct.blocked=0 AND (c.blocked=0 OR c.blocked=?)"
" WHERE m.state=" DC_STRINGIFY(MR_STATE_IN_FRESH) " AND ct.blocked=0 AND (c.blocked=0 OR c.blocked=?)"
" ORDER BY m.timestamp DESC,m.id DESC;"); /* the list starts with the newest messages*/
sqlite3_bind_int(stmt, 1, show_deaddrop? MR_CHAT_DEADDROP_BLOCKED : 0);
@ -1270,9 +1270,9 @@ dc_array_t* dc_get_chat_msgs(dc_context_t* context, uint32_t chat_id, uint32_t f
" FROM msgs m"
" LEFT JOIN chats ON m.chat_id=chats.id"
" LEFT JOIN contacts ON m.from_id=contacts.id"
" WHERE m.from_id!=" MR_STRINGIFY(MR_CONTACT_ID_SELF)
" WHERE m.from_id!=" DC_STRINGIFY(MR_CONTACT_ID_SELF)
" AND m.hidden=0 "
" AND chats.blocked=" MR_STRINGIFY(MR_CHAT_DEADDROP_BLOCKED)
" AND chats.blocked=" DC_STRINGIFY(MR_CHAT_DEADDROP_BLOCKED)
" AND contacts.blocked=0"
" ORDER BY m.timestamp,m.id;"); /* the list starts with the oldest message*/
}
@ -1385,8 +1385,8 @@ dc_array_t* dc_search_msgs(dc_context_t* context, uint32_t chat_id, const char*
goto cleanup;
}
strLikeInText = mr_mprintf("%%%s%%", real_query);
strLikeBeg = mr_mprintf("%s%%", real_query); /*for the name search, we use "Name%" which is fast as it can use the index ("%Name%" could not). */
strLikeInText = dc_mprintf("%%%s%%", real_query);
strLikeBeg = dc_mprintf("%s%%", real_query); /*for the name search, we use "Name%" which is fast as it can use the index ("%Name%" could not). */
dc_sqlite3_lock(context->m_sql);
locked = 1;
@ -1415,7 +1415,7 @@ dc_array_t* dc_search_msgs(dc_context_t* context, uint32_t chat_id, const char*
"SELECT m.id, m.timestamp FROM msgs m"
" LEFT JOIN contacts ct ON m.from_id=ct.id"
" LEFT JOIN chats c ON m.chat_id=c.id"
" WHERE m.chat_id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL)
" WHERE m.chat_id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL)
" AND m.hidden=0 "
" AND (c.blocked=0 OR c.blocked=?)"
" AND ct.blocked=0 AND (m.txt LIKE ? OR ct.name LIKE ?)"
@ -1519,7 +1519,7 @@ int dc_get_fresh_msg_count__(dc_context_t* context, uint32_t chat_id)
stmt = dc_sqlite3_predefine__(context->m_sql, SELECT_COUNT_FROM_msgs_WHERE_state_AND_chat_id,
"SELECT COUNT(*) FROM msgs "
" WHERE state=" MR_STRINGIFY(MR_STATE_IN_FRESH)
" WHERE state=" DC_STRINGIFY(MR_STATE_IN_FRESH)
" AND hidden=0 "
" AND chat_id=?;"); /* we have an index over the state-column, this should be sufficient as there are typically only few fresh messages */
sqlite3_bind_int(stmt, 1, chat_id);
@ -1540,9 +1540,9 @@ uint32_t dc_get_last_deaddrop_fresh_msg__(dc_context_t* context)
"SELECT m.id "
" FROM msgs m "
" LEFT JOIN chats c ON c.id=m.chat_id "
" WHERE m.state=" MR_STRINGIFY(MR_STATE_IN_FRESH)
" WHERE m.state=" DC_STRINGIFY(MR_STATE_IN_FRESH)
" AND m.hidden=0 "
" AND c.blocked=" MR_STRINGIFY(MR_CHAT_DEADDROP_BLOCKED)
" AND c.blocked=" DC_STRINGIFY(MR_CHAT_DEADDROP_BLOCKED)
" ORDER BY m.timestamp DESC, m.id DESC;"); /* we have an index over the state-column, this should be sufficient as there are typically only few fresh messages */
if( sqlite3_step(stmt) != SQLITE_ROW ) {
@ -1578,7 +1578,7 @@ size_t dc_get_chat_cnt__(dc_context_t* context)
}
stmt = dc_sqlite3_predefine__(context->m_sql, SELECT_COUNT_FROM_chats,
"SELECT COUNT(*) FROM chats WHERE id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) " AND blocked=0;");
"SELECT COUNT(*) FROM chats WHERE id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) " AND blocked=0;");
if( sqlite3_step(stmt) != SQLITE_ROW ) {
return 0;
}
@ -1603,7 +1603,7 @@ void dc_lookup_real_nchat_by_contact_id__(dc_context_t* context, uint32_t contac
"SELECT c.id, c.blocked"
" FROM chats c"
" INNER JOIN chats_contacts j ON c.id=j.chat_id"
" WHERE c.type=" MR_STRINGIFY(MR_CHAT_TYPE_SINGLE) " AND c.id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) " AND j.contact_id=?;");
" WHERE c.type=" DC_STRINGIFY(MR_CHAT_TYPE_SINGLE) " AND c.id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) " AND j.contact_id=?;");
sqlite3_bind_int(stmt, 1, contact_id);
if( sqlite3_step(stmt) == SQLITE_ROW ) {
@ -1651,7 +1651,7 @@ void dc_create_or_lookup_nchat_by_contact_id__(dc_context_t* context, uint32_t c
/* create chat record */
q = sqlite3_mprintf("INSERT INTO chats (type, name, param, blocked) VALUES(%i, %Q, %Q, %i)", MR_CHAT_TYPE_SINGLE, chat_name,
contact_id==MR_CONTACT_ID_SELF? "K=1" : "", create_blocked);
assert( MRP_SELFTALK == 'K' );
assert( DC_PARAM_SELFTALK == 'K' );
stmt = dc_sqlite3_prepare_v2_(context->m_sql, q);
if( stmt == NULL) {
goto cleanup;
@ -1912,12 +1912,12 @@ static int last_msg_in_chat_encrypted(dc_sqlite3_t* sql, uint32_t chat_id)
" ORDER BY id DESC;");
sqlite3_bind_int(stmt, 1, chat_id);
if( sqlite3_step(stmt) == SQLITE_ROW ) {
mrparam_t* msg_param = mrparam_new();
mrparam_set_packed(msg_param, (char*)sqlite3_column_text(stmt, 0));
if( mrparam_exists(msg_param, MRP_GUARANTEE_E2EE) ) {
dc_param_t* msg_param = dc_param_new();
dc_param_set_packed(msg_param, (char*)sqlite3_column_text(stmt, 0));
if( dc_param_exists(msg_param, DC_PARAM_GUARANTEE_E2EE) ) {
last_is_encrypted = 1;
}
mrparam_unref(msg_param);
dc_param_unref(msg_param);
}
return last_is_encrypted;
}
@ -1962,16 +1962,16 @@ static uint32_t dc_send_msg_i__(dc_context_t* context, dc_chat_t* chat, const dc
}
else if( MR_CHAT_TYPE_IS_MULTI(chat->m_type) )
{
if( mrparam_get_int(chat->m_param, MRP_UNPROMOTED, 0)==1 ) {
if( dc_param_get_int(chat->m_param, DC_PARAM_UNPROMOTED, 0)==1 ) {
/* mark group as being no longer unpromoted */
mrparam_set(chat->m_param, MRP_UNPROMOTED, NULL);
dc_param_set(chat->m_param, DC_PARAM_UNPROMOTED, NULL);
dc_chat_update_param__(chat);
}
}
/* check if we can guarantee E2EE for this message. If we can, we won't send the message without E2EE later (because of a reset, changed settings etc. - messages may be delayed significally if there is no network present) */
int do_guarantee_e2ee = 0;
if( context->m_e2ee_enabled && mrparam_get_int(msg->m_param, MRP_FORCE_PLAINTEXT, 0)==0 )
if( context->m_e2ee_enabled && dc_param_get_int(msg->m_param, DC_PARAM_FORCE_PLAINTEXT, 0)==0 )
{
int can_encrypt = 1, all_mutual = 1; /* be optimistic */
sqlite3_stmt* stmt = dc_sqlite3_predefine__(context->m_sql, SELECT_p_FROM_chats_contacs_JOIN_contacts_peerstates_WHERE_cc,
@ -1980,7 +1980,7 @@ static uint32_t dc_send_msg_i__(dc_context_t* context, dc_chat_t* chat, const dc
" LEFT JOIN contacts c ON cc.contact_id=c.id "
" LEFT JOIN acpeerstates ps ON c.addr=ps.addr "
" WHERE cc.chat_id=? " /* take care that this statement returns NULL rows if there is no peerstates for a chat member! */
" AND cc.contact_id>" MR_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) ";"); /* for MRP_SELFTALK this statement does not return any row */
" AND cc.contact_id>" DC_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) ";"); /* for DC_PARAM_SELFTALK this statement does not return any row */
sqlite3_bind_int(stmt, 1, chat->m_id);
while( sqlite3_step(stmt) == SQLITE_ROW )
{
@ -1991,7 +1991,7 @@ static uint32_t dc_send_msg_i__(dc_context_t* context, dc_chat_t* chat, const dc
else {
/* the peerstate exist, so we have either public_key or gossip_key and can encrypt potentially */
int prefer_encrypted = sqlite3_column_int(stmt, 0);
if( prefer_encrypted != MRA_PE_MUTUAL ) {
if( prefer_encrypted != DC_PE_MUTUAL ) {
all_mutual = 0;
}
}
@ -2011,9 +2011,9 @@ static uint32_t dc_send_msg_i__(dc_context_t* context, dc_chat_t* chat, const dc
}
if( do_guarantee_e2ee ) {
mrparam_set_int(msg->m_param, MRP_GUARANTEE_E2EE, 1);
dc_param_set_int(msg->m_param, DC_PARAM_GUARANTEE_E2EE, 1);
}
mrparam_set(msg->m_param, MRP_ERRONEOUS_E2EE, NULL); /* reset eg. on forwarding */
dc_param_set(msg->m_param, DC_PARAM_ERRONEOUS_E2EE, NULL); /* reset eg. on forwarding */
/* add message to the database */
stmt = dc_sqlite3_predefine__(context->m_sql, INSERT_INTO_msgs_mcftttstpb,
@ -2087,7 +2087,7 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
}
else if( MR_MSG_NEEDS_ATTACHMENT(msg->m_type) )
{
pathNfilename = mrparam_get(msg->m_param, MRP_FILE, NULL);
pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( pathNfilename )
{
/* Got an attachment. Take care, the file may not be ready in this moment!
@ -2106,19 +2106,19 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
dc_msg_guess_msgtype_from_suffix(pathNfilename, &better_type, &better_mime);
if( better_type ) {
msg->m_type = better_type;
mrparam_set(msg->m_param, MRP_MIMETYPE, better_mime);
dc_param_set(msg->m_param, DC_PARAM_MIMETYPE, better_mime);
}
free(better_mime);
}
if( (msg->m_type == MR_MSG_IMAGE || msg->m_type == MR_MSG_GIF)
&& (mrparam_get_int(msg->m_param, MRP_WIDTH, 0)<=0 || mrparam_get_int(msg->m_param, MRP_HEIGHT, 0)<=0) ) {
&& (dc_param_get_int(msg->m_param, DC_PARAM_WIDTH, 0)<=0 || dc_param_get_int(msg->m_param, DC_PARAM_HEIGHT, 0)<=0) ) {
/* set width/height of images, if not yet done */
unsigned char* buf = NULL; size_t buf_bytes; uint32_t w, h;
if( mr_read_file(pathNfilename, (void**)&buf, &buf_bytes, msg->m_context) ) {
if( mr_get_filemeta(buf, buf_bytes, &w, &h) ) {
mrparam_set_int(msg->m_param, MRP_WIDTH, w);
mrparam_set_int(msg->m_param, MRP_HEIGHT, h);
if( dc_read_file(pathNfilename, (void**)&buf, &buf_bytes, msg->m_context) ) {
if( dc_get_filemeta(buf, buf_bytes, &w, &h) ) {
dc_param_set_int(msg->m_param, DC_PARAM_WIDTH, w);
dc_param_set_int(msg->m_param, DC_PARAM_HEIGHT, h);
}
}
free(buf);
@ -2129,9 +2129,9 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
if( msg->m_text ) { free(msg->m_text); }
if( msg->m_type == MR_MSG_AUDIO ) {
char* filename = mr_get_filename(pathNfilename);
char* author = mrparam_get(msg->m_param, MRP_AUTHORNAME, "");
char* title = mrparam_get(msg->m_param, MRP_TRACKNAME, "");
msg->m_text = mr_mprintf("%s %s %s", filename, author, title); /* for outgoing messages, also add the mediainfo. For incoming messages, this is not needed as the filename is build from these information */
char* author = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, "");
char* title = dc_param_get(msg->m_param, DC_PARAM_TRACKNAME, "");
msg->m_text = dc_mprintf("%s %s %s", filename, author, title); /* for outgoing messages, also add the mediainfo. For incoming messages, this is not needed as the filename is build from these information */
free(filename);
free(author);
free(title);
@ -2140,7 +2140,7 @@ uint32_t dc_send_msg_object(dc_context_t* context, uint32_t chat_id, dc_msg_t* m
msg->m_text = mr_get_filename(pathNfilename);
}
else if( MR_MSG_MAKE_SUFFIX_SEARCHABLE(msg->m_type) ) {
msg->m_text = mr_get_filesuffix_lc(pathNfilename);
msg->m_text = dc_get_filesuffix_lc(pathNfilename);
}
}
else
@ -2259,9 +2259,9 @@ uint32_t dc_send_image_msg(dc_context_t* context, uint32_t chat_id, const char*
}
msg->m_type = MR_MSG_IMAGE;
mrparam_set (msg->m_param, MRP_FILE, file);
mrparam_set_int(msg->m_param, MRP_WIDTH, width); /* set in sending job, if 0 */
mrparam_set_int(msg->m_param, MRP_HEIGHT, height); /* set in sending job, if 0 */
dc_param_set (msg->m_param, DC_PARAM_FILE, file);
dc_param_set_int(msg->m_param, DC_PARAM_WIDTH, width); /* set in sending job, if 0 */
dc_param_set_int(msg->m_param, DC_PARAM_HEIGHT, height); /* set in sending job, if 0 */
ret = dc_send_msg_object(context, chat_id, msg);
@ -2304,11 +2304,11 @@ uint32_t dc_send_video_msg(dc_context_t* context, uint32_t chat_id, const char*
}
msg->m_type = MR_MSG_VIDEO;
mrparam_set (msg->m_param, MRP_FILE, file);
mrparam_set (msg->m_param, MRP_MIMETYPE, filemime);
mrparam_set_int(msg->m_param, MRP_WIDTH, width);
mrparam_set_int(msg->m_param, MRP_HEIGHT, height);
mrparam_set_int(msg->m_param, MRP_DURATION, duration);
dc_param_set (msg->m_param, DC_PARAM_FILE, file);
dc_param_set (msg->m_param, DC_PARAM_MIMETYPE, filemime);
dc_param_set_int(msg->m_param, DC_PARAM_WIDTH, width);
dc_param_set_int(msg->m_param, DC_PARAM_HEIGHT, height);
dc_param_set_int(msg->m_param, DC_PARAM_DURATION, duration);
ret = dc_send_msg_object(context, chat_id, msg);
@ -2348,9 +2348,9 @@ uint32_t dc_send_voice_msg(dc_context_t* context, uint32_t chat_id, const char*
}
msg->m_type = MR_MSG_VOICE;
mrparam_set (msg->m_param, MRP_FILE, file);
mrparam_set (msg->m_param, MRP_MIMETYPE, filemime);
mrparam_set_int(msg->m_param, MRP_DURATION, duration);
dc_param_set (msg->m_param, DC_PARAM_FILE, file);
dc_param_set (msg->m_param, DC_PARAM_MIMETYPE, filemime);
dc_param_set_int(msg->m_param, DC_PARAM_DURATION, duration);
ret = dc_send_msg_object(context, chat_id, msg);
@ -2391,11 +2391,11 @@ uint32_t dc_send_audio_msg(dc_context_t* context, uint32_t chat_id, const char*
}
msg->m_type = MR_MSG_AUDIO;
mrparam_set (msg->m_param, MRP_FILE, file);
mrparam_set (msg->m_param, MRP_MIMETYPE, filemime);
mrparam_set_int(msg->m_param, MRP_DURATION, duration);
mrparam_set (msg->m_param, MRP_AUTHORNAME, author);
mrparam_set (msg->m_param, MRP_TRACKNAME, trackname);
dc_param_set (msg->m_param, DC_PARAM_FILE, file);
dc_param_set (msg->m_param, DC_PARAM_MIMETYPE, filemime);
dc_param_set_int(msg->m_param, DC_PARAM_DURATION, duration);
dc_param_set (msg->m_param, DC_PARAM_AUTHORNAME, author);
dc_param_set (msg->m_param, DC_PARAM_TRACKNAME, trackname);
ret = dc_send_msg_object(context, chat_id, msg);
@ -2433,8 +2433,8 @@ uint32_t dc_send_file_msg(dc_context_t* context, uint32_t chat_id, const char* f
}
msg->m_type = MR_MSG_FILE;
mrparam_set(msg->m_param, MRP_FILE, file);
mrparam_set(msg->m_param, MRP_MIMETYPE, filemime);
dc_param_set(msg->m_param, DC_PARAM_FILE, file);
dc_param_set(msg->m_param, DC_PARAM_MIMETYPE, filemime);
ret = dc_send_msg_object(context, chat_id, msg);
@ -2484,7 +2484,7 @@ uint32_t dc_send_vcard_msg(dc_context_t* context, uint32_t chat_id, uint32_t con
}
if( contact->m_authname && contact->m_authname[0] ) {
text_to_send = mr_mprintf("%s: %s", contact->m_authname, contact->m_addr);
text_to_send = dc_mprintf("%s: %s", contact->m_authname, contact->m_addr);
}
else {
text_to_send = safe_strdup(contact->m_addr);
@ -2564,7 +2564,7 @@ cleanup:
#define IS_SELF_IN_GROUP__ (dc_is_contact_in_chat__(context, chat_id, MR_CONTACT_ID_SELF)==1)
#define DO_SEND_STATUS_MAILS (mrparam_get_int(chat->m_param, MRP_UNPROMOTED, 0)==0)
#define DO_SEND_STATUS_MAILS (dc_param_get_int(chat->m_param, DC_PARAM_UNPROMOTED, 0)==0)
int dc_is_group_explicitly_left__(dc_context_t* context, const char* grpid)
@ -2601,7 +2601,7 @@ static int dc_real_group_exists__(dc_context_t* context, uint32_t chat_id)
stmt = dc_sqlite3_predefine__(context->m_sql, SELECT_id_FROM_chats_WHERE_id,
"SELECT id FROM chats "
" WHERE id=? "
" AND (type=" MR_STRINGIFY(MR_CHAT_TYPE_GROUP) " OR type=" MR_STRINGIFY(MR_CHAT_TYPE_VERIFIED_GROUP) ");");
" AND (type=" DC_STRINGIFY(MR_CHAT_TYPE_GROUP) " OR type=" DC_STRINGIFY(MR_CHAT_TYPE_VERIFIED_GROUP) ");");
sqlite3_bind_int(stmt, 1, chat_id);
if( sqlite3_step(stmt) == SQLITE_ROW ) {
@ -2663,10 +2663,10 @@ uint32_t dc_create_group_chat(dc_context_t* context, int verified, const char* c
locked = 1;
draft_txt = mrstock_str_repl_string(MR_STR_NEWGROUPDRAFT, chat_name);
grpid = mr_create_id();
grpid = dc_create_id();
stmt = dc_sqlite3_prepare_v2_(context->m_sql,
"INSERT INTO chats (type, name, draft_timestamp, draft_txt, grpid, param) VALUES(?, ?, ?, ?, ?, 'U=1');" /*U=MRP_UNPROMOTED*/ );
"INSERT INTO chats (type, name, draft_timestamp, draft_txt, grpid, param) VALUES(?, ?, ?, ?, ?, 'U=1');" /*U=DC_PARAM_UNPROMOTED*/ );
sqlite3_bind_int (stmt, 1, verified? MR_CHAT_TYPE_VERIFIED_GROUP : MR_CHAT_TYPE_GROUP);
sqlite3_bind_text (stmt, 2, chat_name, -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt, 3, time(NULL));
@ -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);
mrparam_set_int(msg->m_param, MRP_CMD, MR_CMD_GROUPNAME_CHANGED);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_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);
}
@ -2820,7 +2820,7 @@ int dc_set_chat_profile_image(dc_context_t* context, uint32_t chat_id, const cha
goto cleanup; /* we shoud respect this - whatever we send to the group, it gets discarded anyway! */
}
mrparam_set(chat->m_param, MRP_PROFILE_IMAGE, new_image/*may be NULL*/);
dc_param_set(chat->m_param, DC_PARAM_PROFILE_IMAGE, new_image/*may be NULL*/);
if( !dc_chat_update_param__(chat) ) {
goto cleanup;
}
@ -2831,8 +2831,8 @@ 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 )
{
mrparam_set_int(msg->m_param, MRP_CMD, MR_CMD_GROUPIMAGE_CHANGED);
mrparam_set (msg->m_param, MRP_CMD_PARAM, new_image);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_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);
msg->m_id = dc_send_msg_object(context, chat_id, msg);
@ -2933,9 +2933,9 @@ int dc_add_contact_to_chat_ex(dc_context_t* context, uint32_t chat_id, uint32_t
goto cleanup; /* we shoud respect this - whatever we send to the group, it gets discarded anyway! */
}
if( (flags&MR_FROM_HANDSHAKE) && mrparam_get_int(chat->m_param, MRP_UNPROMOTED, 0)==1 ) {
if( (flags&MR_FROM_HANDSHAKE) && dc_param_get_int(chat->m_param, DC_PARAM_UNPROMOTED, 0)==1 ) {
// after a handshake, force sending the `Chat-Group-Member-Added` message
mrparam_set(chat->m_param, MRP_UNPROMOTED, NULL);
dc_param_set(chat->m_param, DC_PARAM_UNPROMOTED, NULL);
dc_chat_update_param__(chat);
}
@ -2976,9 +2976,9 @@ 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);
mrparam_set_int(msg->m_param, MRP_CMD, MR_CMD_MEMBER_ADDED_TO_GROUP);
mrparam_set (msg->m_param, MRP_CMD_PARAM, contact->m_addr);
mrparam_set_int(msg->m_param, MRP_CMD_PARAM2,flags); // combine the Secure-Join protocol headers with the Chat-Group-Member-Added header
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_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);
context->m_cb(context, DC_EVENT_MSGS_CHANGED, chat_id, msg->m_id);
}
@ -3083,8 +3083,8 @@ 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);
}
mrparam_set_int(msg->m_param, MRP_CMD, MR_CMD_MEMBER_REMOVED_FROM_GROUP);
mrparam_set (msg->m_param, MRP_CMD_PARAM, contact->m_addr);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_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);
}
@ -3496,7 +3496,7 @@ dc_array_t* dc_get_contacts(dc_context_t* context, uint32_t listflags, const cha
stmt = dc_sqlite3_predefine__(context->m_sql, SELECT_id_FROM_contacts_WHERE_query_ORDER_BY,
"SELECT c.id FROM contacts c"
" LEFT JOIN acpeerstates ps ON c.addr=ps.addr "
" WHERE c.addr!=? AND c.id>" MR_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) " AND c.origin>=" MR_STRINGIFY(MR_ORIGIN_MIN_CONTACT_LIST) " AND c.blocked=0 AND (c.name LIKE ? OR c.addr LIKE ?)" /* see comments in dc_search_msgs() about the LIKE operator */
" WHERE c.addr!=? AND c.id>" DC_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) " AND c.origin>=" DC_STRINGIFY(MR_ORIGIN_MIN_CONTACT_LIST) " AND c.blocked=0 AND (c.name LIKE ? OR c.addr LIKE ?)" /* see comments in dc_search_msgs() about the LIKE operator */
" AND (1=? OR LENGTH(ps.verified_key_fingerprint)!=0) "
" ORDER BY LOWER(c.name||c.addr),c.id;");
sqlite3_bind_text(stmt, 1, self_addr, -1, SQLITE_STATIC);
@ -3514,7 +3514,7 @@ dc_array_t* dc_get_contacts(dc_context_t* context, uint32_t listflags, const cha
{
stmt = dc_sqlite3_predefine__(context->m_sql, SELECT_id_FROM_contacts_ORDER_BY,
"SELECT id FROM contacts"
" WHERE addr!=? AND id>" MR_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) " AND origin>=" MR_STRINGIFY(MR_ORIGIN_MIN_CONTACT_LIST) " AND blocked=0"
" WHERE addr!=? AND id>" DC_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) " AND origin>=" DC_STRINGIFY(MR_ORIGIN_MIN_CONTACT_LIST) " AND blocked=0"
" ORDER BY LOWER(name||addr),id;");
sqlite3_bind_text(stmt, 1, self_addr, -1, SQLITE_STATIC);
@ -3653,7 +3653,7 @@ dc_contact_t* dc_get_contact(dc_context_t* context, uint32_t contact_id)
static void marknoticed_contact__(dc_context_t* context, uint32_t contact_id)
{
sqlite3_stmt* stmt = dc_sqlite3_predefine__(context->m_sql, UPDATE_msgs_SET_state_WHERE_from_id_AND_state,
"UPDATE msgs SET state=" MR_STRINGIFY(MR_STATE_IN_NOTICED) " WHERE from_id=? AND state=" MR_STRINGIFY(MR_STATE_IN_FRESH) ";");
"UPDATE msgs SET state=" DC_STRINGIFY(MR_STATE_IN_NOTICED) " WHERE from_id=? AND state=" DC_STRINGIFY(MR_STATE_IN_FRESH) ";");
sqlite3_bind_int(stmt, 1, contact_id);
sqlite3_step(stmt);
}
@ -3785,22 +3785,22 @@ cleanup:
}
static void cat_fingerprint(mrstrbuilder_t* ret, const char* addr, const char* fingerprint_verified, const char* fingerprint_unverified)
static void cat_fingerprint(dc_strbuilder_t* ret, const char* addr, const char* fingerprint_verified, const char* fingerprint_unverified)
{
mrstrbuilder_cat(ret, "\n\n");
mrstrbuilder_cat(ret, addr);
mrstrbuilder_cat(ret, ":\n");
mrstrbuilder_cat(ret, (fingerprint_verified&&fingerprint_verified[0])? fingerprint_verified : fingerprint_unverified);
dc_strbuilder_cat(ret, "\n\n");
dc_strbuilder_cat(ret, addr);
dc_strbuilder_cat(ret, ":\n");
dc_strbuilder_cat(ret, (fingerprint_verified&&fingerprint_verified[0])? fingerprint_verified : fingerprint_unverified);
if( fingerprint_verified && fingerprint_verified[0]
&& fingerprint_unverified && fingerprint_unverified[0]
&& strcmp(fingerprint_verified, fingerprint_unverified)!=0 ) {
// might be that for verified chats the - older - verified gossiped key is used
// and for normal chats the - newer - unverified key :/
mrstrbuilder_cat(ret, "\n\n");
mrstrbuilder_cat(ret, addr);
mrstrbuilder_cat(ret, " (alternative):\n");
mrstrbuilder_cat(ret, fingerprint_unverified);
dc_strbuilder_cat(ret, "\n\n");
dc_strbuilder_cat(ret, addr);
dc_strbuilder_cat(ret, " (alternative):\n");
dc_strbuilder_cat(ret, fingerprint_unverified);
}
}
@ -3834,8 +3834,8 @@ char* dc_get_contact_encrinfo(dc_context_t* context, uint32_t contact_id)
goto cleanup;
}
mrstrbuilder_t ret;
mrstrbuilder_init(&ret, 0);
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, 0);
dc_sqlite3_lock(context->m_sql);
locked = 1;
@ -3854,7 +3854,7 @@ char* dc_get_contact_encrinfo(dc_context_t* context, uint32_t contact_id)
if( dc_apeerstate_peek_key(peerstate, MRV_NOT_VERIFIED) )
{
// E2E available :)
p = mrstock_str(peerstate->m_prefer_encrypt == MRA_PE_MUTUAL? MR_STR_E2E_PREFERRED : MR_STR_E2E_AVAILABLE); mrstrbuilder_cat(&ret, p); free(p);
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);
if( self_key->m_binary == NULL ) {
dc_pgp_rand_seed(context, peerstate->m_addr, strlen(peerstate->m_addr) /*just some random data*/);
@ -3866,9 +3866,9 @@ char* dc_get_contact_encrinfo(dc_context_t* context, uint32_t contact_id)
locked = 0;
}
mrstrbuilder_cat(&ret, " ");
p = mrstock_str(MR_STR_FINGERPRINTS); mrstrbuilder_cat(&ret, p); free(p);
mrstrbuilder_cat(&ret, ":");
dc_strbuilder_cat(&ret, " ");
p = mrstock_str(MR_STR_FINGERPRINTS); dc_strbuilder_cat(&ret, p); free(p);
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));
@ -3889,11 +3889,11 @@ char* dc_get_contact_encrinfo(dc_context_t* context, uint32_t contact_id)
if( !(loginparam->m_server_flags&MR_IMAP_SOCKET_PLAIN)
&& !(loginparam->m_server_flags&MR_SMTP_SOCKET_PLAIN) )
{
p = mrstock_str(MR_STR_ENCR_TRANSP); mrstrbuilder_cat(&ret, p); free(p);
p = mrstock_str(MR_STR_ENCR_TRANSP); dc_strbuilder_cat(&ret, p); free(p);
}
else
{
p = mrstock_str(MR_STR_ENCR_NONE); mrstrbuilder_cat(&ret, p); free(p);
p = mrstock_str(MR_STR_ENCR_NONE); dc_strbuilder_cat(&ret, p); free(p);
}
}
@ -4026,8 +4026,8 @@ size_t dc_get_real_msg_cnt__(dc_context_t* context)
"SELECT COUNT(*) "
" FROM msgs m "
" LEFT JOIN chats c ON c.id=m.chat_id "
" WHERE m.id>" MR_STRINGIFY(MR_MSG_ID_LAST_SPECIAL)
" AND m.chat_id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL)
" WHERE m.id>" DC_STRINGIFY(MR_MSG_ID_LAST_SPECIAL)
" AND m.chat_id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL)
" AND c.blocked=0;");
if( sqlite3_step(stmt) != SQLITE_ROW ) {
dc_sqlite3_log_error(context->m_sql, "mr_get_assigned_msg_cnt_() failed.");
@ -4166,14 +4166,14 @@ cleanup:
*/
char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
{
mrstrbuilder_t ret;
dc_strbuilder_t ret;
int locked = 0;
sqlite3_stmt* stmt;
dc_msg_t* msg = dc_msg_new();
dc_contact_t* contact_from = dc_contact_new(context);
char *rawtxt = NULL, *p;
mrstrbuilder_init(&ret, 0);
dc_strbuilder_init(&ret, 0);
if( context == NULL || context->m_magic != DC_CONTEXT_MAGIC ) {
goto cleanup;
@ -4189,7 +4189,7 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
"SELECT txt_raw FROM msgs WHERE id=?;");
sqlite3_bind_int(stmt, 1, msg_id);
if( sqlite3_step(stmt) != SQLITE_ROW ) {
p = mr_mprintf("Cannot load message #%i.", (int)msg_id); mrstrbuilder_cat(&ret, p); free(p);
p = dc_mprintf("Cannot load message #%i.", (int)msg_id); dc_strbuilder_cat(&ret, p); free(p);
goto cleanup;
}
@ -4201,23 +4201,23 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
char* subject = rawtxt;
*p = 0;
p++;
rawtxt = mr_mprintf("<b>%s</b>\n%s", subject, p);
rawtxt = dc_mprintf("<b>%s</b>\n%s", subject, p);
free(subject);
}
#endif
mr_trim(rawtxt);
mr_truncate_str(rawtxt, MR_MAX_GET_INFO_LEN);
dc_truncate_str(rawtxt, MR_MAX_GET_INFO_LEN);
/* add time */
mrstrbuilder_cat(&ret, "Sent: ");
p = mr_timestamp_to_str(dc_msg_get_timestamp(msg)); mrstrbuilder_cat(&ret, p); free(p);
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "Sent: ");
p = dc_timestamp_to_str(dc_msg_get_timestamp(msg)); dc_strbuilder_cat(&ret, p); free(p);
dc_strbuilder_cat(&ret, "\n");
if( msg->m_from_id != MR_CONTACT_ID_SELF ) {
mrstrbuilder_cat(&ret, "Received: ");
p = mr_timestamp_to_str(msg->m_timestamp_rcvd? msg->m_timestamp_rcvd : msg->m_timestamp); mrstrbuilder_cat(&ret, p); free(p);
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "Received: ");
p = dc_timestamp_to_str(msg->m_timestamp_rcvd? msg->m_timestamp_rcvd : msg->m_timestamp); dc_strbuilder_cat(&ret, p); free(p);
dc_strbuilder_cat(&ret, "\n");
}
if( msg->m_from_id == MR_CONTACT_ID_DEVICE || msg->m_to_id == MR_CONTACT_ID_DEVICE ) {
@ -4229,15 +4229,15 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
"SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?;");
sqlite3_bind_int (stmt, 1, msg_id);
while( sqlite3_step(stmt) == SQLITE_ROW ) {
mrstrbuilder_cat(&ret, "Read: ");
p = mr_timestamp_to_str(sqlite3_column_int64(stmt, 1)); mrstrbuilder_cat(&ret, p); free(p);
mrstrbuilder_cat(&ret, " by ");
dc_strbuilder_cat(&ret, "Read: ");
p = dc_timestamp_to_str(sqlite3_column_int64(stmt, 1)); dc_strbuilder_cat(&ret, p); free(p);
dc_strbuilder_cat(&ret, " by ");
dc_contact_t* contact = dc_contact_new(context);
dc_contact_load_from_db__(contact, context->m_sql, sqlite3_column_int64(stmt, 0));
p = dc_contact_get_display_name(contact); mrstrbuilder_cat(&ret, p); free(p);
p = dc_contact_get_display_name(contact); dc_strbuilder_cat(&ret, p); free(p);
dc_contact_unref(contact);
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "\n");
}
sqlite3_finalize(stmt);
@ -4254,39 +4254,39 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
case MR_STATE_OUT_ERROR: p = safe_strdup("Error"); break;
case MR_STATE_OUT_MDN_RCVD: p = safe_strdup("Read"); break;
case MR_STATE_OUT_PENDING: p = safe_strdup("Pending"); break;
default: p = mr_mprintf("%i", msg->m_state); break;
default: p = dc_mprintf("%i", msg->m_state); break;
}
mrstrbuilder_catf(&ret, "State: %s", p);
dc_strbuilder_catf(&ret, "State: %s", p);
free(p);
p = NULL;
int e2ee_errors;
if( (e2ee_errors=mrparam_get_int(msg->m_param, MRP_ERRONEOUS_E2EE, 0)) ) {
if( (e2ee_errors=dc_param_get_int(msg->m_param, DC_PARAM_ERRONEOUS_E2EE, 0)) ) {
if( e2ee_errors&MRE2EE_NO_VALID_SIGNATURE ) {
p = safe_strdup("Encrypted, no valid signature");
}
}
else if( mrparam_get_int(msg->m_param, MRP_GUARANTEE_E2EE, 0) ) {
else if( dc_param_get_int(msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0) ) {
p = safe_strdup("Encrypted");
}
if( p ) {
mrstrbuilder_catf(&ret, ", %s", p);
dc_strbuilder_catf(&ret, ", %s", p);
free(p);
}
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "\n");
/* add sender (only for info messages as the avatar may not be shown for them) */
if( dc_msg_is_info(msg) ) {
mrstrbuilder_cat(&ret, "Sender: ");
p = dc_contact_get_name_n_addr(contact_from); mrstrbuilder_cat(&ret, p); free(p);
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "Sender: ");
p = dc_contact_get_name_n_addr(contact_from); dc_strbuilder_cat(&ret, p); free(p);
dc_strbuilder_cat(&ret, "\n");
}
/* add file info */
char* file = mrparam_get(msg->m_param, MRP_FILE, NULL);
char* file = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( file ) {
p = mr_mprintf("\nFile: %s, %i bytes\n", file, (int)mr_get_filebytes(file)); mrstrbuilder_cat(&ret, p); free(p);
p = dc_mprintf("\nFile: %s, %i bytes\n", file, (int)mr_get_filebytes(file)); dc_strbuilder_cat(&ret, p); free(p);
}
if( msg->m_type != MR_MSG_TEXT ) {
@ -4298,44 +4298,44 @@ char* dc_get_msg_info(dc_context_t* context, uint32_t msg_id)
case MR_MSG_IMAGE: p = safe_strdup("Image"); break;
case MR_MSG_VIDEO: p = safe_strdup("Video"); break;
case MR_MSG_VOICE: p = safe_strdup("Voice"); break;
default: p = mr_mprintf("%i", msg->m_type); break;
default: p = dc_mprintf("%i", msg->m_type); break;
}
mrstrbuilder_catf(&ret, "Type: %s\n", p);
dc_strbuilder_catf(&ret, "Type: %s\n", p);
free(p);
}
int w = mrparam_get_int(msg->m_param, MRP_WIDTH, 0), h = mrparam_get_int(msg->m_param, MRP_HEIGHT, 0);
int w = dc_param_get_int(msg->m_param, DC_PARAM_WIDTH, 0), h = dc_param_get_int(msg->m_param, DC_PARAM_HEIGHT, 0);
if( w != 0 || h != 0 ) {
p = mr_mprintf("Dimension: %i x %i\n", w, h); mrstrbuilder_cat(&ret, p); free(p);
p = dc_mprintf("Dimension: %i x %i\n", w, h); dc_strbuilder_cat(&ret, p); free(p);
}
int duration = mrparam_get_int(msg->m_param, MRP_DURATION, 0);
int duration = dc_param_get_int(msg->m_param, DC_PARAM_DURATION, 0);
if( duration != 0 ) {
p = mr_mprintf("Duration: %i ms\n", duration); mrstrbuilder_cat(&ret, p); free(p);
p = dc_mprintf("Duration: %i ms\n", duration); dc_strbuilder_cat(&ret, p); free(p);
}
/* add rawtext */
if( rawtxt && rawtxt[0] ) {
mrstrbuilder_cat(&ret, "\n");
mrstrbuilder_cat(&ret, rawtxt);
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, rawtxt);
dc_strbuilder_cat(&ret, "\n");
}
/* add Message-ID, Server-Folder and Server-UID; the database ID is normally only of interest if you have access to sqlite; if so you can easily get it from the "msgs" table. */
#ifdef __ANDROID__
mrstrbuilder_cat(&ret, "<c#808080>");
dc_strbuilder_cat(&ret, "<c#808080>");
#endif
if( msg->m_rfc724_mid && msg->m_rfc724_mid[0] ) {
mrstrbuilder_catf(&ret, "\nMessage-ID: %s", msg->m_rfc724_mid);
dc_strbuilder_catf(&ret, "\nMessage-ID: %s", msg->m_rfc724_mid);
}
if( msg->m_server_folder && msg->m_server_folder[0] ) {
mrstrbuilder_catf(&ret, "\nLast seen as: %s/%i", msg->m_server_folder, (int)msg->m_server_uid);
dc_strbuilder_catf(&ret, "\nLast seen as: %s/%i", msg->m_server_folder, (int)msg->m_server_uid);
}
#ifdef __ANDROID__
mrstrbuilder_cat(&ret, "</c>");
dc_strbuilder_cat(&ret, "</c>");
#endif
cleanup:
@ -4392,7 +4392,7 @@ void dc_forward_msgs(dc_context_t* context, const uint32_t* msg_ids, int msg_cnt
curr_timestamp = mr_create_smeared_timestamps__(msg_cnt);
idsstr = mr_arr_to_string(msg_ids, msg_cnt);
idsstr = dc_arr_to_string(msg_ids, msg_cnt);
q3 = sqlite3_mprintf("SELECT id FROM msgs WHERE id IN(%s) ORDER BY timestamp,id", idsstr);
stmt = dc_sqlite3_prepare_v2_(context->m_sql, q3);
while( sqlite3_step(stmt)==SQLITE_ROW )
@ -4402,9 +4402,9 @@ void dc_forward_msgs(dc_context_t* context, const uint32_t* msg_ids, int msg_cnt
goto cleanup;
}
mrparam_set_int(msg->m_param, MRP_FORWARDED, 1);
mrparam_set (msg->m_param, MRP_GUARANTEE_E2EE, NULL);
mrparam_set (msg->m_param, MRP_FORCE_PLAINTEXT, NULL);
dc_param_set_int(msg->m_param, DC_PARAM_FORWARDED, 1);
dc_param_set (msg->m_param, DC_PARAM_GUARANTEE_E2EE, NULL);
dc_param_set (msg->m_param, DC_PARAM_FORCE_PLAINTEXT, NULL);
uint32_t new_msg_id = dc_send_msg_i__(context, chat, msg, curr_timestamp++);
carray_add(created_db_entries, (void*)(uintptr_t)chat_id, NULL);
@ -4558,7 +4558,7 @@ void dc_markseen_msgs(dc_context_t* context, const uint32_t* msg_ids, int msg_cn
"SELECT m.state, c.blocked "
" FROM msgs m "
" LEFT JOIN chats c ON c.id=m.chat_id "
" WHERE m.id=? AND m.chat_id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL));
" WHERE m.id=? AND m.chat_id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL));
sqlite3_bind_int(stmt, 1, msg_ids[i]);
if( sqlite3_step(stmt) != SQLITE_ROW ) {
goto cleanup;

30
src/dc_dehtml.c
View file

@ -32,7 +32,7 @@
typedef struct dehtml_t
{
mrstrbuilder_t m_strbuilder;
dc_strbuilder_t m_strbuilder;
#define DO_NOT_ADD 0
#define DO_ADD_REMOVE_LINEENDS 1
@ -49,12 +49,12 @@ static void dehtml_starttag_cb(void* userdata, const char* tag, char** attr)
if( strcmp(tag, "p")==0 || strcmp(tag, "div")==0 || strcmp(tag, "table")==0 || strcmp(tag, "td")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "\n\n");
dc_strbuilder_cat(&dehtml->m_strbuilder, "\n\n");
dehtml->m_add_text = DO_ADD_REMOVE_LINEENDS;
}
else if( strcmp(tag, "br")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "\n");
dc_strbuilder_cat(&dehtml->m_strbuilder, "\n");
dehtml->m_add_text = DO_ADD_REMOVE_LINEENDS;
}
else if( strcmp(tag, "style")==0 || strcmp(tag, "script")==0 || strcmp(tag, "title")==0 )
@ -63,7 +63,7 @@ static void dehtml_starttag_cb(void* userdata, const char* tag, char** attr)
}
else if( strcmp(tag, "pre")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "\n\n");
dc_strbuilder_cat(&dehtml->m_strbuilder, "\n\n");
dehtml->m_add_text = DO_ADD_PRESERVE_LINEENDS;
}
else if( strcmp(tag, "a")==0 )
@ -71,16 +71,16 @@ static void dehtml_starttag_cb(void* userdata, const char* tag, char** attr)
free(dehtml->m_last_href);
dehtml->m_last_href = strdup_keep_null(mrattr_find(attr, "href"));
if( dehtml->m_last_href ) {
mrstrbuilder_cat(&dehtml->m_strbuilder, "[");
dc_strbuilder_cat(&dehtml->m_strbuilder, "[");
}
}
else if( strcmp(tag, "b")==0 || strcmp(tag, "strong")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "*");
dc_strbuilder_cat(&dehtml->m_strbuilder, "*");
}
else if( strcmp(tag, "i")==0 || strcmp(tag, "em")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "_");
dc_strbuilder_cat(&dehtml->m_strbuilder, "_");
}
}
@ -91,7 +91,7 @@ static void dehtml_text_cb(void* userdata, const char* text, int len)
if( dehtml->m_add_text != DO_NOT_ADD )
{
char* last_added = mrstrbuilder_cat(&dehtml->m_strbuilder, text);
char* last_added = dc_strbuilder_cat(&dehtml->m_strbuilder, text);
if( dehtml->m_add_text==DO_ADD_REMOVE_LINEENDS )
{
@ -129,26 +129,26 @@ static void dehtml_endtag_cb(void* userdata, const char* tag)
|| strcmp(tag, "style")==0 || strcmp(tag, "script")==0 || strcmp(tag, "title")==0
|| strcmp(tag, "pre")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "\n\n"); /* do not expect an starting block element (which, of course, should come right now) */
dc_strbuilder_cat(&dehtml->m_strbuilder, "\n\n"); /* do not expect an starting block element (which, of course, should come right now) */
dehtml->m_add_text = DO_ADD_REMOVE_LINEENDS;
}
else if( strcmp(tag, "a")==0 )
{
if( dehtml->m_last_href ) {
mrstrbuilder_cat(&dehtml->m_strbuilder, "](");
mrstrbuilder_cat(&dehtml->m_strbuilder, dehtml->m_last_href);
mrstrbuilder_cat(&dehtml->m_strbuilder, ")");
dc_strbuilder_cat(&dehtml->m_strbuilder, "](");
dc_strbuilder_cat(&dehtml->m_strbuilder, dehtml->m_last_href);
dc_strbuilder_cat(&dehtml->m_strbuilder, ")");
free(dehtml->m_last_href);
dehtml->m_last_href = NULL;
}
}
else if( strcmp(tag, "b")==0 || strcmp(tag, "strong")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "*");
dc_strbuilder_cat(&dehtml->m_strbuilder, "*");
}
else if( strcmp(tag, "i")==0 || strcmp(tag, "em")==0 )
{
mrstrbuilder_cat(&dehtml->m_strbuilder, "_");
dc_strbuilder_cat(&dehtml->m_strbuilder, "_");
}
}
@ -165,7 +165,7 @@ char* dc_dehtml(char* buf_terminated)
memset(&dehtml, 0, sizeof(dehtml_t));
dehtml.m_add_text = DO_ADD_REMOVE_LINEENDS;
mrstrbuilder_init(&dehtml.m_strbuilder, strlen(buf_terminated));
dc_strbuilder_init(&dehtml.m_strbuilder, strlen(buf_terminated));
dc_saxparser_init(&saxparser, &dehtml);
dc_saxparser_set_tag_handler(&saxparser, dehtml_starttag_cb, dehtml_endtag_cb);

20
src/dc_e2ee.c
View file

@ -345,9 +345,9 @@ void dc_e2ee_encrypt(dc_context_t* mailbox, const clist* recipients_addr,
locked = 1;
/* init autocrypt header from db */
autocryptheader->m_prefer_encrypt = MRA_PE_NOPREFERENCE;
autocryptheader->m_prefer_encrypt = DC_PE_NOPREFERENCE;
if( mailbox->m_e2ee_enabled ) {
autocryptheader->m_prefer_encrypt = MRA_PE_MUTUAL;
autocryptheader->m_prefer_encrypt = DC_PE_MUTUAL;
}
autocryptheader->m_addr = dc_sqlite3_get_config__(mailbox->m_sql, "configured_addr", NULL);
@ -360,7 +360,7 @@ void dc_e2ee_encrypt(dc_context_t* mailbox, const clist* recipients_addr,
}
/* load peerstate information etc. */
if( autocryptheader->m_prefer_encrypt==MRA_PE_MUTUAL || e2ee_guaranteed )
if( autocryptheader->m_prefer_encrypt==DC_PE_MUTUAL || e2ee_guaranteed )
{
do_encrypt = 1;
clistiter* iter1;
@ -374,7 +374,7 @@ void dc_e2ee_encrypt(dc_context_t* mailbox, const clist* recipients_addr,
}
else if( dc_apeerstate_load_by_addr__(peerstate, mailbox->m_sql, recipient_addr)
&& (key_to_use=dc_apeerstate_peek_key(peerstate, min_verified)) != NULL
&& (peerstate->m_prefer_encrypt==MRA_PE_MUTUAL || e2ee_guaranteed) )
&& (peerstate->m_prefer_encrypt==DC_PE_MUTUAL || e2ee_guaranteed) )
{
dc_keyring_add(keyring, key_to_use); /* we always add all recipients (even on IMAP upload) as otherwise forwarding may fail */
dc_array_add_ptr(peerstates, peerstate);
@ -459,8 +459,8 @@ void dc_e2ee_encrypt(dc_context_t* mailbox, const clist* recipients_addr,
}
}
char* e = mrstock_str(MR_STR_ENCRYPTEDMSG); char* subject_str = mr_mprintf(MR_CHAT_PREFIX " %s", e); free(e);
struct mailimf_subject* subject = mailimf_subject_new(mr_encode_header_words(subject_str));
char* e = mrstock_str(MR_STR_ENCRYPTEDMSG); char* subject_str = dc_mprintf(MR_CHAT_PREFIX " %s", e); free(e);
struct mailimf_subject* subject = mailimf_subject_new(dc_encode_header_words(subject_str));
mailimf_fields_add(imffields_unprotected, mailimf_field_new(MAILIMF_FIELD_SUBJECT, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, subject, NULL, NULL, NULL));
free(subject_str);
@ -471,13 +471,13 @@ void dc_e2ee_encrypt(dc_context_t* mailbox, const clist* recipients_addr,
if( plain->str == NULL || plain->len<=0 ) {
goto cleanup;
}
//char* t1=mr_null_terminate(plain->str,plain->len);printf("PLAIN:\n%s\n",t1);free(t1); // DEBUG OUTPUT
//char* t1=dc_null_terminate(plain->str,plain->len);printf("PLAIN:\n%s\n",t1);free(t1); // DEBUG OUTPUT
if( !dc_pgp_pk_encrypt(mailbox, plain->str, plain->len, keyring, sign_key, 1/*use_armor*/, (void**)&ctext, &ctext_bytes) ) {
goto cleanup;
}
helper->m_cdata_to_free = ctext;
//char* t2=mr_null_terminate(ctext,ctext_bytes);printf("ENCRYPTED:\n%s\n",t2);free(t2); // DEBUG OUTPUT
//char* t2=dc_null_terminate(ctext,ctext_bytes);printf("ENCRYPTED:\n%s\n",t2);free(t2); // DEBUG OUTPUT
/* create MIME-structure that will contain the encrypted text */
struct mailmime* encrypted_part = new_data_part(NULL, 0, "multipart/encrypted", -1);
@ -496,7 +496,7 @@ void dc_e2ee_encrypt(dc_context_t* mailbox, const clist* recipients_addr,
in_out_message->mm_data.mm_message.mm_msg_mime = encrypted_part;
encrypted_part->mm_parent = in_out_message;
mailmime_free(message_to_encrypt);
//MMAPString* t3=mmap_string_new("");mailmime_write_mem(t3,&col,in_out_message);char* t4=mr_null_terminate(t3->str,t3->len); printf("ENCRYPTED+MIME_ENCODED:\n%s\n",t4);free(t4);mmap_string_free(t3); // DEBUG OUTPUT
//MMAPString* t3=mmap_string_new("");mailmime_write_mem(t3,&col,in_out_message);char* t4=dc_null_terminate(t3->str,t3->len); printf("ENCRYPTED+MIME_ENCODED:\n%s\n",t4);free(t4);mmap_string_free(t3); // DEBUG OUTPUT
helper->m_encryption_successfull = 1;
}
@ -642,7 +642,7 @@ static int decrypt_part(dc_context_t* mailbox,
goto cleanup;
}
//{char* t1=mr_null_terminate(plain_buf,plain_bytes);printf("\n**********\n%s\n**********\n",t1);free(t1);}
//{char* t1=dc_null_terminate(plain_buf,plain_bytes);printf("\n**********\n%s\n**********\n",t1);free(t1);}
{
size_t index = 0;

18
src/dc_imap.c
View file

@ -65,7 +65,7 @@ static void get_config_lastseenuid(dc_imap_t* imap, const char* folder, uint32_t
*uidvalidity = 0;
*lastseenuid = 0;
char* key = mr_mprintf("imap.mailbox.%s", folder);
char* key = dc_mprintf("imap.mailbox.%s", folder);
char* val1 = imap->m_get_config(imap, key, NULL), *val2 = NULL, *val3 = NULL;
if( val1 )
{
@ -90,8 +90,8 @@ static void get_config_lastseenuid(dc_imap_t* imap, const char* folder, uint32_t
static void set_config_lastseenuid(dc_imap_t* imap, const char* folder, uint32_t uidvalidity, uint32_t lastseenuid)
{
char* key = mr_mprintf("imap.mailbox.%s", folder);
char* val = mr_mprintf("%lu:%lu", uidvalidity, lastseenuid);
char* key = dc_mprintf("imap.mailbox.%s", folder);
char* val = dc_mprintf("%lu:%lu", uidvalidity, lastseenuid);
imap->m_set_config(imap, key, val);
free(val);
free(key);
@ -251,7 +251,7 @@ static clist* list_folders__(dc_imap_t* ths)
ret_folder->m_name_to_select = safe_strdup(imap_folder->mb_name);
}
ret_folder->m_name_utf8 = mr_decode_modified_utf7(imap_folder->mb_name, 0);
ret_folder->m_name_utf8 = dc_decode_modified_utf7(imap_folder->mb_name, 0);
ret_folder->m_meaning = get_folder_meaning(ths, imap_folder->mb_flag, ret_folder->m_name_utf8, false);
if( ret_folder->m_meaning == MEANING_IGNORE || ret_folder->m_meaning == MEANING_SENT_OBJECTS /*MEANING_INBOX is no hint for a working XLIST*/ ) {
@ -436,7 +436,7 @@ static uint32_t search_uid__(dc_imap_t* imap, const char* message_id)
On failure, 0 is returned and any or none folder is selected. */
clist *folders = list_folders__(imap), *search_result = NULL;
clistiter *cur, *cur2;
struct mailimap_search_key *key = mailimap_search_key_new_header(strdup("Message-ID"), mr_mprintf("<%s>", message_id));
struct mailimap_search_key *key = mailimap_search_key_new_header(strdup("Message-ID"), dc_mprintf("<%s>", message_id));
uint32_t uid = 0;
for( cur = clist_begin(folders); cur != NULL ; cur = clist_next(cur) )
{
@ -1219,16 +1219,16 @@ int dc_imap_connect(dc_imap_t* ths, const dc_loginparam_t* lp)
{
/* just log the whole capabilities list (the mailimap_has_*() function also use this list, so this is a good overview on problems) */
ths->m_skip_log_capabilities = 1;
mrstrbuilder_t capinfostr;
mrstrbuilder_init(&capinfostr, 0);
dc_strbuilder_t capinfostr;
dc_strbuilder_init(&capinfostr, 0);
clist* list = ths->m_hEtpan->imap_connection_info->imap_capability->cap_list;
if( list ) {
clistiter* cur;
for(cur = clist_begin(list) ; cur != NULL ; cur = clist_next(cur)) {
struct mailimap_capability * cap = clist_content(cur);
if( cap && cap->cap_type == MAILIMAP_CAPABILITY_NAME ) {
mrstrbuilder_cat(&capinfostr, " ");
mrstrbuilder_cat(&capinfostr, cap->cap_data.cap_name);
dc_strbuilder_cat(&capinfostr, " ");
dc_strbuilder_cat(&capinfostr, cap->cap_data.cap_name);
}
}
}

74
src/dc_imex.c
View file

@ -226,7 +226,7 @@ char* dc_render_setup_file(dc_context_t* context, const char* passphrase)
/* done with symmetric key block */
pgp_writer_close(encr_output);
encr_string = mr_null_terminate((const char*)encr_mem->buf, encr_mem->length);
encr_string = dc_null_terminate((const char*)encr_mem->buf, encr_mem->length);
//printf("\n~~~~~~~~~~~~~~~~~~~~SYMMETRICALLY ENCRYPTED~~~~~~~~~~~~~~~~~~~~\n%s~~~~~~~~~~~~~~~~~~~~/SYMMETRICALLY ENCRYPTED~~~~~~~~~~~~~~~~~~~~\n",encr_string); // DEBUG OUTPUT
@ -235,10 +235,10 @@ char* dc_render_setup_file(dc_context_t* context, const char* passphrase)
#define LINEEND "\r\n" /* use the same lineends as the PGP armored data */
{
char* replacement = mr_mprintf("-----BEGIN PGP MESSAGE-----" LINEEND
char* replacement = dc_mprintf("-----BEGIN PGP MESSAGE-----" LINEEND
"Passphrase-Format: numeric9x4" LINEEND
"Passphrase-Begin: %s", passphrase_begin);
mr_str_replace(&encr_string, "-----BEGIN PGP MESSAGE-----", replacement);
dc_str_replace(&encr_string, "-----BEGIN PGP MESSAGE-----", replacement);
free(replacement);
}
@ -248,10 +248,10 @@ char* dc_render_setup_file(dc_context_t* context, const char* passphrase)
char* setup_message_title = mrstock_str(MR_STR_AC_SETUP_MSG_SUBJECT);
char* setup_message_body = mrstock_str(MR_STR_AC_SETUP_MSG_BODY);
mr_str_replace(&setup_message_body, "\r", NULL);
mr_str_replace(&setup_message_body, "\n", "<br>");
dc_str_replace(&setup_message_body, "\r", NULL);
dc_str_replace(&setup_message_body, "\n", "<br>");
ret_setupfilecontent = mr_mprintf(
ret_setupfilecontent = dc_mprintf(
"<!DOCTYPE html>" LINEEND
"<html>" LINEEND
"<head>" LINEEND
@ -370,9 +370,9 @@ char* dc_create_setup_code(dc_context_t* context)
#define CODE_ELEMS 9
uint16_t random_val;
int i;
mrstrbuilder_t ret;
dc_strbuilder_t ret;
mrstrbuilder_init(&ret, 0);
dc_strbuilder_init(&ret, 0);
for( i = 0; i < CODE_ELEMS; i++ )
{
@ -387,7 +387,7 @@ char* dc_create_setup_code(dc_context_t* context)
random_val = random_val % 10000; /* force all blocks into the range 0..9999 */
mrstrbuilder_catf(&ret, "%s%04i", i?"-":"", (int)random_val);
dc_strbuilder_catf(&ret, "%s%04i", i?"-":"", (int)random_val);
}
return ret.m_buf;
@ -401,17 +401,17 @@ char* dc_normalize_setup_code(dc_context_t* context, const char* in)
return NULL;
}
mrstrbuilder_t out;
mrstrbuilder_init(&out, 0);
dc_strbuilder_t out;
dc_strbuilder_init(&out, 0);
int outlen;
const char* p1 = in;
while( *p1 ) {
if( *p1 >= '0' && *p1 <= '9' ) {
mrstrbuilder_catf(&out, "%c", *p1);
dc_strbuilder_catf(&out, "%c", *p1);
outlen = strlen(out.m_buf);
if( outlen==4 || outlen==9 || outlen==14 || outlen==19 || outlen==24 || outlen == 29 || outlen == 34 || outlen == 39 ) {
mrstrbuilder_cat(&out, "-");
dc_strbuilder_cat(&out, "-");
}
}
p1++;
@ -497,8 +497,8 @@ char* dc_initiate_key_transfer(dc_context_t* context)
CHECK_EXIT
if( (setup_file_name=mr_get_fine_pathNfilename(context->m_blobdir, "autocrypt-setup-message.html")) == NULL
|| !mr_write_file(setup_file_name, setup_file_content, strlen(setup_file_content), context) ) {
if( (setup_file_name=dc_get_fine_pathNfilename(context->m_blobdir, "autocrypt-setup-message.html")) == NULL
|| !dc_write_file(setup_file_name, setup_file_content, strlen(setup_file_content), context) ) {
goto cleanup;
}
@ -508,10 +508,10 @@ char* dc_initiate_key_transfer(dc_context_t* context)
msg = dc_msg_new();
msg->m_type = MR_MSG_FILE;
mrparam_set (msg->m_param, MRP_FILE, setup_file_name);
mrparam_set (msg->m_param, MRP_MIMETYPE, "application/autocrypt-setup");
mrparam_set_int(msg->m_param, MRP_CMD, MR_CMD_AUTOCRYPT_SETUP_MESSAGE);
mrparam_set_int(msg->m_param, MRP_FORCE_PLAINTEXT, MRFP_NO_AUTOCRYPT_HEADER);
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_FORCE_PLAINTEXT, MRFP_NO_AUTOCRYPT_HEADER);
CHECK_EXIT
@ -571,7 +571,7 @@ static int set_self_key(dc_context_t* context, const char* armored, int set_defa
goto cleanup;
}
if( !dc_key_set_from_base64(private_key, buf_base64, MR_PRIVATE)
if( !dc_key_set_from_base64(private_key, buf_base64, DC_KEY_PRIVATE)
|| !dc_pgp_is_valid_key(context, private_key)
|| !dc_pgp_split_key(context, private_key, public_key) ) {
dc_log_error(context, 0, "File does not contain a valid private key.");
@ -667,7 +667,7 @@ int dc_continue_key_transfer(dc_context_t* context, uint32_t msg_id, const char*
goto cleanup;
}
if( !mr_read_file(filename, (void**)&filecontent, &filebytes, msg->m_context) || filecontent == NULL || filebytes <= 0 ) {
if( !dc_read_file(filename, (void**)&filecontent, &filebytes, msg->m_context) || filecontent == NULL || filebytes <= 0 ) {
dc_log_error(context, 0, "Cannot read Autocrypt Setup Message file.");
goto cleanup;
}
@ -707,10 +707,10 @@ static void export_key_to_asc_file(dc_context_t* context, const char* dir, int i
{
char* file_name;
if( is_default ) {
file_name = mr_mprintf("%s/%s-key-default.asc", dir, key->m_type==MR_PUBLIC? "public" : "private");
file_name = dc_mprintf("%s/%s-key-default.asc", dir, key->m_type==DC_KEY_PUBLIC? "public" : "private");
}
else {
file_name = mr_mprintf("%s/%s-key-%i.asc", dir, key->m_type==MR_PUBLIC? "public" : "private", id);
file_name = dc_mprintf("%s/%s-key-%i.asc", dir, key->m_type==DC_KEY_PUBLIC? "public" : "private", id);
}
dc_log_info(context, 0, "Exporting key %s", file_name);
mr_delete_file(file_name, context);
@ -740,8 +740,8 @@ static int export_self_keys(dc_context_t* context, const char* dir)
while( sqlite3_step(stmt)==SQLITE_ROW ) {
id = sqlite3_column_int( stmt, 0 );
dc_key_set_from_stmt(public_key, stmt, 1, MR_PUBLIC);
dc_key_set_from_stmt(private_key, stmt, 2, MR_PRIVATE);
dc_key_set_from_stmt(public_key, stmt, 1, DC_KEY_PUBLIC);
dc_key_set_from_stmt(private_key, stmt, 2, DC_KEY_PRIVATE);
is_default = sqlite3_column_int( stmt, 3 );
export_key_to_asc_file(context, dir, id, public_key, is_default);
export_key_to_asc_file(context, dir, id, private_key, is_default);
@ -795,18 +795,18 @@ static int import_self_keys(dc_context_t* context, const char* dir_name)
while( (dir_entry=readdir(dir_handle))!=NULL )
{
free(suffix);
suffix = mr_get_filesuffix_lc(dir_entry->d_name);
suffix = dc_get_filesuffix_lc(dir_entry->d_name);
if( suffix==NULL || strcmp(suffix, "asc")!=0 ) {
continue;
}
free(path_plus_name);
path_plus_name = mr_mprintf("%s/%s", dir_name, dir_entry->d_name/* name without path; may also be `.` or `..` */);
path_plus_name = dc_mprintf("%s/%s", dir_name, dir_entry->d_name/* name without path; may also be `.` or `..` */);
dc_log_info(context, 0, "Checking: %s", path_plus_name);
free(buf);
buf = NULL;
if( !mr_read_file(path_plus_name, (void**)&buf, &buf_bytes, context)
if( !dc_read_file(path_plus_name, (void**)&buf, &buf_bytes, context)
|| buf_bytes < 50 ) {
continue;
}
@ -892,7 +892,7 @@ static int export_backup(dc_context_t* context, const char* dir)
char buffer[256];
timeinfo = localtime(&now);
strftime(buffer, 256, DC_BAK_PREFIX "-%Y-%m-%d." DC_BAK_SUFFIX, timeinfo);
if( (dest_pathNfilename=mr_get_fine_pathNfilename(dir, buffer))==NULL ) {
if( (dest_pathNfilename=dc_get_fine_pathNfilename(dir, buffer))==NULL ) {
dc_log_error(context, 0, "Cannot get backup file name.");
goto cleanup;
}
@ -971,9 +971,9 @@ static int export_backup(dc_context_t* context, const char* dir)
//dc_log_info(context, 0, "Backup \"%s\".", name);
free(curr_pathNfilename);
curr_pathNfilename = mr_mprintf("%s/%s", context->m_blobdir, name);
curr_pathNfilename = dc_mprintf("%s/%s", context->m_blobdir, name);
free(buf);
if( !mr_read_file(curr_pathNfilename, &buf, &buf_bytes, context) || buf==NULL || buf_bytes<=0 ) {
if( !dc_read_file(curr_pathNfilename, &buf, &buf_bytes, context) || buf==NULL || buf_bytes<=0 ) {
continue;
}
@ -1100,8 +1100,8 @@ static int import_backup(dc_context_t* context, const char* backup_to_import)
if( file_bytes > 0 && file_content ) {
free(pathNfilename);
pathNfilename = mr_mprintf("%s/%s", context->m_blobdir, file_name);
if( !mr_write_file(pathNfilename, file_content, file_bytes, context) ) {
pathNfilename = dc_mprintf("%s/%s", context->m_blobdir, file_name);
if( !dc_write_file(pathNfilename, file_content, file_bytes, context) ) {
dc_log_error(context, 0, "Storage full? Cannot write file %s with %i bytes.", pathNfilename, file_bytes);
goto cleanup; /* otherwise the user may believe the stuff is imported correctly, but there are files missing ... */
}
@ -1126,10 +1126,10 @@ static int import_backup(dc_context_t* context, const char* backup_to_import)
dc_log_info(context, 0, "Rewriting paths from '%s' to '%s' ...", repl_from, repl_to);
assert( 'f' == MRP_FILE );
assert( 'i' == MRP_PROFILE_IMAGE );
assert( 'f' == DC_PARAM_FILE );
assert( 'i' == DC_PARAM_PROFILE_IMAGE );
char* q3 = sqlite3_mprintf("UPDATE msgs SET param=replace(param, 'f=%q/', 'f=%q/');", repl_from, repl_to); /* cannot use mr_mprintf() because of "%q" */
char* q3 = sqlite3_mprintf("UPDATE msgs SET param=replace(param, 'f=%q/', 'f=%q/');", repl_from, repl_to); /* cannot use dc_mprintf() because of "%q" */
dc_sqlite3_execute__(context->m_sql, q3);
sqlite3_free(q3);
@ -1356,7 +1356,7 @@ char* dc_imex_has_backup(dc_context_t* context, const char* dir_name)
&& name_len > suffix_len && strncmp(&name[name_len-suffix_len-1], "." DC_BAK_SUFFIX, suffix_len)==0 )
{
free(curr_pathNfilename);
curr_pathNfilename = mr_mprintf("%s/%s", dir_name, name);
curr_pathNfilename = dc_mprintf("%s/%s", dir_name, name);
dc_sqlite3_unref(test_sql);
if( (test_sql=dc_sqlite3_new(context/*for logging only*/))!=NULL

40
src/dc_job.c
View file

@ -180,11 +180,11 @@ static void dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(dc_context_t* mailbox, dc_job_t*
sqlite3_bind_int(stmt, 1, msg->m_id);
sqlite3_step(stmt);
char* pathNfilename = mrparam_get(msg->m_param, MRP_FILE, NULL);
char* pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( pathNfilename ) {
if( strncmp(mailbox->m_blobdir, pathNfilename, strlen(mailbox->m_blobdir))==0 )
{
char* strLikeFilename = mr_mprintf("%%f=%s%%", pathNfilename);
char* strLikeFilename = dc_mprintf("%%f=%s%%", pathNfilename);
sqlite3_stmt* stmt2 = dc_sqlite3_prepare_v2_(mailbox->m_sql, "SELECT id FROM msgs WHERE type!=? AND param LIKE ?;"); /* if this gets too slow, an index over "type" should help. */
sqlite3_bind_int (stmt2, 1, MR_MSG_TEXT);
sqlite3_bind_text(stmt2, 2, strLikeFilename, -1, SQLITE_STATIC);
@ -196,18 +196,18 @@ static void dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(dc_context_t* mailbox, dc_job_t*
{
mr_delete_file(pathNfilename, mailbox);
char* increation_file = mr_mprintf("%s.increation", pathNfilename);
char* increation_file = dc_mprintf("%s.increation", pathNfilename);
mr_delete_file(increation_file, mailbox);
free(increation_file);
char* filenameOnly = mr_get_filename(pathNfilename);
if( msg->m_type==MR_MSG_VOICE ) {
char* waveform_file = mr_mprintf("%s/%s.waveform", mailbox->m_blobdir, filenameOnly);
char* waveform_file = dc_mprintf("%s/%s.waveform", mailbox->m_blobdir, filenameOnly);
mr_delete_file(waveform_file, mailbox);
free(waveform_file);
}
else if( msg->m_type==MR_MSG_VIDEO ) {
char* preview_file = mr_mprintf("%s/%s-preview.jpg", mailbox->m_blobdir, filenameOnly);
char* preview_file = dc_mprintf("%s/%s-preview.jpg", mailbox->m_blobdir, filenameOnly);
mr_delete_file(preview_file, mailbox);
free(preview_file);
}
@ -250,7 +250,7 @@ static void dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(dc_context_t* mailbox, dc_job_
}
/* add an additional job for sending the MDN (here in a thread for fast ui resonses) (an extra job as the MDN has a lower priority) */
if( mrparam_get_int(msg->m_param, MRP_WANTS_MDN, 0) /* MRP_WANTS_MDN is set only for one part of a multipart-message */
if( dc_param_get_int(msg->m_param, DC_PARAM_WANTS_MDN, 0) /* DC_PARAM_WANTS_MDN is set only for one part of a multipart-message */
&& dc_sqlite3_get_config_int__(mailbox->m_sql, "mdns_enabled", MR_MDNS_DEFAULT_ENABLED) ) {
in_ms_flags |= MR_MS_SET_MDNSent_FLAG;
}
@ -298,8 +298,8 @@ cleanup:
static void dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(dc_context_t* mailbox, dc_job_t* job)
{
char* server_folder = mrparam_get (job->m_param, MRP_SERVER_FOLDER, NULL);
uint32_t server_uid = mrparam_get_int(job->m_param, MRP_SERVER_UID, 0);
char* server_folder = dc_param_get (job->m_param, DC_PARAM_SERVER_FOLDER, NULL);
uint32_t server_uid = dc_param_get_int(job->m_param, DC_PARAM_SERVER_UID, 0);
char* new_server_folder = NULL;
uint32_t new_server_uid = 0;
int out_ms_flags = 0;
@ -383,7 +383,7 @@ static void dc_job_do_DC_JOB_SEND_MSG_TO_SMTP(dc_context_t* mailbox, dc_job_t* j
}
/* have we guaranteed encryption but cannot fulfill it for any reason? Do not send the message then.*/
if( mrparam_get_int(mimefactory.m_msg->m_param, MRP_GUARANTEE_E2EE, 0) && !mimefactory.m_out_encrypted ) {
if( dc_param_get_int(mimefactory.m_msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0) && !mimefactory.m_out_encrypted ) {
mark_as_error(mailbox, mimefactory.m_msg);
dc_log_error(mailbox, 0, "End-to-end-encryption unavailable unexpectedly.");
goto cleanup; /* unrecoverable */
@ -402,7 +402,7 @@ static void dc_job_do_DC_JOB_SEND_MSG_TO_SMTP(dc_context_t* mailbox, dc_job_t* j
/* debug print? */
if( dc_sqlite3_get_config_int__(mailbox->m_sql, "save_eml", 0) ) {
char* emlname = mr_mprintf("%s/to-smtp-%i.eml", mailbox->m_blobdir, (int)mimefactory.m_msg->m_id);
char* emlname = dc_mprintf("%s/to-smtp-%i.eml", mailbox->m_blobdir, (int)mimefactory.m_msg->m_id);
FILE* emlfileob = fopen(emlname, "w");
if( emlfileob ) {
if( mimefactory.m_out ) {
@ -414,14 +414,14 @@ static void dc_job_do_DC_JOB_SEND_MSG_TO_SMTP(dc_context_t* mailbox, dc_job_t* j
}
dc_update_msg_state__(mailbox, mimefactory.m_msg->m_id, MR_STATE_OUT_DELIVERED);
if( mimefactory.m_out_encrypted && mrparam_get_int(mimefactory.m_msg->m_param, MRP_GUARANTEE_E2EE, 0)==0 ) {
mrparam_set_int(mimefactory.m_msg->m_param, MRP_GUARANTEE_E2EE, 1); /* can upgrade to E2EE - fine! */
if( mimefactory.m_out_encrypted && dc_param_get_int(mimefactory.m_msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0)==0 ) {
dc_param_set_int(mimefactory.m_msg->m_param, DC_PARAM_GUARANTEE_E2EE, 1); /* can upgrade to E2EE - fine! */
dc_msg_save_param_to_disk__(mimefactory.m_msg);
}
if( (mailbox->m_imap->m_server_flags&MR_NO_EXTRA_IMAP_UPLOAD)==0
&& mrparam_get(mimefactory.m_chat->m_param, MRP_SELFTALK, 0)==0
&& mrparam_get_int(mimefactory.m_msg->m_param, MRP_CMD, 0)!=MR_CMD_SECUREJOIN_MESSAGE ) {
&& 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_job_add(mailbox, DC_JOB_SEND_MSG_TO_IMAP, mimefactory.m_msg->m_id, NULL, 0); /* send message to IMAP in another job */
}
@ -467,7 +467,7 @@ static void dc_job_do_DC_JOB_SEND_MDN(dc_context_t* mailbox, dc_job_t* job)
goto cleanup;
}
//char* t1=mr_null_terminate(mimefactory.m_out->str,mimefactory.m_out->len);printf("~~~~~MDN~~~~~\n%s\n~~~~~/MDN~~~~~",t1);free(t1); // DEBUG OUTPUT
//char* t1=dc_null_terminate(mimefactory.m_out->str,mimefactory.m_out->len);printf("~~~~~MDN~~~~~\n%s\n~~~~~/MDN~~~~~",t1);free(t1); // DEBUG OUTPUT
if( !dc_smtp_send_msg(mailbox->m_smtp, mimefactory.m_recipients_addr, mimefactory.m_out->str, mimefactory.m_out->len) ) {
dc_smtp_disconnect(mailbox->m_smtp);
@ -578,7 +578,7 @@ static void dc_job_perform(dc_context_t* mailbox, int thread)
#define THREAD_STR (thread==DC_IMAP_THREAD? "IMAP" : "SMTP")
memset(&job, 0, sizeof(dc_job_t));
job.m_param = mrparam_new();
job.m_param = dc_param_new();
if( mailbox == NULL || mailbox->m_magic != DC_CONTEXT_MAGIC ) {
goto cleanup;
@ -593,7 +593,7 @@ static void dc_job_perform(dc_context_t* mailbox, int thread)
job.m_job_id = sqlite3_column_int (select_stmt, 0);
job.m_action = sqlite3_column_int (select_stmt, 1);
job.m_foreign_id = sqlite3_column_int (select_stmt, 2);
mrparam_set_packed(job.m_param, (char*)sqlite3_column_text(select_stmt, 3));
dc_param_set_packed(job.m_param, (char*)sqlite3_column_text(select_stmt, 3));
dc_log_info(mailbox, 0, "%s-job #%i, action %i started...", THREAD_STR, (int)job.m_job_id, (int)job.m_action);
@ -624,8 +624,8 @@ static void dc_job_perform(dc_context_t* mailbox, int thread)
}
else if( job.m_try_again == DC_AT_ONCE || job.m_try_again == DC_STANDARD_DELAY )
{
int tries = mrparam_get_int(job.m_param, MRP_TIMES, 0) + 1;
mrparam_set_int(job.m_param, MRP_TIMES, tries);
int tries = dc_param_get_int(job.m_param, DC_PARAM_TIMES, 0) + 1;
dc_param_set_int(job.m_param, DC_PARAM_TIMES, tries);
sqlite3_stmt* update_stmt = dc_sqlite3_prepare_v2_(mailbox->m_sql,
"UPDATE jobs SET desired_timestamp=0, param=? WHERE id=?;");
@ -657,7 +657,7 @@ static void dc_job_perform(dc_context_t* mailbox, int thread)
}
cleanup:
mrparam_unref(job.m_param);
dc_param_unref(job.m_param);
sqlite3_finalize(select_stmt);
}

2
src/dc_job.h
View file

@ -67,7 +67,7 @@ typedef struct dc_job_t
uint32_t m_job_id;
int m_action;
uint32_t m_foreign_id;
mrparam_t* m_param;
dc_param_t* m_param;
int m_try_again;
} dc_job_t;

46
src/dc_key.c
View file

@ -50,14 +50,14 @@ static void dc_key_empty(dc_key_t* ths) /* only use before calling setters; take
return;
}
if( ths->m_type==MR_PRIVATE ) {
if( ths->m_type==DC_KEY_PRIVATE ) {
mr_wipe_secret_mem(ths->m_binary, ths->m_bytes);
}
free(ths->m_binary);
ths->m_binary = NULL;
ths->m_bytes = 0;
ths->m_type = MR_PUBLIC;
ths->m_type = DC_KEY_PUBLIC;
}
@ -172,7 +172,7 @@ int dc_key_set_from_file(dc_key_t* ths, const char* pathNfilename, dc_context_t*
goto cleanup;
}
if( !mr_read_file(pathNfilename, (void**)&buf, &buf_bytes, mailbox)
if( !dc_read_file(pathNfilename, (void**)&buf, &buf_bytes, mailbox)
|| buf_bytes < 50 ) {
goto cleanup; /* error is already loged */
}
@ -183,10 +183,10 @@ int dc_key_set_from_file(dc_key_t* ths, const char* pathNfilename, dc_context_t*
}
if( strcmp(headerline, "-----BEGIN PGP PUBLIC KEY BLOCK-----")==0 ) {
type = MR_PUBLIC;
type = DC_KEY_PUBLIC;
}
else if( strcmp(headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----")==0 ) {
type = MR_PRIVATE;
type = DC_KEY_PRIVATE;
}
else {
dc_log_warning(mailbox, 0, "Header missing for key \"%s\".", pathNfilename);
@ -269,7 +269,7 @@ int dc_key_load_self_public__(dc_key_t* ths, const char* self_addr, dc_sqlite3_t
if( sqlite3_step(stmt) != SQLITE_ROW ) {
return 0;
}
dc_key_set_from_stmt(ths, stmt, 0, MR_PUBLIC);
dc_key_set_from_stmt(ths, stmt, 0, DC_KEY_PUBLIC);
return 1;
}
@ -289,7 +289,7 @@ int dc_key_load_self_private__(dc_key_t* ths, const char* self_addr, dc_sqlite3_
if( sqlite3_step(stmt) != SQLITE_ROW ) {
return 0;
}
dc_key_set_from_stmt(ths, stmt, 0, MR_PRIVATE);
dc_key_set_from_stmt(ths, stmt, 0, DC_KEY_PRIVATE);
return 1;
}
@ -339,7 +339,7 @@ char* mr_render_base64(const void* buf, size_t buf_bytes, int break_every, const
c[2] = (uint8_t)((checksum)&0xFF);
char* c64 = encode_base64((const char*)c, 3);
char* temp = ret;
ret = mr_mprintf("%s=%s", temp, c64);
ret = dc_mprintf("%s=%s", temp, c64);
free(temp);
free(c64);
}
@ -347,7 +347,7 @@ char* mr_render_base64(const void* buf, size_t buf_bytes, int break_every, const
if( break_every>0 ) {
char* temp = ret;
ret = mr_insert_breaks(temp, break_every, break_chars);
ret = dc_insert_breaks(temp, break_every, break_chars);
free(temp);
}
@ -359,7 +359,7 @@ char* mr_render_base64(const void* buf, size_t buf_bytes, int break_every, const
c[2] = (uint8_t)((checksum)&0xFF);
char* c64 = encode_base64((const char*)c, 3);
char* temp = ret;
ret = mr_mprintf("%s%s=%s", temp, break_chars, c64);
ret = dc_mprintf("%s%s=%s", temp, break_chars, c64);
free(temp);
free(c64);
}
@ -391,11 +391,11 @@ char* dc_key_render_asc(const dc_key_t* ths, const char* add_header_lines /*must
goto cleanup;
}
ret = mr_mprintf("-----BEGIN PGP %s KEY BLOCK-----\r\n%s\r\n%s\r\n-----END PGP %s KEY BLOCK-----\r\n",
ths->m_type==MR_PUBLIC? "PUBLIC" : "PRIVATE",
ret = dc_mprintf("-----BEGIN PGP %s KEY BLOCK-----\r\n%s\r\n%s\r\n-----END PGP %s KEY BLOCK-----\r\n",
ths->m_type==DC_KEY_PUBLIC? "PUBLIC" : "PRIVATE",
add_header_lines? add_header_lines : "",
base64,
ths->m_type==MR_PUBLIC? "PUBLIC" : "PRIVATE");
ths->m_type==DC_KEY_PUBLIC? "PUBLIC" : "PRIVATE");
cleanup:
free(base64);
@ -417,7 +417,7 @@ int dc_key_render_asc_to_file(const dc_key_t* key, const char* file, dc_context_
goto cleanup;
}
if( !mr_write_file(file, file_content, strlen(file_content), mailbox) ) {
if( !dc_write_file(file, file_content, strlen(file_content), mailbox) ) {
dc_log_error(mailbox, 0, "Cannot write key to %s", file);
goto cleanup;
}
@ -432,18 +432,18 @@ cleanup:
char* mr_format_fingerprint(const char* fingerprint)
{
int i = 0, fingerprint_len = strlen(fingerprint);
mrstrbuilder_t ret;
mrstrbuilder_init(&ret, 0);
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, 0);
while( fingerprint[i] ) {
mrstrbuilder_catf(&ret, "%c", fingerprint[i]);
dc_strbuilder_catf(&ret, "%c", fingerprint[i]);
i++;
if( i != fingerprint_len ) {
if( i%20 == 0 ) {
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "\n");
}
else if( i%4 == 0 ) {
mrstrbuilder_cat(&ret, " ");
dc_strbuilder_cat(&ret, " ");
}
}
}
@ -454,19 +454,19 @@ char* mr_format_fingerprint(const char* fingerprint)
/* bring a human-readable or otherwise formatted fingerprint back to the
40-characters-uppercase-hex format */
char* mr_normalize_fingerprint(const char* in)
char* dc_normalize_fingerprint(const char* in)
{
if( in == NULL ) {
return NULL;
}
mrstrbuilder_t out;
mrstrbuilder_init(&out, 0);
dc_strbuilder_t out;
dc_strbuilder_init(&out, 0);
const char* p1 = in;
while( *p1 ) {
if( (*p1 >= '0' && *p1 <= '9') || (*p1 >= 'A' && *p1 <= 'F') || (*p1 >= 'a' && *p1 <= 'f') ) {
mrstrbuilder_catf(&out, "%c", toupper(*p1)); /* make uppercase which is needed as we do not search case-insensitive, see comment in mrsqlite3.c */
dc_strbuilder_catf(&out, "%c", toupper(*p1)); /* make uppercase which is needed as we do not search case-insensitive, see comment in mrsqlite3.c */
}
p1++;
}

6
src/dc_key.h
View file

@ -30,8 +30,8 @@ extern "C" {
typedef struct sqlite3_stmt sqlite3_stmt;
#define MR_PUBLIC 0
#define MR_PRIVATE 1
#define DC_KEY_PUBLIC 0
#define DC_KEY_PRIVATE 1
/**
@ -70,7 +70,7 @@ char* dc_key_render_asc (const dc_key_t*, const char* add_header_lines); /* ea
int dc_key_render_asc_to_file(const dc_key_t*, const char* file, dc_context_t* mailbox);
char* mr_format_fingerprint (const char*);
char* mr_normalize_fingerprint (const char*);
char* dc_normalize_fingerprint (const char*);
char* dc_key_get_fingerprint (const dc_key_t*);
char* dc_key_get_formatted_fingerprint(const dc_key_t*);

2
src/dc_keyring.c
View file

@ -92,7 +92,7 @@ int dc_keyring_load_self_private_for_decrypting__(dc_keyring_t* ths, const char*
sqlite3_bind_text (stmt, 1, self_addr, -1, SQLITE_STATIC);
while( sqlite3_step(stmt) == SQLITE_ROW ) {
key = dc_key_new();
if( dc_key_set_from_stmt(key, stmt, 0, MR_PRIVATE) ) {
if( dc_key_set_from_stmt(key, stmt, 0, DC_KEY_PRIVATE) ) {
dc_keyring_add(ths, key);
}
dc_key_unref(key); /* unref in any case, dc_keyring_add() adds its own reference */

6
src/dc_log.c
View file

@ -66,9 +66,9 @@ static void log_vprintf(dc_context_t* mailbox, 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 = mr_mprintf("Info: %i", (int)code); }
else if( event == DC_EVENT_WARNING ) { msg = mr_mprintf("Warning: %i", (int)code); }
else { msg = mr_mprintf("Error: %i", (int)code); }
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); }
}
/* finally, log */

12
src/dc_loginparam.c
View file

@ -120,9 +120,9 @@ void dc_loginparam_write__(const dc_loginparam_t* ths, dc_sqlite3_t* sql, const
static char* get_readable_flags(int flags)
{
mrstrbuilder_t strbuilder;
mrstrbuilder_init(&strbuilder, 0);
#define CAT_FLAG(f, s) if( (1<<bit)==(f) ) { mrstrbuilder_cat(&strbuilder, (s)); flag_added = 1; }
dc_strbuilder_t strbuilder;
dc_strbuilder_init(&strbuilder, 0);
#define CAT_FLAG(f, s) if( (1<<bit)==(f) ) { dc_strbuilder_cat(&strbuilder, (s)); flag_added = 1; }
for( int bit = 0; bit <= 30; bit++ )
{
@ -145,12 +145,12 @@ static char* get_readable_flags(int flags)
CAT_FLAG(MR_NO_MOVE_TO_CHATS, "NO_MOVE_TO_CHATS ");
if( !flag_added ) {
char* temp = mr_mprintf("0x%x ", 1<<bit); mrstrbuilder_cat(&strbuilder, temp); free(temp);
char* temp = dc_mprintf("0x%x ", 1<<bit); dc_strbuilder_cat(&strbuilder, temp); free(temp);
}
}
}
if( strbuilder.m_buf[0]==0 ) { mrstrbuilder_cat(&strbuilder, "0"); }
if( strbuilder.m_buf[0]==0 ) { dc_strbuilder_cat(&strbuilder, "0"); }
mr_trim(strbuilder.m_buf);
return strbuilder.m_buf;
}
@ -167,7 +167,7 @@ char* dc_loginparam_get_readable(const dc_loginparam_t* ths)
char* flags_readable = get_readable_flags(ths->m_server_flags);
char* ret = mr_mprintf("%s %s:%s:%s:%i %s:%s:%s:%i %s",
char* ret = dc_mprintf("%s %s:%s:%s:%i %s:%s:%s:%i %s",
ths->m_addr? ths->m_addr : unset,
ths->m_mail_user? ths->m_mail_user : unset,

94
src/dc_mimefactory.c
View file

@ -139,7 +139,7 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
"SELECT c.authname, c.addr "
" FROM chats_contacts cc "
" LEFT JOIN contacts c ON cc.contact_id=c.id "
" WHERE cc.chat_id=? AND cc.contact_id>" MR_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) ";");
" WHERE cc.chat_id=? AND cc.contact_id>" DC_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL) ";");
sqlite3_bind_int(stmt, 1, factory->m_msg->m_chat_id);
while( sqlite3_step(stmt) == SQLITE_ROW )
{
@ -152,9 +152,9 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
}
}
int command = mrparam_get_int(factory->m_msg->m_param, MRP_CMD, 0);
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 */) {
char* email_to_remove = mrparam_get(factory->m_msg->m_param, MRP_CMD_PARAM, NULL);
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 )
{
@ -212,12 +212,12 @@ int dc_mimefactory_load_msg(dc_mimefactory_t* factory, uint32_t msg_id)
#define NEW_THREAD_THRESHOLD 24*60*60
if( prev_msg_time != 0 && factory->m_msg->m_timestamp - prev_msg_time < NEW_THREAD_THRESHOLD ) {
factory->m_references = mrparam_get(factory->m_chat->m_param, MRP_REFERENCES, NULL);
factory->m_references = dc_param_get(factory->m_chat->m_param, DC_PARAM_REFERENCES, NULL);
}
if( factory->m_references == NULL ) {
factory->m_references = mr_create_dummy_references_mid();
mrparam_set(factory->m_chat->m_param, MRP_REFERENCES, factory->m_references);
dc_param_set(factory->m_chat->m_param, DC_PARAM_REFERENCES, factory->m_references);
dc_chat_update_param__(factory->m_chat);
}
@ -325,9 +325,9 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
struct mailmime* mime_sub = NULL;
struct mailmime_content* content;
char* pathNfilename = mrparam_get(msg->m_param, MRP_FILE, NULL);
char* mimetype = mrparam_get(msg->m_param, MRP_MIMETYPE, NULL);
char* suffix = mr_get_filesuffix_lc(pathNfilename);
char* pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
char* mimetype = dc_param_get(msg->m_param, DC_PARAM_MIMETYPE, NULL);
char* suffix = dc_get_filesuffix_lc(pathNfilename);
char* filename_to_send = NULL;
char* filename_encoded = NULL;
@ -339,16 +339,16 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
if( msg->m_type == MR_MSG_VOICE ) {
struct tm wanted_struct;
memcpy(&wanted_struct, localtime(&msg->m_timestamp), sizeof(struct tm));
filename_to_send = mr_mprintf("voice-message_%04i-%02i-%02i_%02i-%02i-%02i.%s",
filename_to_send = dc_mprintf("voice-message_%04i-%02i-%02i_%02i-%02i-%02i.%s",
(int)wanted_struct.tm_year+1900, (int)wanted_struct.tm_mon+1, (int)wanted_struct.tm_mday,
(int)wanted_struct.tm_hour, (int)wanted_struct.tm_min, (int)wanted_struct.tm_sec,
suffix? suffix : "dat");
}
else if( msg->m_type == MR_MSG_AUDIO ) {
char* author = mrparam_get(msg->m_param, MRP_AUTHORNAME, NULL);
char* title = mrparam_get(msg->m_param, MRP_TRACKNAME, NULL);
char* author = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, NULL);
char* title = dc_param_get(msg->m_param, DC_PARAM_TRACKNAME, NULL);
if( author && author[0] && title && title[0] && suffix ) {
filename_to_send = mr_mprintf("%s - %s.%s", author, title, suffix); /* the separator ` - ` is used on the receiver's side to construct the information; we avoid using ID3-scanners for security purposes */
filename_to_send = dc_mprintf("%s - %s.%s", author, title, suffix); /* the separator ` - ` is used on the receiver's side to construct the information; we avoid using ID3-scanners for security purposes */
}
else {
filename_to_send = mr_get_filename(pathNfilename);
@ -360,10 +360,10 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
if( base_name == NULL ) {
base_name = "image";
}
filename_to_send = mr_mprintf("%s.%s", base_name, suffix? suffix : "dat");
filename_to_send = dc_mprintf("%s.%s", base_name, suffix? suffix : "dat");
}
else if( msg->m_type == MR_MSG_VIDEO ) {
filename_to_send = mr_mprintf("video.%s", suffix? suffix : "dat");
filename_to_send = dc_mprintf("video.%s", suffix? suffix : "dat");
}
else {
filename_to_send = mr_get_filename(pathNfilename);
@ -392,7 +392,7 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
/* create mime part, for Content-Disposition, see RFC 2183.
`Content-Disposition: attachment` seems not to make a difference to `Content-Disposition: inline` at least on tested Thunderbird and Gma'l in 2017.
But I've heard about problems with inline and outl'k, so we just use the attachment-type until we run into other problems ... */
int needs_ext = mr_needs_ext_header(filename_to_send);
int needs_ext = dc_needs_ext_header(filename_to_send);
mime_fields = mailmime_fields_new_filename(MAILMIME_DISPOSITION_TYPE_ATTACHMENT,
needs_ext? NULL : safe_strdup(filename_to_send), MAILMIME_MECHANISM_BASE64);
@ -407,7 +407,7 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
{
struct mailmime_disposition_parm* parm = mailmime_disposition_parm_new(
MAILMIME_DISPOSITION_PARM_PARAMETER, NULL, NULL, NULL, NULL, 0,
mailmime_parameter_new(strdup("filename*"), mr_encode_ext_header(filename_to_send)));
mailmime_parameter_new(strdup("filename*"), dc_encode_ext_header(filename_to_send)));
if( parm ) {
clist_append(file_disposition->dsp_parms, parm);
}
@ -420,7 +420,7 @@ static struct mailmime* build_body_file(const dc_msg_t* msg, const char* base_na
content = mailmime_content_new_with_str(mimetype);
clist_append(content->ct_parameters, mailmime_param_new_with_data("name",
(filename_encoded=mr_encode_header_words(filename_to_send))));
(filename_encoded=dc_encode_header_words(filename_to_send))));
mime_sub = mailmime_new_empty(content, mime_fields);
@ -445,17 +445,17 @@ 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( mrparam_get_int(msg->m_param, MRP_CMD, 0) == MR_CMD_AUTOCRYPT_SETUP_MESSAGE )
if( dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0) == MR_CMD_AUTOCRYPT_SETUP_MESSAGE )
{
ret = mrstock_str(MR_STR_AC_SETUP_MSG_SUBJECT); /* do not add the "Chat:" prefix for setup messages */
}
else if( MR_CHAT_TYPE_IS_MULTI(chat->m_type) )
{
ret = mr_mprintf(MR_CHAT_PREFIX " %s: %s%s", chat->m_name, fwd, raw_subject);
ret = dc_mprintf(MR_CHAT_PREFIX " %s: %s%s", chat->m_name, fwd, raw_subject);
}
else
{
ret = mr_mprintf(MR_CHAT_PREFIX " %s%s", fwd, raw_subject);
ret = dc_mprintf(MR_CHAT_PREFIX " %s%s", fwd, raw_subject);
}
free(raw_subject);
@ -492,7 +492,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
{
struct mailimf_mailbox_list* from = mailimf_mailbox_list_new_empty();
mailimf_mailbox_list_add(from, mailimf_mailbox_new(factory->m_from_displayname? mr_encode_header_words(factory->m_from_displayname) : NULL, safe_strdup(factory->m_from_addr)));
mailimf_mailbox_list_add(from, mailimf_mailbox_new(factory->m_from_displayname? dc_encode_header_words(factory->m_from_displayname) : NULL, safe_strdup(factory->m_from_addr)));
struct mailimf_address_list* to = NULL;
if( factory->m_recipients_names && factory->m_recipients_addr && clist_count(factory->m_recipients_addr)>0 ) {
@ -501,7 +501,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
for( iter1=clist_begin(factory->m_recipients_names),iter2=clist_begin(factory->m_recipients_addr); iter1!=NULL&&iter2!=NULL; iter1=clist_next(iter1),iter2=clist_next(iter2)) {
const char* name = clist_content(iter1);
const char* addr = clist_content(iter2);
mailimf_address_list_add(to, mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mailimf_mailbox_new(name? mr_encode_header_words(name) : NULL, safe_strdup(addr)), NULL));
mailimf_address_list_add(to, mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mailimf_mailbox_new(name? dc_encode_header_words(name) : NULL, safe_strdup(addr)), NULL));
}
}
@ -520,7 +520,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
/* Add a X-Mailer header. This is only informational for debugging and may be removed in the release.
We do not rely on this header as it may be removed by MTAs. */
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("X-Mailer"),
mr_mprintf("Delta Chat %s%s%s",
dc_mprintf("Delta Chat %s%s%s",
DC_VERSION_STR,
factory->m_context->m_os_name? " for " : "",
factory->m_context->m_os_name? factory->m_context->m_os_name : "")));
@ -557,35 +557,35 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
min_verified = MRV_BIDIRECTIONAL;
}
else {
if( (force_plaintext = mrparam_get_int(factory->m_msg->m_param, MRP_FORCE_PLAINTEXT, 0)) == 0 ) {
e2ee_guaranteed = mrparam_get_int(factory->m_msg->m_param, MRP_GUARANTEE_E2EE, 0);
if( (force_plaintext = dc_param_get_int(factory->m_msg->m_param, DC_PARAM_FORCE_PLAINTEXT, 0)) == 0 ) {
e2ee_guaranteed = dc_param_get_int(factory->m_msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0);
}
}
/* build header etc. */
int command = mrparam_get_int(msg->m_param, MRP_CMD, 0);
int command = dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0);
if( MR_CHAT_TYPE_IS_MULTI(chat->m_type) )
{
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-ID"), safe_strdup(chat->m_grpid)));
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Name"), mr_encode_header_words(chat->m_name)));
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 )
{
char* email_to_remove = mrparam_get(msg->m_param, MRP_CMD_PARAM, NULL);
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 )
{
char* email_to_add = mrparam_get(msg->m_param, MRP_CMD_PARAM, NULL);
char* email_to_add = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( email_to_add ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Member-Added"), email_to_add));
grpimage = mrparam_get(chat->m_param, MRP_PROFILE_IMAGE, NULL);
grpimage = dc_param_get(chat->m_param, DC_PARAM_PROFILE_IMAGE, NULL);
}
if( mrparam_get_int(msg->m_param, MRP_CMD_PARAM2, 0)&MR_FROM_HANDSHAKE ) {
if( dc_param_get_int(msg->m_param, DC_PARAM_CMD_ARG2, 0)&MR_FROM_HANDSHAKE ) {
dc_log_info(msg->m_context, 0, "sending secure-join message '%s' >>>>>>>>>>>>>>>>>>>>>>>>>", "vg-member-added");
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Secure-Join"), strdup("vg-member-added")));
}
@ -596,7 +596,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
}
else if( command == MR_CMD_GROUPIMAGE_CHANGED )
{
grpimage = mrparam_get(msg->m_param, MRP_CMD_PARAM, NULL);
grpimage = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG, NULL);
if( grpimage==NULL ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Image"), safe_strdup("0")));
}
@ -609,12 +609,12 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
}
if( command == MR_CMD_SECUREJOIN_MESSAGE ) {
char* step = mrparam_get(msg->m_param, MRP_CMD_PARAM, NULL);
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);
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Secure-Join"), step/*mailimf takes ownership of string*/));
char* param2 = mrparam_get(msg->m_param, MRP_CMD_PARAM2, NULL);
char* param2 = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG2, NULL);
if( param2 ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(
(strcmp(step, "vg-request-with-auth")==0 || strcmp(step, "vc-request-with-auth")==0)?
@ -622,14 +622,14 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
param2/*mailimf takes ownership of string*/));
}
char* fingerprint = mrparam_get(msg->m_param, MRP_CMD_PARAM3, NULL);
char* fingerprint = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG3, NULL);
if( fingerprint ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(
strdup("Secure-Join-Fingerprint"),
fingerprint/*mailimf takes ownership of string*/));
}
char* grpid = mrparam_get(msg->m_param, MRP_CMD_PARAM4, NULL);
char* grpid = dc_param_get(msg->m_param, DC_PARAM_CMD_ARG4, NULL);
if( grpid ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(
strdup("Secure-Join-Group"),
@ -642,7 +642,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
{
dc_msg_t* meta = dc_msg_new();
meta->m_type = MR_MSG_IMAGE;
mrparam_set(meta->m_param, MRP_FILE, grpimage);
dc_param_set(meta->m_param, DC_PARAM_FILE, grpimage);
char* filename_as_sent = NULL;
if( (meta_part=build_body_file(meta, "group-image", &filename_as_sent))!=NULL ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Group-Image"), filename_as_sent/*takes ownership*/));
@ -656,9 +656,9 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Voice-Message"), strdup("1")));
}
int duration_ms = mrparam_get_int(msg->m_param, MRP_DURATION, 0);
int duration_ms = dc_param_get_int(msg->m_param, DC_PARAM_DURATION, 0);
if( duration_ms > 0 ) {
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Duration"), mr_mprintf("%i", (int)duration_ms)));
mailimf_fields_add(imf_fields, mailimf_field_new_custom(strdup("Chat-Duration"), dc_mprintf("%i", (int)duration_ms)));
}
}
@ -666,7 +666,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
- some Apps have problems with Non-text in the main part (eg. "Mail" from stock Android)
- we can add "forward hints" this way
- it looks better */
afwd_email = mrparam_exists(msg->m_param, MRP_FORWARDED);
afwd_email = dc_param_exists(msg->m_param, DC_PARAM_FORWARDED);
char* fwdhint = NULL;
if( afwd_email ) {
fwdhint = safe_strdup("---------- Forwarded message ----------" LINEEND "From: Delta Chat" LINEEND LINEEND); /* do not chage this! expected this way in the simplifier to detect forwarding! */
@ -681,7 +681,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
}
char* footer = factory->m_selfstatus;
message_text = mr_mprintf("%s%s%s%s%s",
message_text = dc_mprintf("%s%s%s%s%s",
fwdhint? fwdhint : "",
final_text? final_text : "",
(final_text&&footer&&footer[0])? (LINEEND LINEEND) : "",
@ -724,14 +724,14 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
/* first body part: always human-readable, always REQUIRED by RFC 6522 */
char *p1 = NULL, *p2 = NULL;
if( mrparam_get_int(factory->m_msg->m_param, MRP_GUARANTEE_E2EE, 0) ) {
if( dc_param_get_int(factory->m_msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0) ) {
p1 = mrstock_str(MR_STR_ENCRYPTEDMSG); /* we SHOULD NOT spread encrypted subjects, date etc. in potentially unencrypted MDNs */
}
else {
p1 = dc_msg_get_summarytext(factory->m_msg, APPROX_SUBJECT_CHARS);
}
p2 = mrstock_str_repl_string(MR_STR_READRCPT_MAILBODY, p1);
message_text = mr_mprintf("%s" LINEEND, p2);
message_text = dc_mprintf("%s" LINEEND, p2);
free(p2);
free(p1);
@ -740,7 +740,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
/* second body part: machine-readable, always REQUIRED by RFC 6522 */
message_text2 = mr_mprintf(
message_text2 = dc_mprintf(
"Reporting-UA: Delta Chat %s" LINEEND
"Original-Recipient: rfc822;%s" LINEEND
"Final-Recipient: rfc822;%s" LINEEND
@ -778,13 +778,13 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
*************************************************************************/
if( factory->m_loaded==MR_MF_MDN_LOADED ) {
char* e = mrstock_str(MR_STR_READRCPT); subject_str = mr_mprintf(MR_CHAT_PREFIX " %s", e); free(e);
char* e = mrstock_str(MR_STR_READRCPT); subject_str = dc_mprintf(MR_CHAT_PREFIX " %s", e); free(e);
}
else {
subject_str = get_subject(factory->m_chat, factory->m_msg, afwd_email);
}
struct mailimf_subject* subject = mailimf_subject_new(mr_encode_header_words(subject_str));
struct mailimf_subject* subject = mailimf_subject_new(dc_encode_header_words(subject_str));
mailimf_fields_add(imf_fields, mailimf_field_new(MAILIMF_FIELD_SUBJECT, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, subject, NULL, NULL, NULL));
if( force_plaintext != MRFP_NO_AUTOCRYPT_HEADER ) {
@ -799,7 +799,7 @@ int dc_mimefactory_render(dc_mimefactory_t* factory)
factory->m_out = mmap_string_new("");
mailmime_write_mem(factory->m_out, &col, message);
//{char* t4=mr_null_terminate(ret->str,ret->len); printf("MESSAGE:\n%s\n",t4);free(t4);}
//{char* t4=dc_null_terminate(ret->str,ret->len); printf("MESSAGE:\n%s\n",t4);free(t4);}
success = 1;

60
src/dc_mimeparser.c
View file

@ -793,7 +793,7 @@ static dc_mimepart_t* mrmimepart_new(void)
}
ths->m_type = MR_MSG_UNDEFINED;
ths->m_param = mrparam_new();
ths->m_param = dc_param_new();
return ths;
}
@ -815,7 +815,7 @@ static void mrmimepart_unref(dc_mimepart_t* ths)
ths->m_msg_raw = NULL;
}
mrparam_unref(ths->m_param);
dc_param_unref(ths->m_param);
free(ths);
}
@ -946,10 +946,10 @@ static void do_add_single_part(dc_mimeparser_t* parser, dc_mimepart_t* part)
{
/* add a single part to the list of parts, the parser takes the ownership of the part, so you MUST NOT unref it after calling this function. */
if( parser->m_e2ee_helper->m_encrypted && dc_hash_count(parser->m_e2ee_helper->m_signatures)>0 ) {
mrparam_set_int(part->m_param, MRP_GUARANTEE_E2EE, 1);
dc_param_set_int(part->m_param, DC_PARAM_GUARANTEE_E2EE, 1);
}
else if( parser->m_e2ee_helper->m_encrypted ) {
mrparam_set_int(part->m_param, MRP_ERRONEOUS_E2EE, MRE2EE_NO_VALID_SIGNATURE);
dc_param_set_int(part->m_param, DC_PARAM_ERRONEOUS_E2EE, MRE2EE_NO_VALID_SIGNATURE);
}
carray_add(parser->m_parts, (void*)part, NULL);
}
@ -963,12 +963,12 @@ static void do_add_single_file_part(dc_mimeparser_t* parser, int msg_type, int m
char* pathNfilename = NULL;
/* create a free file name to use */
if( (pathNfilename=mr_get_fine_pathNfilename(parser->m_blobdir, desired_filename)) == NULL ) {
if( (pathNfilename=dc_get_fine_pathNfilename(parser->m_blobdir, desired_filename)) == NULL ) {
goto cleanup;
}
/* copy data to file */
if( mr_write_file(pathNfilename, decoded_data, decoded_data_bytes, parser->m_context)==0 ) {
if( dc_write_file(pathNfilename, decoded_data, decoded_data_bytes, parser->m_context)==0 ) {
goto cleanup;
}
@ -976,28 +976,28 @@ static void do_add_single_file_part(dc_mimeparser_t* parser, int msg_type, int m
part->m_type = msg_type;
part->m_int_mimetype = mime_type;
part->m_bytes = decoded_data_bytes;
mrparam_set(part->m_param, MRP_FILE, pathNfilename);
dc_param_set(part->m_param, DC_PARAM_FILE, pathNfilename);
if( MR_MSG_MAKE_FILENAME_SEARCHABLE(msg_type) ) {
part->m_msg = mr_get_filename(pathNfilename);
}
else if( MR_MSG_MAKE_SUFFIX_SEARCHABLE(msg_type) ) {
part->m_msg = mr_get_filesuffix_lc(pathNfilename);
part->m_msg = dc_get_filesuffix_lc(pathNfilename);
}
if( mime_type == MR_MIMETYPE_IMAGE ) {
uint32_t w = 0, h = 0;
if( mr_get_filemeta(decoded_data, decoded_data_bytes, &w, &h) ) {
mrparam_set_int(part->m_param, MRP_WIDTH, w);
mrparam_set_int(part->m_param, MRP_HEIGHT, h);
if( dc_get_filemeta(decoded_data, decoded_data_bytes, &w, &h) ) {
dc_param_set_int(part->m_param, DC_PARAM_WIDTH, w);
dc_param_set_int(part->m_param, DC_PARAM_HEIGHT, h);
}
}
/* split author/title from the original filename (if we do it from the real filename, we'll also get numbers appended by mr_get_fine_pathNfilename()) */
/* split author/title from the original filename (if we do it from the real filename, we'll also get numbers appended by dc_get_fine_pathNfilename()) */
if( msg_type == MR_MSG_AUDIO ) {
char* author = NULL, *title = NULL;
dc_msg_get_authorNtitle_from_filename(desired_filename, &author, &title);
mrparam_set(part->m_param, MRP_AUTHORNAME, author);
mrparam_set(part->m_param, MRP_TRACKNAME, title);
dc_param_set(part->m_param, DC_PARAM_AUTHORNAME, author);
dc_param_set(part->m_param, DC_PARAM_TRACKNAME, title);
free(author);
free(title);
}
@ -1138,8 +1138,8 @@ static int dc_mimeparser_add_single_part_if_known(dc_mimeparser_t* ths, struct m
`Content-Disposition: ... filename*=...`
or `Content-Disposition: ... filename*0*=... filename*1*=... filename*2*=...`
or `Content-Disposition: ... filename=...` */
mrstrbuilder_t filename_parts;
mrstrbuilder_init(&filename_parts, 0);
dc_strbuilder_t filename_parts;
dc_strbuilder_init(&filename_parts, 0);
for( clistiter* cur1 = clist_begin(mime->mm_mime_fields->fld_list); cur1 != NULL; cur1 = clist_next(cur1) )
{
struct mailmime_field* field = (struct mailmime_field*)clist_content(cur1);
@ -1158,11 +1158,11 @@ static int dc_mimeparser_add_single_part_if_known(dc_mimeparser_t* ths, struct m
&& dsp_param->pa_data.pa_parameter->pa_name
&& strncmp(dsp_param->pa_data.pa_parameter->pa_name, "filename*", 9)==0 )
{
mrstrbuilder_cat(&filename_parts, dsp_param->pa_data.pa_parameter->pa_value); // we assume the filename*?* parts are in order, not seen anything else yet
dc_strbuilder_cat(&filename_parts, dsp_param->pa_data.pa_parameter->pa_value); // we assume the filename*?* parts are in order, not seen anything else yet
}
else if( dsp_param->pa_type==MAILMIME_DISPOSITION_PARM_FILENAME )
{
desired_filename = mr_decode_header_words(dsp_param->pa_data.pa_filename); // this is used only if the parts buffer stays empty
desired_filename = dc_decode_header_words(dsp_param->pa_data.pa_filename); // this is used only if the parts buffer stays empty
}
}
}
@ -1173,7 +1173,7 @@ static int dc_mimeparser_add_single_part_if_known(dc_mimeparser_t* ths, struct m
if( strlen(filename_parts.m_buf) ) {
free(desired_filename);
desired_filename = mr_decode_ext_header(filename_parts.m_buf);
desired_filename = dc_decode_ext_header(filename_parts.m_buf);
}
free(filename_parts.m_buf);
@ -1189,14 +1189,14 @@ static int dc_mimeparser_add_single_part_if_known(dc_mimeparser_t* ths, struct m
/* if there is still no filename, guess one */
if( desired_filename==NULL ) {
if( mime->mm_content_type && mime->mm_content_type->ct_subtype ) {
desired_filename = mr_mprintf("file.%s", mime->mm_content_type->ct_subtype);
desired_filename = dc_mprintf("file.%s", mime->mm_content_type->ct_subtype);
}
else {
goto cleanup;
}
}
mr_replace_bad_utf8_chars(desired_filename);
dc_replace_bad_utf8_chars(desired_filename);
do_add_single_file_part(ths, msg_type, mime_type, decoded_data, decoded_data_bytes, desired_filename);
}
@ -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 = mr_mprintf(MR_EDITORIAL_OPEN "%s" MR_EDITORIAL_CLOSE, msg_body);
part->m_msg = dc_mprintf(MR_EDITORIAL_OPEN "%s" MR_EDITORIAL_CLOSE, msg_body);
free(msg_body);
carray_add(ths->m_parts, (void*)part, NULL);
@ -1514,7 +1514,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
{
struct mailimf_field* field = dc_mimeparser_lookup_field(ths, "Subject");
if( field && field->fld_type == MAILIMF_FIELD_SUBJECT ) {
ths->m_subject = mr_decode_header_words(field->fld_data.fld_subject->sbj_value);
ths->m_subject = dc_decode_header_words(field->fld_data.fld_subject->sbj_value);
}
}
@ -1575,7 +1575,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
dc_mimepart_t* part = (dc_mimepart_t*)carray_get(ths->m_parts, i);
if( part->m_type == MR_MSG_TEXT ) {
#define MR_NDASH "\xE2\x80\x93"
char* new_txt = mr_mprintf("%s " MR_NDASH " %s", subj, part->m_msg);
char* new_txt = dc_mprintf("%s " MR_NDASH " %s", subj, part->m_msg);
free(part->m_msg);
part->m_msg = new_txt;
break;
@ -1591,7 +1591,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
int i, icnt = carray_count(ths->m_parts); /* should be at least one - maybe empty - part */
for( i = 0; i < icnt; i++ ) {
dc_mimepart_t* part = (dc_mimepart_t*)carray_get(ths->m_parts, i);
mrparam_set_int(part->m_param, MRP_FORWARDED, 1);
dc_param_set_int(part->m_param, DC_PARAM_FORWARDED, 1);
}
}
@ -1605,8 +1605,8 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
free(part->m_msg);
part->m_msg = strdup("ogg"); /* MR_MSG_AUDIO adds sets the whole filename which is useless. however, the extension is useful. */
part->m_type = MR_MSG_VOICE;
mrparam_set(part->m_param, MRP_AUTHORNAME, NULL); /* remove unneeded information */
mrparam_set(part->m_param, MRP_TRACKNAME, NULL);
dc_param_set(part->m_param, DC_PARAM_AUTHORNAME, NULL); /* remove unneeded information */
dc_param_set(part->m_param, DC_PARAM_TRACKNAME, NULL);
}
}
@ -1615,7 +1615,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
if( field ) {
int duration_ms = atoi(field->fld_value);
if( duration_ms > 0 && duration_ms < 24*60*60*1000 ) {
mrparam_set_int(part->m_param, MRP_DURATION, duration_ms);
dc_param_set_int(part->m_param, DC_PARAM_DURATION, duration_ms);
}
}
}
@ -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 ) {
mrparam_set_int(textpart->m_param, MRP_CMD, MR_CMD_GROUPIMAGE_CHANGED);
dc_param_set_int(textpart->m_param, DC_PARAM_CMD, MR_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 ) {
@ -1662,7 +1662,7 @@ void dc_mimeparser_parse(dc_mimeparser_t* ths, const char* body_not_terminated,
Moreover the last one is handy as it is the one typically displayed if the message is larger) */
dc_mimepart_t* part = dc_mimeparser_get_last_nonmeta(ths);
if( part ) {
mrparam_set_int(part->m_param, MRP_WANTS_MDN, 1);
dc_param_set_int(part->m_param, DC_PARAM_WANTS_MDN, 1);
}
}
free(from_addr);

2
src/dc_mimeparser.h
View file

@ -48,7 +48,7 @@ typedef struct dc_mimepart_t
char* m_msg;
char* m_msg_raw;
int m_bytes;
mrparam_t* m_param;
dc_param_t* m_param;
} dc_mimepart_t;

68
src/dc_msg.c
View file

@ -51,7 +51,7 @@ dc_msg_t* dc_msg_new()
ths->m_magic = MR_MSG_MAGIC;
ths->m_type = MR_MSG_UNDEFINED;
ths->m_state = MR_STATE_UNDEFINED;
ths->m_param = mrparam_new();
ths->m_param = dc_param_new();
return ths;
}
@ -73,7 +73,7 @@ void dc_msg_unref(dc_msg_t* msg)
}
dc_msg_empty(msg);
mrparam_unref(msg->m_param);
dc_param_unref(msg->m_param);
msg->m_magic = 0;
free(msg);
}
@ -103,7 +103,7 @@ void dc_msg_empty(dc_msg_t* msg)
free(msg->m_server_folder);
msg->m_server_folder = NULL;
mrparam_set_packed(msg->m_param, NULL);
dc_param_set_packed(msg->m_param, NULL);
msg->m_context = NULL;
@ -290,7 +290,7 @@ char* dc_msg_get_text(const dc_msg_t* msg)
}
ret = safe_strdup(msg->m_text);
mr_truncate_str(ret, MR_MAX_GET_TEXT_LEN); /* we do not do this on load: (1) for speed reasons (2) we may decide to process the full text on other places */
dc_truncate_str(ret, MR_MAX_GET_TEXT_LEN); /* we do not do this on load: (1) for speed reasons (2) we may decide to process the full text on other places */
return ret;
}
@ -318,7 +318,7 @@ char* dc_msg_get_file(const dc_msg_t* msg)
goto cleanup;
}
ret = mrparam_get(msg->m_param, MRP_FILE, NULL);
ret = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
cleanup:
return ret? ret : safe_strdup(NULL);
@ -345,7 +345,7 @@ char* dc_msg_get_filename(const dc_msg_t* msg)
goto cleanup;
}
pathNfilename = mrparam_get(msg->m_param, MRP_FILE, NULL);
pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( pathNfilename == NULL ) {
goto cleanup;
}
@ -378,9 +378,9 @@ char* dc_msg_get_filemime(const dc_msg_t* msg)
goto cleanup;
}
ret = mrparam_get(msg->m_param, MRP_MIMETYPE, NULL);
ret = dc_param_get(msg->m_param, DC_PARAM_MIMETYPE, NULL);
if( ret == NULL ) {
file = mrparam_get(msg->m_param, MRP_FILE, NULL);
file = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( file == NULL ) {
goto cleanup;
}
@ -418,7 +418,7 @@ uint64_t dc_msg_get_filebytes(const dc_msg_t* msg)
goto cleanup;
}
file = mrparam_get(msg->m_param, MRP_FILE, NULL);
file = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( file == NULL ) {
goto cleanup;
}
@ -471,15 +471,15 @@ dc_lot_t* dc_msg_get_mediainfo(const dc_msg_t* msg)
}
else
{
ret->m_text1 = mrparam_get(msg->m_param, MRP_AUTHORNAME, NULL);
ret->m_text2 = mrparam_get(msg->m_param, MRP_TRACKNAME, NULL);
ret->m_text1 = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, NULL);
ret->m_text2 = dc_param_get(msg->m_param, DC_PARAM_TRACKNAME, NULL);
if( ret->m_text1 && ret->m_text1[0] && ret->m_text2 && ret->m_text2[0] ) {
goto cleanup;
}
free(ret->m_text1); ret->m_text1 = NULL;
free(ret->m_text2); ret->m_text2 = NULL;
pathNfilename = mrparam_get(msg->m_param, MRP_FILE, NULL);
pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( pathNfilename == NULL ) {
goto cleanup;
}
@ -517,7 +517,7 @@ int dc_msg_get_width(const dc_msg_t* msg)
if( msg == NULL || msg->m_magic != MR_MSG_MAGIC ) {
return 0;
}
return mrparam_get_int(msg->m_param, MRP_WIDTH, 0);
return dc_param_get_int(msg->m_param, DC_PARAM_WIDTH, 0);
}
@ -542,7 +542,7 @@ int dc_msg_get_height(const dc_msg_t* msg)
if( msg == NULL || msg->m_magic != MR_MSG_MAGIC ) {
return 0;
}
return mrparam_get_int(msg->m_param, MRP_HEIGHT, 0);
return dc_param_get_int(msg->m_param, DC_PARAM_HEIGHT, 0);
}
@ -564,7 +564,7 @@ int dc_msg_get_duration(const dc_msg_t* msg)
if( msg == NULL || msg->m_magic != MR_MSG_MAGIC ) {
return 0;
}
return mrparam_get_int(msg->m_param, MRP_DURATION, 0);
return dc_param_get_int(msg->m_param, DC_PARAM_DURATION, 0);
}
@ -596,7 +596,7 @@ int dc_msg_get_showpadlock(const dc_msg_t* msg)
}
if( show_encryption_state ) {
if( mrparam_get_int(msg->m_param, MRP_GUARANTEE_E2EE, 0) != 0 ) {
if( dc_param_get_int(msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0) != 0 ) {
return 1;
}
}
@ -754,7 +754,7 @@ int dc_msg_is_forwarded(const dc_msg_t* msg)
if( msg == NULL || msg->m_magic != MR_MSG_MAGIC ) {
return 0;
}
return mrparam_get_int(msg->m_param, MRP_FORWARDED, 0)? 1 : 0;
return dc_param_get_int(msg->m_param, DC_PARAM_FORWARDED, 0)? 1 : 0;
}
@ -782,7 +782,7 @@ int dc_msg_is_info(const dc_msg_t* msg)
return 0;
}
int cmd = mrparam_get_int(msg->m_param, MRP_CMD, 0);
int cmd = dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0);
if( msg->m_from_id == MR_CONTACT_ID_DEVICE
|| msg->m_to_id == MR_CONTACT_ID_DEVICE
@ -816,7 +816,7 @@ int dc_msg_is_setupmessage(const dc_msg_t* msg)
return 0;
}
return mrparam_get_int(msg->m_param, MRP_CMD, 0)==MR_CMD_AUTOCRYPT_SETUP_MESSAGE? 1 : 0;
return dc_param_get_int(msg->m_param, DC_PARAM_CMD, 0)==MR_CMD_AUTOCRYPT_SETUP_MESSAGE? 1 : 0;
}
@ -853,7 +853,7 @@ char* dc_msg_get_setupcodebegin(const dc_msg_t* msg)
goto cleanup;
}
if( !mr_read_file(filename, (void**)&buf, &buf_bytes, msg->m_context) || buf == NULL || buf_bytes <= 0 ) {
if( !dc_read_file(filename, (void**)&buf, &buf_bytes, msg->m_context) || buf == NULL || buf_bytes <= 0 ) {
goto cleanup;
}
@ -902,7 +902,7 @@ static int dc_msg_set_from_stmt__(dc_msg_t* ths, sqlite3_stmt* row, int row_offs
ths->m_is_msgrmsg = sqlite3_column_int (row, row_offset++);
ths->m_text = safe_strdup((char*)sqlite3_column_text (row, row_offset++));
mrparam_set_packed( ths->m_param, (char*)sqlite3_column_text (row, row_offset++));
dc_param_set_packed( ths->m_param, (char*)sqlite3_column_text (row, row_offset++));
ths->m_starred = sqlite3_column_int (row, row_offset++);
ths->m_hidden = sqlite3_column_int (row, row_offset++);
ths->m_chat_blocked = sqlite3_column_int (row, row_offset++);
@ -981,7 +981,7 @@ void dc_msg_guess_msgtype_from_suffix(const char* pathNfilename, int* ret_msgtyp
*ret_msgtype = MR_MSG_UNDEFINED;
*ret_mime = NULL;
suffix = mr_get_filesuffix_lc(pathNfilename);
suffix = dc_get_filesuffix_lc(pathNfilename);
if( suffix == NULL ) {
goto cleanup;
}
@ -1031,7 +1031,7 @@ void dc_msg_get_authorNtitle_from_filename(const char* pathNfilename, char** ret
}
char* dc_msg_get_summarytext_by_raw(int type, const char* text, mrparam_t* param, int approx_characters)
char* dc_msg_get_summarytext_by_raw(int type, const char* text, dc_param_t* param, int approx_characters)
{
/* get a summary text, result must be free()'d, never returns NULL. */
char* ret = NULL;
@ -1055,23 +1055,23 @@ char* dc_msg_get_summarytext_by_raw(int type, const char* text, mrparam_t* param
break;
case MR_MSG_AUDIO:
if( (value=mrparam_get(param, MRP_TRACKNAME, NULL))==NULL ) { /* although we send files with "author - title" in the filename, existing files may follow other conventions, so this lookup is neccessary */
pathNfilename = mrparam_get(param, MRP_FILE, "ErrFilename");
if( (value=dc_param_get(param, DC_PARAM_TRACKNAME, NULL))==NULL ) { /* although we send files with "author - title" in the filename, existing files may follow other conventions, so this lookup is neccessary */
pathNfilename = dc_param_get(param, DC_PARAM_FILE, "ErrFilename");
dc_msg_get_authorNtitle_from_filename(pathNfilename, NULL, &value);
}
label = mrstock_str(MR_STR_AUDIO);
ret = mr_mprintf("%s: %s", label, value);
ret = dc_mprintf("%s: %s", label, value);
break;
case MR_MSG_FILE:
if( mrparam_get_int(param, MRP_CMD, 0)==MR_CMD_AUTOCRYPT_SETUP_MESSAGE ) {
if( dc_param_get_int(param, DC_PARAM_CMD, 0)==MR_CMD_AUTOCRYPT_SETUP_MESSAGE ) {
ret = mrstock_str(MR_STR_AC_SETUP_MSG_SUBJECT);
}
else {
pathNfilename = mrparam_get(param, MRP_FILE, "ErrFilename");
pathNfilename = dc_param_get(param, DC_PARAM_FILE, "ErrFilename");
value = mr_get_filename(pathNfilename);
label = mrstock_str(MR_STR_FILE);
ret = mr_mprintf("%s: %s", label, value);
ret = dc_mprintf("%s: %s", label, value);
}
break;
@ -1099,9 +1099,9 @@ int dc_msg_is_increation__(const dc_msg_t* msg)
int is_increation = 0;
if( MR_MSG_NEEDS_ATTACHMENT(msg->m_type) )
{
char* pathNfilename = mrparam_get(msg->m_param, MRP_FILE, NULL);
char* pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
if( pathNfilename ) {
char* totest = mr_mprintf("%s.increation", pathNfilename);
char* totest = dc_mprintf("%s.increation", pathNfilename);
if( mr_file_exist(totest) ) {
is_increation = 1;
}
@ -1203,15 +1203,15 @@ void dc_msg_latefiling_mediasize(dc_msg_t* msg, int width, int height, int durat
locked = 1;
if( width > 0 ) {
mrparam_set_int(msg->m_param, MRP_WIDTH, width);
dc_param_set_int(msg->m_param, DC_PARAM_WIDTH, width);
}
if( height > 0 ) {
mrparam_set_int(msg->m_param, MRP_HEIGHT, height);
dc_param_set_int(msg->m_param, DC_PARAM_HEIGHT, height);
}
if( duration > 0 ) {
mrparam_set_int(msg->m_param, MRP_DURATION, duration);
dc_param_set_int(msg->m_param, DC_PARAM_DURATION, duration);
}
dc_msg_save_param_to_disk__(msg);

6
src/dc_msg.h
View file

@ -27,7 +27,7 @@ extern "C" {
#endif
typedef struct mrparam_t mrparam_t;
typedef struct dc_param_t dc_param_t;
typedef struct sqlite3_stmt sqlite3_stmt;
@ -90,13 +90,13 @@ struct _dc_msg
int m_is_msgrmsg; /**< Set to 1 if the message was sent by another messenger. 0 otherwise. */
int m_starred; /**< Starred-state of the message. 0=no, 1=yes. */
int m_chat_blocked; /**< Internal */
mrparam_t* m_param; /**< Additional paramter for the message. Never a NULL-pointer. It is recommended to use setters and getters instead of accessing this field directly. */
dc_param_t* m_param; /**< Additional paramter for the message. Never a NULL-pointer. It is recommended to use setters and getters instead of accessing this field directly. */
};
int dc_msg_load_from_db__ (dc_msg_t*, dc_context_t*, uint32_t id);
int dc_msg_is_increation__ (const dc_msg_t*);
char* dc_msg_get_summarytext_by_raw (int type, const char* text, mrparam_t*, int approx_bytes); /* the returned value must be free()'d */
char* dc_msg_get_summarytext_by_raw (int type, const char* text, dc_param_t*, int approx_bytes); /* the returned value must be free()'d */
void dc_msg_save_param_to_disk__ (dc_msg_t*);
void dc_msg_guess_msgtype_from_suffix (const char* pathNfilename, int* ret_msgtype, char** ret_mime);
void dc_msg_get_authorNtitle_from_filename (const char* pathNfilename, char** ret_author, char** ret_title);

74
src/dc_param.c
View file

@ -62,15 +62,15 @@ static char* find_param(char* ths, int key, char** ret_p2)
/**
* Create new parameter list object.
*
* @private @memberof mrparam_t
* @private @memberof dc_param_t
*
* @return The created parameter list object.
*/
mrparam_t* mrparam_new()
dc_param_t* dc_param_new()
{
mrparam_t* param;
dc_param_t* param;
if( (param=calloc(1, sizeof(mrparam_t)))==NULL ) {
if( (param=calloc(1, sizeof(dc_param_t)))==NULL ) {
exit(28); /* cannot allocate little memory, unrecoverable error */
}
@ -81,19 +81,19 @@ mrparam_t* mrparam_new()
/**
* Free an parameter list object created eg. by mrparam_new().
* Free an parameter list object created eg. by dc_param_new().
*
* @private @memberof mrparam_t
* @private @memberof dc_param_t
*
* @param param The parameter list object to free.
*/
void mrparam_unref(mrparam_t* param)
void dc_param_unref(dc_param_t* param)
{
if( param==NULL ) {
return;
}
mrparam_empty(param);
dc_param_empty(param);
free(param->m_packed);
free(param);
}
@ -102,13 +102,13 @@ void mrparam_unref(mrparam_t* param)
/**
* Delete all parameters in the object.
*
* @memberof mrparam_t
* @memberof dc_param_t
*
* @param param Parameter object to modify.
*
* @return None.
*/
void mrparam_empty(mrparam_t* param)
void dc_param_empty(dc_param_t* param)
{
if( param == NULL ) {
return;
@ -124,7 +124,7 @@ void mrparam_empty(mrparam_t* param)
*
* Before the new packed parameters are stored, _all_ existant parameters are deleted.
*
* @private @memberof mrparam_t
* @private @memberof dc_param_t
*
* @param param Parameter object to modify.
*
@ -132,13 +132,13 @@ void mrparam_empty(mrparam_t* param)
*
* @return None.
*/
void mrparam_set_packed(mrparam_t* param, const char* packed)
void dc_param_set_packed(dc_param_t* param, const char* packed)
{
if( param == NULL ) {
return;
}
mrparam_empty(param);
dc_param_empty(param);
if( packed ) {
free(param->m_packed);
@ -148,21 +148,21 @@ void mrparam_set_packed(mrparam_t* param, const char* packed)
/**
* Same as mrparam_set_packed() but uses '&' as a separator (instead '\n').
* Same as dc_param_set_packed() but uses '&' as a separator (instead '\n').
* Urldecoding itself is not done by this function, this is up to the caller.
*/
void mrparam_set_urlencoded(mrparam_t* param, const char* urlencoded)
void dc_param_set_urlencoded(dc_param_t* param, const char* urlencoded)
{
if( param == NULL ) {
return;
}
mrparam_empty(param);
dc_param_empty(param);
if( urlencoded ) {
free(param->m_packed);
param->m_packed = safe_strdup(urlencoded);
mr_str_replace(&param->m_packed, "&", "\n");
dc_str_replace(&param->m_packed, "&", "\n");
}
}
@ -170,15 +170,15 @@ void mrparam_set_urlencoded(mrparam_t* param, const char* urlencoded)
/**
* Check if a parameter exists.
*
* @memberof mrparam_t
* @memberof dc_param_t
*
* @param param Parameter object to query.
*
* @param key Key of the parameter to check the existance, one of the MRP_* constants.
* @param key Key of the parameter to check the existance, one of the DC_PARAM_* constants.
*
* @return 1=parameter exists in object, 0=parameter does not exist in parameter object.
*/
int mrparam_exists(mrparam_t* param, int key)
int dc_param_exists(dc_param_t* param, int key)
{
char *p2;
@ -193,17 +193,17 @@ int mrparam_exists(mrparam_t* param, int key)
/**
* Get value of a parameter.
*
* @memberof mrparam_t
* @memberof dc_param_t
*
* @param param Parameter object to query.
*
* @param key Key of the parameter to get, one of the MRP_* constants.
* @param key Key of the parameter to get, one of the DC_PARAM_* constants.
*
* @param def Value to return if the parameter is not set.
*
* @return The stored value or the default value. In both cases, the returned value must be free()'d.
*/
char* mrparam_get(mrparam_t* param, int key, const char* def)
char* dc_param_get(dc_param_t* param, int key, const char* def)
{
char *p1, *p2, bak, *ret;
@ -230,23 +230,23 @@ char* mrparam_get(mrparam_t* param, int key, const char* def)
/**
* Get value of a parameter.
*
* @memberof mrparam_t
* @memberof dc_param_t
*
* @param param Parameter object to query.
*
* @param key Key of the parameter to get, one of the MRP_* constants.
* @param key Key of the parameter to get, one of the DC_PARAM_* constants.
*
* @param def Value to return if the parameter is not set.
*
* @return The stored value or the default value.
*/
int32_t mrparam_get_int(mrparam_t* param, int key, int32_t def)
int32_t dc_param_get_int(dc_param_t* param, int key, int32_t def)
{
if( param == NULL || key == 0 ) {
return def;
}
char* str = mrparam_get(param, key, NULL);
char* str = dc_param_get(param, key, NULL);
if( str == NULL ) {
return def;
}
@ -259,18 +259,18 @@ int32_t mrparam_get_int(mrparam_t* param, int key, int32_t def)
/**
* Set parameter to a string.
*
* @memberof mrparam_t
* @memberof dc_param_t
*
* @param param Parameter object to modify.
*
* @param key Key of the parameter to modify, one of the MRP_* constants.
* @param key Key of the parameter to modify, one of the DC_PARAM_* constants.
*
* @param value Value to store for key. NULL to clear the value.
*
* @return None.
*/
void mrparam_set(mrparam_t* param, int key, const char* value)
void dc_param_set(dc_param_t* param, int key, const char* value)
{
char *old1, *old2, *new1 = NULL;
@ -302,7 +302,7 @@ void mrparam_set(mrparam_t* param, int key, const char* value)
/* create new string */
if( value ) {
new1 = mr_mprintf("%s%s%c=%s%s%s",
new1 = dc_mprintf("%s%s%c=%s%s%s",
old1? old1 : "",
old1? "\n" : "",
key,
@ -311,7 +311,7 @@ void mrparam_set(mrparam_t* param, int key, const char* value)
old2? old2 : "");
}
else {
new1 = mr_mprintf("%s%s%s",
new1 = dc_mprintf("%s%s%s",
old1? old1 : "",
(old1&&old2)? "\n" : "",
old2? old2 : "");
@ -325,26 +325,26 @@ void mrparam_set(mrparam_t* param, int key, const char* value)
/**
* Set parameter to an integer.
*
* @memberof mrparam_t
* @memberof dc_param_t
*
* @param param Parameter object to modify.
*
* @param key Key of the parameter to modify, one of the MRP_* constants.
* @param key Key of the parameter to modify, one of the DC_PARAM_* constants.
*
* @param value Value to store for key.
*
* @return None.
*/
void mrparam_set_int(mrparam_t* param, int key, int32_t value)
void dc_param_set_int(dc_param_t* param, int key, int32_t value)
{
if( param == NULL || key == 0 ) {
return;
}
char* value_str = mr_mprintf("%i", (int)value);
char* value_str = dc_mprintf("%i", (int)value);
if( value_str == NULL ) {
return;
}
mrparam_set(param, key, value_str);
dc_param_set(param, key, value_str);
free(value_str);
}

84
src/dc_param.h
View file

@ -20,8 +20,8 @@
******************************************************************************/
#ifndef __MRPARAM_H__
#define __MRPARAM_H__
#ifndef __DC_PARAM_H__
#define __DC_PARAM_H__
#ifdef __cplusplus
extern "C" {
#endif
@ -32,66 +32,66 @@ extern "C" {
* a single character is allowed.
*
* The object is used eg. by dc_chat_t or dc_msg_t, for readable paramter names,
* these classes define some MRP_* constantats.
* these classes define some DC_PARAM_* constantats.
*
* Only for library-internal use.
*/
typedef struct mrparam_t
typedef struct dc_param_t
{
/** @privatesection */
char* m_packed; /**< Always set, never NULL. */
} mrparam_t;
} dc_param_t;
#define MRP_FILE 'f' /* for msgs */
#define MRP_WIDTH 'w' /* for msgs */
#define MRP_HEIGHT 'h' /* for msgs */
#define MRP_DURATION 'd' /* for msgs */
#define MRP_MIMETYPE 'm' /* for msgs */
#define MRP_AUTHORNAME 'N' /* for msgs: name of author or artist */
#define MRP_TRACKNAME 'n' /* for msgs: name of author or artist */
#define MRP_GUARANTEE_E2EE 'c' /* for msgs: incoming: message is encryoted, outgoing: guarantee E2EE or the message is not send */
#define MRP_ERRONEOUS_E2EE 'e' /* for msgs: decrypted with validation errors or without mutual set, if neither 'c' nor 'e' are preset, the messages is only transport encrypted */
#define MRP_FORCE_PLAINTEXT 'u' /* for msgs: force unencrypted message, either MRFP_ADD_AUTOCRYPT_HEADER (1), MRFP_NO_AUTOCRYPT_HEADER (2) or 0 */
#define MRP_WANTS_MDN 'r' /* for msgs: an incoming message which requestes a MDN (aka read receipt) */
#define MRP_FORWARDED 'a' /* for msgs */
#define MRP_CMD 'S' /* for msgs */
#define MRP_CMD_PARAM 'E' /* for msgs */
#define MRP_CMD_PARAM2 'F' /* for msgs */
#define MRP_CMD_PARAM3 'G' /* for msgs */
#define MRP_CMD_PARAM4 'H' /* for msgs */
#define DC_PARAM_FILE 'f' /* for msgs */
#define DC_PARAM_WIDTH 'w' /* for msgs */
#define DC_PARAM_HEIGHT 'h' /* for msgs */
#define DC_PARAM_DURATION 'd' /* for msgs */
#define DC_PARAM_MIMETYPE 'm' /* for msgs */
#define DC_PARAM_AUTHORNAME 'N' /* for msgs: name of author or artist */
#define DC_PARAM_TRACKNAME 'n' /* for msgs: name of author or artist */
#define DC_PARAM_GUARANTEE_E2EE 'c' /* for msgs: incoming: message is encryoted, outgoing: guarantee E2EE or the message is not send */
#define DC_PARAM_ERRONEOUS_E2EE 'e' /* for msgs: decrypted with validation errors or without mutual set, if neither 'c' nor 'e' are preset, the messages is only transport encrypted */
#define DC_PARAM_FORCE_PLAINTEXT 'u' /* for msgs: force unencrypted message, either MRFP_ADD_AUTOCRYPT_HEADER (1), MRFP_NO_AUTOCRYPT_HEADER (2) or 0 */
#define DC_PARAM_WANTS_MDN 'r' /* for msgs: an incoming message which requestes a MDN (aka read receipt) */
#define DC_PARAM_FORWARDED 'a' /* for msgs */
#define DC_PARAM_CMD 'S' /* for msgs */
#define DC_PARAM_CMD_ARG 'E' /* for msgs */
#define DC_PARAM_CMD_ARG2 'F' /* for msgs */
#define DC_PARAM_CMD_ARG3 'G' /* for msgs */
#define DC_PARAM_CMD_ARG4 'H' /* for msgs */
#define MRP_SERVER_FOLDER 'Z' /* for jobs */
#define MRP_SERVER_UID 'z' /* for jobs */
#define MRP_TIMES 't' /* for jobs: times a job was tried */
#define DC_PARAM_SERVER_FOLDER 'Z' /* for jobs */
#define DC_PARAM_SERVER_UID 'z' /* for jobs */
#define DC_PARAM_TIMES 't' /* for jobs: times a job was tried */
#define MRP_REFERENCES 'R' /* for groups and chats: References-header last used for a chat */
#define MRP_UNPROMOTED 'U' /* for groups */
#define MRP_PROFILE_IMAGE 'i' /* for groups and contacts */
#define MRP_SELFTALK 'K' /* for chats */
#define DC_PARAM_REFERENCES 'R' /* for groups and chats: References-header last used for a chat */
#define DC_PARAM_UNPROMOTED 'U' /* for groups */
#define DC_PARAM_PROFILE_IMAGE 'i' /* for groups and contacts */
#define DC_PARAM_SELFTALK 'K' /* for chats */
// values for MRP_FORCE_PLAINTEXT
// values for DC_PARAM_FORCE_PLAINTEXT
#define MRFP_ADD_AUTOCRYPT_HEADER 1
#define MRFP_NO_AUTOCRYPT_HEADER 2
/* user functions */
int mrparam_exists (mrparam_t*, int key);
char* mrparam_get (mrparam_t*, int key, const char* def); /* the value may be an empty string, "def" is returned only if the value unset. The result must be free()'d in any case. */
int32_t mrparam_get_int (mrparam_t*, int key, int32_t def);
void mrparam_set (mrparam_t*, int key, const char* value);
void mrparam_set_int (mrparam_t*, int key, int32_t value);
int dc_param_exists (dc_param_t*, int key);
char* dc_param_get (dc_param_t*, int key, const char* def); /* the value may be an empty string, "def" is returned only if the value unset. The result must be free()'d in any case. */
int32_t dc_param_get_int (dc_param_t*, int key, int32_t def);
void dc_param_set (dc_param_t*, int key, const char* value);
void dc_param_set_int (dc_param_t*, int key, int32_t value);
/* library-private */
mrparam_t* mrparam_new ();
void mrparam_empty (mrparam_t*);
void mrparam_unref (mrparam_t*);
void mrparam_set_packed (mrparam_t*, const char*);
void mrparam_set_urlencoded (mrparam_t*, const char*);
dc_param_t* dc_param_new ();
void dc_param_empty (dc_param_t*);
void dc_param_unref (dc_param_t*);
void dc_param_set_packed (dc_param_t*, const char*);
void dc_param_set_urlencoded (dc_param_t*, const char*);
#ifdef __cplusplus
} /* /extern "C" */
} // /extern "C"
#endif
#endif /* __MRPARAM_H__ */
#endif // __DC_PARAM_H__

18
src/dc_pgp.c
View file

@ -324,9 +324,9 @@ int dc_pgp_create_keypair(dc_context_t* mailbox, const char* addr, dc_key_t* ret
However, as eg. Enigmail displayes the user-id in "Good signature from <user-id>,
for now, we decided to leave the address in the user-id */
#if 0
user_id = (uint8_t*)mr_mprintf("<%08X@%08X.org>", (int)random(), (int)random());
user_id = (uint8_t*)dc_mprintf("<%08X@%08X.org>", (int)random(), (int)random());
#else
user_id = (uint8_t*)mr_mprintf("<%s>", addr);
user_id = (uint8_t*)dc_mprintf("<%s>", addr);
#endif
@ -388,8 +388,8 @@ int dc_pgp_create_keypair(dc_context_t* mailbox, const char* addr, dc_key_t* ret
goto cleanup;
}
dc_key_set_from_binary(ret_public_key, pubmem->buf, pubmem->length, MR_PUBLIC);
dc_key_set_from_binary(ret_private_key, secmem->buf, secmem->length, MR_PRIVATE);
dc_key_set_from_binary(ret_public_key, pubmem->buf, pubmem->length, DC_KEY_PUBLIC);
dc_key_set_from_binary(ret_private_key, secmem->buf, secmem->length, DC_KEY_PRIVATE);
success = 1;
@ -427,10 +427,10 @@ int dc_pgp_is_valid_key(dc_context_t* mailbox, const dc_key_t* raw_key)
pgp_memory_add(keysmem, raw_key->m_binary, raw_key->m_bytes);
pgp_filter_keys_from_mem(&s_io, public_keys, private_keys, NULL, 0, keysmem); /* function returns 0 on any error in any packet - this does not mean, we cannot use the key. We check the details below therefore. */
if( raw_key->m_type == MR_PUBLIC && public_keys->keyc >= 1 ) {
if( raw_key->m_type == DC_KEY_PUBLIC && public_keys->keyc >= 1 ) {
key_is_valid = 1;
}
else if( raw_key->m_type == MR_PRIVATE && private_keys->keyc >= 1 ) {
else if( raw_key->m_type == DC_KEY_PRIVATE && private_keys->keyc >= 1 ) {
key_is_valid = 1;
}
@ -458,7 +458,7 @@ int dc_pgp_calc_fingerprint(const dc_key_t* raw_key, uint8_t** ret_fingerprint,
pgp_memory_add(keysmem, raw_key->m_binary, raw_key->m_bytes);
pgp_filter_keys_from_mem(&s_io, public_keys, private_keys, NULL, 0, keysmem);
if( raw_key->m_type != MR_PUBLIC || public_keys->keyc <= 0 ) {
if( raw_key->m_type != DC_KEY_PUBLIC || public_keys->keyc <= 0 ) {
goto cleanup;
}
@ -499,7 +499,7 @@ int dc_pgp_split_key(dc_context_t* mailbox, const dc_key_t* private_in, dc_key_t
pgp_memory_add(keysmem, private_in->m_binary, private_in->m_bytes);
pgp_filter_keys_from_mem(&s_io, public_keys, private_keys, NULL, 0, keysmem);
if( private_in->m_type!=MR_PRIVATE || private_keys->keyc <= 0 ) {
if( private_in->m_type!=DC_KEY_PRIVATE || private_keys->keyc <= 0 ) {
dc_log_warning(mailbox, 0, "Split key: Given key is no private key.");
goto cleanup;
}
@ -515,7 +515,7 @@ int dc_pgp_split_key(dc_context_t* mailbox, const dc_key_t* private_in, dc_key_t
goto cleanup;
}
dc_key_set_from_binary(ret_public_key, pubmem->buf, pubmem->length, MR_PUBLIC);
dc_key_set_from_binary(ret_public_key, pubmem->buf, pubmem->length, DC_KEY_PUBLIC);
success = 1;

30
src/dc_qr.c
View file

@ -83,35 +83,35 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
*fragment = 0;
fragment++;
mrparam_t* param = mrparam_new();
mrparam_set_urlencoded(param, fragment);
dc_param_t* param = dc_param_new();
dc_param_set_urlencoded(param, fragment);
addr = mrparam_get(param, 'a', NULL);
addr = dc_param_get(param, 'a', NULL);
if( addr ) {
char* urlencoded = mrparam_get(param, 'n', NULL);
char* urlencoded = dc_param_get(param, 'n', NULL);
if(urlencoded ) {
name = mr_urldecode(urlencoded);
name = dc_urldecode(urlencoded);
mr_normalize_name(name);
free(urlencoded);
}
invitenumber = mrparam_get(param, 'i', NULL);
auth = mrparam_get(param, 's', NULL);
invitenumber = dc_param_get(param, 'i', NULL);
auth = dc_param_get(param, 's', NULL);
grpid = mrparam_get(param, 'x', NULL);
grpid = dc_param_get(param, 'x', NULL);
if( grpid ) {
urlencoded = mrparam_get(param, 'g', NULL);
urlencoded = dc_param_get(param, 'g', NULL);
if( urlencoded ) {
grpname = mr_urldecode(urlencoded);
grpname = dc_urldecode(urlencoded);
free(urlencoded);
}
}
}
mrparam_unref(param);
dc_param_unref(param);
}
fingerprint = mr_normalize_fingerprint(payload);
fingerprint = dc_normalize_fingerprint(payload);
}
else if( strncasecmp(qr, MAILTO_SCHEME, strlen(MAILTO_SCHEME)) == 0 )
{
@ -166,7 +166,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
else if( strcasecmp(key, "N") == 0 ) {
semicolon = strchr(value, ';'); if( semicolon ) { semicolon = strchr(semicolon+1, ';'); if( semicolon ) { *semicolon = 0; } } /* the N format is `lastname;prename;wtf;title` - skip everything after the second semicolon */
name = safe_strdup(value);
mr_str_replace(&name, ";", ","); /* the format "lastname,prename" is handled by mr_normalize_name() */
dc_str_replace(&name, ";", ","); /* the format "lastname,prename" is handled by mr_normalize_name() */
mr_normalize_name(name);
}
}
@ -178,7 +178,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
---------------------- */
if( addr ) {
char* temp = mr_urldecode(addr); free(addr); addr = temp; /* urldecoding is needed at least for OPENPGP4FPR but should not hurt in the other cases */
char* temp = dc_urldecode(addr); free(addr); addr = temp; /* urldecoding is needed at least for OPENPGP4FPR but should not hurt in the other cases */
temp = mr_normalize_addr(addr); free(addr); addr = temp;
if( strlen(addr) < 3 || strchr(addr, '@')==NULL || strchr(addr, '.')==NULL ) {
@ -215,7 +215,7 @@ dc_lot_t* dc_check_qr(dc_context_t* context, const char* qr)
qr_parsed->m_id = dc_add_or_lookup_contact__(context, NULL, peerstate->m_addr, MR_ORIGIN_UNHANDLED_QR_SCAN, NULL);
dc_create_or_lookup_nchat_by_contact_id__(context, qr_parsed->m_id, MR_CHAT_DEADDROP_BLOCKED, &chat_id, NULL);
device_msg = mr_mprintf("%s verified.", peerstate->m_addr);
device_msg = dc_mprintf("%s verified.", peerstate->m_addr);
}
else {
qr_parsed->m_text1 = mr_format_fingerprint(fingerprint);

34
src/dc_receive_imf.c
View file

@ -61,7 +61,7 @@ static void add_or_lookup_contact_by_addr__(dc_context_t* mailbox, const char* d
/* add addr_spec if missing, update otherwise */
char* display_name_dec = NULL;
if( display_name_enc ) {
display_name_dec = mr_decode_header_words(display_name_enc);
display_name_dec = dc_decode_header_words(display_name_enc);
mr_normalize_name(display_name_dec);
}
@ -134,7 +134,7 @@ static int is_known_rfc724_mid__(dc_context_t* mailbox, const char* rfc724_mid)
"SELECT m.id FROM msgs m "
" LEFT JOIN chats c ON m.chat_id=c.id "
" WHERE m.rfc724_mid=? "
" AND m.chat_id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL)
" AND m.chat_id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL)
" AND c.blocked=0;");
sqlite3_bind_text(stmt, 1, rfc724_mid, -1, SQLITE_STATIC);
if( sqlite3_step(stmt) == SQLITE_ROW ) {
@ -212,7 +212,7 @@ static int is_msgrmsg_rfc724_mid__(dc_context_t* mailbox, const char* rfc724_mid
"SELECT id FROM msgs "
" WHERE rfc724_mid=? "
" AND msgrmsg!=0 "
" AND chat_id>" MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) ";");
" AND chat_id>" DC_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL) ";");
sqlite3_bind_text(stmt, 1, rfc724_mid, -1, SQLITE_STATIC);
if( sqlite3_step(stmt) == SQLITE_ROW ) {
return 1;
@ -362,8 +362,8 @@ static dc_array_t* search_chat_ids_by_contact_ids(dc_context_t* mailbox, const d
" FROM chats_contacts cc "
" LEFT JOIN chats c ON c.id=cc.chat_id "
" WHERE cc.chat_id IN(SELECT chat_id FROM chats_contacts WHERE contact_id IN(%s))"
" AND c.type=" MR_STRINGIFY(MR_CHAT_TYPE_GROUP) /* no verified groups and no single chats (which are equal to a group with a single member and without SELF) */
" AND cc.contact_id!=" MR_STRINGIFY(MR_CONTACT_ID_SELF) /* ignore SELF, we've also removed it above - if the user has left the group, it is still the same group */
" AND c.type=" DC_STRINGIFY(MR_CHAT_TYPE_GROUP) /* no verified groups and no single chats (which are equal to a group with a single member and without SELF) */
" AND cc.contact_id!=" DC_STRINGIFY(MR_CONTACT_ID_SELF) /* ignore SELF, we've also removed it above - if the user has left the group, it is still the same group */
" ORDER BY cc.chat_id, cc.contact_id;",
contact_ids_str);
stmt = dc_sqlite3_prepare_v2_(mailbox->m_sql, q3);
@ -416,17 +416,17 @@ static char* create_adhoc_grp_id__(dc_context_t* mailbox, dc_array_t* member_ids
*/
dc_array_t* member_addrs = dc_array_new(mailbox, 23);
char* member_ids_str = dc_array_get_string(member_ids, ",");
mrstrbuilder_t member_cs;
dc_strbuilder_t member_cs;
sqlite3_stmt* stmt = NULL;
char* q3 = NULL, *addr;
int i, iCnt;
uint8_t* binary_hash = NULL;
char* ret = NULL;
mrstrbuilder_init(&member_cs, 0);
dc_strbuilder_init(&member_cs, 0);
/* collect all addresses and sort them */
q3 = sqlite3_mprintf("SELECT addr FROM contacts WHERE id IN(%s) AND id!=" MR_STRINGIFY(MR_CONTACT_ID_SELF), member_ids_str);
q3 = sqlite3_mprintf("SELECT addr FROM contacts WHERE id IN(%s) AND id!=" DC_STRINGIFY(MR_CONTACT_ID_SELF), member_ids_str);
stmt = dc_sqlite3_prepare_v2_(mailbox->m_sql, q3);
addr = dc_sqlite3_get_config__(mailbox->m_sql, "configured_addr", "no-self");
mr_strlower_in_place(addr);
@ -441,8 +441,8 @@ static char* create_adhoc_grp_id__(dc_context_t* mailbox, dc_array_t* member_ids
/* build a single, comma-separated (cs) string from all addresses */
iCnt = dc_array_get_cnt(member_addrs);
for( i = 0; i < iCnt; i++ ) {
if( i ) { mrstrbuilder_cat(&member_cs, ","); }
mrstrbuilder_cat(&member_cs, (const char*)dc_array_get_ptr(member_addrs, i));
if( i ) { dc_strbuilder_cat(&member_cs, ","); }
dc_strbuilder_cat(&member_cs, (const char*)dc_array_get_ptr(member_addrs, i));
}
/* make sha-256 from the string */
@ -746,7 +746,7 @@ 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-Name", "X-MrGrpName"))!=NULL ) {
grpname = mr_decode_header_words(optional_field->fld_value); /* this is no changed groupname message */
grpname = dc_decode_header_words(optional_field->fld_value); /* this is no changed groupname message */
}
if( (optional_field=dc_mimeparser_lookup_optional_field2(mime_parser, "Chat-Group-Member-Removed", "X-MrRemoveFromGrp"))!=NULL ) {
@ -851,7 +851,7 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
if( carray_count(mime_parser->m_parts)>=2 ) {
dc_mimepart_t* imgpart = (dc_mimepart_t*)carray_get(mime_parser->m_parts, 1);
if( imgpart->m_type == MR_MSG_IMAGE ) {
grpimage = mrparam_get(imgpart->m_param, MRP_FILE, NULL);
grpimage = dc_param_get(imgpart->m_param, DC_PARAM_FILE, NULL);
ok = 1;
}
}
@ -865,7 +865,7 @@ static void create_or_lookup_group__(dc_context_t* mailbox, dc_mimeparser_t* mim
dc_chat_t* chat = dc_chat_new(mailbox);
dc_log_info(mailbox, 0, "New group image set to %s.", grpimage? "DELETED" : grpimage);
dc_chat_load_from_db__(chat, chat_id);
mrparam_set(chat->m_param, MRP_PROFILE_IMAGE, grpimage/*may be NULL*/);
dc_param_set(chat->m_param, DC_PARAM_PROFILE_IMAGE, grpimage/*may be NULL*/);
dc_chat_update_param__(chat);
dc_chat_unref(chat);
free(grpimage);
@ -1288,11 +1288,11 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
}
if( part->m_type == MR_MSG_TEXT ) {
txt_raw = mr_mprintf("%s\n\n%s", mime_parser->m_subject? mime_parser->m_subject : "", part->m_msg_raw);
txt_raw = dc_mprintf("%s\n\n%s", mime_parser->m_subject? mime_parser->m_subject : "", part->m_msg_raw);
}
if( mime_parser->m_is_system_message ) {
mrparam_set_int(part->m_param, MRP_CMD, mime_parser->m_is_system_message);
dc_param_set_int(part->m_param, DC_PARAM_CMD, mime_parser->m_is_system_message);
}
stmt = dc_sqlite3_predefine__(mailbox->m_sql, INSERT_INTO_msgs_msscftttsmttpb,
@ -1443,7 +1443,7 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
otherwise, the moved message get a new server_uid and is "fresh" again and we will be here again to move it away -
a classical deadlock, see also (***) in mrimap.c */
if( mime_parser->m_is_send_by_messenger || mdn_consumed ) {
char* jobparam = mr_mprintf("%c=%s\n%c=%lu", MRP_SERVER_FOLDER, server_folder, MRP_SERVER_UID, server_uid);
char* jobparam = dc_mprintf("%c=%s\n%c=%lu", DC_PARAM_SERVER_FOLDER, server_folder, DC_PARAM_SERVER_UID, server_uid);
dc_job_add(mailbox, DC_JOB_MARKSEEN_MDN_ON_IMAP, 0, jobparam, 0);
free(jobparam);
}
@ -1455,7 +1455,7 @@ void dc_receive_imf(dc_context_t* mailbox, const char* imf_raw_not_terminated, s
/* debug print? */
if( dc_sqlite3_get_config_int__(mailbox->m_sql, "save_eml", 0) ) {
char* emlname = mr_mprintf("%s/%s-%i.eml", mailbox->m_blobdir, server_folder, (int)first_dblocal_id /*may be 0 for MDNs*/);
char* emlname = dc_mprintf("%s/%s-%i.eml", mailbox->m_blobdir, server_folder, (int)first_dblocal_id /*may be 0 for MDNs*/);
FILE* emlfileob = fopen(emlname, "w");
if( emlfileob ) {
fwrite(imf_raw_not_terminated, 1, imf_raw_bytes, emlfileob);

40
src/dc_securejoin.c
View file

@ -75,7 +75,7 @@ void dc_handle_degrade_event(dc_context_t* context, dc_apeerstate_t* peerstate)
UNLOCK
char* msg = mr_mprintf("Changed setup for %s", peerstate->m_addr);
char* msg = dc_mprintf("Changed setup for %s", peerstate->m_addr);
dc_add_device_msg(context, contact_chat_id, msg);
free(msg);
context->m_cb(context, DC_EVENT_CHAT_MODIFIED, contact_chat_id, 0);
@ -188,7 +188,7 @@ static int fingerprint_equals_sender(dc_context_t* context, const char* fingerpr
dc_sqlite3_unlock(context->m_sql);
locked = 0;
fingerprint_normalized = mr_normalize_fingerprint(fingerprint);
fingerprint_normalized = dc_normalize_fingerprint(fingerprint);
if( strcasecmp(fingerprint_normalized, peerstate->m_public_key_fingerprint) == 0 ) {
fingerprint_equal = 1;
@ -219,7 +219,7 @@ static int mark_peer_as_verified__(dc_context_t* context, const char* fingerprin
// set MUTUAL as an out-of-band-verification is a strong hint that encryption is wanted.
// 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 = MRA_PE_MUTUAL;
peerstate->m_prefer_encrypt = DC_PE_MUTUAL;
peerstate->m_to_save |= MRA_SAVE_ALL;
dc_apeerstate_save_to_db__(peerstate, context->m_sql, 0);
@ -248,28 +248,28 @@ static void send_handshake_msg(dc_context_t* context, uint32_t contact_chat_id,
dc_msg_t* msg = dc_msg_new();
msg->m_type = MR_MSG_TEXT;
msg->m_text = mr_mprintf("Secure-Join: %s", step);
msg->m_text = dc_mprintf("Secure-Join: %s", step);
msg->m_hidden = 1;
mrparam_set_int(msg->m_param, MRP_CMD, MR_CMD_SECUREJOIN_MESSAGE);
mrparam_set (msg->m_param, MRP_CMD_PARAM, step);
dc_param_set_int(msg->m_param, DC_PARAM_CMD, MR_CMD_SECUREJOIN_MESSAGE);
dc_param_set (msg->m_param, DC_PARAM_CMD_ARG, step);
if( param2 ) {
mrparam_set(msg->m_param, MRP_CMD_PARAM2, param2); // depening on step, this goes either to Secure-Join-Invitenumber or Secure-Join-Auth in mrmimefactory.c
dc_param_set(msg->m_param, DC_PARAM_CMD_ARG2, param2); // depening on step, this goes either to Secure-Join-Invitenumber or Secure-Join-Auth in mrmimefactory.c
}
if( fingerprint ) {
mrparam_set(msg->m_param, MRP_CMD_PARAM3, fingerprint);
dc_param_set(msg->m_param, DC_PARAM_CMD_ARG3, fingerprint);
}
if( grpid ) {
mrparam_set(msg->m_param, MRP_CMD_PARAM4, grpid);
dc_param_set(msg->m_param, DC_PARAM_CMD_ARG4, grpid);
}
if( strcmp(step, "vg-request")==0 || strcmp(step, "vc-request")==0 ) {
mrparam_set_int(msg->m_param, MRP_FORCE_PLAINTEXT, MRFP_ADD_AUTOCRYPT_HEADER); // the request message MUST NOT be encrypted - it may be that the key has changed and the message cannot be decrypted otherwise
dc_param_set_int(msg->m_param, DC_PARAM_FORCE_PLAINTEXT, MRFP_ADD_AUTOCRYPT_HEADER); // the request message MUST NOT be encrypted - it may be that the key has changed and the message cannot be decrypted otherwise
}
else {
mrparam_set_int(msg->m_param, MRP_GUARANTEE_E2EE, 1); /* all but the first message MUST be encrypted */
dc_param_set_int(msg->m_param, DC_PARAM_GUARANTEE_E2EE, 1); /* all but the first message MUST be encrypted */
}
dc_send_msg_object(context, contact_chat_id, msg);
@ -282,7 +282,7 @@ static void could_not_establish_secure_connection(dc_context_t* context, uint32_
{
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 = mr_mprintf("Could not establish secure connection to %s.", contact? contact->m_addr : "?");
char* msg = dc_mprintf("Could not establish secure connection to %s.", contact? contact->m_addr : "?");
dc_add_device_msg(context, contact_chat_id, msg);
@ -297,7 +297,7 @@ static void secure_connection_established(dc_context_t* context, uint32_t contac
{
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 = mr_mprintf("Secure connection to %s established.", contact? contact->m_addr : "?");
char* msg = dc_mprintf("Secure connection to %s established.", contact? contact->m_addr : "?");
dc_add_device_msg(context, contact_chat_id, msg);
@ -383,13 +383,13 @@ 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 = mrtoken_lookup__(context, MRT_INVITENUMBER, group_chat_id);
if( invitenumber == NULL ) {
invitenumber = mr_create_id();
invitenumber = dc_create_id();
mrtoken_save__(context, MRT_INVITENUMBER, group_chat_id, invitenumber);
}
auth = mrtoken_lookup__(context, MRT_AUTH, group_chat_id);
if( auth == NULL ) {
auth = mr_create_id();
auth = dc_create_id();
mrtoken_save__(context, MRT_AUTH, group_chat_id, auth);
}
@ -407,8 +407,8 @@ char* dc_get_securejoin_qr(dc_context_t* context, uint32_t group_chat_id)
goto cleanup;
}
self_addr_urlencoded = mr_urlencode(self_addr);
self_name_urlencoded = mr_urlencode(self_name);
self_addr_urlencoded = dc_urlencode(self_addr);
self_name_urlencoded = dc_urlencode(self_name);
if( group_chat_id )
{
@ -419,13 +419,13 @@ char* dc_get_securejoin_qr(dc_context_t* context, uint32_t group_chat_id)
goto cleanup;
}
group_name = dc_chat_get_name(chat);
group_name_urlencoded = mr_urlencode(group_name);
qr = mr_mprintf(OPENPGP4FPR_SCHEME "%s#a=%s&g=%s&x=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, group_name_urlencoded, chat->m_grpid, invitenumber, auth);
group_name_urlencoded = dc_urlencode(group_name);
qr = dc_mprintf(OPENPGP4FPR_SCHEME "%s#a=%s&g=%s&x=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, group_name_urlencoded, chat->m_grpid, invitenumber, auth);
}
else
{
// parameters used: a=n=i=s=
qr = mr_mprintf(OPENPGP4FPR_SCHEME "%s#a=%s&n=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, self_name_urlencoded, invitenumber, auth);
qr = dc_mprintf(OPENPGP4FPR_SCHEME "%s#a=%s&n=%s&i=%s&s=%s", fingerprint, self_addr_urlencoded, self_name_urlencoded, invitenumber, auth);
}
cleanup:

12
src/dc_simplify.c
View file

@ -249,11 +249,11 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* ths, const char* buf
}
/* re-create buffer from the remaining lines */
mrstrbuilder_t ret;
mrstrbuilder_init(&ret, strlen(buf_terminated));
dc_strbuilder_t ret;
dc_strbuilder_init(&ret, strlen(buf_terminated));
if( ths->m_is_cut_at_begin ) {
mrstrbuilder_cat(&ret, MR_EDITORIAL_ELLIPSE " ");
dc_strbuilder_cat(&ret, MR_EDITORIAL_ELLIPSE " ");
}
int pending_linebreaks = 0; /* we write empty lines only in case and non-empty line follows */
@ -273,12 +273,12 @@ static char* dc_simplify_simplify_plain_text(dc_simplify_t* ths, const char* buf
{
if( pending_linebreaks > 2 ) { pending_linebreaks = 2; } /* ignore more than one empty line (however, regard normal line ends) */
while( pending_linebreaks ) {
mrstrbuilder_cat(&ret, "\n");
dc_strbuilder_cat(&ret, "\n");
pending_linebreaks--;
}
}
mrstrbuilder_cat(&ret, line);
dc_strbuilder_cat(&ret, line);
content_lines_added++;
pending_linebreaks = 1;
}
@ -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 */ ) {
mrstrbuilder_cat(&ret, " " MR_EDITORIAL_ELLIPSE);
dc_strbuilder_cat(&ret, " " MR_EDITORIAL_ELLIPSE);
}
mr_free_splitted_lines(lines);

2
src/dc_sqlite3.c
View file

@ -681,7 +681,7 @@ int32_t dc_sqlite3_get_config_int__(dc_sqlite3_t* ths, const char* key, int32_t
int dc_sqlite3_set_config_int__(dc_sqlite3_t* ths, const char* key, int32_t value)
{
char* value_str = mr_mprintf("%i", (int)value);
char* value_str = dc_mprintf("%i", (int)value);
if( value_str == NULL ) {
return 0;
}

12
src/dc_stock.c
View file

@ -42,8 +42,8 @@ static char* default_string(int id, int qty)
case MR_STR_NOMESSAGES: return safe_strdup("No messages.");
case MR_STR_SELF: return safe_strdup("Me");
case MR_STR_DRAFT: return safe_strdup("Draft");
case MR_STR_MEMBER: return mr_mprintf("%i member(s)", qty);
case MR_STR_CONTACT: return mr_mprintf("%i contact(s)", qty);
case MR_STR_MEMBER: return dc_mprintf("%i member(s)", qty);
case MR_STR_CONTACT: return dc_mprintf("%i contact(s)", qty);
case MR_STR_VOICEMESSAGE: return safe_strdup("Voice message");
case MR_STR_DEADDROP: return safe_strdup("Mailbox");
case MR_STR_IMAGE: return safe_strdup("Image");
@ -96,14 +96,14 @@ char* mrstock_str(int id) /* get the string with the given ID, the result must b
char* mrstock_str_repl_string(int id, const char* to_insert)
{
char* p1 = mrstock_str(id);
mr_str_replace(&p1, "%1$s", to_insert);
dc_str_replace(&p1, "%1$s", to_insert);
return p1;
}
char* mrstock_str_repl_int(int id, int to_insert_int)
{
char* ret, *to_insert_str = mr_mprintf("%i", (int)to_insert_int);
char* ret, *to_insert_str = dc_mprintf("%i", (int)to_insert_int);
ret = mrstock_str_repl_string(id, to_insert_str);
free(to_insert_str);
return ret;
@ -113,8 +113,8 @@ char* mrstock_str_repl_int(int id, int to_insert_int)
char* mrstock_str_repl_string2(int id, const char* to_insert, const char* to_insert2)
{
char* p1 = mrstock_str(id);
mr_str_replace(&p1, "%1$s", to_insert);
mr_str_replace(&p1, "%2$s", to_insert2);
dc_str_replace(&p1, "%1$s", to_insert);
dc_str_replace(&p1, "%2$s", to_insert2);
return p1;
}

34
src/dc_strbuilder.c
View file

@ -28,11 +28,11 @@
* A string-builder-object is placed typically on the stack and contains a string-buffer
* which is initially empty.
*
* You can add data to the string-buffer using eg. mrstrbuilder_cat() or
* mrstrbuilder_catf() - the buffer is reallocated as needed.
* You can add data to the string-buffer using eg. dc_strbuilder_cat() or
* dc_strbuilder_catf() - the buffer is reallocated as needed.
*
* When you're done with string building, the ready-to-use, null-terminates
* string can be found at mrstrbuilder_t::m_buf, you can do whatever you like
* string can be found at dc_strbuilder_t::m_buf, you can do whatever you like
* with this buffer, however, never forget to call free() when done.
*
* @param strbuilder The object to initialze.
@ -44,7 +44,7 @@
*
* @return None.
*/
void mrstrbuilder_init(mrstrbuilder_t* strbuilder, int init_bytes)
void dc_strbuilder_init(dc_strbuilder_t* strbuilder, int init_bytes)
{
if( strbuilder==NULL ) {
return;
@ -69,17 +69,17 @@ void mrstrbuilder_init(mrstrbuilder_t* strbuilder, int init_bytes)
* If reallocation fails, the program halts.
*
* @param strbuilder The object to initialze. Must be initialized with
* mrstrbuilder_init().
* dc_strbuilder_init().
*
* @param text Null-terminated string to add to the end of the string-builder-string.
*
* @return Returns a pointer to the copy of the given text.
* The returned pointer is a pointer inside mrstrbuilder_t::m_buf and MUST NOT
* The returned pointer is a pointer inside dc_strbuilder_t::m_buf and MUST NOT
* be freed. If the string-builder was empty before, the returned
* pointer is equal to mrstrbuilder_t::m_buf.
* pointer is equal to dc_strbuilder_t::m_buf.
* If the given text is NULL, NULL is returned and the string-builder-object is not modified.
*/
char* mrstrbuilder_cat(mrstrbuilder_t* strbuilder, const char* text)
char* dc_strbuilder_cat(dc_strbuilder_t* strbuilder, const char* text)
{
// this function MUST NOT call logging functions as it is used to output the log
if( strbuilder==NULL || text==NULL ) {
@ -115,11 +115,11 @@ char* mrstrbuilder_cat(mrstrbuilder_t* strbuilder, const char* text)
/**
* Add a formatted string to a string-builder-object.
* This function is similar to mrstrbuilder_cat() but allows the same
* This function is similar to dc_strbuilder_cat() but allows the same
* formatting options as eg. printf()
*
* @param strbuilder The object to initialze. Must be initialized with
* mrstrbuilder_init().
* dc_strbuilder_init().
*
* @param format The formatting string to add to the string-builder-object.
* This parameter may be followed by data to be inserted into the
@ -127,7 +127,7 @@ char* mrstrbuilder_cat(mrstrbuilder_t* strbuilder, const char* text)
*
* @return None.
*/
void mrstrbuilder_catf(mrstrbuilder_t* strbuilder, const char* format, ...)
void dc_strbuilder_catf(dc_strbuilder_t* strbuilder, const char* format, ...)
{
char testbuf[1];
char* buf;
@ -142,35 +142,35 @@ void mrstrbuilder_catf(mrstrbuilder_t* strbuilder, const char* format, ...)
va_end(argp);
if( char_cnt_without_zero < 0) {
va_end(argp_copy);
mrstrbuilder_cat(strbuilder, "ErrFmt");
dc_strbuilder_cat(strbuilder, "ErrFmt");
return;
}
buf = malloc(char_cnt_without_zero+2 /* +1 would be enough, however, protect against off-by-one-errors */);
if( buf == NULL ) {
va_end(argp_copy);
mrstrbuilder_cat(strbuilder, "ErrMem");
dc_strbuilder_cat(strbuilder, "ErrMem");
return;
}
vsnprintf(buf, char_cnt_without_zero+1, format, argp_copy);
va_end(argp_copy);
mrstrbuilder_cat(strbuilder, buf);
dc_strbuilder_cat(strbuilder, buf);
free(buf);
}
/**
* Set the string to a lenght of 0. This does not free the buffer;
* if you want to free the buffer, you have to call free() on mrstrbuilder_t::m_buf.
* if you want to free the buffer, you have to call free() on dc_strbuilder_t::m_buf.
*
* @param strbuilder The object to initialze. Must be initialized with
* mrstrbuilder_init().
* dc_strbuilder_init().
*
* @return None
*/
void mrstrbuilder_empty(mrstrbuilder_t* strbuilder)
void dc_strbuilder_empty(dc_strbuilder_t* strbuilder)
{
strbuilder->m_buf[0] = 0;
strbuilder->m_free = strbuilder->m_allocated - 1 /*the nullbyte! */;

20
src/dc_strbuilder.h
View file

@ -20,30 +20,30 @@
******************************************************************************/
#ifndef __MRSTRBUILDER_H__
#define __MRSTRBUILDER_H__
#ifndef __DC_STRBUILDER_H__
#define __DC_STRBUILDER_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct mrstrbuilder_t
typedef struct dc_strbuilder_t
{
char* m_buf;
int m_allocated;
int m_free;
char* m_eos;
} mrstrbuilder_t;
} dc_strbuilder_t;
void mrstrbuilder_init (mrstrbuilder_t* ths, int init_bytes);
char* mrstrbuilder_cat (mrstrbuilder_t* ths, const char* text);
void mrstrbuilder_catf (mrstrbuilder_t* ths, const char* format, ...);
void mrstrbuilder_empty (mrstrbuilder_t* ths);
void dc_strbuilder_init (dc_strbuilder_t*, int init_bytes);
char* dc_strbuilder_cat (dc_strbuilder_t*, const char* text);
void dc_strbuilder_catf (dc_strbuilder_t*, const char* format, ...);
void dc_strbuilder_empty (dc_strbuilder_t*);
#ifdef __cplusplus
} /* /extern "C" */
} // /extern "C"
#endif
#endif /* __MRSTRBUILDER_H__ */
#endif // __DC_STRBUILDER_H__

26
src/dc_strencode.c
View file

@ -61,7 +61,7 @@ static char hex_2_int(char ch)
* On memory allocation errors the program halts.
* On other errors, an empty string is returned.
*/
char* mr_urlencode(const char *to_encode)
char* dc_urlencode(const char *to_encode)
{
const char *pstr = to_encode;
@ -97,7 +97,7 @@ char* mr_urlencode(const char *to_encode)
/**
* Returns a url-decoded version of the given string.
* The string may be encoded eg. by mr_urlencode().
* The string may be encoded eg. by dc_urlencode().
* Belongs to RFC 3986: https://tools.ietf.org/html/rfc3986#section-2
*
* @param to_decode Null-terminated string to decode.
@ -107,7 +107,7 @@ char* mr_urlencode(const char *to_encode)
* On memory allocation errors the program halts.
* On other errors, an empty string is returned.
*/
char* mr_urldecode(const char* to_decode)
char* dc_urldecode(const char* to_decode)
{
const char *pstr = to_decode;
@ -361,7 +361,7 @@ static void get_word(const char* begin, const char** pend, int* pto_be_quoted)
* @return Returns the encoded string which must be free()'d when no longed needed.
* On errors, NULL is returned.
*/
char* mr_encode_header_words(const char* to_encode)
char* dc_encode_header_words(const char* to_encode)
{
char* ret_str = NULL;
const char* cur = to_encode;
@ -452,7 +452,7 @@ cleanup:
* @return Returns the null-terminated decoded string as UTF-8. Must be free()'d when no longed needed.
* On errors, NULL is returned.
*/
char* mr_decode_header_words(const char* in)
char* dc_decode_header_words(const char* in)
{
/* decode strings as. `=?UTF-8?Q?Bj=c3=b6rn_Petersen?=`)
if `in` is NULL, `out` is NULL as well; also returns NULL on errors */
@ -497,7 +497,7 @@ static const char base64chars[] =
* for all other errors, an empty string is returned.
* NULL is never returned.
*/
char* mr_encode_modified_utf7(const char* to_encode, int change_spaces)
char* dc_encode_modified_utf7(const char* to_encode, int change_spaces)
{
#define UTF16MASK 0x03FFUL
#define UTF16SHIFT 10
@ -641,7 +641,7 @@ char* mr_encode_modified_utf7(const char* to_encode, int change_spaces)
* for all other errors, an empty string is returned.
* NULL is never returned.
*/
char* mr_decode_modified_utf7(const char *to_decode, int change_spaces)
char* dc_decode_modified_utf7(const char *to_decode, int change_spaces)
{
unsigned c, i, bitcount;
unsigned long ucs4, utf16, bitbuf;
@ -758,9 +758,9 @@ char* mr_decode_modified_utf7(const char *to_decode, int change_spaces)
*
* @return 0=extended header encoding is not needed,
* 1=extended header encoding is needed,
* use mr_encode_ext_header() for this purpose.
* use dc_encode_ext_header() for this purpose.
*/
int mr_needs_ext_header(const char* to_check)
int dc_needs_ext_header(const char* to_check)
{
if( to_check ) {
while( *to_check )
@ -788,7 +788,7 @@ int mr_needs_ext_header(const char* to_check)
* for all other errors, an empty string is returned or just the given string is returned.
* NULL is never returned.
*/
char* mr_encode_ext_header(const char* to_encode)
char* dc_encode_ext_header(const char* to_encode)
{
#define PREFIX "utf-8''"
const char *pstr = to_encode;
@ -834,7 +834,7 @@ char* mr_encode_ext_header(const char* to_encode)
* for all other errors, an empty string is returned or just the given string is returned.
* NULL is never returned.
*/
char* mr_decode_ext_header(const char* to_decode)
char* dc_decode_ext_header(const char* to_decode)
{
char *decoded = NULL, *charset = NULL;
const char *p2 = NULL;
@ -849,7 +849,7 @@ char* mr_decode_ext_header(const char* to_decode)
goto cleanup;
}
charset = mr_null_terminate(to_decode, p2-to_decode);
charset = dc_null_terminate(to_decode, p2-to_decode);
p2++;
// skip language
@ -860,7 +860,7 @@ char* mr_decode_ext_header(const char* to_decode)
p2++;
// decode text
decoded = mr_urldecode(p2);
decoded = dc_urldecode(p2);
if( charset!=NULL && strcmp(charset, "utf-8")!=0 && strcmp(charset, "UTF-8")!=0 ) {
char* converted = NULL;

26
src/dc_strencode.h
View file

@ -20,29 +20,29 @@
******************************************************************************/
#ifndef __MRSTRENCODE_H__
#define __MRSTRENCODE_H__
#ifndef __DC_STRENCODE_H__
#define __DC_STRENCODE_H__
#ifdef __cplusplus
extern "C" {
#endif
char* mr_urlencode (const char*);
char* mr_urldecode (const char*);
char* dc_urlencode (const char*);
char* dc_urldecode (const char*);
char* mr_encode_header_words (const char*);
char* mr_decode_header_words (const char*);
char* dc_encode_header_words (const char*);
char* dc_decode_header_words (const char*);
char* mr_encode_modified_utf7 (const char*, int change_spaces);
char* mr_decode_modified_utf7 (const char*, int change_spaces);
char* dc_encode_modified_utf7 (const char*, int change_spaces);
char* dc_decode_modified_utf7 (const char*, int change_spaces);
int mr_needs_ext_header (const char*);
char* mr_encode_ext_header (const char*);
char* mr_decode_ext_header (const char*);
int dc_needs_ext_header (const char*);
char* dc_encode_ext_header (const char*);
char* dc_decode_ext_header (const char*);
#ifdef __cplusplus
} /* /extern "C" */
} // /extern "C"
#endif
#endif /* __MRSTRENCODE_H__ */
#endif // __DC_STRENCODE_H__

50
src/dc_tools.c
View file

@ -148,7 +148,7 @@ char* mr_strlower(const char* in) /* the result must be free()'d */
/*
* haystack may be realloc()'d, returns the number of replacements.
*/
int mr_str_replace(char** haystack, const char* needle, const char* replacement)
int dc_str_replace(char** haystack, const char* needle, const char* replacement)
{
int replacements = 0, start_search_pos = 0, needle_len, replacement_len;
@ -166,7 +166,7 @@ int mr_str_replace(char** haystack, const char* needle, const char* replacement)
*p2 = 0;
p2 += needle_len;
char* new_string = mr_mprintf("%s%s%s", *haystack, replacement? replacement : "", p2);
char* new_string = dc_mprintf("%s%s%s", *haystack, replacement? replacement : "", p2);
free(*haystack);
*haystack = new_string;
replacements++;
@ -211,7 +211,7 @@ int mr_str_contains(const char* haystack, const const char* needle)
* On memory-allocation errors, the program halts.
* On other errors, an empty string is returned.
*/
char* mr_null_terminate(const char* in, int bytes) /* the result must be free()'d */
char* dc_null_terminate(const char* in, int bytes) /* the result must be free()'d */
{
char* out = malloc(bytes+1);
if( out==NULL ) {
@ -264,7 +264,7 @@ cleanup:
}
char* mr_mprintf(const char* format, ...)
char* dc_mprintf(const char* format, ...)
{
char testbuf[1];
char* buf;
@ -366,7 +366,7 @@ void mr_unify_lineends(char* buf)
}
void mr_replace_bad_utf8_chars(char* buf)
void dc_replace_bad_utf8_chars(char* buf)
{
if( buf==NULL ) {
return;
@ -478,7 +478,7 @@ void mr_truncate_n_unwrap_str(char* buf, int approx_characters, int do_unwrap)
}
void mr_truncate_str(char* buf, int approx_chars)
void dc_truncate_str(char* buf, int approx_chars)
{
if( approx_chars > 0 && strlen(buf) > approx_chars+strlen(MR_EDITORIAL_ELLIPSE) )
{
@ -535,7 +535,7 @@ void mr_free_splitted_lines(carray* lines)
}
char* mr_insert_breaks(const char* in, int break_every, const char* break_chars)
char* dc_insert_breaks(const char* in, int break_every, const char* break_chars)
{
/* insert a space every n characters, the return must be free()'d.
this is useful to allow lines being wrapped according to RFC 5322 (adds linebreaks before spaces) */
@ -705,7 +705,7 @@ long mr_gm2local_offset(void)
}
char* mr_timestamp_to_str(time_t wanted)
char* dc_timestamp_to_str(time_t wanted)
{
struct tm wanted_struct;
memcpy(&wanted_struct, localtime(&wanted), sizeof(struct tm));
@ -717,7 +717,7 @@ char* mr_timestamp_to_str(time_t wanted)
memcpy(&curr_struct, localtime(&curr), sizeof(struct tm));
*/
return mr_mprintf("%02i.%02i.%04i %02i:%02i:%02i",
return dc_mprintf("%02i.%02i.%04i %02i:%02i:%02i",
(int)wanted_struct.tm_mday, (int)wanted_struct.tm_mon+1, (int)wanted_struct.tm_year+1900,
(int)wanted_struct.tm_hour, (int)wanted_struct.tm_min, (int)wanted_struct.tm_sec);
}
@ -834,7 +834,7 @@ static char* encode_66bits_as_base64(uint32_t v1, uint32_t v2, uint32_t fill /*o
}
char* mr_create_id(void)
char* dc_create_id(void)
{
/* generate an id. the generated ID should be as short and as unique as possible:
- short, because it may also used as part of Message-ID headers or in QR codes
@ -856,8 +856,8 @@ char* mr_create_id(void)
char* mr_create_dummy_references_mid()
{
char* msgid = mr_create_id(), *ret = NULL;
ret = mr_mprintf("Rf.%s@mr.thread", msgid);
char* msgid = dc_create_id(), *ret = NULL;
ret = dc_mprintf("Rf.%s@mr.thread", msgid);
free(msgid);
return ret;
}
@ -871,7 +871,7 @@ char* mr_create_outgoing_rfc724_mid(const char* grpid, const char* from_addr)
- do not add a counter or any private data as as this may give unneeded information to the receiver */
char* rand1 = NULL;
char* rand2 = mr_create_id();
char* rand2 = dc_create_id();
char* ret = NULL;
const char* at_hostname = strchr(from_addr, '@');
@ -880,12 +880,12 @@ char* mr_create_outgoing_rfc724_mid(const char* grpid, const char* from_addr)
}
if( grpid ) {
ret = mr_mprintf("Gr.%s.%s%s", grpid, rand2, at_hostname);
ret = dc_mprintf("Gr.%s.%s%s", grpid, rand2, at_hostname);
/* ^^^ `Gr.` must never change as this is used to identify group messages in normal-clients-replies. The dot is choosen as this is normally not used for random ID creation. */
}
else {
rand1 = mr_create_id();
ret = mr_mprintf("Mr.%s.%s%s", rand1, rand2, at_hostname);
rand1 = dc_create_id();
ret = dc_mprintf("Mr.%s.%s%s", rand1, rand2, at_hostname);
/* ^^^ `Mr.` is currently not used, however, this may change in future */
}
@ -918,7 +918,7 @@ char* mr_create_incoming_rfc724_mid(time_t message_timestamp, uint32_t contact_i
/* build a more or less unique string based on the timestamp and one receiver -
for our purposes, this seems "good enough" for the moment, esp. as clients normally set Message-ID on sent. */
return mr_mprintf("%lu-%lu-%lu@stub", (unsigned long)message_timestamp, (unsigned long)contact_id_from, (unsigned long)largest_id_to);
return dc_mprintf("%lu-%lu-%lu@stub", (unsigned long)message_timestamp, (unsigned long)contact_id_from, (unsigned long)largest_id_to);
}
@ -943,7 +943,7 @@ char* mr_extract_grpid_from_rfc724_mid(const char* mid)
#define MR_ALSO_VALID_ID_LEN 16 /* length returned by create_adhoc_grp_id__() */
grpid_len = strlen(grpid);
if( grpid_len!=MR_CREATE_ID_LEN && grpid_len!=MR_ALSO_VALID_ID_LEN ) { /* strict length comparison, the 'Gr.' magic is weak enough */
if( grpid_len!=DC_CREATE_ID_LEN && grpid_len!=MR_ALSO_VALID_ID_LEN ) { /* strict length comparison, the 'Gr.' magic is weak enough */
goto cleanup;
}
@ -1094,7 +1094,7 @@ int mr_create_folder(const char* pathNfilename, dc_context_t* log)
}
char* mr_get_filesuffix_lc(const char* pathNfilename)
char* dc_get_filesuffix_lc(const char* pathNfilename)
{
if( pathNfilename ) {
const char* p = strrchr(pathNfilename, '.'); /* use the last point, we're interesting the "main" type */
@ -1144,7 +1144,7 @@ void mr_validate_filename(char* filename)
}
char* mr_get_fine_pathNfilename(const char* folder, const char* desired_filenameNsuffix__)
char* dc_get_fine_pathNfilename(const char* folder, const char* desired_filenameNsuffix__)
{
char* ret = NULL, *filenameNsuffix, *basename = NULL, *dotNSuffix = NULL;
time_t now = time(NULL);
@ -1158,10 +1158,10 @@ char* mr_get_fine_pathNfilename(const char* folder, const char* desired_filename
for( i = 0; i < 1000 /*no deadlocks, please*/; i++ ) {
if( i ) {
time_t idx = i<100? i : now+i;
ret = mr_mprintf("%s/%s-%lu%s", folder, basename, (unsigned long)idx, dotNSuffix);
ret = dc_mprintf("%s/%s-%lu%s", folder, basename, (unsigned long)idx, dotNSuffix);
}
else {
ret = mr_mprintf("%s/%s%s", folder, basename, dotNSuffix);
ret = dc_mprintf("%s/%s%s", folder, basename, dotNSuffix);
}
if (stat(ret, &st) == -1) {
goto cleanup; /* fine filename found */
@ -1178,7 +1178,7 @@ cleanup:
}
int mr_write_file(const char* pathNfilename, const void* buf, size_t buf_bytes, dc_context_t* log)
int dc_write_file(const char* pathNfilename, const void* buf, size_t buf_bytes, dc_context_t* log)
{
int success = 0;
@ -1200,7 +1200,7 @@ int mr_write_file(const char* pathNfilename, const void* buf, size_t buf_bytes,
}
int mr_read_file(const char* pathNfilename, void** buf, size_t* buf_bytes, dc_context_t* log)
int dc_read_file(const char* pathNfilename, void** buf, size_t* buf_bytes, dc_context_t* log)
{
int success = 0;
@ -1241,7 +1241,7 @@ cleanup:
}
int mr_get_filemeta(const void* buf_start, size_t buf_bytes, uint32_t* ret_width, uint32_t *ret_height)
int dc_get_filemeta(const void* buf_start, size_t buf_bytes, uint32_t* ret_width, uint32_t *ret_height)
{
/* Strategy:
reading GIF dimensions requires the first 10 bytes of the file

30
src/dc_tools.h
View file

@ -51,19 +51,19 @@ void mr_rtrim (char*);
void mr_trim (char*);
char* mr_strlower (const char*); /* the result must be free()'d */
void mr_strlower_in_place (char*);
int mr_str_replace (char** haystack, const char* needle, const char* replacement);
int dc_str_replace (char** haystack, const char* needle, const char* replacement);
int mr_str_contains (const char* haystack, const char* needle);
char* mr_null_terminate (const char*, int bytes); /* the result must be free()'d */
char* mr_mprintf (const char* format, ...); /* The result must be free()'d. */
char* dc_null_terminate (const char*, int bytes); /* the result must be free()'d */
char* dc_mprintf (const char* format, ...); /* The result must be free()'d. */
char* mr_binary_to_uc_hex (const uint8_t* buf, size_t bytes);
void mr_remove_cr_chars (char*); /* remove all \r characters from string */
void mr_unify_lineends (char*);
void mr_replace_bad_utf8_chars (char*); /* replace bad UTF-8 characters by sequences of `_` (to avoid problems in filenames, we do not use eg. `?`) the function is useful if strings are unexpectingly encoded eg. as ISO-8859-1 */
void mr_truncate_str (char*, int approx_characters);
void dc_replace_bad_utf8_chars (char*); /* replace bad UTF-8 characters by sequences of `_` (to avoid problems in filenames, we do not use eg. `?`) the function is useful if strings are unexpectingly encoded eg. as ISO-8859-1 */
void dc_truncate_str (char*, int approx_characters);
void mr_truncate_n_unwrap_str (char*, int approx_characters, int do_unwrap);
carray* mr_split_into_lines (const char* buf_terminated); /* split string into lines*/
void mr_free_splitted_lines (carray* lines);
char* mr_insert_breaks (const char*, int break_every, const char* break_chars); /* insert a break every n characters, the return must be free()'d */
char* dc_insert_breaks (const char*, int break_every, const char* break_chars); /* insert a break every n characters, the return must be free()'d */
char* encode_base64 (const char * in, int len); /* prototype, from libetpan/src/data-types/base64.h which cannot be included without adding libetpan/src/... to the include-search-paths, which would result in double-file-name-errors */
@ -74,7 +74,7 @@ int clist_search_string_nocase (const clist*, const char* str);
/* date/time tools */
#define MR_INVALID_TIMESTAMP (-1)
time_t mr_timestamp_from_date (struct mailimf_date_time * date_time); /* the result is UTC or MR_INVALID_TIMESTAMP */
char* mr_timestamp_to_str (time_t); /* the return value must be free()'d */
char* dc_timestamp_to_str (time_t); /* the return value must be free()'d */
struct mailimap_date_time* mr_timestamp_to_mailimap_date_time (time_t);
long mr_gm2local_offset (void);
@ -84,8 +84,8 @@ time_t mr_create_smeared_timestamp__ (void);
time_t mr_create_smeared_timestamps__(int count);
/* Message-ID tools */
#define MR_CREATE_ID_LEN 11
char* mr_create_id (void);
#define DC_CREATE_ID_LEN 11
char* dc_create_id (void);
char* mr_create_dummy_references_mid (void);
char* mr_create_incoming_rfc724_mid (time_t message_timestamp, uint32_t contact_id_from, dc_array_t* contact_ids_to);
char* mr_create_outgoing_rfc724_mid (const char* grpid, const char* addr);
@ -100,17 +100,17 @@ char* mr_get_filename (const char* pathNfilename); /* the return v
int mr_delete_file (const char* pathNFilename, dc_context_t* log);
int mr_copy_file (const char* src_pathNFilename, const char* dest_pathNFilename, dc_context_t* log);
int mr_create_folder (const char* pathNfilename, dc_context_t* log);
int mr_write_file (const char* pathNfilename, const void* buf, size_t buf_bytes, dc_context_t* log);
int mr_read_file (const char* pathNfilename, void** buf, size_t* buf_bytes, dc_context_t* log);
char* mr_get_filesuffix_lc (const char* pathNfilename); /* the returned suffix is lower-case */
int dc_write_file (const char* pathNfilename, const void* buf, size_t buf_bytes, dc_context_t* log);
int dc_read_file (const char* pathNfilename, void** buf, size_t* buf_bytes, dc_context_t* log);
char* dc_get_filesuffix_lc (const char* pathNfilename); /* the returned suffix is lower-case */
void mr_split_filename (const char* pathNfilename, char** ret_basename, char** ret_all_suffixes_incl_dot); /* the case of the suffix is preserved! */
int mr_get_filemeta (const void* buf, size_t buf_bytes, uint32_t* ret_width, uint32_t *ret_height);
char* mr_get_fine_pathNfilename (const char* folder, const char* desired_name);
int dc_get_filemeta (const void* buf, size_t buf_bytes, uint32_t* ret_width, uint32_t *ret_height);
char* dc_get_fine_pathNfilename (const char* folder, const char* desired_name);
/* macros */
#define MR_QUOTEHELPER(name) #name
#define MR_STRINGIFY(macro) MR_QUOTEHELPER(macro)
#define DC_STRINGIFY(macro) MR_QUOTEHELPER(macro)
#define MR_MIN(X, Y) (((X) < (Y))? (X) : (Y))
#define MR_MAX(X, Y) (((X) > (Y))? (X) : (Y))