diff --git a/mms-engine/main.c b/mms-engine/main.c
index 42ebc3f..b3e0c61 100644
--- a/mms-engine/main.c
+++ b/mms-engine/main.c
@@ -9,7 +9,7 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
@@ -51,6 +51,7 @@ typedef struct mms_app_dbus_policy {
 #define MMS_ENGINE_DBUS_METHOD_RECEIVE_MESSAGE  "receiveMessage"
 #define MMS_ENGINE_DBUS_METHOD_SEND_READ_REPORT "sendReadReport"
 #define MMS_ENGINE_DBUS_METHOD_SEND_MESSAGE     "sendMessage"
+#define MMS_ENGINE_DBUS_METHOD_SEND_MESSAGE_FD  "sendMessageFd"
 #define MMS_ENGINE_DBUS_METHOD_PUSH             "push"
 #define MMS_ENGINE_DBUS_METHOD_PUSH_NOTIFY      "pushNotify"
 #define MMS_ENGINE_DBUS_METHOD_SET_LOG_LEVEL    "setLogLevel"
@@ -60,8 +61,8 @@ typedef struct mms_app_dbus_policy {
 #define MMS_ENGINE_DBUS_METHOD_EXIT             "exit"
 
 static const DA_ACTION mms_engine_dbus_actions[] = {
-    #define INIT_DA_ACTION(id) \
-        {MMS_ENGINE_DBUS_METHOD_##id, MMS_ENGINE_ACTION_##id, 0},
+    #define INIT_DA_ACTION(ID,id,name) \
+        {MMS_ENGINE_DBUS_METHOD_##ID, MMS_ENGINE_ACTION_##ID, 0},
     MMS_ENGINE_DBUS_METHODS(INIT_DA_ACTION)
     #undef INIT_DA_ACTION
     { NULL }
@@ -73,6 +74,7 @@ static const MMSAppDBusPolicy mms_engine_default_dbus_policy = {
     MMS_ENGINE_DBUS_METHOD_RECEIVE_MESSAGE "()|"
     MMS_ENGINE_DBUS_METHOD_SEND_READ_REPORT"()|"
     MMS_ENGINE_DBUS_METHOD_SEND_MESSAGE"()|"
+    MMS_ENGINE_DBUS_METHOD_SEND_MESSAGE_FD"()|"
     MMS_ENGINE_DBUS_METHOD_SET_LOG_LEVEL"()|"
     MMS_ENGINE_DBUS_METHOD_SET_LOG_TYPE"()|"
     MMS_ENGINE_DBUS_METHOD_MIGRATE_SETTINGS"()|"
diff --git a/mms-engine/mms_engine.c b/mms-engine/mms_engine.c
index f3f60d8..4a2216e 100644
--- a/mms-engine/mms_engine.c
+++ b/mms-engine/mms_engine.c
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2013-2020 Jolla Ltd.
  * Copyright (C) 2013-2020 Slava Monich <slava.monich@jolla.com>
- * Copyright (C) 2019 Open Mobile Platform LLC.
+ * Copyright (C) 2019-2020 Open Mobile Platform LLC.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -9,13 +9,14 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
 #include "mms_engine.h"
 #include "mms_log.h"
 
+#include "mms_attachment_info.h"
 #include "mms_dispatcher.h"
 #include "mms_settings.h"
 #include "mms_lib_util.h"
@@ -43,9 +44,11 @@
 #include <gutil_misc.h>
 #include <gutil_log.h>
 
+#include <gio/gunixfdlist.h>
+
 /* D-Bus proxy Signals */
 enum mms_engine_dbus_methods {
-    #define MMS_ENGINE_METHOD_(id) MMS_ENGINE_METHOD_##id,
+    #define MMS_ENGINE_METHOD_(ID,id,name) MMS_ENGINE_METHOD_##ID,
     MMS_ENGINE_DBUS_METHODS(MMS_ENGINE_METHOD_)
     #undef MMS_ENGINE_METHOD_
     MMS_ENGINE_METHOD_COUNT
@@ -138,6 +141,18 @@ mms_engine_idle_timer_check(
     }
 }
 
+static
+GArray*
+mms_engine_new_attachment_array()
+{
+    GArray* ais = g_array_sized_new(FALSE, TRUE,
+        sizeof(MMSAttachmentInfo), 0);
+
+    g_array_set_clear_func(ais, (GDestroyNotify)
+        mms_attachment_info_cleanup);
+    return ais;
+}
+
 static
 gboolean
 mms_engine_dbus_access_allowed(
@@ -183,63 +198,185 @@ mms_engine_handle_send_message(
         MMS_ENGINE_ACTION_SEND_MESSAGE)) {
         /* mms_engine_dbus_access_allowed has completed the call */
     } else if (to && *to) {
-        unsigned int i;
-        char* to_list = g_strjoinv(",", (char**)to);
-        char* cc_list = NULL;
-        char* bcc_list = NULL;
-        char* id = NULL;
-        char* imsi;
-        MMSAttachmentInfo* parts;
-        GArray* info = g_array_sized_new(FALSE, FALSE, sizeof(*parts), 0);
+        GPtrArray* strings = g_ptr_array_new_full(3, g_free);
+        GArray* ais = mms_engine_new_attachment_array();
         GError* error = NULL;
 
         /* Extract attachment info */
         char* fn = NULL;
         char* ct = NULL;
         char* cid = NULL;
-        GVariantIter* iter = NULL;
-        g_variant_get(attachments, "a(sss)", &iter);
-        while (g_variant_iter_loop(iter, "(sss)", &fn, &ct, &cid)) {
-            MMSAttachmentInfo part;
-            part.file_name = g_strdup(fn);
-            part.content_type = g_strdup(ct);
-            part.content_id = g_strdup(cid);
-            g_array_append_vals(info, &part, 1);
+        GVariantIter* it = NULL;
+
+        g_variant_get(attachments, "a(sss)", &it);
+        while (g_variant_iter_loop(it, "(sss)", &fn, &ct, &cid)) {
+            MMSAttachmentInfo ai;
+
+            g_ptr_array_add(strings, fn);
+            g_ptr_array_add(strings, ct);
+            g_ptr_array_add(strings, cid);
+            if (mms_attachment_info_path(&ai, fn, ct, cid, &error)) {
+                /*
+                 * Need to zero these pointers to stop the next
+                 * g_variant_iter_loop() call from deallocating
+                 * the data allocated by the previous loop.
+                 */
+                fn = ct = cid = NULL;
+                g_array_append_vals(ais, &ai, 1);
+            } else {
+                GERR("%s", GERRMSG(error));
+                break;
+            }
         }
 
-        /* Convert address lists into comma-separated strings
-         * expected by mms_dispatcher_send_message and mms_codec */
-        if (cc && *cc) cc_list = g_strjoinv(",", (char**)cc);
-        if (bcc && *bcc) bcc_list = g_strjoinv(",", (char**)bcc);
-        if (database_id > 0) id = g_strdup_printf("%u", database_id);
-
-        /* Queue the message */
-        parts = (void*)info->data;
-        imsi = mms_dispatcher_send_message(engine->dispatcher, id,
-            imsi_to, to_list, cc_list, bcc_list, subject, flags, parts,
-            info->len, &error);
-        if (imsi) {
-            mms_dispatcher_start(engine->dispatcher);
-            org_nemomobile_mms_engine_complete_send_message(proxy, call, imsi);
-            g_free(imsi);
-        } else {
+        if (error) {
             g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
                 G_DBUS_ERROR_FAILED, "%s", GERRMSG(error));
             g_error_free(error);
+        } else {
+            MMSAttachmentInfo* parts = (MMSAttachmentInfo*)ais->data;
+            char* to_list = g_strjoinv(",", (char**)to);
+            char* cc_list = NULL;
+            char* bcc_list = NULL;
+            char* id = NULL;
+            char* imsi;
+
+            /* Convert address lists into comma-separated strings
+             * expected by mms_dispatcher_send_message and mms_codec */
+            if (cc && *cc) cc_list = g_strjoinv(",", (char**)cc);
+            if (bcc && *bcc) bcc_list = g_strjoinv(",", (char**)bcc);
+            if (database_id > 0) id = g_strdup_printf("%u", database_id);
+
+            /* Queue the message */
+            imsi = mms_dispatcher_send_message(engine->dispatcher, id,
+                imsi_to, to_list, cc_list, bcc_list, subject, flags, parts,
+                ais->len, &error);
+            if (imsi) {
+                mms_dispatcher_start(engine->dispatcher);
+                org_nemomobile_mms_engine_complete_send_message(proxy, call,
+                    imsi);
+                g_free(imsi);
+            } else {
+                g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
+                    G_DBUS_ERROR_FAILED, "%s", GERRMSG(error));
+                g_error_free(error);
+            }
+
+            g_free(to_list);
+            g_free(cc_list);
+            g_free(bcc_list);
+            g_free(id);
         }
 
-        for (i=0; i<info->len; i++) {
-            g_free((void*)parts[i].file_name);
-            g_free((void*)parts[i].content_type);
-            g_free((void*)parts[i].content_id);
+        g_variant_iter_free(it);
+        g_array_unref(ais);
+        g_ptr_array_free(strings, TRUE);
+    } else {
+        g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
+            G_DBUS_ERROR_FAILED, "Missing recipient");
+    }
+    mms_engine_idle_timer_check(engine);
+    return TRUE;
+}
+
+/* org.nemomobile.MmsEngine.sendMessageFd */
+static
+gboolean
+mms_engine_handle_send_message_fd(
+    OrgNemomobileMmsEngine* proxy,
+    GDBusMethodInvocation* call,
+    GUnixFDList* fdl,
+    int database_id,
+    const char* imsi_to,
+    const char* const* to,
+    const char* const* cc,
+    const char* const* bcc,
+    const char* subject,
+    guint flags,
+    GVariant* attachments,
+    MMSEngine* engine)
+{
+    if (!mms_engine_dbus_access_allowed(engine, call,
+        MMS_ENGINE_ACTION_SEND_MESSAGE)) {
+        /* mms_engine_dbus_access_allowed has completed the call */
+    } else if (to && *to) {
+        gint nfds = 0;
+        const gint* fds = g_unix_fd_list_peek_fds(fdl, &nfds);
+        GPtrArray* strings = g_ptr_array_new_full(3, g_free);
+        GArray* ais = mms_engine_new_attachment_array();
+        GError* error = NULL;
+
+        /* Extract attachment info */
+        gint32 fdi;
+        char* fn = NULL;
+        char* ct = NULL;
+        char* cid = NULL;
+        GVariantIter* it = NULL;
+
+        g_variant_get(attachments, "a(hsss)", &it);
+        while (g_variant_iter_loop(it, "(hsss)", &fdi, &fn, &ct, &cid)) {
+            MMSAttachmentInfo ai;
+
+            g_ptr_array_add(strings, fn);
+            g_ptr_array_add(strings, ct);
+            g_ptr_array_add(strings, cid);
+            if (fdi >= 0 && fdi < nfds /* validate the index */ &&
+                mms_attachment_info_fd(&ai, fds[fdi], fn, ct, cid, &error)) {
+                /*
+                 * Need to zero these pointers to stop the next
+                 * g_variant_iter_loop() call from deallocating
+                 * the data allocated by the previous loop.
+                 */
+                fn = ct = cid = NULL;
+                g_array_append_vals(ais, &ai, 1);
+            } else {
+                GERR("%s", GERRMSG(error));
+                break;
+            }
         }
 
-        g_free(to_list);
-        g_free(cc_list);
-        g_free(bcc_list);
-        g_free(id);
-        g_array_unref(info);
-        g_variant_iter_free(iter);
+        if (error) {
+            g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
+                G_DBUS_ERROR_FAILED, "%s", GERRMSG(error));
+            g_error_free(error);
+        } else {
+            MMSAttachmentInfo* parts = (MMSAttachmentInfo*)ais->data;
+            char* to_list = g_strjoinv(",", (char**)to);
+            char* cc_list = NULL;
+            char* bcc_list = NULL;
+            char* id = NULL;
+            char* imsi;
+
+            /* Convert address lists into comma-separated strings
+             * expected by mms_dispatcher_send_message and mms_codec */
+            if (cc && *cc) cc_list = g_strjoinv(",", (char**)cc);
+            if (bcc && *bcc) bcc_list = g_strjoinv(",", (char**)bcc);
+            if (database_id > 0) id = g_strdup_printf("%u", database_id);
+
+            /* Queue the message */
+            imsi = mms_dispatcher_send_message(engine->dispatcher, id,
+                imsi_to, to_list, cc_list, bcc_list, subject, flags, parts,
+                ais->len, &error);
+            if (imsi) {
+                mms_dispatcher_start(engine->dispatcher);
+                org_nemomobile_mms_engine_complete_send_message_fd(proxy,
+                    call, fdl, imsi);
+                g_free(imsi);
+            } else {
+                g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
+                    G_DBUS_ERROR_FAILED, "%s", GERRMSG(error));
+                g_error_free(error);
+            }
+
+            g_free(to_list);
+            g_free(cc_list);
+            g_free(bcc_list);
+            g_free(id);
+        }
+
+        g_variant_iter_free(it);
+        g_array_unref(ais);
+        g_ptr_array_free(strings, TRUE);
     } else {
         g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
             G_DBUS_ERROR_FAILED, "Missing recipient");
@@ -623,39 +760,12 @@ mms_engine_new(
             DA_BUS_SESSION : DA_BUS_SYSTEM;
 
         mms->proxy = org_nemomobile_mms_engine_skeleton_new();
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_SEND_MESSAGE] =
-            g_signal_connect(mms->proxy, "handle-send-message",
-            G_CALLBACK(mms_engine_handle_send_message), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_PUSH] =
-            g_signal_connect(mms->proxy, "handle-push",
-            G_CALLBACK(mms_engine_handle_push), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_PUSH_NOTIFY] =
-            g_signal_connect(mms->proxy, "handle-push-notify",
-            G_CALLBACK(mms_engine_handle_push_notify), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_CANCEL] =
-            g_signal_connect(mms->proxy, "handle-cancel",
-            G_CALLBACK(mms_engine_handle_cancel), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_RECEIVE_MESSAGE] =
-            g_signal_connect(mms->proxy, "handle-receive-message",
-            G_CALLBACK(mms_engine_handle_receive_message), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_SEND_READ_REPORT] =
-            g_signal_connect(mms->proxy, "handle-send-read-report",
-            G_CALLBACK(mms_engine_handle_send_read_report), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_SET_LOG_LEVEL] =
-            g_signal_connect(mms->proxy, "handle-set-log-level",
-            G_CALLBACK(mms_engine_handle_set_log_level), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_SET_LOG_TYPE] =
-            g_signal_connect(mms->proxy, "handle-set-log-type",
-            G_CALLBACK(mms_engine_handle_set_log_type), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_GET_VERSION] =
-            g_signal_connect(mms->proxy, "handle-get-version",
-            G_CALLBACK(mms_engine_handle_get_version), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_MIGRATE_SETTINGS] =
-            g_signal_connect(mms->proxy, "handle-migrate-settings",
-            G_CALLBACK(mms_engine_handle_migrate_settings), mms);
-        mms->proxy_signal_id[MMS_ENGINE_METHOD_EXIT] =
-            g_signal_connect(mms->proxy, "handle-exit",
-            G_CALLBACK(mms_engine_handle_exit), mms);
+#define MMS_ENGINE_HANDLER_(ID,id,name)  \
+        mms->proxy_signal_id[MMS_ENGINE_METHOD_##ID] = \
+            g_signal_connect(mms->proxy, "handle-" name, \
+            G_CALLBACK(mms_engine_handle_##id), mms);
+        MMS_ENGINE_DBUS_METHODS(MMS_ENGINE_HANDLER_)
+#undef  MMS_ENGINE_HANDLER_
 
         return mms;
     }
diff --git a/mms-engine/mms_engine.h b/mms-engine/mms_engine.h
index 11e4aeb..3582981 100644
--- a/mms-engine/mms_engine.h
+++ b/mms-engine/mms_engine.h
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2013-2020 Jolla Ltd.
  * Copyright (C) 2013-2020 Slava Monich <slava.monich@jolla.com>
- * Copyright (C) 2019 Open Mobile Platform LLC.
+ * Copyright (C) 2019-2020 Open Mobile Platform LLC.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -9,7 +9,7 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
@@ -40,22 +40,23 @@
 #endif /* MMS_ENGINE_CONFIG_FILE */
 
 #define MMS_ENGINE_DBUS_METHODS(m) \
-    m(CANCEL) \
-    m(RECEIVE_MESSAGE) \
-    m(SEND_READ_REPORT) \
-    m(SEND_MESSAGE) \
-    m(PUSH) \
-    m(PUSH_NOTIFY) \
-    m(SET_LOG_LEVEL) \
-    m(SET_LOG_TYPE) \
-    m(GET_VERSION) \
-    m(MIGRATE_SETTINGS) \
-    m(EXIT)
+    m(CANCEL,cancel,"cancel") \
+    m(RECEIVE_MESSAGE,receive_message,"receive-message") \
+    m(SEND_READ_REPORT,send_read_report,"send-read-report") \
+    m(SEND_MESSAGE,send_message,"send-message") \
+    m(SEND_MESSAGE_FD,send_message_fd,"send-message-fd") \
+    m(PUSH,push,"push") \
+    m(PUSH_NOTIFY,push_notify,"push-notify") \
+    m(SET_LOG_LEVEL,set_log_level,"set-log-level") \
+    m(SET_LOG_TYPE,set_log_type,"set-log-type") \
+    m(GET_VERSION,get_version,"get-version") \
+    m(MIGRATE_SETTINGS,migrate_settings,"migrate-settings") \
+    m(EXIT,exit,"exit")
 
 typedef enum mms_engine_action {
     /* Action ids must be non-zero, shift those by one */
     MMS_ENGINE_ACTION_NONE = 0,
-    #define MMS_ENGINE_ACTION_(id) MMS_ENGINE_ACTION_##id,
+    #define MMS_ENGINE_ACTION_(ID,id,name) MMS_ENGINE_ACTION_##ID,
     MMS_ENGINE_DBUS_METHODS(MMS_ENGINE_ACTION_)
     #undef MMS_ENGINE_ACTION_
 } MMS_ENGINE_ACTION;
diff --git a/mms-engine/org.nemomobile.MmsEngine.xml b/mms-engine/org.nemomobile.MmsEngine.xml
index a47e7d3..9229300 100644
--- a/mms-engine/org.nemomobile.MmsEngine.xml
+++ b/mms-engine/org.nemomobile.MmsEngine.xml
@@ -160,6 +160,32 @@
       <arg direction="out" type="s" name="imsiActual"/>
     </method> 
 
+    <!--
+        Does the same thing as sendMessage, all parameters have the
+        same meaning, the only difference is that parts contain file
+        descriptors rather than file names.
+    -->
+    <method name="sendMessageFd">
+      <arg direction="in" type="i" name="recId"/>
+      <arg direction="in" type="s" name="imsi"/>
+      <arg direction="in" type="as" name="to"/>
+      <arg direction="in" type="as" name="cc"/>
+      <arg direction="in" type="as" name="bcc"/>
+      <arg direction="in" type="s" name="subject"/>
+      <arg direction="in" type="u" name="flags"/>
+      <!--
+          Each variant in the parts array is (hsss):
+
+          h - file descriptor open for reading
+          s - file name, without directory
+          s - content type (including charset)
+          s - content id (optional)
+      -->
+      <arg direction="in" type="a(hsss)" name="parts"/>
+      <arg direction="out" type="s" name="imsiActual"/>
+      <annotation name="org.gtk.GDBus.C.UnixFD" value="1"/>
+    </method>
+
     <!--
         ===============================================================
         ================== M I S C E L L A N E O U S ==================
diff --git a/mms-lib/include/mms_attachment_info.h b/mms-lib/include/mms_attachment_info.h
new file mode 100644
index 0000000..9332823
--- /dev/null
+++ b/mms-lib/include/mms_attachment_info.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020 Jolla Ltd.
+ * Copyright (C) 2020 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2020 Open Mobile Platform LLC.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef SAILFISH_MMS_ATTACHMENT_INFO_H
+#define SAILFISH_MMS_ATTACHMENT_INFO_H
+
+#include "mms_lib_types.h"
+
+/* Attachment information */
+struct mms_attachment_info {
+    GMappedFile* map;
+    gsize size;
+    const void* data;
+    const char* file_name;
+    const char* content_type;
+    const char* content_id;
+};
+
+gboolean
+mms_attachment_info_path(
+    MMSAttachmentInfo* ai,
+    const char* path,
+    const char* content_type,
+    const char* content_id,
+    GError** error);
+
+gboolean
+mms_attachment_info_fd(
+    MMSAttachmentInfo* ai,
+    int fd,
+    const char* name,
+    const char* content_type,
+    const char* content_id,
+    GError** error);
+
+void
+mms_attachment_info_cleanup(
+    MMSAttachmentInfo* ai);
+
+#endif /* SAILFISH_MMS_ATTACHMENT_INFO_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/mms-lib/include/mms_lib_types.h b/mms-lib/include/mms_lib_types.h
index 88c3fc4..29189cb 100644
--- a/mms-lib/include/mms_lib_types.h
+++ b/mms-lib/include/mms_lib_types.h
@@ -1,6 +1,7 @@
 /*
- * Copyright (C) 2013-2018 Jolla Ltd.
- * Contact: Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2013-2020 Jolla Ltd.
+ * Copyright (C) 2013-2020 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2020 Open Mobile Platform LLC.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -8,12 +9,12 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
-#ifndef JOLLA_MMS_LIB_TYPES_H
-#define JOLLA_MMS_LIB_TYPES_H
+#ifndef SAILFISH_MMS_LIB_TYPES_H
+#define SAILFISH_MMS_LIB_TYPES_H
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -43,17 +44,10 @@ typedef GLogModule MMSLogModule;
 
 #ifdef __linux__
 #  define HAVE_MAGIC
-#  define HAVE_REALPATH
 #endif
 
-/* Attachment information */
-typedef struct mms_attachment_info {
-    const char* file_name;      /* Full path name */
-    const char* content_type;   /* Content type */
-    const char* content_id;     /* Content id */
-} MMSAttachmentInfo;
-
 /* Types */
+typedef struct mms_attachment_info MMSAttachmentInfo;
 typedef struct mms_config MMSConfig;
 typedef struct mms_settings MMSSettings;
 typedef struct mms_settings_sim_data MMSSettingsSimData;
@@ -83,7 +77,7 @@ typedef enum _MMS_CONNECTION_TYPE {
     MMS_CONNECTION_TYPE_USER        /* Connection requested by user */
 } MMS_CONNECTION_TYPE;
 
-#endif /* JOLLA_MMS_LIB_TYPES_H */
+#endif /* SAILFISH_MMS_LIB_TYPES_H */
 
 /*
  * Local Variables:
diff --git a/mms-lib/mms-lib.pro b/mms-lib/mms-lib.pro
index ee573d2..56d4fc3 100644
--- a/mms-lib/mms-lib.pro
+++ b/mms-lib/mms-lib.pro
@@ -65,6 +65,7 @@ HEADERS += \
   src/mms_util.h \
 
 HEADERS += \
+  include/mms_attachment_info.h \
   include/mms_connection.h \
   include/mms_connman.h \
   include/mms_dispatcher.h \
diff --git a/mms-lib/src/mms_attachment.c b/mms-lib/src/mms_attachment.c
index e74f855..0bcca67 100644
--- a/mms-lib/src/mms_attachment.c
+++ b/mms-lib/src/mms_attachment.c
@@ -9,11 +9,12 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
 #include "mms_attachment.h"
+#include "mms_attachment_info.h"
 #include "mms_file_util.h"
 #include "mms_settings.h"
 #include "mms_codec.h"
@@ -38,6 +39,8 @@ G_DEFINE_TYPE(MMSAttachment, mms_attachment, G_TYPE_OBJECT)
 #define MMS_ATTACHMENT_GET_CLASS(obj)  \
     (G_TYPE_INSTANCE_GET_CLASS((obj), MMS_TYPE_ATTACHMENT, MMSAttachmentClass))
 
+#define SMIL_CONTENT_ID "smil"
+
 #define REGION_TEXT     "Text"
 #define REGION_MEDIA    "Media"
 
@@ -52,6 +55,8 @@ G_DEFINE_TYPE(MMSAttachment, mms_attachment, G_TYPE_OBJECT)
 #define MEDIA_TYPE_VIDEO_PREFIX "video/"
 #define MEDIA_TYPE_AUDIO_PREFIX "audio/"
 
+#define MEDIA_TYPE_IMAGE_JPEG   MEDIA_TYPE_IMAGE_PREFIX "jpeg"
+
 static
 void
 mms_attachment_finalize(
@@ -89,31 +94,6 @@ mms_attachment_init(
     GVERBOSE_("%p", at);
 }
 
-static
-char*
-mms_attachment_get_path(
-    const char* file,
-    GError** error)
-{
-#ifdef HAVE_REALPATH
-    char* path = g_malloc(PATH_MAX);
-    if (realpath(file, path)) {
-        if (g_file_test(path, G_FILE_TEST_IS_REGULAR)) {
-            char* fname = g_strdup(path);
-            g_free(path);
-            return fname;
-        } else {
-            MMS_ERROR(error, MMS_LIB_ERROR_IO, "%s not found", file);
-        }
-    } else {
-        MMS_ERROR(error, MMS_LIB_ERROR_IO, "%s: %s\n", file, strerror(errno));
-    }
-    return NULL;
-#else
-    return g_strdup(file);
-#endif
-}
-
 static
 gboolean
 mms_attachment_write_smil(
@@ -205,7 +185,7 @@ mms_attachment_write_smil(
 static
 char*
 mms_attachment_guess_content_type(
-    const char* path)
+    const MMSAttachmentInfo* ai)
 {
     char* content_type = NULL;
     const char* detected_type = NULL;
@@ -215,7 +195,7 @@ mms_attachment_guess_content_type(
     magic_t magic = magic_open(MAGIC_MIME_TYPE);
     if (magic) {
         if (magic_load(magic, NULL) == 0) {
-            detected_type = magic_file(magic, path);
+            detected_type = magic_buffer(magic, ai->data, ai->size);
         }
     }
 #endif
@@ -223,12 +203,12 @@ mms_attachment_guess_content_type(
     /* Magic detects SMIL as text/html */
     if ((!detected_type ||
          g_str_has_prefix(detected_type, MEDIA_TYPE_TEXT_PREFIX)) &&
-         mms_file_is_smil(path)) {
+         mms_file_is_smil(ai)) {
         detected_type = SMIL_CONTENT_TYPE;
     }
 
     if (!detected_type) {
-        GWARN("No mime type for %s", path);
+        GWARN("No mime type for %s", ai->file_name);
         detected_type = MMS_ATTACHMENT_DEFAULT_TYPE;
     }
 
@@ -244,7 +224,7 @@ mms_attachment_guess_content_type(
 static
 char*
 mms_attachment_guess_text_encoding(
-    const char* path)
+    const MMSAttachmentInfo* ai)
 {
     char* encoding = NULL;
     const char* detected = NULL;
@@ -254,13 +234,13 @@ mms_attachment_guess_text_encoding(
     magic_t magic = magic_open(MAGIC_MIME_ENCODING);
     if (magic) {
         if (magic_load(magic, NULL) == 0) {
-            detected = magic_file(magic, path);
+            detected = magic_buffer(magic, ai->data, ai->size);
         }
     }
 #endif
 
     if (detected) {
-        GDEBUG("%s: detected %s", path, detected);
+        GDEBUG("%s: detected %s", ai->file_name, detected);
         encoding = g_strdup(detected);
     } else {
         encoding = g_strdup(MMS_DEFAULT_CHARSET);
@@ -273,6 +253,64 @@ mms_attachment_guess_text_encoding(
     return encoding;
 }
 
+static
+gboolean
+mms_attachment_info_init(
+    MMSAttachmentInfo* ai,
+    GMappedFile* map,
+    const char* path,
+    const char* content_type,
+    const char* content_id)
+{
+    if (map) {
+        ai->map = map;
+        ai->data = g_mapped_file_get_contents(map);
+        ai->size = g_mapped_file_get_length(map);
+        ai->file_name = path;
+        ai->content_type = content_type;
+        ai->content_id = content_id;
+        return TRUE;
+    } else {
+        memset(ai, 0, sizeof(*ai));
+        return FALSE;
+    }
+}
+
+gboolean
+mms_attachment_info_path(
+    MMSAttachmentInfo* ai,
+    const char* path,
+    const char* content_type,
+    const char* content_id,
+    GError** error)
+{
+    return mms_attachment_info_init(ai,
+        g_mapped_file_new(path, FALSE, error),
+        path, content_type, content_id);
+}
+
+gboolean
+mms_attachment_info_fd(
+    MMSAttachmentInfo* ai,
+    int fd,
+    const char* name,
+    const char* content_type,
+    const char* content_id,
+    GError** error)
+{
+    return mms_attachment_info_init(ai,
+        g_mapped_file_new_from_fd(fd, FALSE, error),
+        name, content_type, content_id);
+}
+
+void
+mms_attachment_info_cleanup(
+    MMSAttachmentInfo* ai)
+{
+    if (ai->map) g_mapped_file_unref(ai->map);
+    memset(ai, 0, sizeof(*ai));
+}
+
 MMSAttachment*
 mms_attachment_new_smil(
     const MMSConfig* config,
@@ -283,21 +321,26 @@ mms_attachment_new_smil(
 {
     MMSAttachment* smil = NULL;
     int fd = open(path, O_CREAT|O_RDWR|O_TRUNC, MMS_FILE_PERM);
+
     if (fd >= 0) {
         FILE* f = fdopen(fd, "w");
+
         if (f) {
             gboolean ok;
+
             GVERBOSE("Writing SMIL %s", path);
             ok = mms_attachment_write_smil(f, ats, n, error);
             fclose(f);
             if (ok) {
                 MMSAttachmentInfo ai;
-                ai.file_name = path;
-                ai.content_type = SMIL_CONTENT_TYPE "; "
-                    CONTENT_TYPE_PARAM_CHARSET "=" MMS_DEFAULT_CHARSET;
-                ai.content_id = NULL;
-                smil = mms_attachment_new(config, &ai, error);
-                GASSERT(smil && (smil->flags & MMS_ATTACHMENT_SMIL));
+
+                if (mms_attachment_info_path(&ai, path,
+                    SMIL_CONTENT_TYPE "; " CONTENT_TYPE_PARAM_CHARSET "="
+                    MMS_DEFAULT_CHARSET, SMIL_CONTENT_ID, error)) {
+                    smil = mms_attachment_new(config, &ai, error);
+                    GASSERT(smil && (smil->flags & MMS_ATTACHMENT_SMIL));
+                    mms_attachment_info_cleanup(&ai);
+                }
             }
         } else {
             MMS_ERROR(error, MMS_LIB_ERROR_IO,
@@ -317,124 +360,116 @@ mms_attachment_new(
     const MMSAttachmentInfo* info,
     GError** error)
 {
-    char* path = mms_attachment_get_path(info->file_name, error);
-    if (path) {
-        GMappedFile* map = g_mapped_file_new(path, FALSE, error);
-        if (map) {
-            unsigned int flags = 0;
-            char* media_type = NULL;
-            char* name = g_path_get_basename(path);
-            char* content_type = NULL;
-            GType type = MMS_TYPE_ATTACHMENT;
-            MMSAttachment* at;
-            MMSAttachmentClass* klass;
-
-            /*
-             * We always need to provide charset for text attachments because
-             * operators may (and often do) want to convert those to their
-             * favorite charset, in which case they need to know the original
-             * one (some just blindly assume us-ascii and mess things up).
-             */
-            if (info->content_type && info->content_type[0]) {
-                char** ct = mms_parse_http_content_type(info->content_type);
-                if (ct) {
-                    char** ptr;
-                    gboolean append_name = TRUE;
-                    gboolean append_charset = g_str_has_prefix(ct[0],
-                        MEDIA_TYPE_TEXT_PREFIX);
-
-                    for (ptr = ct+1; *ptr; ptr+=2) {
-                        const char* p = ptr[0];
-
-                        if (!g_ascii_strcasecmp(p, CONTENT_TYPE_PARAM_NAME)) {
-                            g_free(ptr[1]);
-                            ptr[1] = g_strdup(name);
-                            append_name = FALSE;
-                        } else if (append_charset && !g_ascii_strcasecmp(p,
-                            CONTENT_TYPE_PARAM_CHARSET)) {
-                            /* Charset is provided by the caller */
-                            append_charset = FALSE;
-                        }
-                    }
-                    if (append_name) {
-                        ct = gutil_strv_addv(ct,
-                            CONTENT_TYPE_PARAM_NAME, name,
-                            NULL);
-                    }
-                    if (append_charset) {
-                        char* enc = mms_attachment_guess_text_encoding(path);
-
-                        if (enc) {
-                            ct = gutil_strv_addv(ct,
-                                CONTENT_TYPE_PARAM_CHARSET, enc,
-                                NULL);
-                            g_free(enc);
-                        }
-                    }
-                    content_type = mms_unparse_http_content_type(ct);
-                    media_type = g_strdup(ct[0]);
-                    g_strfreev(ct);
+    unsigned int flags = 0;
+    char* media_type = NULL;
+    char* content_type = NULL;
+    char* name = g_path_get_basename(info->file_name);
+    GType type = MMS_TYPE_ATTACHMENT;
+    MMSAttachment* at;
+    MMSAttachmentClass* klass;
+
+    /*
+     * We always need to provide charset for text attachments because
+     * operators may (and often do) want to convert those to their
+     * favorite charset, in which case they need to know the original
+     * one (some just blindly assume us-ascii and mess things up).
+     */
+    if (info->content_type && info->content_type[0]) {
+        char** ct = mms_parse_http_content_type(info->content_type);
+        if (ct) {
+            char** ptr;
+            gboolean append_name = TRUE;
+            gboolean append_charset = g_str_has_prefix(ct[0],
+                MEDIA_TYPE_TEXT_PREFIX);
+
+            for (ptr = ct+1; *ptr; ptr+=2) {
+                const char* p = ptr[0];
+
+                if (!g_ascii_strcasecmp(p, CONTENT_TYPE_PARAM_NAME)) {
+                    g_free(ptr[1]);
+                    ptr[1] = g_strdup(name);
+                    append_name = FALSE;
+                } else if (append_charset && !g_ascii_strcasecmp(p,
+                    CONTENT_TYPE_PARAM_CHARSET)) {
+                    /* Charset is provided by the caller */
+                    append_charset = FALSE;
                 }
             }
+            if (append_name) {
+                ct = gutil_strv_addv(ct, CONTENT_TYPE_PARAM_NAME, name, NULL);
+            }
+            if (append_charset) {
+                char* enc = mms_attachment_guess_text_encoding(info);
 
-            if (!content_type) {
-                char* detected = NULL;
-                const char* charset = NULL;
-                const char* ct[6];
-                int n = 0;
-
-                media_type = mms_attachment_guess_content_type(path);
-                if (g_str_has_prefix(media_type, MEDIA_TYPE_TEXT_PREFIX)) {
-                    detected = mms_attachment_guess_text_encoding(path);
-                    charset = detected;
-                }
-
-                ct[n++] = media_type;
-                if (charset) {
-                    ct[n++] = CONTENT_TYPE_PARAM_CHARSET;
-                    ct[n++] = charset;
+                if (enc) {
+                    ct = gutil_strv_addv(ct, CONTENT_TYPE_PARAM_CHARSET,
+                        enc, NULL);
+                    g_free(enc);
                 }
-                ct[n++] = CONTENT_TYPE_PARAM_NAME;
-                ct[n++] = name;
-                ct[n++] = NULL;
-                content_type = mms_unparse_http_content_type((char**)ct);
-                g_free(detected);
             }
+            content_type = mms_unparse_http_content_type(ct);
+            media_type = g_strdup(ct[0]);
+            g_strfreev(ct);
+        }
+    }
 
-            if (!strcmp(media_type, SMIL_CONTENT_TYPE)) {
-                flags |= MMS_ATTACHMENT_SMIL;
-            } else if (!strcmp(media_type, "image/jpeg")) {
-                type = MMS_TYPE_ATTACHMENT_JPEG;
-            } else if (g_str_has_prefix(media_type, MEDIA_TYPE_IMAGE_PREFIX)) {
-                type = MMS_TYPE_ATTACHMENT_IMAGE;
-            } else if (g_str_has_prefix(media_type, MEDIA_TYPE_TEXT_PREFIX)) {
-                type = MMS_TYPE_ATTACHMENT_TEXT;
-            }
+    if (!content_type) {
+        char* detected = NULL;
+        const char* charset = NULL;
+        const char* ct[6];
+        int n = 0;
 
-            at = g_object_new(type, NULL);
-            at->config = config;
-            at->map = map;
-            at->flags |= flags;
-            at->file_name = at->original_file = path;
-            at->content_type = content_type;
-            at->content_location = name;
-            at->content_id = (info->content_id && info->content_id[0]) ?
-                g_strdup(info->content_id) :
-                g_strdup(at->content_location);
-
-            path = NULL;
-            g_free(media_type);
-            klass = MMS_ATTACHMENT_GET_CLASS(at);
-
-            if (!klass->fn_init || klass->fn_init(at)) {
-                GDEBUG("%s: %s", at->file_name, at->content_type);
-                return at;
-            }
-            /* Init failed */
-            mms_attachment_unref(at);
+        media_type = mms_attachment_guess_content_type(info);
+        if (g_str_has_prefix(media_type, MEDIA_TYPE_TEXT_PREFIX)) {
+            detected = mms_attachment_guess_text_encoding(info);
+            charset = detected;
+        }
+
+        ct[n++] = media_type;
+        if (charset) {
+            ct[n++] = CONTENT_TYPE_PARAM_CHARSET;
+            ct[n++] = charset;
         }
-        g_free(path);
+        ct[n++] = CONTENT_TYPE_PARAM_NAME;
+        ct[n++] = name;
+        ct[n++] = NULL;
+        content_type = mms_unparse_http_content_type((char**)ct);
+        g_free(detected);
+    }
+
+    if (!strcmp(media_type, SMIL_CONTENT_TYPE)) {
+        flags |= MMS_ATTACHMENT_SMIL;
+    } else if (!strcmp(media_type, MEDIA_TYPE_IMAGE_JPEG)) {
+        type = MMS_TYPE_ATTACHMENT_JPEG;
+    } else if (g_str_has_prefix(media_type, MEDIA_TYPE_IMAGE_PREFIX)) {
+        type = MMS_TYPE_ATTACHMENT_IMAGE;
+    } else if (g_str_has_prefix(media_type, MEDIA_TYPE_TEXT_PREFIX)) {
+        type = MMS_TYPE_ATTACHMENT_TEXT;
+    }
+
+    at = g_object_new(type, NULL);
+    at->config = config;
+    at->flags |= flags;
+    at->file_name = at->original_file = g_strdup(info->file_name);
+    at->content_type = content_type;
+    at->content_location = name;
+    at->content_id = (info->content_id && info->content_id[0]) ?
+        g_strdup(info->content_id) :
+        g_strdup(at->content_location);
+
+    if (info->map) {
+        at->map = g_mapped_file_ref(info->map);
+    }
+
+    g_free(media_type);
+    klass = MMS_ATTACHMENT_GET_CLASS(at);
+
+    if (!klass->fn_init || klass->fn_init(at)) {
+        GDEBUG("%s: %s", at->file_name, at->content_type);
+        return at;
     }
+    /* Init failed */
+    mms_attachment_unref(at);
     return NULL;
 }
 
diff --git a/mms-lib/src/mms_file_util.c b/mms-lib/src/mms_file_util.c
index a016fd0..4896b9e 100644
--- a/mms-lib/src/mms_file_util.c
+++ b/mms-lib/src/mms_file_util.c
@@ -9,10 +9,11 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
+#include "mms_attachment_info.h"
 #include "mms_file_util.h"
 #include "mms_error.h"
 
@@ -54,25 +55,18 @@ mms_smil_parse_end(
  */
 gboolean
 mms_file_is_smil(
-    const char* file)
+    const MMSAttachmentInfo* ai)
 {
     static const GMarkupParser toplevel = { mms_smil_parse_start,
         mms_smil_parse_end, NULL, NULL, NULL };
-    gboolean smil = FALSE;
-    GMappedFile* map = g_mapped_file_new(file, FALSE, NULL);
-    if (map) {
-        gboolean smil_found = FALSE;
-        GMarkupParseContext* parser = g_markup_parse_context_new(&toplevel,
-            G_MARKUP_TREAT_CDATA_AS_TEXT, &smil_found, NULL);
-        if (g_markup_parse_context_parse(parser,
-            g_mapped_file_get_contents(map),
-            g_mapped_file_get_length(map), NULL)) {
-            g_markup_parse_context_end_parse(parser, NULL);
-            smil = smil_found;
-        }
-        g_mapped_file_unref(map);
-        g_markup_parse_context_free(parser);
+    gboolean smil = FALSE, smil_found = FALSE;
+    GMarkupParseContext* parser = g_markup_parse_context_new(&toplevel,
+        G_MARKUP_TREAT_CDATA_AS_TEXT, &smil_found, NULL);
+    if (g_markup_parse_context_parse(parser, ai->data, ai->size, NULL)) {
+        g_markup_parse_context_end_parse(parser, NULL);
+        smil = smil_found;
     }
+    g_markup_parse_context_free(parser);
     return smil;
 }
 
@@ -200,46 +194,29 @@ mms_write_bytes(
 }
 
 /**
- * Copies the file. Assumes that the destination directory exists.
+ * Copies attachment to a file. Assumes that the destination directory
+ * already exists.
  */
 gboolean
-mms_file_copy(
-    const char* src,
+mms_copy_attachment(
+    const MMSAttachmentInfo* ai,
     const char* dest,
     GError** error)
 {
     gboolean ok = FALSE;
     int out = open(dest, O_CREAT|O_WRONLY|O_TRUNC|O_BINARY, MMS_FILE_PERM);
+
     if (out >= 0) {
-        int in = open(src, O_RDONLY | O_BINARY);
-        if (in >= 0) {
-            int nbytes;
-            const size_t buflen = 4096;
-            void* buf = g_malloc(buflen);
+        if (write(out, ai->data, ai->size) == (gssize)ai->size) {
             ok = TRUE;
-            while ((nbytes = read(in, buf, buflen)) > 0) {
-                if (write(out, buf, nbytes) < nbytes) {
-                    ok = FALSE;
-                    MMS_ERROR(error, MMS_LIB_ERROR_IO,
-                        "Failed to write %s: %s", dest, strerror(errno));
-                    break;
-                }
-            }
-            if (nbytes < 0) {
-                ok = FALSE;
-                MMS_ERROR(error, MMS_LIB_ERROR_IO,
-                    "Failed to read %s: %s", src, strerror(errno));
-            }
-            g_free(buf);
-            close(in);
         } else {
-            MMS_ERROR(error, MMS_LIB_ERROR_IO,
-                "Failed to open file %s: %s", src, strerror(errno));
+            MMS_ERROR(error, MMS_LIB_ERROR_IO, "Failed to write %s: %s",
+                dest, strerror(errno));
         }
         close(out);
     } else {
-        MMS_ERROR(error, MMS_LIB_ERROR_IO,
-            "Failed to create file %s: %s", dest, strerror(errno));
+        MMS_ERROR(error, MMS_LIB_ERROR_IO, "Failed to create file %s: %s",
+            dest, strerror(errno));
     }
     return ok;
 }
diff --git a/mms-lib/src/mms_file_util.h b/mms-lib/src/mms_file_util.h
index 990f3f9..d3135ab 100644
--- a/mms-lib/src/mms_file_util.h
+++ b/mms-lib/src/mms_file_util.h
@@ -9,7 +9,7 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  */
@@ -45,7 +45,7 @@
 
 gboolean
 mms_file_is_smil(
-    const char* file);
+    const MMSAttachmentInfo* ai);
 
 void
 mms_remove_file_and_dir(
@@ -81,8 +81,8 @@ mms_write_bytes(
     char** path);
 
 gboolean
-mms_file_copy(
-    const char* src,
+mms_copy_attachment(
+    const MMSAttachmentInfo* parts,
     const char* dest,
     GError** error);
 
diff --git a/mms-lib/src/mms_task_encode.c b/mms-lib/src/mms_task_encode.c
index aea4ba4..8e4411e 100644
--- a/mms-lib/src/mms_task_encode.c
+++ b/mms-lib/src/mms_task_encode.c
@@ -9,12 +9,13 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
 #include "mms_task.h"
 #include "mms_attachment.h"
+#include "mms_attachment_info.h"
 #include "mms_dispatcher.h"
 #include "mms_settings.h"
 #include "mms_handler.h"
@@ -457,24 +458,29 @@ mms_task_encode_prepare_attachments(
     int smil_index = -1;
     GPtrArray* array = g_ptr_array_sized_new(nparts);
     for (i=0; i<nparts; i++) {
+        const MMSAttachmentInfo* part = parts + i;
         MMSAttachment* attachment = NULL;
-        MMSAttachmentInfo info = parts[i];
         char* path;
 
         G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
         path = mms_task_encode_generate_path(dir,
-            g_basename(info.file_name), info.content_type);
+            g_basename(part->file_name), part->content_type);
         G_GNUC_END_IGNORE_DEPRECATIONS;
 
-        if (mms_file_copy(info.file_name, path, error)) {
-            info.file_name = path;
-            attachment = mms_attachment_new(config, &info, error);
-            if (attachment) {
-                if (smil_index < 0 &&
-                   (attachment->flags & MMS_ATTACHMENT_SMIL)) {
-                    smil_index = i;
+        if (mms_copy_attachment(part, path, error)) {
+            MMSAttachmentInfo ai;
+            
+            if (mms_attachment_info_path(&ai, path, part->content_type,
+                part->content_id, error)) {
+                attachment = mms_attachment_new(config, &ai, error);
+                if (attachment) {
+                    if (smil_index < 0 && (attachment->flags &
+                        MMS_ATTACHMENT_SMIL)) {
+                        smil_index = i;
+                    }
+                    g_ptr_array_add(array, attachment);
                 }
-                g_ptr_array_add(array, attachment);
+                mms_attachment_info_cleanup(&ai);
             }
         } else if (error && *error) {
             GERR("%s", GERRMSG(*error));
diff --git a/mms-lib/test/test_resize/test_resize.c b/mms-lib/test/test_resize/test_resize.c
index 1f98d04..3e87af9 100644
--- a/mms-lib/test/test_resize/test_resize.c
+++ b/mms-lib/test/test_resize/test_resize.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2013-2020 Jolla Ltd.
  * Copyright (C) 2013-2020 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2020 Open Mobile Platform LLC.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -15,6 +16,7 @@
 #include "test_util.h"
 
 #include "mms_attachment.h"
+#include "mms_attachment_info.h"
 #include "mms_settings.h"
 #include "mms_lib_util.h"
 #include "mms_lib_log.h"
@@ -381,13 +383,19 @@ run_test(
     g_assert(dir);
     testfile = g_build_filename(dir, name, NULL);
 
-    g_assert(mms_file_copy(test->file, testfile, NULL));
+    /* Copy the file */
+    g_assert(mms_attachment_info_path(&info, test->file, NULL, NULL, &error));
+    g_assert(mms_copy_attachment(&info, testfile, &error));
+    mms_attachment_info_cleanup(&info);
+
     mms_settings_sim_data_default(&sim_settings);
     sim_settings.max_pixels = test->max_pixels;
-    info.file_name = testfile;
-    info.content_type = test->type->content_type;
-    info.content_id = name;
+
+    /* Create the attachment */
+    g_assert(mms_attachment_info_path(&info, testfile,test->type->content_type,
+        name, &error));
     at = mms_attachment_new(&config, &info, &error);
+    mms_attachment_info_cleanup(&info);
 
     g_assert(at);
     for (i = 0; i < test->steps && ok; i++) {
diff --git a/mms-lib/test/test_send/test_send.c b/mms-lib/test/test_send/test_send.c
index 2cebe80..35cf063 100644
--- a/mms-lib/test/test_send/test_send.c
+++ b/mms-lib/test/test_send/test_send.c
@@ -9,7 +9,7 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  */
 
@@ -24,6 +24,7 @@
 #include "mms_lib_util.h"
 #include "mms_settings.h"
 #include "mms_dispatcher.h"
+#include "mms_attachment_info.h"
 
 #include <gutil_macros.h>
 #include <gutil_log.h>
@@ -34,9 +35,15 @@
 
 static TestOpt test_opt;
 
+typedef struct test_attachment {
+    const char* file_name;
+    const char* content_type;
+    const char* content_id;
+} TestAttachment;
+
 typedef struct test_desc {
     const char* name;
-    const MMSAttachmentInfo* parts;
+    const TestAttachment* parts;
     int nparts;
     gsize size_limit;
     const char* subject;
@@ -84,25 +91,27 @@ typedef struct test {
     GMappedFile* resp_file;
 } Test;
 
-static const MMSAttachmentInfo test_files_accept [] = {
+static const TestAttachment test_files_accept [] = {
     { "smil", "application/smil;charset=us-ascii", NULL },
     { "0001.jpg", "image/jpeg;name=0001.jpg", "image" },
     { "test.txt", "text/plain;charset=utf-8;name=wrong.name", "text" }
 };
 
-static const MMSAttachmentInfo test_files_accept_no_ext [] = {
+#ifdef HAVE_MAGIC
+static const TestAttachment test_files_accept_no_ext [] = {
     { "smil", NULL, NULL },
     { "0001", NULL, "image1" },
     { "0001", "", "image2" },
     { "test.text", "text/plain;charset=utf-8", "text" }
 };
+#endif /* HAVE_MAGIC */
 
-static const MMSAttachmentInfo test_files_reject [] = {
+static const TestAttachment test_files_reject [] = {
     { "0001.png", "image/png", "image" },
     { "test.txt", "text/plain", "text" }
 };
 
-static const MMSAttachmentInfo test_txt [] = {
+static const TestAttachment test_txt [] = {
     { "test.txt", NULL, "text" }
 };
 
@@ -126,6 +135,7 @@ static const TestDesc send_tests[] = {
         NULL,
         "TestMessageId"
     },{
+#ifdef HAVE_MAGIC
         "AcceptNoExt",
         ATTACHMENTS(test_files_accept_no_ext),
         0,
@@ -142,6 +152,7 @@ static const TestDesc send_tests[] = {
         NULL,
         "TestMessageId"
     },{
+#endif /* HAVE_MAGIC */
         "ServiceDenied",
         ATTACHMENTS(test_files_reject),
         0,
@@ -348,7 +359,8 @@ run_test(
     GError* error = NULL;
     TestDirs dirs;
     Test test;
-    guint port, i;
+    guint port;
+    int i;
     const char* id;
     char* imsi;
     char* imsi2;
@@ -383,8 +395,9 @@ run_test(
     for (i = 0; i < desc->nparts; i++) {
         test.files[i] = g_build_filename(DATA_DIR, desc->name,
             desc->parts[i].file_name, NULL);
-        test.parts[i] = desc->parts[i];
-        test.parts[i].file_name = test.files[i];
+
+        g_assert(mms_attachment_info_path(test.parts + i, test.files[i],
+            desc->parts[i].content_type, desc->parts[i].content_id, &error));
     }
     test.config = &config;
     test.desc = desc;
@@ -434,9 +447,6 @@ run_test(
     }
 
     /* Done */
-    g_free(imsi);
-    g_free(imsi2);
-
     test_http_close(test.http);
     test_http_unref(test.http);
     mms_connman_test_close_connection(test.cm);
@@ -445,11 +455,16 @@ run_test(
     mms_dispatcher_unref(test.disp);
     g_main_loop_unref(test.loop);
     if (test.resp_file) g_mapped_file_unref(test.resp_file);
-    for (i = 0; i < test.desc->nparts; i++) g_free(test.files[i]);
+    for (i = 0; i < test.desc->nparts; i++) {
+        mms_attachment_info_cleanup(test.parts + i);
+        g_free(test.files[i]);
+    }
     g_free(test.files);
     g_free(test.parts);
     g_free(test.id);
 
+    g_free(imsi);
+    g_free(imsi2);
     test_dirs_cleanup(&dirs, TRUE);
 }
 
diff --git a/mms-send/mms-send.c b/mms-send/mms-send.c
index adc405d..f29307a 100644
--- a/mms-send/mms-send.c
+++ b/mms-send/mms-send.c
@@ -1,5 +1,7 @@
 /*
- * Copyright (C) 2013-2019 Jolla Ltd.
+ * Copyright (C) 2013-2020 Jolla Ltd.
+ * Copyright (C) 2013-2020 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2020 Open Mobile Platform LLC.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -7,7 +9,7 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  */
@@ -18,13 +20,18 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <gutil_log.h>
 #include <gutil_strv.h>
 
+#include <gio/gunixfdlist.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
 /* Generated headers */
 #include "org.nemomobile.MmsEngine.h"
 
-static const char pname[] = "mms-send";
-
 enum app_ret_value {
     RET_OK,
     RET_ERR_CMDLINE,
@@ -41,73 +48,138 @@ typedef struct mms_send_opt {
 
 #define MMS_SEND_REQUEST_DELIVERY_REPORT (0x01)
 #define MMS_SEND_REQUEST_READ_REPORT     (0x02)
+#define MMS_SEND_REQUEST_LEGACY_API      (0x04)
 
 static
 char*
-mms_send(
+mms_send_proxy(
+    OrgNemomobileMmsEngine* proxy,
     char* files[],
     int count,
     const MmsSendOpt* opt)
 {
-    char* imsi_out = NULL;
+    int i;
     GError* error = NULL;
-    OrgNemomobileMmsEngine* proxy =
-        org_nemomobile_mms_engine_proxy_new_for_bus_sync(
-            G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE,
-            "org.nemomobile.MmsEngine", "/", NULL, &error);
+    GVariant* parts = NULL;
+    GVariantBuilder gb;
+    char* imsi_out = NULL;
+    char** to_list = g_strsplit(opt->to, ",", 0);
+    const char* imsi = opt->imsi ? opt->imsi : "";
+    const char* subject = opt->subject ? opt->subject : "";
+    const char* none = NULL;
+    gboolean ok = TRUE;
 
-    if (proxy) {
-        int i;
-        gboolean ok = TRUE;
+    if (opt->flags & MMS_SEND_REQUEST_LEGACY_API) {
         char* fname = g_malloc(PATH_MAX);
-        GVariant* parts;
-        GVariantBuilder b;
 
-        g_variant_builder_init(&b, G_VARIANT_TYPE("a(sss)"));
+        g_variant_builder_init(&gb, G_VARIANT_TYPE("a(sss)"));
         for (i = 0; ok && i < count; i++) {
             if (realpath(files[i], fname)) {
                 if (g_file_test(fname, G_FILE_TEST_IS_REGULAR)) {
                     const char* ctype = gutil_strv_at(opt->ctype, i);
 
-                    g_variant_builder_add(&b, "(sss)", fname,
+                    g_variant_builder_add(&gb, "(sss)", fname,
                         ctype ? ctype : "", "");
-                } else {
-                    fprintf(stderr, "%s: no such file: %s\n", pname, fname);
-                    ok = FALSE;
+                    continue;
                 }
+                GERR("no such file: %s\n", fname);
             } else {
-                fprintf(stderr, "%s: %s\n", fname, strerror(errno));
-                ok = FALSE;
+                GERR("%s: %s\n", fname, strerror(errno));
             }
+            ok = FALSE;
         }
 
-        parts = g_variant_ref_sink(g_variant_builder_end(&b));
         if (ok) {
-            char** to_list = g_strsplit(opt->to, ",", 0);
-            const char* imsi = opt->imsi ? opt->imsi : "";
-            const char* subject = opt->subject ? opt->subject : "";
-            const char* none = NULL;
-
-            if (!org_nemomobile_mms_engine_call_send_message_sync(proxy,
+            parts = g_variant_ref_sink(g_variant_builder_end(&gb));
+            org_nemomobile_mms_engine_call_send_message_sync(proxy,
                 0, imsi, (const gchar* const*)to_list, &none, &none,
-                subject, opt->flags, parts, &imsi_out, NULL, &error)) {
-                /* D-Bus error */
-                fprintf(stderr, "%s\n", error->message);
-                g_error_free(error);
+                subject, opt->flags, parts, &imsi_out, NULL, &error);
+        }
+        g_free(fname);
+    } else {
+        int* fds = g_new(int, count);
+
+        g_variant_builder_init(&gb, G_VARIANT_TYPE("a(hsss)"));
+        for (i = 0; i < count; i++) {
+            const char* fname = files[i];
+
+            fds[i] = open(fname, O_RDONLY, 0);
+            if (fds[i] >= 0) {
+                struct stat st;
+
+                if (!fstat(fds[i], &st)) {
+                    if (S_ISREG(st.st_mode)) {
+                        char* basename = g_path_get_basename(fname);
+                        const char* ctype = gutil_strv_at(opt->ctype, i);
+
+                        g_variant_builder_add(&gb, "(@hsss)",
+                            g_variant_new_handle(i), basename,
+                            ctype ? ctype : "", "");
+                        g_free(basename);
+                        continue;
+                    } else {
+                        GERR("not a regular file: %s", fname);
+                    }
+                } else {
+                    GERR("%s: %s\n", fname, strerror(errno));
+                }
+                close(fds[i]);
             }
-            g_strfreev(to_list);
+            ok = FALSE;
+            while (i > 0) close(fds[--i]);
+            break;
         }
+        if (ok) {
+            GUnixFDList* fdl = g_unix_fd_list_new_from_array(fds, count);
 
-        g_free(fname);
+            parts = g_variant_ref_sink(g_variant_builder_end(&gb));
+            org_nemomobile_mms_engine_call_send_message_fd_sync(proxy,
+                0, imsi, (const gchar* const*)to_list, &none, &none,
+                subject, opt->flags, parts, fdl, &imsi_out, NULL, NULL,
+                &error);
+            g_object_unref(fdl);
+        }
+        g_free(fds);
+    }
+    if (parts) {
         g_variant_unref(parts);
-        g_object_unref(proxy);
-    } else if (error) {
-        fprintf(stderr, "%s\n", error->message);
+    } else {
+        g_variant_builder_clear(&gb);
+    }
+    if (error) {
+        /* D-Bus error */
+        GERR("%s", GERRMSG(error));
         g_error_free(error);
     }
+    g_strfreev(to_list);
     return imsi_out;
 }
 
+static
+char*
+mms_send(
+    char* files[],
+    int count,
+    const MmsSendOpt* opt)
+{
+    GError* error = NULL;
+    OrgNemomobileMmsEngine* proxy =
+        org_nemomobile_mms_engine_proxy_new_for_bus_sync(
+            G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE,
+            "org.nemomobile.MmsEngine", "/", NULL, &error);
+
+    if (proxy) {
+        char* imsi_out = mms_send_proxy(proxy, files, count, opt);
+
+        g_object_unref(proxy);
+        return imsi_out;
+    } else {
+        GERR("%s", GERRMSG(error));
+        g_error_free(error);
+        return NULL;
+    }
+}
+
 /* Limit the scape of global variable */
 static MmsSendOpt app_opt;
 
@@ -144,7 +216,7 @@ mms_send_opt_content_type(
 int main(int argc, char* argv[])
 {
     int ret = RET_ERR_CMDLINE;
-    gboolean ok, verbose = FALSE, dr = FALSE, rr = FALSE;
+    gboolean ok, verbose = FALSE, dr = FALSE, rr = FALSE, legacy = FALSE;
     GError* error = NULL;
     GOptionEntry entries[] = {
         { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
@@ -160,19 +232,25 @@ int main(int argc, char* argv[])
         { "content-type", 't', 0, G_OPTION_ARG_CALLBACK,
           mms_send_opt_content_type,
           "Content type (repeatable)", "TYPE" },
+        { "legacy", 'l', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &legacy,
+          "Use legacy D-Bus API", NULL },
         { NULL }
     };
     GOptionContext* options = g_option_context_new("TO FILES...");
 
+    gutil_log_timestamp = FALSE;
+    gutil_log_default.name = "mms-send";
     mms_send_opt_init(&app_opt);
     g_option_context_add_main_entries(options, entries, NULL);
     ok = g_option_context_parse(options, &argc, &argv, &error);
     if (ok) {
+        if (verbose) gutil_log_default.level = GLOG_LEVEL_VERBOSE;
         if (argc > 2) {
             char* res;
 
             if (dr) app_opt.flags |= MMS_SEND_REQUEST_DELIVERY_REPORT;
             if (rr) app_opt.flags |= MMS_SEND_REQUEST_READ_REPORT;
+            if (legacy) app_opt.flags |= MMS_SEND_REQUEST_LEGACY_API;
             app_opt.to = argv[1];
             res = mms_send(argv + 2, argc - 2, &app_opt);
             if (res) {
@@ -186,7 +264,7 @@ int main(int argc, char* argv[])
             g_free(help);
         }
     } else {
-        printf("%s: %s\n", pname, error->message);
+        GERR("%s", GERRMSG(error));
         g_error_free(error);
     }
     g_option_context_free(options);