refactor cmdline, strbuilder, tools

cmdline/cmdline.h

@@ -20,8 +20,8 @@
  ******************************************************************************/
 
 
-#ifndef __MRCMDLINE_H__
+#ifndef __DC_CMDLINE_H__
-#define __MRCMDLINE_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,
+/* If the command line authorisation (see dc_cmdline()) is not desired, eg. for a command line client,
-you can skip this using mrmailbox_cmdline_skip_auth().*/
+you can skip this using dc_cmdline_skip_auth().*/
-void            mrmailbox_cmdline_skip_auth ();
+void            dc_cmdline_skip_auth ();
 
 
 #ifdef __cplusplus
-} /* /extern "C" */
+} // /extern "C"
 #endif
-#endif /* __MRCMDLINE_H__ */
+#endif // __DC_CMDLINE_H__

cmdline/main.c

@@ -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 DC_EVENT_GET_STRING:
-		case MR_EVENT_GET_QUANTITY_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* tempFile = dc_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* 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:
+		case DC_EVENT_IS_OFFLINE:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_IS_OFFLINE()}}\n" ANSI_NORMAL);
+			printf(ANSI_YELLOW "{{Received DC_EVENT_IS_OFFLINE()}}\n" ANSI_NORMAL);
 			break;
 
-		case MR_EVENT_MSGS_CHANGED:
+		case DC_EVENT_MSGS_CHANGED:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_MSGS_CHANGED(%i, %i)}}\n" ANSI_NORMAL, (int)data1, (int)data2);
+			printf(ANSI_YELLOW "{{Received DC_EVENT_MSGS_CHANGED(%i, %i)}}\n" ANSI_NORMAL, (int)data1, (int)data2);
 			break;
 
-		case MR_EVENT_CONTACTS_CHANGED:
+		case DC_EVENT_CONTACTS_CHANGED:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_CONTACTS_CHANGED()}}\n" ANSI_NORMAL);
+			printf(ANSI_YELLOW "{{Received DC_EVENT_CONTACTS_CHANGED()}}\n" ANSI_NORMAL);
 			break;
 
-		case MR_EVENT_CONFIGURE_PROGRESS:
+		case DC_EVENT_CONFIGURE_PROGRESS:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_CONFIGURE_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
+			printf(ANSI_YELLOW "{{Received DC_EVENT_CONFIGURE_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
 			break;
 
-		case MR_EVENT_IMEX_PROGRESS:
+		case DC_EVENT_IMEX_PROGRESS:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_IMEX_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
+			printf(ANSI_YELLOW "{{Received DC_EVENT_IMEX_PROGRESS(%i ‰)}}\n" ANSI_NORMAL, (int)data1);
 			break;
 
-		case MR_EVENT_IMEX_FILE_WRITTEN:
+		case DC_EVENT_IMEX_FILE_WRITTEN:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_IMEX_FILE_WRITTEN(%s)}}\n" ANSI_NORMAL, (char*)data1);
+			printf(ANSI_YELLOW "{{Received DC_EVENT_IMEX_FILE_WRITTEN(%s)}}\n" ANSI_NORMAL, (char*)data1);
 			break;
 
-		case MR_EVENT_CHAT_MODIFIED:
+		case DC_EVENT_CHAT_MODIFIED:
-			printf(ANSI_YELLOW "{{Received MR_EVENT_CHAT_MODIFIED(%i)}}\n" ANSI_NORMAL, (int)data1);
+			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);
+	dc_close(mailbox);
-	mrmailbox_unref(mailbox);
+	dc_context_unref(mailbox);
 	mailbox = NULL;
 	return 0;
 }

cmdline/stress.c

@@ -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("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="   MR_STRINGIFY(MR_STATE_IN_NOTICED),    "noticed=13")==0 );
+		assert( strcmp("noticed="   DC_STRINGIFY(DC_STATE_IN_NOTICED),    "noticed=13")==0 );
-		assert( strcmp("seen="      MR_STRINGIFY(MR_STATE_IN_SEEN),       "seen=16")==0 );
+		assert( strcmp("seen="      DC_STRINGIFY(DC_STATE_IN_SEEN),       "seen=16")==0 );
-		assert( strcmp("pending="   MR_STRINGIFY(MR_STATE_OUT_PENDING),   "pending=20")==0 );
+		assert( strcmp("pending="   DC_STRINGIFY(DC_STATE_OUT_PENDING),   "pending=20")==0 );
-		assert( strcmp("error="     MR_STRINGIFY(MR_STATE_OUT_ERROR),     "error=24")==0 );
+		assert( strcmp("error="     DC_STRINGIFY(DC_STATE_OUT_ERROR),     "error=24")==0 );
-		assert( strcmp("delivered=" MR_STRINGIFY(MR_STATE_OUT_DELIVERED), "delivered=26")==0 );
+		assert( strcmp("delivered=" DC_STRINGIFY(DC_STATE_OUT_DELIVERED), "delivered=26")==0 );
-		assert( strcmp("mdn_rcvd="  MR_STRINGIFY(MR_STATE_OUT_MDN_RCVD),  "mdn_rcvd=28")==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("undefined="    DC_STRINGIFY(DC_CHAT_TYPE_UNDEFINED),      "undefined=0")==0 );
-		assert( strcmp("single="       MR_STRINGIFY(MR_CHAT_TYPE_SINGLE),         "single=100")==0 );
+		assert( strcmp("single="       DC_STRINGIFY(DC_CHAT_TYPE_SINGLE),         "single=100")==0 );
-		assert( strcmp("group="        MR_STRINGIFY(MR_CHAT_TYPE_GROUP),          "group=120")==0 );
+		assert( strcmp("group="        DC_STRINGIFY(DC_CHAT_TYPE_GROUP),          "group=120")==0 );
-		assert( strcmp("vgroup="       MR_STRINGIFY(MR_CHAT_TYPE_VERIFIED_GROUP), "vgroup=130")==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("deaddrop="     DC_STRINGIFY(DC_CHAT_ID_DEADDROP),         "deaddrop=1")==0 );
-		assert( strcmp("trash="        MR_STRINGIFY(MR_CHAT_ID_TRASH),            "trash=3")==0 );
+		assert( strcmp("trash="        DC_STRINGIFY(DC_CHAT_ID_TRASH),            "trash=3")==0 );
-		assert( strcmp("in_creation="  MR_STRINGIFY(MR_CHAT_ID_MSGS_IN_CREATION), "in_creation=4")==0 );
+		assert( strcmp("in_creation="  DC_STRINGIFY(DC_CHAT_ID_MSGS_IN_CREATION), "in_creation=4")==0 );
-		assert( strcmp("starred="      MR_STRINGIFY(MR_CHAT_ID_STARRED),          "starred=5")==0 );
+		assert( strcmp("starred="      DC_STRINGIFY(DC_CHAT_ID_STARRED),          "starred=5")==0 );
-		assert( strcmp("archivedlink=" MR_STRINGIFY(MR_CHAT_ID_ARCHIVED_LINK),    "archivedlink=6")==0 );
+		assert( strcmp("archivedlink=" DC_STRINGIFY(DC_CHAT_ID_ARCHIVED_LINK),    "archivedlink=6")==0 );
-		assert( strcmp("spcl_chat="    MR_STRINGIFY(MR_CHAT_ID_LAST_SPECIAL),     "spcl_chat=9")==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("self="         DC_STRINGIFY(DC_CONTACT_ID_SELF),          "self=1")==0 );
-		assert( strcmp("spcl_contact=" MR_STRINGIFY(MR_CONTACT_ID_LAST_SPECIAL),  "spcl_contact=9")==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("notverified="    DC_STRINGIFY(MRV_NOT_VERIFIED),  "notverified=0")==0 );
-		assert( strcmp("bidirectional="  MR_STRINGIFY(MRV_BIDIRECTIONAL), "bidirectional=2")==0 );
+		assert( strcmp("bidirectional="  DC_STRINGIFY(MRV_BIDIRECTIONAL), "bidirectional=2")==0 );
 
-		assert( MRP_FILE == 'f' );
+		assert( strcmp("public="  DC_STRINGIFY(DC_KEY_PUBLIC), "public=0")==0 );
-		assert( MRP_WIDTH == 'w' );
+		assert( strcmp("private="  DC_STRINGIFY(DC_KEY_PRIVATE), "private=1")==0 );
-		assert( MRP_HEIGHT == 'h' );
+
-		assert( MRP_DURATION == 'd' );
+		assert( DC_PARAM_FILE == 'f' );
-		assert( MRP_MIMETYPE == 'm' );
+		assert( DC_PARAM_WIDTH == 'w' );
-		assert( MRP_AUTHORNAME == 'N' );
+		assert( DC_PARAM_HEIGHT == 'h' );
-		assert( MRP_TRACKNAME == 'n' );
+		assert( DC_PARAM_DURATION == 'd' );
-		assert( MRP_FORWARDED == 'a' );
+		assert( DC_PARAM_MIMETYPE == 'm' );
-		assert( MRP_UNPROMOTED == 'U' );
+		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();
+		buf1 = dc_create_id();
-		assert( strlen(buf1) == MR_CREATE_ID_LEN );
+		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(  dc_needs_ext_header("Björn") );
-		assert( !mr_needs_ext_header("Bjoern") );
+		assert( !dc_needs_ext_header("Bjoern") );
-		assert( !mr_needs_ext_header("") );
+		assert( !dc_needs_ext_header("") );
-		assert(  mr_needs_ext_header(" ") );
+		assert(  dc_needs_ext_header(" ") );
-		assert(  mr_needs_ext_header("a b") );
+		assert(  dc_needs_ext_header("a b") );
-		assert( !mr_needs_ext_header(NULL) );
+		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);
+		dc_array_t* arr = dc_array_new(NULL, 7);
-		assert( mrarray_get_cnt(arr) == 0 );
+		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( dc_array_get_id(arr, -1) == 0 ); /* test out-of-range access */
-		assert( mrarray_get_id(arr, TEST_CNT) == 0 ); /* test out-of-range access */
+		assert( dc_array_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, 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( dc_param_get_int(p1, 'a', 0)==1 );
-		assert( mrparam_get_int(p1, 'b', 0)==2 );
+		assert( dc_param_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( 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( mrparam_exists (p1, 'c')==0 );
+		assert( dc_param_exists (p1, 'c')==0 );
 
-		mrparam_set_int(p1, 'd', 4);
+		dc_param_set_int(p1, 'd', 4);
-		assert( mrparam_get_int(p1, 'd', 0)==4 );
+		assert( dc_param_get_int(p1, 'd', 0)==4 );
 
-		mrparam_empty(p1);
+		dc_param_empty(p1);
-		mrparam_set    (p1, 'a', "foo");
+		dc_param_set    (p1, 'a', "foo");
-		mrparam_set_int(p1, 'b', 2);
+		dc_param_set_int(p1, 'b', 2);
-		mrparam_set    (p1, 'c', NULL);
+		dc_param_set    (p1, 'c', NULL);
-		mrparam_set_int(p1, 'd', 4);
+		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);
+		dc_param_set    (p1, 'a', NULL);
-		mrparam_set    (p1, 'd', 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(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);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(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);
 	}

src/dc_aheader.c

@@ -66,22 +66,22 @@ char* dc_aheader_render(const dc_aheader_t* ths)
 {
 	int            success = 0;
 	char*          keybase64_wrapped = NULL;
-	mrstrbuilder_t ret;
+	dc_strbuilder_t ret;
-	mrstrbuilder_init(&ret, 0);
+	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=");
+	dc_strbuilder_cat(&ret, "addr=");
-	mrstrbuilder_cat(&ret, ths->m_addr);
+	dc_strbuilder_cat(&ret, ths->m_addr);
-	mrstrbuilder_cat(&ret, "; ");
+	dc_strbuilder_cat(&ret, "; ");
 
-	if( ths->m_prefer_encrypt==MRA_PE_MUTUAL ) {
+	if( ths->m_prefer_encrypt==DC_PE_MUTUAL ) {
-		mrstrbuilder_cat(&ret, "prefer-encrypt=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;

src/dc_apeerstate.c

@@ -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;
 			}
 

src/dc_apeerstate.h

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

src/dc_array.c

@@ -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;

src/dc_array.h

@@ -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

src/dc_chat.c

@@ -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);
 	}

src/dc_chat.h

@@ -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. */
 };
 
 

src/dc_chatlist.c

@@ -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);

src/dc_configure.c

@@ -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);
+	dc_str_replace(&val, "%EMAILADDRESS%",   moz_ac->m_in->m_addr);
-	mr_str_replace(&val, "%EMAILLOCALPART%", moz_ac->m_in_emaillocalpart);
+	dc_str_replace(&val, "%EMAILLOCALPART%", moz_ac->m_in_emaillocalpart);
-	mr_str_replace(&val, "%EMAILDOMAIN%",    moz_ac->m_in_emaildomain);
+	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 ) {

src/dc_contact.c

@@ -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);

src/dc_context.c

@@ -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;
+	dc_strbuilder_t  ret;
-	mrstrbuilder_init(&ret, 0);
+	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);
+				temp = dc_mprintf("\n%02i:%02i:%02i ", (int)wanted_struct.tm_hour, (int)wanted_struct.tm_min, (int)wanted_struct.tm_sec);
-					mrstrbuilder_cat(&ret, temp);
+					dc_strbuilder_cat(&ret, temp);
-					mrstrbuilder_cat(&ret, context->m_log_ringbuf[j]);
+					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);
+	strLikeInText = dc_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). */
+	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();
+		dc_param_t* msg_param = dc_param_new();
-		mrparam_set_packed(msg_param, (char*)sqlite3_column_text(stmt, 0));
+		dc_param_set_packed(msg_param, (char*)sqlite3_column_text(stmt, 0));
-		if( mrparam_exists(msg_param, MRP_GUARANTEE_E2EE) ) {
+		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( dc_read_file(pathNfilename, (void**)&buf, &buf_bytes, msg->m_context) ) {
-					if( mr_get_filemeta(buf, buf_bytes, &w, &h) ) {
+					if( dc_get_filemeta(buf, buf_bytes, &w, &h) ) {
-						mrparam_set_int(msg->m_param, MRP_WIDTH, w);
+						dc_param_set_int(msg->m_param, DC_PARAM_WIDTH, w);
-						mrparam_set_int(msg->m_param, MRP_HEIGHT, h);
+						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* author = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, "");
-				char* title = mrparam_get(msg->m_param, MRP_TRACKNAME, "");
+				char* title = dc_param_get(msg->m_param, DC_PARAM_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 */
+				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);
+	dc_param_set    (msg->m_param, DC_PARAM_FILE,   file);
-	mrparam_set_int(msg->m_param, MRP_WIDTH,  width);  /* set in sending job, if 0 */
+	dc_param_set_int(msg->m_param, DC_PARAM_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_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);
+	dc_param_set    (msg->m_param, DC_PARAM_FILE,     file);
-	mrparam_set    (msg->m_param, MRP_MIMETYPE, filemime);
+	dc_param_set    (msg->m_param, DC_PARAM_MIMETYPE, filemime);
-	mrparam_set_int(msg->m_param, MRP_WIDTH,    width);
+	dc_param_set_int(msg->m_param, DC_PARAM_WIDTH,    width);
-	mrparam_set_int(msg->m_param, MRP_HEIGHT,   height);
+	dc_param_set_int(msg->m_param, DC_PARAM_HEIGHT,   height);
-	mrparam_set_int(msg->m_param, MRP_DURATION, duration);
+	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);
+	dc_param_set    (msg->m_param, DC_PARAM_FILE,     file);
-	mrparam_set    (msg->m_param, MRP_MIMETYPE, filemime);
+	dc_param_set    (msg->m_param, DC_PARAM_MIMETYPE, filemime);
-	mrparam_set_int(msg->m_param, MRP_DURATION, duration);
+	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);
+	dc_param_set    (msg->m_param, DC_PARAM_FILE,       file);
-	mrparam_set    (msg->m_param, MRP_MIMETYPE,   filemime);
+	dc_param_set    (msg->m_param, DC_PARAM_MIMETYPE,   filemime);
-	mrparam_set_int(msg->m_param, MRP_DURATION,   duration);
+	dc_param_set_int(msg->m_param, DC_PARAM_DURATION,   duration);
-	mrparam_set    (msg->m_param, MRP_AUTHORNAME, author);
+	dc_param_set    (msg->m_param, DC_PARAM_AUTHORNAME, author);
-	mrparam_set    (msg->m_param, MRP_TRACKNAME,  trackname);
+	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);
+	dc_param_set(msg->m_param, DC_PARAM_FILE,     file);
-	mrparam_set(msg->m_param, MRP_MIMETYPE, filemime);
+	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);
+		dc_param_set_int(msg->m_param, DC_PARAM_CMD,       MR_CMD_GROUPIMAGE_CHANGED);
-		mrparam_set    (msg->m_param, MRP_CMD_PARAM, new_image);
+		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);
+		dc_param_set_int(msg->m_param, DC_PARAM_CMD,       MR_CMD_MEMBER_ADDED_TO_GROUP);
-		mrparam_set    (msg->m_param, MRP_CMD_PARAM, contact->m_addr);
+		dc_param_set    (msg->m_param, DC_PARAM_CMD_ARG ,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_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);
+			dc_param_set_int(msg->m_param, DC_PARAM_CMD,       MR_CMD_MEMBER_REMOVED_FROM_GROUP);
-			mrparam_set    (msg->m_param, MRP_CMD_PARAM, contact->m_addr);
+			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");
+	dc_strbuilder_cat(ret, "\n\n");
-	mrstrbuilder_cat(ret, addr);
+	dc_strbuilder_cat(ret, addr);
-	mrstrbuilder_cat(ret, ":\n");
+	dc_strbuilder_cat(ret, ":\n");
-	mrstrbuilder_cat(ret, (fingerprint_verified&&fingerprint_verified[0])? fingerprint_verified : fingerprint_unverified);
+	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");
+		dc_strbuilder_cat(ret, "\n\n");
-		mrstrbuilder_cat(ret, addr);
+		dc_strbuilder_cat(ret, addr);
-		mrstrbuilder_cat(ret, " (alternative):\n");
+		dc_strbuilder_cat(ret, " (alternative):\n");
-		mrstrbuilder_cat(ret, fingerprint_unverified);
+		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;
+	dc_strbuilder_t  ret;
-	mrstrbuilder_init(&ret, 0);
+	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, " ");
+		dc_strbuilder_cat(&ret, " ");
-		p = mrstock_str(MR_STR_FINGERPRINTS); mrstrbuilder_cat(&ret, p); free(p);
+		p = mrstock_str(MR_STR_FINGERPRINTS); dc_strbuilder_cat(&ret, p); free(p);
-		mrstrbuilder_cat(&ret, ":");
+		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)
+		" WHERE m.id>" DC_STRINGIFY(MR_MSG_ID_LAST_SPECIAL)
-		" 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;");
 	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: ");
+		dc_strbuilder_cat(&ret, "Sent: ");
-		p = mr_timestamp_to_str(dc_msg_get_timestamp(msg)); mrstrbuilder_cat(&ret, p); free(p);
+		p = dc_timestamp_to_str(dc_msg_get_timestamp(msg)); dc_strbuilder_cat(&ret, p); free(p);
-		mrstrbuilder_cat(&ret, "\n");
+		dc_strbuilder_cat(&ret, "\n");
 
 		if( msg->m_from_id != MR_CONTACT_ID_SELF ) {
-			mrstrbuilder_cat(&ret, "Received: ");
+			dc_strbuilder_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);
+			p = dc_timestamp_to_str(msg->m_timestamp_rcvd? msg->m_timestamp_rcvd : msg->m_timestamp); dc_strbuilder_cat(&ret, p); free(p);
-			mrstrbuilder_cat(&ret, "\n");
+			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: ");
+			dc_strbuilder_cat(&ret, "Read: ");
-			p = mr_timestamp_to_str(sqlite3_column_int64(stmt, 1)); mrstrbuilder_cat(&ret, p); free(p);
+			p = dc_timestamp_to_str(sqlite3_column_int64(stmt, 1)); dc_strbuilder_cat(&ret, p); free(p);
-			mrstrbuilder_cat(&ret, " by ");
+			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: ");
+		dc_strbuilder_cat(&ret, "Sender: ");
-		p = dc_contact_get_name_n_addr(contact_from); mrstrbuilder_cat(&ret, p); free(p);
+		p = dc_contact_get_name_n_addr(contact_from); dc_strbuilder_cat(&ret, p); free(p);
-		mrstrbuilder_cat(&ret, "\n");
+		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");
+		dc_strbuilder_cat(&ret, "\n");
-		mrstrbuilder_cat(&ret, rawtxt);
+		dc_strbuilder_cat(&ret, rawtxt);
-		mrstrbuilder_cat(&ret, "\n");
+		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);
+			dc_param_set_int(msg->m_param, DC_PARAM_FORWARDED, 1);
-			mrparam_set    (msg->m_param, MRP_GUARANTEE_E2EE, NULL);
+			dc_param_set    (msg->m_param, DC_PARAM_GUARANTEE_E2EE, NULL);
-			mrparam_set    (msg->m_param, MRP_FORCE_PLAINTEXT, 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;

src/dc_dehtml.c

@@ -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, "](");
+			dc_strbuilder_cat(&dehtml->m_strbuilder, "](");
-			mrstrbuilder_cat(&dehtml->m_strbuilder, dehtml->m_last_href);
+			dc_strbuilder_cat(&dehtml->m_strbuilder, dehtml->m_last_href);
-			mrstrbuilder_cat(&dehtml->m_strbuilder, ")");
+			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);

src/dc_e2ee.c

@@ -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);
+		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(mr_encode_header_words(subject_str));
+		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;

src/dc_imap.c

@@ -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* key = dc_mprintf("imap.mailbox.%s", folder);
-	char* val = mr_mprintf("%lu:%lu", uidvalidity, lastseenuid);
+	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;
+		dc_strbuilder_t capinfostr;
-		mrstrbuilder_init(&capinfostr, 0);
+		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, " ");
+					dc_strbuilder_cat(&capinfostr, " ");
-					mrstrbuilder_cat(&capinfostr, cap->cap_data.cap_name);
+					dc_strbuilder_cat(&capinfostr, cap->cap_data.cap_name);
 				}
 			}
 		}

src/dc_imex.c

@@ -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);
+		dc_str_replace(&setup_message_body, "\r", NULL);
-		mr_str_replace(&setup_message_body, "\n", "<br>");
+		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;
+	dc_strbuilder_t out;
-	mrstrbuilder_init(&out, 0);
+	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
+	if( (setup_file_name=dc_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) ) {
+	 || !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);
+	dc_param_set    (msg->m_param, DC_PARAM_FILE,              setup_file_name);
-	mrparam_set    (msg->m_param, MRP_MIMETYPE,          "application/autocrypt-setup");
+	dc_param_set    (msg->m_param, DC_PARAM_MIMETYPE,          "application/autocrypt-setup");
-	mrparam_set_int(msg->m_param, MRP_CMD,               MR_CMD_AUTOCRYPT_SETUP_MESSAGE);
+	dc_param_set_int(msg->m_param, DC_PARAM_CMD,               MR_CMD_AUTOCRYPT_SETUP_MESSAGE);
-	mrparam_set_int(msg->m_param, MRP_FORCE_PLAINTEXT,   MRFP_NO_AUTOCRYPT_HEADER);
+	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(public_key,  stmt, 1, DC_KEY_PUBLIC);
-			dc_key_set_from_stmt(private_key, stmt, 2, MR_PRIVATE);
+			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);
+			pathNfilename = dc_mprintf("%s/%s", context->m_blobdir, file_name);
-			if( !mr_write_file(pathNfilename, file_content, file_bytes, context) ) {
+			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( 'f' == DC_PARAM_FILE );
-		assert( 'i' == MRP_PROFILE_IMAGE );
+		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

src/dc_job.c

@@ -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);
+	char*    server_folder = dc_param_get    (job->m_param, DC_PARAM_SERVER_FOLDER, NULL);
-	uint32_t server_uid    = mrparam_get_int(job->m_param, MRP_SERVER_UID, 0);
+	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 ) {
+		if( mimefactory.m_out_encrypted && dc_param_get_int(mimefactory.m_msg->m_param, DC_PARAM_GUARANTEE_E2EE, 0)==0 ) {
-			mrparam_set_int(mimefactory.m_msg->m_param, MRP_GUARANTEE_E2EE, 1); /* can upgrade to E2EE - fine! */
+			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
+		 && dc_param_get(mimefactory.m_chat->m_param, DC_PARAM_SELFTALK, 0)==0
-		 && mrparam_get_int(mimefactory.m_msg->m_param, MRP_CMD, 0)!=MR_CMD_SECUREJOIN_MESSAGE ) {
+		 && 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;
+			int tries = dc_param_get_int(job.m_param, DC_PARAM_TIMES, 0) + 1;
-			mrparam_set_int(job.m_param, MRP_TIMES, tries);
+			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);
 }
 

src/dc_job.h

@@ -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;
 

src/dc_key.c

@@ -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",
+	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==MR_PUBLIC? "PUBLIC" : "PRIVATE",
+		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;
+	dc_strbuilder_t ret;
-	mrstrbuilder_init(&ret, 0);
+	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;
+	dc_strbuilder_t out;
-	mrstrbuilder_init(&out, 0);
+	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++;
 	}

src/dc_key.h

@@ -30,8 +30,8 @@ extern "C" {
 typedef struct sqlite3_stmt sqlite3_stmt;
 
 
-#define MR_PUBLIC  0
+#define DC_KEY_PUBLIC  0
-#define MR_PRIVATE 1
+#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*);
 

src/dc_keyring.c

@@ -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 */

src/dc_log.c

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

src/dc_loginparam.c

@@ -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;
+	dc_strbuilder_t strbuilder;
-	mrstrbuilder_init(&strbuilder, 0);
+	dc_strbuilder_init(&strbuilder, 0);
-	#define CAT_FLAG(f, s) if( (1<<bit)==(f) ) { mrstrbuilder_cat(&strbuilder, (s)); flag_added = 1; }
+	#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,

src/dc_mimefactory.c

@@ -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* pathNfilename = dc_param_get(msg->m_param, DC_PARAM_FILE, NULL);
-	char* mimetype = mrparam_get(msg->m_param, MRP_MIMETYPE, NULL);
+	char* mimetype = dc_param_get(msg->m_param, DC_PARAM_MIMETYPE, NULL);
-	char* suffix = mr_get_filesuffix_lc(pathNfilename);
+	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* author = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, NULL);
-		char* title = mrparam_get(msg->m_param, MRP_TRACKNAME, 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 ) {
+			if( (force_plaintext = dc_param_get_int(factory->m_msg->m_param, DC_PARAM_FORCE_PLAINTEXT, 0)) == 0 ) {
-				e2ee_guaranteed = mrparam_get_int(factory->m_msg->m_param, MRP_GUARANTEE_E2EE, 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;
 

src/dc_mimeparser.c

@@ -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) ) {
+		if( dc_get_filemeta(decoded_data, decoded_data_bytes, &w, &h) ) {
-			mrparam_set_int(part->m_param, MRP_WIDTH, w);
+			dc_param_set_int(part->m_param, DC_PARAM_WIDTH, w);
-			mrparam_set_int(part->m_param, MRP_HEIGHT, h);
+			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);
+		dc_param_set(part->m_param, DC_PARAM_AUTHORNAME, author);
-		mrparam_set(part->m_param, MRP_TRACKNAME, title);
+		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;
+				dc_strbuilder_t filename_parts;
-				mrstrbuilder_init(&filename_parts, 0);
+				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 */
+				dc_param_set(part->m_param, DC_PARAM_AUTHORNAME, NULL); /* remove unneeded information */
-				mrparam_set(part->m_param, MRP_TRACKNAME, NULL);
+				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);

src/dc_mimeparser.h

@@ -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;
 

src/dc_msg.c

@@ -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_text1 = dc_param_get(msg->m_param, DC_PARAM_AUTHORNAME, NULL);
-		ret->m_text2 = mrparam_get(msg->m_param, MRP_TRACKNAME, 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 */
+			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 = mrparam_get(param, MRP_FILE, "ErrFilename");
+				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);

src/dc_msg.h

@@ -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);

src/dc_param.c

@@ -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);
 }

src/dc_param.h

@@ -20,8 +20,8 @@
  ******************************************************************************/
 
 
-#ifndef __MRPARAM_H__
+#ifndef __DC_PARAM_H__
-#define __MRPARAM_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 DC_PARAM_FILE              'f'  /* for msgs */
-#define MRP_WIDTH             'w'  /* for msgs */
+#define DC_PARAM_WIDTH             'w'  /* for msgs */
-#define MRP_HEIGHT            'h'  /* for msgs */
+#define DC_PARAM_HEIGHT            'h'  /* for msgs */
-#define MRP_DURATION          'd'  /* for msgs */
+#define DC_PARAM_DURATION          'd'  /* for msgs */
-#define MRP_MIMETYPE          'm'  /* for msgs */
+#define DC_PARAM_MIMETYPE          'm'  /* for msgs */
-#define MRP_AUTHORNAME        'N'  /* for msgs: name of author or artist */
+#define DC_PARAM_AUTHORNAME        'N'  /* for msgs: name of author or artist */
-#define MRP_TRACKNAME         'n'  /* for msgs: name of author or artist */
+#define DC_PARAM_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 DC_PARAM_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 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 MRP_FORCE_PLAINTEXT   'u'  /* for msgs: force unencrypted message, either MRFP_ADD_AUTOCRYPT_HEADER (1), MRFP_NO_AUTOCRYPT_HEADER (2) or 0 */
+#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 MRP_WANTS_MDN         'r'  /* for msgs: an incoming message which requestes a MDN (aka read receipt) */
+#define DC_PARAM_WANTS_MDN         'r'  /* for msgs: an incoming message which requestes a MDN (aka read receipt) */
-#define MRP_FORWARDED         'a'  /* for msgs */
+#define DC_PARAM_FORWARDED         'a'  /* for msgs */
-#define MRP_CMD               'S'  /* for msgs */
+#define DC_PARAM_CMD               'S'  /* for msgs */
-#define MRP_CMD_PARAM         'E'  /* for msgs */
+#define DC_PARAM_CMD_ARG           'E'  /* for msgs */
-#define MRP_CMD_PARAM2        'F'  /* for msgs */
+#define DC_PARAM_CMD_ARG2          'F'  /* for msgs */
-#define MRP_CMD_PARAM3        'G'  /* for msgs */
+#define DC_PARAM_CMD_ARG3          'G'  /* for msgs */
-#define MRP_CMD_PARAM4        'H'  /* for msgs */
+#define DC_PARAM_CMD_ARG4          'H'  /* for msgs */
 
-#define MRP_SERVER_FOLDER     'Z'  /* for jobs */
+#define DC_PARAM_SERVER_FOLDER     'Z'  /* for jobs */
-#define MRP_SERVER_UID        'z'  /* for jobs */
+#define DC_PARAM_SERVER_UID        'z'  /* for jobs */
-#define MRP_TIMES             't'  /* for jobs: times a job was tried */
+#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 DC_PARAM_REFERENCES        'R'  /* for groups and chats: References-header last used for a chat */
-#define MRP_UNPROMOTED        'U'  /* for groups */
+#define DC_PARAM_UNPROMOTED        'U'  /* for groups */
-#define MRP_PROFILE_IMAGE     'i'  /* for groups and contacts */
+#define DC_PARAM_PROFILE_IMAGE     'i'  /* for groups and contacts */
-#define MRP_SELFTALK          'K'  /* for chats */
+#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);
+int             dc_param_exists         (dc_param_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. */
+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         mrparam_get_int        (mrparam_t*, int key, int32_t def);
+int32_t         dc_param_get_int        (dc_param_t*, int key, int32_t def);
-void            mrparam_set            (mrparam_t*, int key, const char* value);
+void            dc_param_set            (dc_param_t*, int key, const char* value);
-void            mrparam_set_int        (mrparam_t*, int key, int32_t value);
+void            dc_param_set_int        (dc_param_t*, int key, int32_t value);
 
 /* library-private */
-mrparam_t*      mrparam_new            ();
+dc_param_t*     dc_param_new            ();
-void            mrparam_empty          (mrparam_t*);
+void            dc_param_empty          (dc_param_t*);
-void            mrparam_unref          (mrparam_t*);
+void            dc_param_unref          (dc_param_t*);
-void            mrparam_set_packed     (mrparam_t*, const char*);
+void            dc_param_set_packed     (dc_param_t*, const char*);
-void            mrparam_set_urlencoded (mrparam_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__

src/dc_pgp.c

@@ -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_public_key, pubmem->buf, pubmem->length, DC_KEY_PUBLIC);
-	dc_key_set_from_binary(ret_private_key, secmem->buf, secmem->length, MR_PRIVATE);
+	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;
 

src/dc_qr.c

@@ -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();
+			dc_param_t* param = dc_param_new();
-			mrparam_set_urlencoded(param, fragment);
+			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);
+				invitenumber  = dc_param_get(param, 'i', NULL);
-				auth          = mrparam_get(param, 's', 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);

src/dc_receive_imf.c

@@ -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 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!=" 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 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, ","); }
+		if( i ) { dc_strbuilder_cat(&member_cs, ","); }
-		mrstrbuilder_cat(&member_cs, (const char*)dc_array_get_ptr(member_addrs, i));
+		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);

src/dc_securejoin.c

@@ -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);
+	dc_param_set_int(msg->m_param, DC_PARAM_CMD,       MR_CMD_SECUREJOIN_MESSAGE);
-	mrparam_set    (msg->m_param, MRP_CMD_PARAM, step);
+	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_addr_urlencoded = dc_urlencode(self_addr);
-	self_name_urlencoded = mr_urlencode(self_name);
+	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);
+		group_name_urlencoded = dc_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);
+		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:

src/dc_simplify.c

@@ -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;
+	dc_strbuilder_t ret;
-	mrstrbuilder_init(&ret, strlen(buf_terminated));
+	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);

src/dc_sqlite3.c

@@ -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;
     }

src/dc_stock.c

@@ -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_MEMBER:                return dc_mprintf("%i member(s)", qty);
-		case MR_STR_CONTACT:               return mr_mprintf("%i contact(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);
+	dc_str_replace(&p1, "%1$s", to_insert);
-	mr_str_replace(&p1, "%2$s", to_insert2);
+	dc_str_replace(&p1, "%2$s", to_insert2);
 	return p1;
 }
 

src/dc_strbuilder.c

@@ -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
+ * You can add data to the string-buffer using eg. dc_strbuilder_cat() or
- * mrstrbuilder_catf() - the buffer is reallocated as needed.
+ * 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! */;

src/dc_strbuilder.h

@@ -20,30 +20,30 @@
  ******************************************************************************/
 
 
-#ifndef __MRSTRBUILDER_H__
+#ifndef __DC_STRBUILDER_H__
-#define __MRSTRBUILDER_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);
+void  dc_strbuilder_init    (dc_strbuilder_t*, int init_bytes);
-char* mrstrbuilder_cat     (mrstrbuilder_t* ths, const char* text);
+char* dc_strbuilder_cat     (dc_strbuilder_t*, const char* text);
-void  mrstrbuilder_catf    (mrstrbuilder_t* ths, const char* format, ...);
+void  dc_strbuilder_catf    (dc_strbuilder_t*, const char* format, ...);
-void  mrstrbuilder_empty   (mrstrbuilder_t* ths);
+void  dc_strbuilder_empty   (dc_strbuilder_t*);
 
 
 #ifdef __cplusplus
-} /* /extern "C" */
+} // /extern "C"
 #endif
-#endif /* __MRSTRBUILDER_H__ */
+#endif // __DC_STRBUILDER_H__
 

src/dc_strencode.c

@@ -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;

src/dc_strencode.h

@@ -20,29 +20,29 @@
  ******************************************************************************/
 
 
-#ifndef __MRSTRENCODE_H__
+#ifndef __DC_STRENCODE_H__
-#define __MRSTRENCODE_H__
+#define __DC_STRENCODE_H__
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
-char*   mr_urlencode              (const char*);
+char*   dc_urlencode              (const char*);
-char*   mr_urldecode              (const char*);
+char*   dc_urldecode              (const char*);
 
-char*   mr_encode_header_words    (const char*);
+char*   dc_encode_header_words    (const char*);
-char*   mr_decode_header_words    (const char*);
+char*   dc_decode_header_words    (const char*);
 
-char*   mr_encode_modified_utf7   (const char*, int change_spaces);
+char*   dc_encode_modified_utf7   (const char*, int change_spaces);
-char*   mr_decode_modified_utf7   (const char*, int change_spaces);
+char*   dc_decode_modified_utf7   (const char*, int change_spaces);
 
-int     mr_needs_ext_header       (const char*);
+int     dc_needs_ext_header       (const char*);
-char*   mr_encode_ext_header      (const char*);
+char*   dc_encode_ext_header      (const char*);
-char*   mr_decode_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__
 

src/dc_tools.c

@@ -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;
+	char* msgid = dc_create_id(), *ret = NULL;
-	ret = mr_mprintf("Rf.%s@mr.thread", msgid);
+	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();
+		rand1 = dc_create_id();
-		ret = mr_mprintf("Mr.%s.%s%s", rand1, rand2, at_hostname);
+		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

src/dc_tools.h

@@ -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*   dc_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_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    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    mr_truncate_str            (char*, int approx_characters);
+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
+#define DC_CREATE_ID_LEN                   11
-char* mr_create_id                         (void);
+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      dc_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);
+int      dc_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 */
+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);
+int      dc_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);
+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))