Merge lp:~phablet-team/media-hub/fix-1449790 into lp:media-hub

[Jim Hodapp]

Make sure to interpret the incoming path as a URI which makes sure media-hub will always be able to open the track with an encoded URI

Make sure to interpret the incoming path as a URI which makes sure media-hub will always be able to open the track with an encoded URI

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:170
http://jenkins.qa.ubuntu.com/job/media-hub-ci/394/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/234
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/234
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/234/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/234

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/media-hub-ci/394/rebuild

review: Approve (continuous-integration)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

LGTM

review: Approve

[lp:~phablet-team/media-hub/fix-1449790]

171. By Jim Hodapp on 2016-02-19

Do the percent encoding and checking only from media-hub and don't involve qtubuntu-media

172. By Jim Hodapp on 2016-02-19

Get rid of some debug statements

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

See comments below.

review: Needs Fixing

[lp:~phablet-team/media-hub/fix-1449790]

173. By Jim Hodapp on 2016-02-22

Make sure other tracks can still be added to the tracklist after an invalid URI is determined. Also make sure to free all gchar strings

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Still some comments, see below.

review: Needs Fixing

[lp:~phablet-team/media-hub/fix-1449790]

174. By Jim Hodapp on 2016-02-22

Address review comments

175. By Jim Hodapp on 2016-02-22

One last comment addressed

176. By Jim Hodapp on 2016-02-22

Make sure to not crash during std::string::assign(gchar*)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

LGTM

review: Approve

[lp:~phablet-team/media-hub/fix-1449790]

177. By Jim Hodapp on 2016-02-22

Removed no longer needed debug statement

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2016-01-14 19:47:40 +0000
+++ include/core/media/player.h	2016-02-22 18:59:27 +0000
@@ -61,6 +61,11 @@
         {
             InsufficientAppArmorPermissions(const std::string& err);
         };
+
+        struct UriNotFound : public std::runtime_error
+        {
+            UriNotFound(const std::string& err);
+        };
     };
 
     struct Configuration;
 
=== modified file 'src/core/media/gstreamer/engine.cpp'
--- src/core/media/gstreamer/engine.cpp	2015-09-04 18:46:08 +0000
+++ src/core/media/gstreamer/engine.cpp	2016-02-22 18:59:27 +0000
@@ -400,7 +400,8 @@
     d->state = media::Engine::State::no_media;
 }
 
-const std::shared_ptr<media::Engine::MetaDataExtractor>& gstreamer::Engine::meta_data_extractor() const
+const std::shared_ptr<media::Engine::MetaDataExtractor>&
+        gstreamer::Engine::meta_data_extractor() const
 {
     return d->meta_data_extractor;
 }
@@ -410,13 +411,15 @@
     return d->state;
 }
 
-bool gstreamer::Engine::open_resource_for_uri(const media::Track::UriType& uri, bool do_pipeline_reset)
+bool gstreamer::Engine::open_resource_for_uri(const media::Track::UriType& uri,
+                                              bool do_pipeline_reset)
 {
     d->playbin.set_uri(uri, core::ubuntu::media::Player::HeadersType{}, do_pipeline_reset);
     return true;
 }
 
-bool gstreamer::Engine::open_resource_for_uri(const media::Track::UriType& uri, const core::ubuntu::media::Player::HeadersType& headers)
+bool gstreamer::Engine::open_resource_for_uri(const media::Track::UriType& uri,
+                                              const core::ubuntu::media::Player::HeadersType& headers)
 {
     d->playbin.set_uri(uri, headers);
     return true;
 
=== modified file 'src/core/media/gstreamer/playbin.cpp'
--- src/core/media/gstreamer/playbin.cpp	2015-12-16 16:55:51 +0000
+++ src/core/media/gstreamer/playbin.cpp	2016-02-22 18:59:27 +0000
@@ -17,7 +17,6 @@
  */
 
 #include <core/media/gstreamer/playbin.h>
-
 #include <core/media/gstreamer/engine.h>
 
 #include <gst/pbutils/missing-plugins.h>
@@ -26,8 +25,12 @@
 #include <hybris/media/surface_texture_client_hybris.h>
 #include <hybris/media/media_codec_layer.h>
 
+#include "../util/uri_check.h"
+
 #include <utility>
 
+//#define VERBOSE_DEBUG
+
 namespace
 {
 void setup_video_sink_for_buffer_streaming(GstElement* pipeline)
@@ -464,10 +467,23 @@
     if (current_uri and do_pipeline_reset)
         reset_pipeline();
 
-    g_object_set(pipeline, "uri", uri.c_str(), NULL);
-    if (is_video_file(uri))
+    std::string encoded_uri;
+    media::UriCheck::Ptr uri_check{std::make_shared<media::UriCheck>(uri)};
+    if (uri_check->is_encoded())
+    {
+        encoded_uri = decode_uri(uri);
+#ifdef VERBOSE_DEBUG
+        std::cout << "File URI was encoded, now decoded: " << encoded_uri << std::endl;
+#endif
+        encoded_uri = encode_uri(encoded_uri);
+    }
+    else
+        encoded_uri = encode_uri(uri);
+
+    g_object_set(pipeline, "uri", encoded_uri.c_str(), NULL);
+    if (is_video_file(encoded_uri))
         file_type = MEDIA_FILE_TYPE_VIDEO;
-    else if (is_audio_file(uri))
+    else if (is_audio_file(encoded_uri))
         file_type = MEDIA_FILE_TYPE_AUDIO;
 
     request_headers = headers;
@@ -607,25 +623,13 @@
         signals.on_video_dimensions_changed(new_dimensions);
 }
 
-std::string gstreamer::Playbin::get_file_content_type(const std::string& uri) const
+std::string gstreamer::Playbin::file_info_from_uri(const std::string& uri) const
 {
-    if (uri.empty())
-        return std::string();
-
-    std::string filename(uri);
-    size_t pos = uri.find("file://");
-    if (pos != std::string::npos)
-        filename = uri.substr(pos + 7, std::string::npos);
-    else
-        // Anything other than a file, for now claim that the type
-        // is both audio and video.
-        // FIXME: implement true net stream sampling and get the type from GstCaps
-        return std::string("audio/video/");
-
-
     GError *error = nullptr;
+    // Open the URI and get the mime type from it. This will currently only work for
+    // a local file
     std::unique_ptr<GFile, void(*)(void *)> file(
-            g_file_new_for_path(filename.c_str()), g_object_unref);
+            g_file_new_for_uri(uri.c_str()), g_object_unref);
     std::unique_ptr<GFileInfo, void(*)(void *)> info(
             g_file_query_info(
                 file.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE ","
@@ -633,17 +637,114 @@
                 /* cancellable */ NULL, &error),
             g_object_unref);
     if (!info)
-    {
-        std::string error_str(error->message);
-        g_error_free(error);
-
-        std::cout << "Failed to query the URI for the presence of video content: "
-            << error_str << std::endl;
         return std::string();
-    }
 
-    std::string content_type(g_file_info_get_attribute_string(
+    return std::string(g_file_info_get_attribute_string(
                 info.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE));
+}
+
+std::string gstreamer::Playbin::encode_uri(const std::string& uri) const
+{
+    if (uri.empty())
+        return std::string();
+
+    std::string encoded_uri;
+    media::UriCheck::Ptr uri_check{std::make_shared<media::UriCheck>(uri)};
+    gchar *uri_scheme = g_uri_parse_scheme(uri.c_str());
+    // We have a URI and it is already percent encoded
+    if (uri_scheme and strlen(uri_scheme) > 0 and uri_check->is_encoded())
+    {
+#ifdef VERBOSE_DEBUG
+        std::cout << "Is a URI and is already percent encoded" << std::endl;
+#endif
+        encoded_uri = uri;
+    }
+    // We have a URI but it's not already percent encoded
+    else if (uri_scheme and strlen(uri_scheme) > 0 and !uri_check->is_encoded())
+    {
+#ifdef VERBOSE_DEBUG
+        std::cout << "Is a URI and is not already percent encoded" << std::endl;
+#endif
+        gchar *encoded = g_uri_escape_string(uri.c_str(),
+                                                   "!$&'()*+,;=:/?[]@", // reserved chars
+                                                   TRUE); // Allow UTF-8 chars
+        if (!encoded)
+        {
+            g_free(uri_scheme);
+            return std::string();
+        }
+        encoded_uri.assign(encoded);
+        g_free(encoded);
+    }
+    else // We have a path and not a URI. Turn it into a full URI and encode it
+    {
+        GError *error = nullptr;
+#ifdef VERBOSE_DEBUG
+        std::cout << "Is a path and is not already percent encoded" << std::endl;
+#endif
+        gchar *str = g_filename_to_uri(uri.c_str(), nullptr, &error);
+        if (!str)
+        {
+            g_free(uri_scheme);
+            return std::string();
+        }
+        encoded_uri.assign(str);
+        g_free(str);
+        if (error != nullptr)
+        {
+            std::cerr << "Warning: failed to get actual track content type: " << error->message
+                      << std::endl;
+            g_error_free(error);
+            g_free(str);
+            g_free(uri_scheme);
+            return std::string("audio/video/");
+        }
+        gchar *escaped = g_uri_escape_string(encoded_uri.c_str(),
+                                         "!$&'()*+,;=:/?[]@", // reserved chars
+                                         TRUE); // Allow UTF-8 chars
+        if (!escaped)
+        {
+            g_free(uri_scheme);
+            return std::string();
+        }
+        encoded_uri.assign(escaped);
+        g_free(escaped);
+    }
+
+    g_free(uri_scheme);
+
+    return encoded_uri;
+}
+
+std::string gstreamer::Playbin::decode_uri(const std::string& uri) const
+{
+    if (uri.empty())
+        return std::string();
+
+    gchar *decoded_gchar = g_uri_unescape_string(uri.c_str(), nullptr);
+    if (!decoded_gchar)
+        return std::string();
+
+    const std::string decoded{decoded_gchar};
+    g_free(decoded_gchar);
+    return decoded;
+}
+
+std::string gstreamer::Playbin::get_file_content_type(const std::string& uri) const
+{
+    if (uri.empty())
+        return std::string();
+
+    const std::string encoded_uri{encode_uri(uri)};
+
+    const std::string content_type {file_info_from_uri(encoded_uri)};
+    if (content_type.empty())
+    {
+        std::cerr << "Warning: failed to get actual track content type" << std::endl;
+        return std::string("audio/video/");
+    }
+
+    std::cout << "Found content type: " << content_type << std::endl;
 
     return content_type;
 }
 
=== modified file 'src/core/media/gstreamer/playbin.h'
--- src/core/media/gstreamer/playbin.h	2015-09-23 11:17:26 +0000
+++ src/core/media/gstreamer/playbin.h	2016-02-22 18:59:27 +0000
@@ -104,6 +104,9 @@
     core::ubuntu::media::video::Dimensions get_video_dimensions() const;
     void emit_video_dimensions_changed_if_changed(const core::ubuntu::media::video::Dimensions &new_dimensions);
 
+    std::string file_info_from_uri(const std::string& uri) const;
+    std::string encode_uri(const std::string& uri) const;
+    std::string decode_uri(const std::string& uri) const;
     std::string get_file_content_type(const std::string& uri) const;
 
     bool is_audio_file(const std::string& uri) const;
 
=== modified file 'src/core/media/mpris/player.h'
--- src/core/media/mpris/player.h	2016-01-14 19:47:40 +0000
+++ src/core/media/mpris/player.h	2016-02-22 18:59:27 +0000
@@ -124,6 +124,14 @@
                 "mpris.Player.Error.InsufficientAppArmorPermissions"
             };
         };
+
+        struct UriNotFound
+        {
+            static constexpr const char* name
+            {
+                "mpris.Player.Error.UriNotFound"
+            };
+        };
     };
 
     typedef std::map<std::string, core::dbus::types::Variant> Dictionary;
 
=== modified file 'src/core/media/player.cpp'
--- src/core/media/player.cpp	2016-01-14 19:47:40 +0000
+++ src/core/media/player.cpp	2016-02-22 18:59:27 +0000
@@ -33,6 +33,12 @@
 {
 }
 
+media::Player::Errors::UriNotFound::UriNotFound
+    (const std::string &e)
+    : std::runtime_error{e}
+{
+}
+
 const media::Player::Configuration& media::Player::Client::default_configuration()
 {
     static const media::Player::Configuration config
 
=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2015-11-18 15:55:23 +0000
+++ src/core/media/player_implementation.cpp	2016-02-22 18:59:27 +0000
@@ -292,8 +292,8 @@
         const Track::UriType uri = track_list->query_uri_for_track(id);
         if (!uri.empty())
         {
-            // Using a TrackList for playback, added tracks via add_track(), but open_uri hasn't been called yet
-            // to load a media resource
+            // Using a TrackList for playback, added tracks via add_track(), but open_uri hasn't
+            // been called yet to load a media resource
             std::cout << "Calling d->engine->open_resource_for_uri() for first track added only: "
                       << uri << std::endl;
             std::cout << "\twith a Track::Id: " << id << std::endl;
 
=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2016-01-14 20:08:38 +0000
+++ src/core/media/player_skeleton.cpp	2016-02-22 18:59:27 +0000
@@ -31,6 +31,7 @@
 #include "mpris/metadata.h"
 #include "mpris/player.h"
 #include "mpris/playlists.h"
+#include "util/uri_check.h"
 
 #include <core/dbus/object.h>
 #include <core/dbus/property.h>
@@ -54,6 +55,7 @@
           object(session),
           request_context_resolver{request_context_resolver},
           request_authenticator{request_authenticator},
+          uri_check(std::make_shared<UriCheck>()),
           skeleton{mpris::Player::Skeleton::Configuration{bus, session, mpris::Player::Skeleton::Configuration::Defaults{}}},
           signals
           {
@@ -180,22 +182,38 @@
             in->reader() >> uri;
 
             auto reply = dbus::Message::make_method_return(in);
-            // Make sure the client has adequate apparmor permissions to open the URI
-            const auto result = request_authenticator->authenticate_open_uri_request(context, uri);
-            if (std::get<0>(result))
-            {
-                reply->writer() << (std::get<0>(result) ? impl->open_uri(uri) : false);
-            }
-            else
-            {
-                const std::string err_str = {"Warning: Failed to authenticate necessary "
-                    "apparmor permissions to open uri: " + std::get<1>(result)};
+            uri_check->set(uri);
+            const bool valid_uri = !uri_check->is_local_file() or
+                    (uri_check->is_local_file() and uri_check->file_exists());
+            if (!valid_uri)
+            {
+                const std::string err_str = {"Warning: Failed to open uri " + uri +
+                     " because it can't be found."};
                 std::cerr << err_str << std::endl;
                 reply = dbus::Message::make_error(
                             in,
-                            mpris::Player::Error::InsufficientAppArmorPermissions::name,
+                            mpris::Player::Error::UriNotFound::name,
                             err_str);
             }
+            else
+            {
+                // Make sure the client has adequate apparmor permissions to open the URI
+                const auto result = request_authenticator->authenticate_open_uri_request(context, uri);
+                if (std::get<0>(result))
+                {
+                    reply->writer() << (std::get<0>(result) ? impl->open_uri(uri) : false);
+                }
+                else
+                {
+                    const std::string err_str = {"Warning: Failed to authenticate necessary "
+                        "apparmor permissions to open uri: " + std::get<1>(result)};
+                    std::cerr << err_str << std::endl;
+                    reply = dbus::Message::make_error(
+                                in,
+                                mpris::Player::Error::InsufficientAppArmorPermissions::name,
+                                err_str);
+                }
+            }
 
             bus->send(reply);
         });
@@ -211,22 +229,38 @@
             in->reader() >> uri >> headers;
 
             auto reply = dbus::Message::make_method_return(in);
-            // Make sure the client has adequate apparmor permissions to open the URI
-            const auto result = request_authenticator->authenticate_open_uri_request(context, uri);
-            if (std::get<0>(result))
-            {
-                reply->writer() << (std::get<0>(result) ? impl->open_uri(uri, headers) : false);
-            }
-            else
-            {
-                const std::string err_str = {"Warning: Failed to authenticate necessary "
-                    "apparmor permissions to open uri: " + std::get<1>(result)};
+            uri_check->set(uri);
+            const bool valid_uri = !uri_check->is_local_file() or
+                    (uri_check->is_local_file() and uri_check->file_exists());
+            if (!valid_uri)
+            {
+                const std::string err_str = {"Warning: Failed to open uri " + uri +
+                     " because it can't be found."};
                 std::cerr << err_str << std::endl;
                 reply = dbus::Message::make_error(
                             in,
-                            mpris::Player::Error::InsufficientAppArmorPermissions::name,
+                            mpris::Player::Error::UriNotFound::name,
                             err_str);
             }
+            else
+            {
+                // Make sure the client has adequate apparmor permissions to open the URI
+                const auto result = request_authenticator->authenticate_open_uri_request(context, uri);
+                if (std::get<0>(result))
+                {
+                    reply->writer() << (std::get<0>(result) ? impl->open_uri(uri, headers) : false);
+                }
+                else
+                {
+                    const std::string err_str = {"Warning: Failed to authenticate necessary "
+                        "apparmor permissions to open uri: " + std::get<1>(result)};
+                    std::cerr << err_str << std::endl;
+                    reply = dbus::Message::make_error(
+                                in,
+                                mpris::Player::Error::InsufficientAppArmorPermissions::name,
+                                err_str);
+                }
+            }
 
             bus->send(reply);
         });
@@ -258,6 +292,7 @@
     dbus::Object::Ptr object;
     media::apparmor::ubuntu::RequestContextResolver::Ptr request_context_resolver;
     media::apparmor::ubuntu::RequestAuthenticator::Ptr request_authenticator;
+    media::UriCheck::Ptr uri_check;
 
     mpris::Player::Skeleton skeleton;
 
 
=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2016-01-14 19:47:40 +0000
+++ src/core/media/player_stub.cpp	2016-02-22 18:59:27 +0000
@@ -266,6 +266,8 @@
     {
         if (op.error().name() == mpris::Player::Error::InsufficientAppArmorPermissions::name)
             throw media::Player::Errors::InsufficientAppArmorPermissions{op.error().print()};
+        else if (op.error().name() == mpris::Player::Error::UriNotFound::name)
+            throw media::Player::Errors::UriNotFound{op.error().print()};
         else
             throw std::runtime_error{op.error().print()};
     }
 
=== modified file 'src/core/media/track_list_implementation.cpp'
--- src/core/media/track_list_implementation.cpp	2015-11-18 18:33:31 +0000
+++ src/core/media/track_list_implementation.cpp	2016-02-22 18:59:27 +0000
@@ -140,7 +140,6 @@
     {
         auto it = std::find(container.begin(), container.end(), position);
         container.insert(it, id);
-        std::cout << "container.size(): " << container.size() << std::endl;
 
         return true;
     });
 
=== modified file 'src/core/media/track_list_skeleton.cpp'
--- src/core/media/track_list_skeleton.cpp	2015-11-18 18:33:31 +0000
+++ src/core/media/track_list_skeleton.cpp	2016-02-22 18:59:27 +0000
@@ -27,7 +27,9 @@
 #include "track_list_traits.h"
 #include "the_session_bus.h"
 
+#include "mpris/player.h"
 #include "mpris/track_list.h"
+#include "util/uri_check.h"
 
 #include <core/dbus/object.h>
 #include <core/dbus/property.h>
@@ -56,6 +58,7 @@
           object(object),
           request_context_resolver(request_context_resolver),
           request_authenticator(request_authenticator),
+          uri_check(std::make_shared<UriCheck>()),
           skeleton(mpris::TrackList::Skeleton::Configuration{object, mpris::TrackList::Skeleton::Configuration::Defaults{}}),
           current_track(skeleton.properties.tracks->get().begin()),
           empty_iterator(skeleton.properties.tracks->get().begin()),
@@ -112,23 +115,39 @@
 
             // Make sure the client has adequate apparmor permissions to open the URI
             const auto result = request_authenticator->authenticate_open_uri_request(context, uri);
-
             auto reply = dbus::Message::make_method_return(msg);
-            // Only add the track to the TrackList if it passes the apparmor permissions check
-            if (std::get<0>(result))
-            {
-                impl->add_track_with_uri_at(uri, after, make_current);
-            }
-            else
+
+            uri_check->set(uri);
+            const bool valid_uri = !uri_check->is_local_file() or
+                    (uri_check->is_local_file() and uri_check->file_exists());
+            if (!valid_uri)
             {
                 const std::string err_str = {"Warning: Not adding track " + uri +
-                    " to TrackList because of inadequate client apparmor permissions."};
+                     " to TrackList because it can't be found."};
                 std::cerr << err_str << std::endl;
                 reply = dbus::Message::make_error(
                             msg,
-                            mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name,
+                            mpris::Player::Error::UriNotFound::name,
                             err_str);
             }
+            else
+            {
+                // Only add the track to the TrackList if it passes the apparmor permissions check
+                if (std::get<0>(result))
+                {
+                    impl->add_track_with_uri_at(uri, after, make_current);
+                }
+                else
+                {
+                    const std::string err_str = {"Warning: Not adding track " + uri +
+                        " to TrackList because of inadequate client apparmor permissions."};
+                    std::cerr << err_str << std::endl;
+                    reply = dbus::Message::make_error(
+                                msg,
+                                mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name,
+                                err_str);
+                }
+            }
 
             bus->send(reply);
         });
@@ -144,10 +163,26 @@
             media::Track::Id after;
             msg->reader() >> uris >> after;
 
+            bool valid_uri = false;
             media::apparmor::ubuntu::RequestAuthenticator::Result result;
-            std::string err_str;
+            std::string uri_err_str, err_str;
+            core::dbus::Message::Ptr reply;
             for (const auto uri : uris)
             {
+                uri_check->set(uri);
+                valid_uri = !uri_check->is_local_file() or
+                        (uri_check->is_local_file() and uri_check->file_exists());
+                if (!valid_uri)
+                {
+                    uri_err_str = {"Warning: Not adding track " + uri +
+                         " to TrackList because it can't be found."};
+                    std::cerr << uri_err_str << std::endl;
+                    reply = dbus::Message::make_error(
+                                msg,
+                                mpris::Player::Error::UriNotFound::name,
+                                err_str);
+                }
+
                 // Make sure the client has adequate apparmor permissions to open the URI
                 result = request_authenticator->authenticate_open_uri_request(context, uri);
                 if (not std::get<0>(result))
@@ -158,7 +193,6 @@
                 }
             }
 
-            core::dbus::Message::Ptr reply;
             // Only add the track to the TrackList if it passes the apparmor permissions check
             if (std::get<0>(result))
             {
@@ -312,6 +346,7 @@
     dbus::Object::Ptr object;
     media::apparmor::ubuntu::RequestContextResolver::Ptr request_context_resolver;
     media::apparmor::ubuntu::RequestAuthenticator::Ptr request_authenticator;
+    media::UriCheck::Ptr uri_check;
 
     mpris::TrackList::Skeleton skeleton;
     TrackList::ConstIterator current_track;
 
=== modified file 'src/core/media/track_list_stub.cpp'
--- src/core/media/track_list_stub.cpp	2015-11-18 15:55:23 +0000
+++ src/core/media/track_list_stub.cpp	2016-02-22 18:59:27 +0000
@@ -25,6 +25,7 @@
 #include "track_list_traits.h"
 #include "the_session_bus.h"
 
+#include "mpris/player.h"
 #include "mpris/track_list.h"
 
 #include <core/dbus/property.h>
@@ -239,6 +240,8 @@
         if (op.error().name() ==
                 mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name)
             throw media::TrackList::Errors::InsufficientPermissionsToAddTrack{};
+        else if (op.error().name() == mpris::Player::Error::UriNotFound::name)
+            throw media::Player::Errors::UriNotFound{op.error().print()};
         else
             throw std::runtime_error{op.error().print()};
     }
@@ -255,6 +258,8 @@
         if (op.error().name() ==
                 mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name)
             throw media::TrackList::Errors::InsufficientPermissionsToAddTrack{};
+        else if (op.error().name() == mpris::Player::Error::UriNotFound::name)
+            throw media::Player::Errors::UriNotFound{op.error().print()};
         else
             throw std::runtime_error{op.error().print()};
     }
 
=== added file 'src/core/media/util/uri_check.h'
--- src/core/media/util/uri_check.h	1970-01-01 00:00:00 +0000
+++ src/core/media/util/uri_check.h	2016-02-22 18:59:27 +0000
@@ -0,0 +1,160 @@
+/*
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ *
+ */
+
+#ifndef URI_CHECK_H_
+#define URI_CHECK_H_
+
+#include <gio/gio.h>
+
+#include <memory>
+#include <iostream>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+
+class UriCheck
+{
+public:
+    typedef std::shared_ptr<UriCheck> Ptr;
+
+    UriCheck()
+        : is_encoded_(false),
+          is_local_file_(false),
+          local_file_exists_(false)
+    {
+    }
+
+    UriCheck(const std::string& uri)
+        : uri_(uri),
+          is_encoded_(determine_if_encoded()),
+          is_local_file_(determine_if_local_file()),
+          local_file_exists_(determine_if_file_exists())
+    {
+    }
+
+    virtual ~UriCheck()
+    {
+    }
+
+    void set(const std::string& uri)
+    {
+        if (uri.empty())
+            return;
+
+        uri_ = uri;
+        is_encoded_ = determine_if_encoded();
+        is_local_file_ = determine_if_local_file();
+        local_file_exists_ = determine_if_file_exists();
+    }
+
+    void clear()
+    {
+        uri_.clear();
+    }
+
+    bool is_encoded() const
+    {
+        return is_encoded_;
+    }
+
+    bool is_local_file() const
+    {
+        return is_local_file_;
+    }
+
+    bool file_exists() const
+    {
+        return local_file_exists_;
+    }
+
+protected:
+    UriCheck(const UriCheck&) = delete;
+    UriCheck& operator=(const UriCheck&) = delete;
+
+private:
+    bool determine_if_encoded()
+    {
+        if (uri_.empty())
+            return false;
+
+        gchar *tmp = g_uri_unescape_string(uri_.c_str(), nullptr);
+        if (!tmp)
+            return false;
+
+        const std::string unescaped_uri{tmp};
+        g_free(tmp);
+        return unescaped_uri.length() < uri_.length();
+    }
+
+    bool determine_if_local_file()
+    {
+        if (uri_.empty())
+            return false;
+
+        gchar *tmp = g_uri_parse_scheme(uri_.c_str());
+        std::string uri_scheme;
+        if (tmp)
+            uri_scheme.assign(tmp);
+        g_free(tmp);
+        try {
+        return uri_.at(0) == '/' or
+                (uri_.at(0) == '.' and uri_.at(1) == '/') or
+                uri_scheme == "file";
+        }
+        catch (const std::out_of_range &e) {
+            std::cerr << "Invalid URI string provided: " << uri_ << std::endl;
+            return false;
+        }
+    }
+
+    bool determine_if_file_exists()
+    {
+        if (!is_local_file_)
+            return false;
+
+        GError *error = nullptr;
+        // Open the URI and get the mime type from it. This will currently only work for
+        // a local file
+        std::unique_ptr<GFile, void(*)(void *)> file(
+                g_file_new_for_uri(uri_.c_str()), g_object_unref);
+        std::unique_ptr<GFileInfo, void(*)(void *)> info(
+                g_file_query_info(
+                    file.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE ","
+                    G_FILE_ATTRIBUTE_ETAG_VALUE, G_FILE_QUERY_INFO_NONE,
+                    /* cancellable */ NULL, &error),
+                g_object_unref);
+
+        return info.get() != nullptr;
+    }
+
+private:
+    std::string uri_;
+    bool is_encoded_;
+    bool is_local_file_;
+    bool local_file_exists_;
+};
+
+}
+}
+}
+
+#endif // URI_CHECK_H_