Support rendering previews with data: URLs in them

synapse/rest/media/v1/preview_html.py

@@ -323,10 +323,13 @@ def _iterate_over_text(
 def rebase_url(url: str, base: str) -> str:
     base_parts = list(urlparse.urlparse(base))
     url_parts = list(urlparse.urlparse(url))
-    if not url_parts[0]:  # fix up schema
+    # Add a scheme, if one does not exist.
+    if not url_parts[0]:
         url_parts[0] = base_parts[0] or "http"
-    if not url_parts[1]:  # fix up hostname
+    # Fix up the hostname, if this is not a data URL.
+    if url_parts[0] != "data" and not url_parts[1]:
         url_parts[1] = base_parts[1]
+        # If the path does not start with a /, nest it under the base path.
         if not url_parts[2].startswith("/"):
             url_parts[2] = re.sub(r"/[^/]+$", "/", base_parts[2]) + url_parts[2]
     return urlparse.urlunparse(url_parts)

synapse/rest/media/v1/preview_url_resource.py

@@ -23,6 +23,7 @@
 import traceback
 from typing import TYPE_CHECKING, BinaryIO, Iterable, Optional, Tuple
 from urllib import parse as urlparse
+from urllib.request import urlopen
 
 import attr
 
@@ -417,6 +418,38 @@ async def _download_url(
 
         return length, uri, code, media_type, download_name, expires, etag
 
+    async def _parse_data_url(
+        self, url: str, output_stream: BinaryIO
+    ) -> Tuple[int, str, int, str, Optional[str], int, Optional[str]]:
+        """
+        Parses a data: URL and stores it.
+        """
+        try:
+            logger.debug("Trying to parse data url '%s'", url)
+            with urlopen(url) as url_info:
+                # TODO Can this be more efficient.
+                output_stream.write(url_info.read())
+        except Exception as e:
+            logger.warning("Error parsing data: URL %s: %r", url, e)
+
+            raise SynapseError(
+                500,
+                "Failed to parse data URL: %s"
+                % (traceback.format_exception_only(sys.exc_info()[0], e),),
+                Codes.UNKNOWN,
+            )
+
+        length = output_stream.seek(1)
+
+        media_type = url_info.headers.get_content_type()
+
+        # Some features are not supported by data: URLs.
+        download_name = None
+        expires = ONE_HOUR
+        etag = None
+
+        return length, url, 200, media_type, download_name, expires, etag
+
     async def _handle_url(self, url: str, user: UserID) -> MediaInfo:
         """
         Fetches remote content and parses the headers to generate a MediaInfo.
@@ -441,15 +474,27 @@ async def _handle_url(self, url: str, user: UserID) -> MediaInfo:
         file_info = FileInfo(server_name=None, file_id=file_id, url_cache=True)
 
         with self.media_storage.store_into_file(file_info) as (f, fname, finish):
-            (
-                length,
-                uri,
-                code,
-                media_type,
-                download_name,
-                expires,
-                etag,
-            ) = await self._download_url(url, f)
+            if url.startswith("data:"):
+                (
+                    length,
+                    uri,
+                    code,
+                    media_type,
+                    download_name,
+                    expires,
+                    etag,
+                ) = await self._parse_data_url(url, f)
+            else:
+                (
+                    length,
+                    uri,
+                    code,
+                    media_type,
+                    download_name,
+                    expires,
+                    etag,
+                ) = await self._download_url(url, f)
+
             await finish()
 
         try:

tests/rest/media/v1/test_url_preview.py

@@ -12,6 +12,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import base64
 import json
 import os
 import re
@@ -23,6 +24,7 @@
 
 from synapse.config.oembed import OEmbedEndpointConfig
 from synapse.rest.media.v1.preview_url_resource import IMAGE_CACHE_EXPIRY_MS
+from synapse.types import JsonDict
 from synapse.util.stringutils import parse_and_validate_mxc_uri
 
 from tests import unittest
@@ -142,6 +144,13 @@ def resolveHostName(
     def create_test_resource(self):
         return self.hs.get_media_repository_resource()
 
+    def _assert_small_png(self, json_body: JsonDict) -> None:
+        """Assert properties from the SMALL_PNG test image."""
+        self.assertTrue(json_body["og:image"].startswith("mxc://"))
+        self.assertEqual(json_body["og:image:height"], 1)
+        self.assertEqual(json_body["og:image:width"], 1)
+        self.assertEqual(json_body["og:image:type"], "image/png")
+
     def test_cache_returns_correct_type(self):
         self.lookups["matrix.org"] = [(IPv4Address, "10.1.2.3")]
 
@@ -569,6 +578,41 @@ def test_accept_language_config_option(self):
             server.data,
         )
 
+    def test_data_url(self):
+        self.lookups["matrix.org"] = [(IPv4Address, "10.1.2.3")]
+
+        data = base64.b64encode(SMALL_PNG)
+
+        end_content = (
+            b"<html><head>" b'<img src="data:image/png;base64,%s" />' b"</head></html>"
+        ) % (data,)
+
+        channel = self.make_request(
+            "GET",
+            "preview_url?url=http://matrix.org",
+            shorthand=False,
+            await_result=False,
+        )
+        self.pump()
+
+        client = self.reactor.tcpClients[0][2].buildProtocol(None)
+        server = AccumulatingProtocol()
+        server.makeConnection(FakeTransport(client, self.reactor))
+        client.makeConnection(FakeTransport(server, self.reactor))
+        client.dataReceived(
+            (
+                b"HTTP/1.0 200 OK\r\nContent-Length: %d\r\n"
+                b'Content-Type: text/html; charset="utf8"\r\n\r\n'
+            )
+            % (len(end_content),)
+            + end_content
+        )
+
+        self.pump()
+        self.assertEqual(channel.code, 200)
+        self.assertEqual(channel.code, 200)
+        self._assert_small_png(channel.json_body)
+
     def test_oembed_photo(self):
         """Test an oEmbed endpoint which returns a 'photo' type which redirects the preview to a new URL."""
         self.lookups["publish.twitter.com"] = [(IPv4Address, "10.1.2.3")]
@@ -626,10 +670,7 @@ def test_oembed_photo(self):
         self.assertEqual(channel.code, 200)
         body = channel.json_body
         self.assertEqual(body["og:url"], "http://twitter.com/matrixdotorg/status/12345")
-        self.assertTrue(body["og:image"].startswith("mxc://"))
-        self.assertEqual(body["og:image:height"], 1)
-        self.assertEqual(body["og:image:width"], 1)
-        self.assertEqual(body["og:image:type"], "image/png")
+        self._assert_small_png(body)
 
     def test_oembed_rich(self):
         """Test an oEmbed endpoint which returns HTML content via the 'rich' type."""
@@ -820,10 +861,7 @@ def test_oembed_autodiscovery(self):
         self.assertEqual(
             body["og:url"], "http://www.twitter.com/matrixdotorg/status/12345"
         )
-        self.assertTrue(body["og:image"].startswith("mxc://"))
-        self.assertEqual(body["og:image:height"], 1)
-        self.assertEqual(body["og:image:width"], 1)
-        self.assertEqual(body["og:image:type"], "image/png")
+        self._assert_small_png(body)
 
     def _download_image(self):
         """Downloads an image into the URL cache.