Merge lp:~cyphermox/mtp/windows+sdcard+security into lp:mtp

[Mathieu Trudel-Lapierre]

Add support for Windows, SD card, and screen locking.

Add support for Windows, SD card, and screen locking.

[Michael Frey (mfrey)]

Tested on both Mac OS and Ubuntu.

Can confirm security, sdcard support works as intended.

review: Approve

[lp:~cyphermox/mtp/windows+sdcard+security]

49. By Mathieu Trudel-Lapierre on 2014-08-14

Add missing 0.0.3+14.04.20140409-0ubuntu2 changelog

50. By Mathieu Trudel-Lapierre on 2014-08-14

Add missing changes for 0.0.3+14.04.20140409-0ubuntu3.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:48
http://jenkins.qa.ubuntu.com/job/mtp-ci/16/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/1
        deb: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/1/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-i386-ci/1

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mtp-ci/16/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:50
http://jenkins.qa.ubuntu.com/job/mtp-ci/17/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-amd64-ci/2
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/2
        deb: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/2/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-i386-ci/2

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mtp-ci/17/rebuild

review: Approve (continuous-integration)

[Sergio Schvezov (sergiusens)]

I'm getting a bunch of these on boot:
terminate called after throwing an instance of 'std::runtime_error'
  what(): org.freedesktop.DBus.Error.NoReply: Did not receive a reply. Possible causes include: the remote application did not send a reply, the message bus security policy blocked the reply, the reply timeout expired, or the network connection was broken.
I0814 16:34:34.118505 2627 server.cpp:359] MTP server starting...

I'm also not seeing my sdcard; only the internal one (my sdcard has files dropped in, no directories in it)

review: Needs Fixing

[Mathieu Trudel-Lapierre (cyphermox)]

Are you using the latest image? The security bits depend on having UnityGreeter available on the session bus. It's the only thing that requires DBus.

How do you proceed to do the SD card tests?

[Sergio Schvezov (sergiusens)]

On viernes 15 de agosto de 2014 11h'33:39 ART, Mathieu Trudel-Lapierre
wrote:
> Are you using the latest image? The security bits depend on
> having UnityGreeter available on the session bus. It's the only
> thing that requires DBus.

- Tried on image 190.

> How do you proceed to do the SD card tests?

- Tried to test with the sdcard plugged on boot
- Tried popping in the sdcard while in the session.

I have music in the sdcard root. The patched mediascanner picks it up just
fine fwiw.

[lp:~cyphermox/mtp/windows+sdcard+security]

51. By Mathieu Trudel-Lapierre on 2014-08-18

Fix sdcard hotswapping.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:51
http://jenkins.qa.ubuntu.com/job/mtp-ci/18/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-amd64-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/3
        deb: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/3/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-i386-ci/3

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mtp-ci/18/rebuild

review: Approve (continuous-integration)

[Manuel de la Peña (mandel)]

Some small comments about the code just to make it clear for new commers.

review: Needs Fixing

[lp:~cyphermox/mtp/windows+sdcard+security]

52. By Mathieu Trudel-Lapierre on 2014-08-20

Apply suggested changes from review by mandel

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:52
http://jenkins.qa.ubuntu.com/job/mtp-ci/19/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/4
        deb: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/4/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-i386-ci/4

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mtp-ci/19/rebuild

review: Approve (continuous-integration)

[Manuel de la Peña (mandel)]

review: Approve

[lp:~cyphermox/mtp/windows+sdcard+security]

53. By Mathieu Trudel-Lapierre on 2014-08-21

Revert use of scoped_ptr; seems to crash at least object listing in some cases.

54. By Mathieu Trudel-Lapierre on 2014-08-21

Simplify retry logic for when the mountpoint is available but not yet populated.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:54
http://jenkins.qa.ubuntu.com/job/mtp-ci/20/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/mtp-utopic-armhf-ci/5/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mtp-utopic-i386-ci/5

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mtp-ci/20/rebuild

review: Approve (continuous-integration)

[Sergio Schvezov (sergiusens)]

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-03-27 15:45:30 +0000
+++ CMakeLists.txt	2014-08-21 19:42:07 +0000
@@ -13,7 +13,8 @@
 set(MTP_VERSION_PATCH 0)
 
 find_package(Boost REQUIRED COMPONENTS thread system filesystem unit_test_framework)
-pkg_check_modules(GLOG libglog)
+pkg_check_modules(DBUSCPP REQUIRED dbus-cpp)
+pkg_check_modules(GLOG REQUIRED libglog)
 
 set(
     MTP_HEADERS
@@ -59,6 +60,7 @@
     include/
     libusbhost/include
     ${Boost_INCLUDE_DIRS}
+    ${DBUSCPP_INCLUDE_DIRS}
 )
 
 add_library(
@@ -70,6 +72,7 @@
   mtpserver
   android-properties
   ${GLOG_LIBRARIES}
+  ${DBUSCPP_LIBRARIES}
 )
 
 set_target_properties(

=== modified file 'debian/changelog'
--- debian/changelog	2014-04-09 03:00:23 +0000
+++ debian/changelog	2014-08-21 19:42:07 +0000
@@ -1,3 +1,29 @@
+mtp (0.0.4+14.04.20140814-0ubuntu1) UNRELEASED; urgency=medium
+
+  * New release:
+    - Bugfixes.
+    - Enhancements on error handling.
+    - Add support for working with Windows systems.
+    - Add support for locking: don't allow access to storage while the screen
+      is locked.
+    - Support removable storage by watching for mounted storage in the /media
+      directory tree.   
+
+ -- Mathieu Trudel-Lapierre <[e-mail]>  Thu, 14 Aug 2014 11:09:02 -0400
+
+mtp (0.0.3+14.04.20140409-0ubuntu3) utopic; urgency=medium
+
+  * make sure mtp-server only gets started in user sessions and not in lightdm
+    greeter sessions
+
+ -- Oliver Grawert <[e-mail]>  Tue, 03 Jun 2014 13:24:56 +0200
+
+mtp (0.0.3+14.04.20140409-0ubuntu2) utopic; urgency=high
+
+  * No change rebuild against boost1.55.
+
+ -- Dimitri John Ledkov <[e-mail]>  Tue, 29 Apr 2014 04:38:54 +0100
+
 mtp (0.0.3+14.04.20140409-0ubuntu1) trusty; urgency=medium
 
   [ Mathieu Trudel-Lapierre ]

=== modified file 'debian/control'
--- debian/control	2014-03-27 15:45:30 +0000
+++ debian/control	2014-08-21 19:42:07 +0000
@@ -12,6 +12,9 @@
                libboost-test-dev,
                libandroid-properties-dev,
                libgoogle-glog-dev,
+               libdbus-1-dev,
+               libproperties-cpp-dev,
+               libdbus-cpp-dev,
 Standards-Version: 3.9.4
 Homepage: http://launchpad.net/mtp
 # If you aren't ~phablet-team but need to upload packaging changes,

=== modified file 'debian/mtp-server.conf'
--- debian/mtp-server.conf	2014-03-27 15:45:30 +0000
+++ debian/mtp-server.conf	2014-08-21 19:42:07 +0000
@@ -3,6 +3,10 @@
 start on :sys:android-mtp-on or :sys:android-usb-connected
 stop on desktop-end or :sys:android-mtp-off
 
+pre-start script
+    [ "$USER" != "lightdm" ] || { stop; exit 0; }
+end script
+
 env GOOGLE_LOGTOSTDERR=1
 
 respawn

=== modified file 'include/MtpDatabase.h'
--- include/MtpDatabase.h	2014-03-27 15:50:32 +0000
+++ include/MtpDatabase.h	2014-08-21 19:42:07 +0000
@@ -30,6 +30,14 @@
 public:
     virtual ~MtpDatabase() {}
 
+    // called to add a path to include in the database.
+    virtual void                    addStoragePath(const MtpString& path,
+                                                   MtpStorageID storage,
+                                                   bool hidden) = 0;
+
+    // Called to remove database entries for a storage.
+    virtual void                    removeStorage(MtpStorageID storage) = 0;
+
     // called from SendObjectInfo to reserve a database entry for the incoming file
     virtual MtpObjectHandle         beginSendObject(const MtpString& path,
                                             MtpObjectFormat format,

=== modified file 'server/UbuntuMtpDatabase.h'
--- server/UbuntuMtpDatabase.h	2014-04-01 15:50:59 +0000
+++ server/UbuntuMtpDatabase.h	2014-08-21 19:42:07 +0000
@@ -45,9 +45,12 @@
 #include <boost/filesystem.hpp>
 #include <boost/range/adaptors.hpp>
 #include <boost/range/algorithm.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <glog/logging.h>
 
+#define ALL_PROPERTIES 0xffffffff
+
 namespace asio = boost::asio;
 using namespace boost::filesystem;
 
@@ -64,6 +67,7 @@
         std::string display_name;
         std::string path;
         int watch_fd;
+        std::time_t last_modified;
     };
 
     MtpServer* local_server;
@@ -85,6 +89,7 @@
     boost::thread io_service_thread;
 
     asio::io_service io_svc;
+    asio::io_service::work work;
     asio::posix::stream_descriptor stream_desc;
     asio::streambuf buf;
     int inotify_fd;
@@ -113,7 +118,7 @@
     }
 
     
-    void add_file_entry(path p, MtpObjectHandle parent)
+    void add_file_entry(path p, MtpObjectHandle parent, MtpStorageID storage)
     {
         MtpObjectHandle handle = counter;
         DbEntry entry;
@@ -121,28 +126,30 @@
         counter++;
 
         if (is_directory(p)) {
-            entry.storage_id = MTP_STORAGE_FIXED_RAM;
+            entry.storage_id = storage;
             entry.parent = parent;
             entry.display_name = std::string(p.filename().string());
             entry.path = p.string();
             entry.object_format = MTP_FORMAT_ASSOCIATION;
             entry.object_size = 0;
             entry.watch_fd = setup_dir_inotify(p);
+            entry.last_modified = last_write_time(p);
 
             db.insert( std::pair<MtpObjectHandle, DbEntry>(handle, entry) );
 
             if (local_server)
                 local_server->sendObjectAdded(handle);
 
-            parse_directory (p, handle);
+            parse_directory (p, handle, storage);
         } else {
             try {
-                entry.storage_id = MTP_STORAGE_FIXED_RAM;
+                entry.storage_id = storage;
                 entry.parent = parent;
                 entry.display_name = std::string(p.filename().string());
                 entry.path = p.string();
                 entry.object_format = guess_object_format(p.extension().string());
                 entry.object_size = file_size(p);
+                entry.last_modified = last_write_time(p);
 
                 VLOG(1) << "Adding \"" << p.string() << "\"";
 
@@ -157,20 +164,28 @@
         }
     }
 
-    void parse_directory(path p, MtpObjectHandle parent)
+    void parse_directory(path p, MtpObjectHandle parent, MtpStorageID storage)
     {
 	DbEntry entry;
         std::vector<path> v;
-
-        copy(directory_iterator(p), directory_iterator(), std::back_inserter(v));
+        boost::system::error_code ec;
+        directory_iterator i (p, ec);
+
+        if (ec == boost::system::errc::permission_denied) {
+            VLOG(2) << "Could not immediately read dir; retrying.";
+            boost::this_thread::sleep(boost::posix_time::millisec(500));
+            i = directory_iterator(p);
+        }
+
+        copy(i, directory_iterator(), std::back_inserter(v));
 
         for (std::vector<path>::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
         {
-            add_file_entry(*it, parent);
+            add_file_entry(*it, parent, storage);
         }
     }
 
-    void readFiles(const std::string& sourcedir)
+    void readFiles(const std::string& sourcedir, MtpStorageID storage, bool hidden)
     {
         path p (sourcedir);
 	DbEntry entry;
@@ -179,20 +194,34 @@
         try {
             if (exists(p)) {
                 if (is_directory(p)) {
-                    entry.storage_id = MTP_STORAGE_FIXED_RAM;
-                    entry.parent = MTP_PARENT_ROOT;
+                    entry.storage_id = storage;
+                    entry.parent = hidden ? MTP_PARENT_ROOT : 0;
                     entry.display_name = std::string(p.filename().string());
                     entry.path = p.string();
                     entry.object_format = MTP_FORMAT_ASSOCIATION;
                     entry.object_size = 0;
                     entry.watch_fd = setup_dir_inotify(p);
+                    entry.last_modified = last_write_time(p);
 
                     db.insert( std::pair<MtpObjectHandle, DbEntry>(handle, entry) );
 
-                    parse_directory (p, handle);
+                    parse_directory (p, hidden ? 0 : handle, storage);
+                } else
+                    LOG(WARNING) << p << " is not a directory.";
+            } else {
+                if (storage == MTP_STORAGE_FIXED_RAM)
+                    LOG(WARNING) << p << " does not exist.";
+                else {
+                    entry.storage_id = storage;
+                    entry.parent = -1;
+                    entry.display_name = std::string(p.parent_path().filename().string());
+                    entry.path = p.parent_path().string();
+                    entry.object_format = MTP_FORMAT_ASSOCIATION;
+                    entry.object_size = 0;
+                    entry.watch_fd = setup_dir_inotify(p.parent_path());
+                    entry.last_modified = 0;
                 }
-            } else
-                LOG(WARNING) << p << " does not exist\n";
+            }
         }
         catch (const filesystem_error& ex) {
             LOG(ERROR) << ex.what();
@@ -247,10 +276,22 @@
             }
             else if(ievent->len > 0 && ievent->mask & IN_CREATE)
             {
+                int parent_handle = parent;
+
                 VLOG(2) << __PRETTY_FUNCTION__ << ": file created: " << p.string();
 
+                /* Deal with the special case where the SD card might initially
+                 * require an inotify watch, because it's not yet mounted.
+                 * In this case, the SD card inotify watch is entered as a
+                 * normal object, but the parent for the "real" directory
+                 * for the mounted removable media should be the MTP root
+                 * for the storage ID.
+                 */
+                if (db.at(parent).parent == MTP_PARENT_ROOT)
+                    parent_handle = 0;
+
                 /* try to deal with it as if it was a file. */
-                add_file_entry(p, parent);
+                add_file_entry(p, parent_handle, db.at(parent).storage_id);
             }
             else if(ievent->len > 0 && ievent->mask & IN_DELETE)
             {
@@ -271,18 +312,18 @@
     }
 
 public:
-    UbuntuMtpDatabase(const char *dir):
+    UbuntuMtpDatabase():
         counter(1),
         stream_desc(io_svc),
+        work(io_svc),
         buf(1024)
     {
-	std::string basedir (dir);
-
         local_server = nullptr;
 
         inotify_fd = inotify_init();
         if (inotify_fd <= 0)
-            PLOG(FATAL) << "Unable to initialize inotify";
+            PLOG(FATAL) << "Invalid file descriptor to inotify";
+        VLOG(1) << "using inotify fd " << inotify_fd << " for database";
 
         stream_desc.assign(inotify_fd);
 
@@ -291,14 +332,6 @@
         notifier_thread = boost::thread(&UbuntuMtpDatabase::read_more_notify,
                                        this);
 
-	readFiles(basedir + "/Documents");
-	readFiles(basedir + "/Music");
-	readFiles(basedir + "/Videos");
-	readFiles(basedir + "/Pictures");
-	readFiles(basedir + "/Downloads");
-
-        LOG(INFO) << "Added " << counter << " entries to the database.";
-
         io_service_thread = boost::thread(boost::bind(&asio::io_service::run, &io_svc));
     }
 
@@ -309,6 +342,22 @@
         close(inotify_fd);
     }
 
+    virtual void addStoragePath(const MtpString& path,
+                                MtpStorageID storage,
+                                bool hidden)
+    {
+	readFiles(path, storage, hidden);
+    }
+
+    virtual void removeStorage(MtpStorageID storage)
+    {
+        // remove all database entries corresponding to said storage.
+        BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
+            if (db.at(i).storage_id == storage)
+                db.erase(i);
+        }
+    }
+
     // called from SendObjectInfo to reserve a database entry for the incoming file
     virtual MtpObjectHandle beginSendObject(
         const MtpString& path,
@@ -324,7 +373,8 @@
         if (parent == 0)
             return kInvalidObjectHandle;
 
-        VLOG(1) << __PRETTY_FUNCTION__ << ": " << path << " - " << parent;
+        VLOG(1) << __PRETTY_FUNCTION__ << ": " << path << " - " << parent
+                << " format: " << std::hex << format << std::dec;
 
         entry.storage_id = storage;
         entry.parent = parent;
@@ -332,6 +382,7 @@
         entry.path = path;
         entry.object_format = format;
         entry.object_size = size;
+        entry.last_modified = modified;
 
         db.insert( std::pair<MtpObjectHandle, DbEntry>(handle, entry) );
 
@@ -351,15 +402,22 @@
     {
         VLOG(1) << __PRETTY_FUNCTION__ << ": " << path;
 
-	if (!succeeded) {
-            db.erase(handle);
-        } else {
-            boost::filesystem::path p (path);
+        try
+        {
+	    if (!succeeded) {
+                db.erase(handle);
+            } else {
+                boost::filesystem::path p (path);
 
-            if (format != MTP_FORMAT_ASSOCIATION) {
-                /* Resync file size, just in case this is actually an Edit. */
-                db.at(handle).object_size = file_size(p);
+                if (format != MTP_FORMAT_ASSOCIATION) {
+                    /* Resync file size, just in case this is actually an Edit. */
+                    db.at(handle).object_size = file_size(p);
+                }
             }
+        } catch(...)
+        {
+            LOG(ERROR) << __PRETTY_FUNCTION__
+                       << ": failed to complete object creation:" << path;
         }
     }
 
@@ -370,13 +428,18 @@
     {
         VLOG(1) << __PRETTY_FUNCTION__ << ": " << storageID << ", " << format << ", " << parent;
         MtpObjectHandleList* list = nullptr;
+
+        if (parent == MTP_PARENT_ROOT)
+            parent = 0;
+
         try
         {
             std::vector<MtpObjectHandle> keys;
 
             BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
-                if (db.at(i).parent == parent)
-                    keys.push_back(i);
+                if (db.at(i).storage_id == storageID && db.at(i).parent == parent)
+                    if (format == 0 || db.at(i).object_format == format)
+                        keys.push_back(i);
             }
 
             list = new MtpObjectHandleList(keys);
@@ -394,14 +457,19 @@
         MtpObjectHandle parent)
     {
         VLOG(1) << __PRETTY_FUNCTION__ << ": " << storageID << ", " << format << ", " << parent;
+
+        int result = 0;
+
         try
         {
-            return db.size();
+            MtpObjectHandleList *list = getObjectList(storageID, format, parent);
+            result = list->size();
+            delete list;
         } catch(...)
         {
         }
         
-        return 0;
+        return result;
     }
 
     // callee should delete[] the results from these
@@ -412,6 +480,22 @@
         static const MtpObjectFormatList list = {
             /* Generic files */
             MTP_FORMAT_UNDEFINED,
+            MTP_FORMAT_ASSOCIATION, // folders
+            MTP_FORMAT_TEXT,
+            MTP_FORMAT_HTML,
+
+            /* Supported image formats */
+            MTP_FORMAT_DEFINED, // generic image
+            MTP_FORMAT_EXIF_JPEG,
+            MTP_FORMAT_TIFF_EP,
+            MTP_FORMAT_BMP,
+            MTP_FORMAT_GIF,
+            MTP_FORMAT_JFIF,
+            MTP_FORMAT_PNG,
+            MTP_FORMAT_TIFF,
+            MTP_FORMAT_TIFF_IT,
+            MTP_FORMAT_JP2,
+            MTP_FORMAT_JPX,
 
             /* Supported audio formats */
             MTP_FORMAT_OGG,
@@ -455,11 +539,17 @@
             MTP_PROPERTY_PARENT_OBJECT,
             MTP_PROPERTY_OBJECT_FORMAT,
             MTP_PROPERTY_OBJECT_SIZE,
-            MTP_PROPERTY_WIDTH,
-            MTP_PROPERTY_HEIGHT,
-            MTP_PROPERTY_IMAGE_BIT_DEPTH,
             MTP_PROPERTY_OBJECT_FILE_NAME,
-            MTP_PROPERTY_DISPLAY_NAME            
+            MTP_PROPERTY_DISPLAY_NAME,
+            MTP_PROPERTY_PERSISTENT_UID,
+            MTP_PROPERTY_ASSOCIATION_TYPE,
+            MTP_PROPERTY_ASSOCIATION_DESC,
+            MTP_PROPERTY_PROTECTION_STATUS,
+            MTP_PROPERTY_DATE_CREATED,
+            MTP_PROPERTY_DATE_MODIFIED,
+            MTP_PROPERTY_HIDDEN,
+            MTP_PROPERTY_NON_CONSUMABLE,
+
         };
          
         return new MtpObjectPropertyList{list};
@@ -468,7 +558,10 @@
     virtual MtpDevicePropertyList* getSupportedDeviceProperties()
     {
         VLOG(1) << __PRETTY_FUNCTION__;
-        static const MtpDevicePropertyList list = { MTP_DEVICE_PROPERTY_UNDEFINED };
+        static const MtpDevicePropertyList list = {
+            MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME,
+            MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER, 
+        };
         return new MtpDevicePropertyList{list};
     }
 
@@ -477,22 +570,62 @@
         MtpObjectProperty property,
         MtpDataPacket& packet)
     {        
+        char date[20];
+
         VLOG(1) << __PRETTY_FUNCTION__
                 << " handle: " << handle
                 << " property: " << MtpDebug::getObjectPropCodeName(property);
 
-        switch(property)
-        {
-            case MTP_PROPERTY_STORAGE_ID: packet.putUInt32(db.at(handle).storage_id); break;            
-            case MTP_PROPERTY_PARENT_OBJECT: packet.putUInt32(db.at(handle).parent); break;            
-            case MTP_PROPERTY_OBJECT_FORMAT: packet.putUInt32(db.at(handle).object_format); break;
-            case MTP_PROPERTY_OBJECT_SIZE: packet.putUInt32(db.at(handle).object_size); break;
-            case MTP_PROPERTY_DISPLAY_NAME: packet.putString(db.at(handle).display_name.c_str()); break;
-            case MTP_PROPERTY_OBJECT_FILE_NAME: packet.putString(db.at(handle).display_name.c_str()); break;
-            default: return MTP_RESPONSE_GENERAL_ERROR; break;                
-        }
+        if (handle == MTP_PARENT_ROOT || handle == 0)
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
+        try {
+            switch(property)
+            {
+                case MTP_PROPERTY_STORAGE_ID: packet.putUInt32(db.at(handle).storage_id); break;            
+                case MTP_PROPERTY_PARENT_OBJECT: packet.putUInt32(db.at(handle).parent); break;            
+                case MTP_PROPERTY_OBJECT_FORMAT: packet.putUInt16(db.at(handle).object_format); break;
+                case MTP_PROPERTY_OBJECT_SIZE: packet.putUInt32(db.at(handle).object_size); break;
+                case MTP_PROPERTY_DISPLAY_NAME: packet.putString(db.at(handle).display_name.c_str()); break;
+                case MTP_PROPERTY_OBJECT_FILE_NAME: packet.putString(db.at(handle).display_name.c_str()); break;
+                case MTP_PROPERTY_PERSISTENT_UID: packet.putUInt128(handle); break;
+                case MTP_PROPERTY_ASSOCIATION_TYPE:
+                    if (db.at(handle).object_format == MTP_FORMAT_ASSOCIATION)
+                        packet.putUInt16(MTP_ASSOCIATION_TYPE_GENERIC_FOLDER);
+                    else
+                        packet.putUInt16(0);
+                    break;
+                case MTP_PROPERTY_ASSOCIATION_DESC: packet.putUInt32(0); break;
+                case MTP_PROPERTY_PROTECTION_STATUS:
+                    packet.putUInt16(0x0000); // no files are read-only for now.
+                    break;
+                case MTP_PROPERTY_DATE_CREATED:
+                    formatDateTime(0, date, sizeof(date));
+                    packet.putString(date);
+                    break;
+                case MTP_PROPERTY_DATE_MODIFIED:
+                    formatDateTime(db.at(handle).last_modified, date, sizeof(date));
+                    packet.putString(date);
+                    break;
+                case MTP_PROPERTY_HIDDEN: packet.putUInt16(0); break;
+                case MTP_PROPERTY_NON_CONSUMABLE: break;
+                    if (db.at(handle).object_format == MTP_FORMAT_ASSOCIATION)
+                        packet.putUInt16(0); // folders are non-consumable
+                    else
+                        packet.putUInt16(1); // files can usually be played.
+                    break;
+                default: return MTP_RESPONSE_GENERAL_ERROR; break;                
+            }
         
-        return MTP_RESPONSE_OK;
+            return MTP_RESPONSE_OK;
+        }
+        catch (...) {
+            LOG(ERROR) << __PRETTY_FUNCTION__
+                       << "Could not retrieve property: "
+                       << MtpDebug::getObjectPropCodeName(property)
+                       << " for handle: " << handle;
+            return MTP_RESPONSE_GENERAL_ERROR;
+        }
     }
 
     virtual MtpResponseCode setObjectPropertyValue(
@@ -511,6 +644,9 @@
                 << " handle: " << handle
                 << " property: " << MtpDebug::getObjectPropCodeName(property);
 
+        if (handle == MTP_PARENT_ROOT || handle == 0)
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
         switch(property)
         {
             case MTP_PROPERTY_OBJECT_FILE_NAME:
@@ -539,6 +675,16 @@
 		}
 
                 break;
+            case MTP_PROPERTY_PARENT_OBJECT:
+                try {
+                    entry = db.at(handle);
+                    entry.parent = packet.getUInt32();
+                }
+                catch (...) {
+                    LOG(ERROR) << "Could not change parent object for handle "
+                               << handle;
+                    return MTP_RESPONSE_GENERAL_ERROR;
+                }
             default: return MTP_RESPONSE_OPERATION_NOT_SUPPORTED; break;
         }
         
@@ -550,7 +696,16 @@
         MtpDataPacket& packet)
     {
         VLOG(1) << __PRETTY_FUNCTION__;
-        return MTP_RESPONSE_GENERAL_ERROR;
+        switch(property)
+        {
+            case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER:
+            case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME:
+                packet.putString("");
+                break;
+            default: return MTP_RESPONSE_OPERATION_NOT_SUPPORTED; break;
+        }
+        
+        return MTP_RESPONSE_OK;
     }
 
     virtual MtpResponseCode setDevicePropertyValue(
@@ -558,14 +713,14 @@
         MtpDataPacket& packet)
     {
         VLOG(1) << __PRETTY_FUNCTION__;
-        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+        return MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED;
     }
 
     virtual MtpResponseCode resetDeviceProperty(
         MtpDeviceProperty property)
     {
         VLOG(1) << __PRETTY_FUNCTION__;
-        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+        return MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED;
     }
 
     virtual MtpResponseCode getObjectPropertyList(
@@ -576,8 +731,184 @@
         int depth,
         MtpDataPacket& packet)
     {
+        std::vector<MtpObjectHandle> handles;
+
         VLOG(2) << __PRETTY_FUNCTION__;
-        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;
+
+        if (handle == kInvalidObjectHandle)
+            return MTP_RESPONSE_PARAMETER_NOT_SUPPORTED;
+
+        if (property == 0 && groupCode == 0)
+            return MTP_RESPONSE_PARAMETER_NOT_SUPPORTED;
+
+        if (groupCode != 0)
+            return MTP_RESPONSE_SPECIFICATION_BY_GROUP_UNSUPPORTED;
+
+        if (depth > 1)
+            return MTP_RESPONSE_SPECIFICATION_BY_DEPTH_UNSUPPORTED;
+
+        if (depth == 0) {
+            /* For a depth search, a handle of 0 is valid (objects at the root)
+             * but it isn't when querying for the properties of a single object.
+             */
+            if (db.find(handle) == db.end())
+                return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
+            handles.push_back(handle);
+        } else {
+            BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
+                if (db.at(i).parent == handle)
+                    handles.push_back(i);
+            }
+        }
+
+        /*
+         * getObjectPropList returns an ObjectPropList dataset table;
+         * built as such:
+         *
+         * 1- Number of elements (quadruples)
+         * a1- Element 1 Object Handle
+         * a2- Element 1 Property Code
+         * a3- Element 1 Data type
+         * a4- Element 1 Value
+         * b... rinse, repeat.
+         */
+
+        if (property == ALL_PROPERTIES)
+             packet.putUInt32(6 * handles.size());
+        else
+             packet.putUInt32(1 * handles.size());
+
+        BOOST_FOREACH(MtpObjectHandle i, handles) {
+            DbEntry entry = db.at(i);
+
+            // Persistent Unique Identifier.
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_PERSISTENT_UID) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_PERSISTENT_UID);
+                packet.putUInt16(MTP_TYPE_UINT128);
+                packet.putUInt128(i);
+            }
+
+            // Storage ID
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_STORAGE_ID) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_STORAGE_ID);
+                packet.putUInt16(MTP_TYPE_UINT32);
+                packet.putUInt32(entry.storage_id);
+            }
+
+            // Parent
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_PARENT_OBJECT) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_PARENT_OBJECT);
+                packet.putUInt16(MTP_TYPE_UINT32);
+                packet.putUInt32(entry.parent);
+            }
+
+            // Object Format
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_OBJECT_FORMAT) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_OBJECT_FORMAT);
+                packet.putUInt16(MTP_TYPE_UINT16);
+                packet.putUInt16(entry.object_format);
+            }
+
+            // Object Size
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_OBJECT_SIZE) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_OBJECT_SIZE);
+                packet.putUInt16(MTP_TYPE_UINT32);
+                packet.putUInt32(entry.object_size);
+            }
+
+            // Object File Name
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_OBJECT_FILE_NAME) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_OBJECT_FILE_NAME);
+                packet.putUInt16(MTP_TYPE_STR);
+                packet.putString(entry.display_name.c_str());
+            }
+
+            // Display Name
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_DISPLAY_NAME) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_DISPLAY_NAME);
+                packet.putUInt16(MTP_TYPE_STR);
+                packet.putString(entry.display_name.c_str());
+            }
+
+            // Association Type
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_ASSOCIATION_TYPE) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_ASSOCIATION_TYPE);
+                packet.putUInt16(MTP_TYPE_UINT16);
+                if (entry.object_format == MTP_FORMAT_ASSOCIATION)
+                    packet.putUInt16(MTP_ASSOCIATION_TYPE_GENERIC_FOLDER);
+                else
+                    packet.putUInt16(0);
+            }
+
+            // Association Description
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_ASSOCIATION_DESC) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_ASSOCIATION_DESC);
+                packet.putUInt16(MTP_TYPE_UINT32);
+                packet.putUInt32(0);
+            }
+
+            // Protection Status
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_PROTECTION_STATUS) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_PROTECTION_STATUS);
+                packet.putUInt16(MTP_TYPE_UINT16);
+                packet.putUInt16(0x0000); //FIXME: all files are read-write for now
+                // packet.putUInt16(0x8001);
+            }
+
+            // Date Created
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_DATE_CREATED) {
+                char date[20];
+                formatDateTime(0, date, sizeof(date));
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_DATE_CREATED);
+                packet.putUInt16(MTP_TYPE_STR);
+                packet.putString(date);
+            }
+
+            // Date Modified
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_DATE_MODIFIED) {
+                char date[20];
+                formatDateTime(entry.last_modified, date, sizeof(date));
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_DATE_CREATED);
+                packet.putUInt16(MTP_TYPE_STR);
+                packet.putString(date);
+            }
+
+            // Hidden
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_HIDDEN) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_HIDDEN);
+                packet.putUInt16(MTP_TYPE_UINT16);
+                packet.putUInt16(0);
+            }
+
+            // Non Consumable
+            if (property == ALL_PROPERTIES || property == MTP_PROPERTY_NON_CONSUMABLE) {
+                packet.putUInt32(i);
+                packet.putUInt16(MTP_PROPERTY_NON_CONSUMABLE);
+                packet.putUInt16(MTP_TYPE_UINT16);
+                if (entry.object_format == MTP_FORMAT_ASSOCIATION)
+                    packet.putUInt16(0); // folders are non-consumable
+                else
+                    packet.putUInt16(1); // files can usually be played.
+                break;
+            }
+
+        }
+
+        return MTP_RESPONSE_OK;
     }
 
     virtual MtpResponseCode getObjectInfo(
@@ -586,27 +917,37 @@
     {
         VLOG(2) << __PRETTY_FUNCTION__;
 
-        info.mHandle = handle;
-        info.mStorageID = db.at(handle).storage_id;
-        info.mFormat = db.at(handle).object_format;
-        info.mProtectionStatus = 0x0;
-        info.mCompressedSize = db.at(handle).object_size;
-        info.mImagePixWidth = 0;
-        info.mImagePixHeight = 0;
-        info.mImagePixDepth = 0;
-        info.mParent = db.at(handle).parent;
-        info.mAssociationType = 0;
-        info.mAssociationDesc = 0;
-        info.mSequenceNumber = 0;
-        info.mName = ::strdup(db.at(handle).display_name.c_str());
-        info.mDateCreated = 0;
-        info.mDateModified = 0;
-        info.mKeywords = ::strdup("ubuntu,touch");
-        
-        if (VLOG_IS_ON(2))
-            info.print();
-
-        return MTP_RESPONSE_OK;
+        if (handle == 0 || handle == MTP_PARENT_ROOT)
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
+        try {
+            info.mHandle = handle;
+            info.mStorageID = db.at(handle).storage_id;
+            info.mFormat = db.at(handle).object_format;
+            info.mProtectionStatus = 0x0;
+            info.mCompressedSize = db.at(handle).object_size;
+            info.mImagePixWidth = 0;
+            info.mImagePixHeight = 0;
+            info.mImagePixDepth = 0;
+            info.mParent = db.at(handle).parent;
+            info.mAssociationType
+                = info.mFormat == MTP_FORMAT_ASSOCIATION
+                    ? MTP_ASSOCIATION_TYPE_GENERIC_FOLDER : 0;
+            info.mAssociationDesc = 0;
+            info.mSequenceNumber = 0;
+            info.mName = ::strdup(db.at(handle).display_name.c_str());
+            info.mDateCreated = 0;
+            info.mDateModified = db.at(handle).last_modified;
+            info.mKeywords = ::strdup("ubuntu,touch");
+
+            if (VLOG_IS_ON(2))
+                info.print();
+
+            return MTP_RESPONSE_OK;
+        }
+        catch (...) {
+            return MTP_RESPONSE_GENERAL_ERROR;
+        }
     }
 
     virtual void* getThumbnail(MtpObjectHandle handle, size_t& outThumbSize)
@@ -625,15 +966,29 @@
         int64_t& outFileLength,
         MtpObjectFormat& outFormat)
     {
-        DbEntry entry = db.at(handle);
-
         VLOG(1) << __PRETTY_FUNCTION__ << " handle: " << handle;
 
-        outFilePath = std::string(entry.path);
-        outFileLength = entry.object_size;
-        outFormat = entry.object_format;
-
-        return MTP_RESPONSE_OK;
+        if (handle == 0 || handle == MTP_PARENT_ROOT)
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
+        try {
+            DbEntry entry = db.at(handle);
+
+            VLOG(2) << __PRETTY_FUNCTION__
+                    << "handle: " << handle
+                    << "path: " << entry.path
+                    << "length: " << entry.object_size
+                    << "format: " << entry.object_format;
+
+            outFilePath = std::string(entry.path);
+            outFileLength = entry.object_size;
+            outFormat = entry.object_format;
+
+            return MTP_RESPONSE_OK;
+        }
+        catch (...) {
+            return MTP_RESPONSE_GENERAL_ERROR;
+        }
     }
 
     virtual MtpResponseCode deleteFile(MtpObjectHandle handle)
@@ -643,25 +998,33 @@
 
         VLOG(2) << __PRETTY_FUNCTION__ << " handle: " << handle;
 
-        if (db.at(handle).object_format == MTP_FORMAT_ASSOCIATION)
-            inotify_rm_watch(inotify_fd, db.at(handle).watch_fd);
-
-        new_size = db.erase(handle);
-
-        if (orig_size > new_size) {
-            /* Recursively remove children object from the DB as well.
-             * we can safely ignore failures here, since the objects
-             * would not be reachable anyway.
-             */
-            BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
-                if (db.at(i).parent == handle)
-                    db.erase(i);
+        if (handle == 0 || handle == MTP_PARENT_ROOT)
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
+        try {
+            if (db.at(handle).object_format == MTP_FORMAT_ASSOCIATION)
+                inotify_rm_watch(inotify_fd, db.at(handle).watch_fd);
+
+            new_size = db.erase(handle);
+
+            if (orig_size > new_size) {
+                /* Recursively remove children object from the DB as well.
+                 * we can safely ignore failures here, since the objects
+                 * would not be reachable anyway.
+                 */
+                BOOST_FOREACH(MtpObjectHandle i, db | boost::adaptors::map_keys) {
+                    if (db.at(i).parent == handle)
+                        db.erase(i);
+                }
+
+                return MTP_RESPONSE_OK;
             }
-
-            return MTP_RESPONSE_OK;
+            else
+                return MTP_RESPONSE_GENERAL_ERROR;
         }
-        else
+        catch (...) {
             return MTP_RESPONSE_GENERAL_ERROR;
+        }
     }
 
     virtual MtpResponseCode moveFile(MtpObjectHandle handle, MtpObjectHandle new_parent)
@@ -669,8 +1032,16 @@
         VLOG(1) << __PRETTY_FUNCTION__ << " handle: " << handle
                 << " new parent: " << new_parent;
 
-        // change parent
-        db.at(handle).parent = new_parent;
+        if (handle == 0 || handle == MTP_PARENT_ROOT)
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+
+        try {
+            // change parent
+            db.at(handle).parent = new_parent;
+        }
+        catch (...) {
+            return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
+        }
 
         return MTP_RESPONSE_OK;
     }
@@ -690,7 +1061,13 @@
     virtual MtpObjectHandleList* getObjectReferences(MtpObjectHandle handle)
     {
         VLOG(1) << __PRETTY_FUNCTION__;
-        return nullptr;
+
+        if (handle == 0 || handle == MTP_PARENT_ROOT)
+            return nullptr;
+
+        return getObjectList(db.at(handle).storage_id,
+                             handle,
+                             db.at(handle).object_format);
     }
 
     virtual MtpResponseCode setObjectReferences(
@@ -698,7 +1075,10 @@
         MtpObjectHandleList* references)
     {
         VLOG(1) << __PRETTY_FUNCTION__;
-        return MTP_RESPONSE_OPERATION_NOT_SUPPORTED;    
+
+        // ignore, we don't keep the references in a list.
+
+        return MTP_RESPONSE_OK;
     }
 
     virtual MtpProperty* getObjectPropertyDesc(
@@ -710,14 +1090,23 @@
         MtpProperty* result = nullptr;
         switch(property)
         {
-            case MTP_PROPERTY_STORAGE_ID: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
-            case MTP_PROPERTY_OBJECT_FORMAT: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
-            case MTP_PROPERTY_OBJECT_SIZE: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
-            case MTP_PROPERTY_WIDTH: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
-            case MTP_PROPERTY_HEIGHT: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
-            case MTP_PROPERTY_IMAGE_BIT_DEPTH: result = new MtpProperty(property, MTP_TYPE_UINT32); break;
+            case MTP_PROPERTY_STORAGE_ID: result = new MtpProperty(property, MTP_TYPE_UINT32, false); break;
+            case MTP_PROPERTY_PARENT_OBJECT: result = new MtpProperty(property, MTP_TYPE_UINT32, true); break;
+            case MTP_PROPERTY_OBJECT_FORMAT: result = new MtpProperty(property, MTP_TYPE_UINT16, false); break;
+            case MTP_PROPERTY_OBJECT_SIZE: result = new MtpProperty(property, MTP_TYPE_UINT32, false); break;
+            case MTP_PROPERTY_WIDTH: result = new MtpProperty(property, MTP_TYPE_UINT32, false); break;
+            case MTP_PROPERTY_HEIGHT: result = new MtpProperty(property, MTP_TYPE_UINT32, false); break;
+            case MTP_PROPERTY_IMAGE_BIT_DEPTH: result = new MtpProperty(property, MTP_TYPE_UINT32, false); break;
             case MTP_PROPERTY_DISPLAY_NAME: result = new MtpProperty(property, MTP_TYPE_STR, true); break;
             case MTP_PROPERTY_OBJECT_FILE_NAME: result = new MtpProperty(property, MTP_TYPE_STR, true); break;
+            case MTP_PROPERTY_PERSISTENT_UID: result = new MtpProperty(property, MTP_TYPE_UINT128, false); break;
+            case MTP_PROPERTY_ASSOCIATION_TYPE: result = new MtpProperty(property, MTP_TYPE_UINT16, false); break;
+            case MTP_PROPERTY_ASSOCIATION_DESC: result = new MtpProperty(property, MTP_TYPE_UINT32, false); break;
+            case MTP_PROPERTY_PROTECTION_STATUS: result = new MtpProperty(property, MTP_TYPE_UINT16, false); break;
+            case MTP_PROPERTY_DATE_CREATED: result = new MtpProperty(property, MTP_TYPE_STR, false); break;
+            case MTP_PROPERTY_DATE_MODIFIED: result = new MtpProperty(property, MTP_TYPE_STR, false); break;
+            case MTP_PROPERTY_HIDDEN: result = new MtpProperty(property, MTP_TYPE_UINT16, false); break;
+            case MTP_PROPERTY_NON_CONSUMABLE: result = new MtpProperty(property, MTP_TYPE_UINT16, false); break;
             default: break;                
         }
         
@@ -727,7 +1116,17 @@
     virtual MtpProperty* getDevicePropertyDesc(MtpDeviceProperty property)
     {
         VLOG(1) << __PRETTY_FUNCTION__ << MtpDebug::getDevicePropCodeName(property);
-        return new MtpProperty(MTP_DEVICE_PROPERTY_UNDEFINED, MTP_TYPE_UNDEFINED);
+
+        MtpProperty* result = nullptr;
+        switch(property)
+        {
+            case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER:
+            case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME:
+                result = new MtpProperty(property, MTP_TYPE_STR, false); break;
+            default: break;                
+        }
+        
+        return result;
     }
     
     virtual void sessionStarted(MtpServer* server)

=== modified file 'server/server.cpp'
--- server/server.cpp	2014-03-27 15:45:30 +0000
+++ server/server.cpp	2014-08-21 19:42:07 +0000
@@ -32,6 +32,69 @@
 #include <hybris/properties/properties.h>
 #include <glog/logging.h>
 
+#include <core/dbus/bus.h>
+#include <core/dbus/object.h>
+#include <core/dbus/property.h>
+#include <core/dbus/service.h>
+#include <core/dbus/signal.h>
+    
+#include <core/dbus/asio/executor.h>
+#include <core/dbus/types/stl/tuple.h>
+#include <core/dbus/types/stl/vector.h>
+#include <core/dbus/types/struct.h>
+
+namespace dbus = core::dbus;
+using namespace android;
+
+namespace core
+{
+dbus::Bus::Ptr the_session_bus()
+{
+    static dbus::Bus::Ptr session_bus = std::make_shared<dbus::Bus>(dbus::WellKnownBus::session);
+    return session_bus;
+}
+
+struct UnityGreeter
+{
+    struct Properties
+    {
+        struct IsActive
+        {
+            inline static std::string name()
+            {
+                return "IsActive";
+            };
+            typedef UnityGreeter Interface;
+            typedef bool ValueType;
+            static const bool readable = true;
+            static const bool writable = false;
+        };
+    };
+};
+}
+
+namespace core  
+{               
+namespace dbus      
+{               
+namespace traits
+{               
+template<>      
+struct Service<core::UnityGreeter> 
+{        
+    inline static const std::string& interface_name()
+    {
+        static const std::string s
+        {
+            "com.canonical.UnityGreeter"
+        };      
+        return s;
+    }               
+};
+}
+}
+}
+
 namespace
 {
 struct FileSystemConfig
@@ -40,59 +103,303 @@
     static const int directory_perm = 0755;
 };
 
-android::MtpStorage* home_storage;
-
 }
 
+class MtpDaemon
+{
+
+private:
+    struct passwd *userdata;
+
+    // Mtp stuff
+    MtpServer* server;
+    MtpStorage* home_storage;
+    MtpStorage* sd_card;
+    MtpDatabase* mtp_database;
+
+    // Security
+    std::shared_ptr<core::dbus::Property<core::UnityGreeter::Properties::IsActive> > is_active;
+
+    // inotify stuff
+    boost::thread notifier_thread;
+    boost::thread io_service_thread;
+
+    asio::io_service io_svc;
+    asio::io_service::work work;
+    asio::posix::stream_descriptor stream_desc;
+    asio::streambuf buf;
+
+    int inotify_fd;
+
+    int watch_fd;
+    int media_fd;
+
+    // storage
+    std::map<std::string, std::tuple<MtpStorage*, bool> > removables;
+    bool home_storage_added;
+
+    void add_removable_storage(const char *path, const char *name)
+    {
+        static int storageID = MTP_STORAGE_REMOVABLE_RAM;
+
+        MtpStorage *removable = new MtpStorage(
+            storageID, 
+            path,
+            name,
+            1024 * 1024 * 100,  /* 100 MB reserved space, to avoid filling the disk */
+            true,
+            1024 * 1024 * 1024 * 2  /* 2GB arbitrary max file size */);
+
+        storageID++;
+
+        bool screen_locked = is_active->get();
+
+        if (!screen_locked) {
+            mtp_database->addStoragePath(path,
+                                         removable->getStorageID(),
+                                         true);
+            server->addStorage(removable);
+        }
+
+        removables.insert(std::pair<std::string, std::tuple<MtpStorage*, bool> >
+                              (name,
+                               std::make_tuple(removable,
+                                               screen_locked ? false : true)));
+    }
+
+    void add_mountpoint_watch(const std::string& path)
+    {
+        VLOG(1) << "Adding notify watch for " << path;
+        watch_fd = inotify_add_watch(inotify_fd,
+                                     path.c_str(),
+                                     IN_CREATE | IN_DELETE);
+    }
+
+    void read_more_notify()
+    {
+        VLOG(1) << __PRETTY_FUNCTION__;
+
+        stream_desc.async_read_some(buf.prepare(buf.max_size()),
+                                    boost::bind(&MtpDaemon::inotify_handler,
+                                                this,
+                                                asio::placeholders::error,
+                                                asio::placeholders::bytes_transferred));
+    }
+
+    void inotify_handler(const boost::system::error_code&,
+                         std::size_t transferred)
+    {
+        size_t processed = 0;
+ 
+        while(transferred - processed >= sizeof(inotify_event))
+        {
+            const char* cdata = processed + asio::buffer_cast<const char*>(buf.data());
+            const inotify_event* ievent = reinterpret_cast<const inotify_event*>(cdata);
+            path storage_path ("/media");
+     
+            processed += sizeof(inotify_event) + ievent->len;
+     
+            storage_path /= userdata->pw_name;
+
+            if (ievent->len > 0 && ievent->mask & IN_CREATE)
+            {
+                if (ievent->wd == media_fd) {
+                    VLOG(1) << "media root was created for user " << ievent->name;
+                    add_mountpoint_watch(storage_path.string());
+                } else {
+                    VLOG(1) << "Storage was added: " << ievent->name;
+                    storage_path /= ievent->name;
+                    add_removable_storage(storage_path.string().c_str(), ievent->name);
+                }
+            }
+            else if (ievent->len > 0 && ievent->mask & IN_DELETE)
+            {
+                VLOG(1) << "Storage was removed: " << ievent->name;
+
+                // Try to match to which storage was removed.
+                BOOST_FOREACH(std::string name, removables | boost::adaptors::map_keys) {
+                    if (name == ievent->name) {
+                        auto t = removables.at(name);
+                        MtpStorage *storage = std::get<0>(t);
+
+                        VLOG(2) << "removing storage id "
+                                << storage->getStorageID();
+
+                        server->removeStorage(storage);
+                        mtp_database->removeStorage(storage->getStorageID());
+                    }
+                }
+            }
+        }
+
+        read_more_notify();
+    }
+
+public:
+
+    MtpDaemon(int fd):
+        stream_desc(io_svc),
+        work(io_svc),
+        buf(1024)
+    {
+        userdata = getpwuid (getuid());
+
+        // Removable storage hacks
+        inotify_fd = inotify_init();
+        if (inotify_fd <= 0)
+            PLOG(FATAL) << "Unable to initialize inotify";
+        VLOG(1) << "using inotify fd " << inotify_fd << " for daemon";
+
+        stream_desc.assign(inotify_fd);
+        notifier_thread = boost::thread(&MtpDaemon::read_more_notify, this);
+        io_service_thread = boost::thread(boost::bind(&asio::io_service::run, &io_svc));
+
+
+        // MTP database.
+        mtp_database = new UbuntuMtpDatabase();
+
+
+        // MTP server
+        server = new MtpServer(
+                fd, 
+                mtp_database,
+                false, 
+                userdata->pw_gid, 
+                FileSystemConfig::file_perm, 
+                FileSystemConfig::directory_perm);
+
+        // security / screen locking
+        auto bus = core::the_session_bus();
+        bus->install_executor(core::dbus::asio::make_executor(bus));
+        std::thread t {std::bind(&dbus::Bus::run, bus)};
+        auto greeter_service = dbus::Service::use_service(bus, "com.canonical.UnityGreeter");
+        dbus::Object::Ptr greeter = greeter_service->object_for_path(dbus::types::ObjectPath("/"));
+
+        t.detach();
+
+        is_active = greeter->get_property<core::UnityGreeter::Properties::IsActive>();
+    }
+
+    void initStorage()
+    {
+        char product_name[PROP_VALUE_MAX];
+
+        // Local storage
+        property_get ("ro.product.model", product_name, "Ubuntu Touch device");
+
+        home_storage = new MtpStorage(
+            MTP_STORAGE_FIXED_RAM, 
+            userdata->pw_dir,
+	    product_name,
+            1024 * 1024 * 100,  /* 100 MB reserved space, to avoid filling the disk */
+            false,
+            1024 * 1024 * 1024 * 2  /* 2GB arbitrary max file size */);
+        mtp_database->addStoragePath(std::string(userdata->pw_dir) + "/Documents",
+                                     MTP_STORAGE_FIXED_RAM, false);
+        mtp_database->addStoragePath(std::string(userdata->pw_dir) + "/Music",
+                                     MTP_STORAGE_FIXED_RAM, false);
+        mtp_database->addStoragePath(std::string(userdata->pw_dir) + "/Videos",
+                                     MTP_STORAGE_FIXED_RAM, false);
+        mtp_database->addStoragePath(std::string(userdata->pw_dir) + "/Pictures",
+                                     MTP_STORAGE_FIXED_RAM, false);
+        mtp_database->addStoragePath(std::string(userdata->pw_dir) + "/Downloads",
+                                     MTP_STORAGE_FIXED_RAM, false);
+        home_storage_added = false;
+
+        // Get any already-mounted removable storage.
+        path p(std::string("/media/") + userdata->pw_name);
+        if (exists(p)) {
+            std::vector<path> v;
+            copy(directory_iterator(p), directory_iterator(), std::back_inserter(v));
+            for (std::vector<path>::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
+            {
+                add_removable_storage(it->string().c_str(), it->leaf().c_str());
+            }
+
+            // make sure we can catch any new removable storage that gets added.
+            add_mountpoint_watch(p.string());
+        } else {
+            media_fd = inotify_add_watch(inotify_fd,
+                                         "/media",
+                                         IN_CREATE | IN_DELETE);
+        }
+
+    }
+
+    ~MtpDaemon()
+    {
+        // Cleanup
+        inotify_rm_watch(inotify_fd, watch_fd);
+        io_svc.stop();
+        notifier_thread.detach();
+        io_service_thread.join();
+        close(inotify_fd);
+    }
+
+    void run()
+    {
+        if (is_active->get()) {
+            is_active->changed().connect([this](bool active)
+            {
+                if (!active) {
+                    VLOG(2) << "device was unlocked, adding storage";
+                    if (home_storage && !home_storage_added) {
+                        server->addStorage(home_storage);
+                        home_storage_added = true;
+                    }
+                    BOOST_FOREACH(std::string name, removables | boost::adaptors::map_keys) {
+                        auto t = removables.at(name);
+                        MtpStorage *storage = std::get<0>(t);
+                        bool added = std::get<1>(t);
+                        if (!added) {
+                            mtp_database->addStoragePath(storage->getPath(),
+                                                         storage->getStorageID(),
+                                                         true);
+                            server->addStorage(storage);
+                        }
+                    }
+                }
+            });
+        } else {
+            VLOG(2) << "device is not locked, adding storage";
+            if (home_storage) {
+                server->addStorage(home_storage);
+                home_storage_added = true;
+            }
+            BOOST_FOREACH(std::string name, removables | boost::adaptors::map_keys) {
+                auto t = removables.at(name);
+                MtpStorage *storage = std::get<0>(t);
+                bool added = std::get<1>(t);
+                if (!added) {
+                    mtp_database->addStoragePath(storage->getPath(),
+                                                 storage->getStorageID(),
+                                                 true);
+                    server->addStorage(storage);
+                }
+            }
+        }
+
+        // start the MtpServer main loop
+        server->run();
+    }
+};
+
 int main(int argc, char** argv)
 {
-    struct passwd *userdata = getpwuid (getuid());
-    char product_name[PROP_VALUE_MAX];
-    int fd = open("/dev/mtp_usb", O_RDWR);
-
     google::InitGoogleLogging(argv[0]);
 
     LOG(INFO) << "MTP server starting...";
 
+    int fd = open("/dev/mtp_usb", O_RDWR);
     if (fd < 0)
     {
         LOG(FATAL) << "Error opening /dev/mtp_usb, aborting now...";
     }
  
-    std::shared_ptr<android::MtpServer> server
-    {
-        new android::MtpServer(
-            fd, 
-            new android::UbuntuMtpDatabase(userdata->pw_dir),
-            false, 
-            userdata->pw_gid, 
-            FileSystemConfig::file_perm, 
-            FileSystemConfig::directory_perm)
-    };
-
-    property_get ("ro.product.model", product_name, "Ubuntu Touch device");
-
-    home_storage = new android::MtpStorage(
-        MTP_STORAGE_FIXED_RAM, 
-        userdata->pw_dir,
-	product_name,
-        1024 * 1024 * 100,  /* 100 MB reserved space, to avoid filling the disk */
-        false,
-        1024 * 1024 * 1024 * 2  /* 2GB arbitrary max file size */);
-
-    server->addStorage(home_storage);
-    server->run();
-
-    /*
-      std::thread t{[&server](){ server->run(); }};
-
-      sigset_t signal_set;
-      sigemptyset(&signal_set);
-      sigaddset(&signal_set, SIGINT);
-      int signal;
-      sigwait(&signal_set, &signal);
-
-      if (t.joinable())
-      t.join();
-    */
+    MtpDaemon *d = new MtpDaemon(fd);
+
+    d->initStorage();
+    d->run();
+
+    delete d;
 }

=== modified file 'tests/MockMtpDatabase.h'
--- tests/MockMtpDatabase.h	2014-03-27 15:50:32 +0000
+++ tests/MockMtpDatabase.h	2014-08-21 19:42:07 +0000
@@ -74,6 +74,14 @@
 
     virtual ~MockMtpDatabase() {}
 
+    virtual void addStoragePath(const MtpString& path, MtpStorageID storage, bool hidden)
+    {
+    }
+
+    virtual void removeStorage(MtpStorageID storage)
+    {
+    }
+
     virtual MtpObjectHandle beginSendObject(
         const MtpString& path,
         MtpObjectFormat format,