From 60d4dce0193fb9d592f2fe065908bfc88da89dff Mon Sep 17 00:00:00 2001 From: "Juan J. Martinez" Date: Sun, 16 Jan 2022 00:22:24 +0000 Subject: Refactor Gemini protocol --- server/src/net/usebox/gemini/server/Server.scala | 193 +++---------------- server/src/net/usebox/gemini/server/URIUtils.scala | 21 +++ .../gemini/server/handlers/GeminiHandler.scala | 129 +++++++++++++ .../gemini/server/handlers/ProtocolHandler.scala | 38 ++++ server/test/src/ServerSpec.scala | 209 --------------------- server/test/src/TestData.scala | 108 +++++++++++ server/test/src/URIUtilsSpec.scala | 26 +++ server/test/src/handlers/ProtocolHandlerSpec.scala | 100 ++++++++++ 8 files changed, 444 insertions(+), 380 deletions(-) create mode 100644 server/src/net/usebox/gemini/server/handlers/GeminiHandler.scala create mode 100644 server/src/net/usebox/gemini/server/handlers/ProtocolHandler.scala create mode 100644 server/test/src/TestData.scala create mode 100644 server/test/src/URIUtilsSpec.scala create mode 100644 server/test/src/handlers/ProtocolHandlerSpec.scala diff --git a/server/src/net/usebox/gemini/server/Server.scala b/server/src/net/usebox/gemini/server/Server.scala index 42a097c..d474bd3 100644 --- a/server/src/net/usebox/gemini/server/Server.scala +++ b/server/src/net/usebox/gemini/server/Server.scala @@ -3,7 +3,6 @@ package net.usebox.gemini.server import java.nio.charset.Charset import javax.net.ssl.SSLEngine import java.net.URI -import java.nio.file.{Path, FileSystems, Files} import scala.util.{Try, Success => TrySuccess} @@ -14,7 +13,7 @@ import akka.stream.scaladsl._ import akka.actor.ActorSystem import akka.util.ByteString -import URIUtils._ +import net.usebox.gemini.server.handlers.GeminiHandler case class Server(conf: ServiceConf) { @@ -23,182 +22,35 @@ case class Server(conf: ServiceConf) { private[this] val logger = getLogger - val mimeTypes = conf.mimeTypes - val defaultMimeType = conf.defaultMimeType - val vHosts = conf.virtualHosts + val geminiHandler = new GeminiHandler(conf) val charsetDecoder = Charset.forName("utf-8").newDecoder() def decodeUTF8(value: ByteString): Either[Throwable, String] = Try(charsetDecoder.decode(value.toByteBuffer).toString()).toEither - def validPath(path: String): Boolean = - !path - .split('/') - .drop(1) - .foldLeft(List(0)) { - case (acc, "..") => acc.appended(acc.last - 1) - case (acc, ".") => acc.appended(acc.last) - case (acc, _) => acc.appended(acc.last + 1) - } - .exists(_ < 0) - - def guessMimeType(path: Path, params: Option[String]): String = - mimeTypes.fold { - List(".gmi", ".gemini") - .find(path.toString().endsWith(_)) - .fold { - Try(Files.probeContentType(path)).toOption match { - case Some(mime) if mime != null => mime - case _ => defaultMimeType - } - }(_ => "text/gemini") - } { types => - types - .find { - case (t, exts) => exts.exists(path.toString().endsWith(_)) - } - .fold(defaultMimeType) { case (t, _) => t } - } match { - case mime @ "text/gemini" => - params.fold(mime)(p => s"$mime; ${p.stripMargin(';').trim()}") - case mime => mime - } - def handleReq(req: String, remoteAddr: String): Response = (for { uri <- Try(URI.create(req)).toEither - resp <- Try( - ( - uri.getScheme(), - uri.getHost(), - uri.getPath().decode(), - vHosts.find(vh => - Some(vh.host.toLowerCase) == Option(uri.getHost()) - .map(_.toLowerCase) + scheme <- Try(uri.getScheme()).toEither + resp <- Try(scheme match { + case null => + logger.debug(s"no scheme") + BadRequest(req) + case _ if uri.getPort() != -1 && uri.getPort() != conf.port => + logger.debug(s"invalid port, is a proxy request") + ProxyRequestRefused(req) + case _ if uri.getPort() == -1 && conf.port != Server.defPort => + logger.debug( + s"default port but non default was configured, is a proxy request" ) - ) match { - case (null, _, _, _) => - logger.debug(s"no scheme") - BadRequest(req) - case _ if uri.getPort() != -1 && uri.getPort() != conf.port => - logger.debug(s"invalid port, is a proxy request") - ProxyRequestRefused(req) - case _ if uri.getPort() == -1 && conf.port != Server.defPort => - logger.debug( - s"default port but non default was configured, is a proxy request" - ) - ProxyRequestRefused(req) - case ("gemini", host, _, None) => - logger.debug(s"vhost $host not found in $vHosts") - ProxyRequestRefused(req) - case ("gemini", host, _, _) if uri.getUserInfo() != null => - logger.debug(s"user info present") - BadRequest(req, "Userinfo component is not allowed") - case ("gemini", _, path, _) if !validPath(path) => - logger.debug("invalid path, out of root") - BadRequest(req) - case ("gemini", _, _, _) if uri.normalize() != uri => - logger.debug("redirect to normalize uri") - PermanentRedirect(req, uri.normalize().toString()) - case ("gemini", host, rawPath, Some(vhost)) => - val (root, path) = vhost.getRoot(rawPath) - - val resource = FileSystems - .getDefault() - .getPath(root, path) - .normalize() - val cgi = vhost - .getCgi(resource) match { - case None => vhost.getCgi(resource.resolve(vhost.indexFile)) - case cgi => cgi - } - - logger.debug(s"requesting: '$resource', cgi is '$cgi'") - - resource.toFile() match { - case _ - if cgi - .map(_.toFile()) - .map(f => f.isFile() && f.canExecute()) - .getOrElse(false) => - logger.debug("is cgi, will execute") - - val cgiFile = cgi.get - val queryString = - if (uri.getQuery() == null) "" else uri.getQuery() - val pathInfo = - if (cgiFile.compareTo(resource) >= 0) "" - else - "/" + resource - .subpath( - cgiFile.getNameCount(), - resource.getNameCount() - ) - .toString() - - Cgi( - req, - filename = cgiFile.toString(), - queryString = queryString, - pathInfo = pathInfo, - scriptName = cgiFile.getFileName().toString(), - host = vhost.host, - port = conf.port.toString(), - remoteAddr = remoteAddr, - vhEnv = vhost.environment.getOrElse(Map()) - ) - case path if !path.exists() => - logger.debug("no resource") - NotFound(req) - case path if path.exists() && !path.canRead() => - logger.debug("no read permissions") - NotFound(req) - case file if file.getName().startsWith(".") => - logger.debug("dot file, ignored request") - NotFound(req) - case file if file.isFile() => - Success( - req, - meta = guessMimeType(resource, vhost.geminiParams), - bodySize = file.length(), - bodyPath = Some(resource) - ) - case dir - if dir.isDirectory() && !path.isEmpty() && !path - .endsWith("/") => - logger.debug("redirect directory") - PermanentRedirect(req, uri.toString() + "/") - case dir if dir.isDirectory() => - val dirFilePath = resource.resolve(vhost.indexFile) - val dirFile = dirFilePath.toFile() - - if (dirFile.isFile() && dirFile.canRead()) { - logger.debug(s"serving index file: $dirFilePath") - Success( - req, - meta = guessMimeType(dirFilePath, vhost.geminiParams), - bodySize = dirFile.length(), - bodyPath = Some(dirFilePath) - ) - } else if (vhost.getDirectoryListing(resource)) { - logger.debug("directory listing") - DirListing( - req, - meta = "text/gemini", - bodyPath = Some(resource), - uriPath = path - ) - } else - NotFound(req) - case _ => - logger.debug("default: other resource type") - NotFound(req) - } - case (scheme, _, _, _) => - logger.debug(s"scheme $scheme not allowed") - ProxyRequestRefused(req) - } - ).toEither + ProxyRequestRefused(req) + case "gemini" => + logger.debug(s"gemini request: $req") + geminiHandler.handle(req, uri, remoteAddr) + case _ => + logger.debug(s"scheme $scheme not allowed") + ProxyRequestRefused(req) + }).toEither } yield resp) match { case Left(error: IllegalArgumentException) => logger.debug(s"invalid request: ${error.getMessage()}") @@ -206,12 +58,11 @@ case class Server(conf: ServiceConf) { case Left(error) => logger.error(error)("Internal server error") PermanentFailure(req, "Internal server error") - case Right(resp) => resp } def serve = { - val certs = vHosts.map { vhost => + val certs = conf.virtualHosts.map { vhost => vhost.keyStore.fold( ( vhost.host, diff --git a/server/src/net/usebox/gemini/server/URIUtils.scala b/server/src/net/usebox/gemini/server/URIUtils.scala index 63c1534..76e2adf 100644 --- a/server/src/net/usebox/gemini/server/URIUtils.scala +++ b/server/src/net/usebox/gemini/server/URIUtils.scala @@ -2,9 +2,12 @@ package net.usebox.gemini.server import java.nio.charset.StandardCharsets import java.net.{URLEncoder, URLDecoder} +import java.net.URI import scala.util.Try +import net.usebox.gemini.server.VirtualHost + object URIUtils { // FIXME: decoding/encoding errors implicit class StringOps(s: String) { @@ -15,5 +18,23 @@ object URIUtils { def decode(): String = Try(URLDecoder.decode(s, StandardCharsets.UTF_8.name())).toOption .getOrElse(s) + + def isValidPath: Boolean = + !s.split('/') + .drop(1) + .foldLeft(List(0)) { + case (acc, "..") => acc.appended(acc.last - 1) + case (acc, ".") => acc.appended(acc.last) + case (acc, _) => acc.appended(acc.last + 1) + } + .exists(_ < 0) + } + + implicit class UriOps(uri: URI) { + def toVirtualHost(vHosts: List[VirtualHost]): Option[VirtualHost] = + vHosts.find(vh => + Some(vh.host.toLowerCase) == Option(uri.getHost()) + .map(_.toLowerCase) + ) } } diff --git a/server/src/net/usebox/gemini/server/handlers/GeminiHandler.scala b/server/src/net/usebox/gemini/server/handlers/GeminiHandler.scala new file mode 100644 index 0000000..b582d55 --- /dev/null +++ b/server/src/net/usebox/gemini/server/handlers/GeminiHandler.scala @@ -0,0 +1,129 @@ +package net.usebox.gemini.server.handlers + +import java.net.URI +import java.nio.file.FileSystems + +import org.log4s._ + +import net.usebox.gemini.server._ +import URIUtils._ + +class GeminiHandler(conf: ServiceConf) extends ProtocolHandler(conf) { + + private[this] val logger = getLogger + + def handle(req: String, uri: URI, remoteAddr: String): Response = + ( + uri.getHost(), + uri.getPath().decode(), + uri.toVirtualHost(vHosts) + ) match { + case (host, _, None) => + logger.debug(s"vhost $host not found in $vHosts") + ProxyRequestRefused(req) + case (host, _, _) if uri.getUserInfo() != null => + logger.debug(s"user info present") + BadRequest(req, "Userinfo component is not allowed") + case (_, path, _) if !path.isValidPath => + logger.debug("invalid path, out of root") + BadRequest(req) + case _ if uri.normalize() != uri => + logger.debug("redirect to normalize uri") + PermanentRedirect(req, uri.normalize().toString()) + case (host, rawPath, Some(vhost)) => + val (root, path) = vhost.getRoot(rawPath) + + val resource = FileSystems + .getDefault() + .getPath(root, path) + .normalize() + val cgi = vhost + .getCgi(resource) match { + case None => vhost.getCgi(resource.resolve(vhost.indexFile)) + case cgi => cgi + } + + logger.debug(s"requesting: '$resource', cgi is '$cgi'") + + resource.toFile() match { + case _ + if cgi + .map(_.toFile()) + .map(f => f.isFile() && f.canExecute()) + .getOrElse(false) => + logger.debug("is cgi, will execute") + + val cgiFile = cgi.get + val queryString = + if (uri.getQuery() == null) "" else uri.getQuery() + val pathInfo = + if (cgiFile.compareTo(resource) >= 0) "" + else + "/" + resource + .subpath( + cgiFile.getNameCount(), + resource.getNameCount() + ) + .toString() + + Cgi( + req, + filename = cgiFile.toString(), + queryString = queryString, + pathInfo = pathInfo, + scriptName = cgiFile.getFileName().toString(), + host = vhost.host, + port = conf.port.toString(), + remoteAddr = remoteAddr, + vhEnv = vhost.environment.getOrElse(Map()) + ) + case path if !path.exists() => + logger.debug("no resource") + NotFound(req) + case path if path.exists() && !path.canRead() => + logger.debug("no read permissions") + NotFound(req) + case file if file.getName().startsWith(".") => + logger.debug("dot file, ignored request") + NotFound(req) + case file if file.isFile() => + Success( + req, + meta = guessMimeType(resource, vhost.geminiParams), + bodySize = file.length(), + bodyPath = Some(resource) + ) + case dir + if dir.isDirectory() && !path.isEmpty() && !path + .endsWith("/") => + logger.debug("redirect directory") + PermanentRedirect(req, uri.toString() + "/") + case dir if dir.isDirectory() => + val dirFilePath = resource.resolve(vhost.indexFile) + val dirFile = dirFilePath.toFile() + + if (dirFile.isFile() && dirFile.canRead()) { + logger.debug(s"serving index file: $dirFilePath") + Success( + req, + meta = guessMimeType(dirFilePath, vhost.geminiParams), + bodySize = dirFile.length(), + bodyPath = Some(dirFilePath) + ) + } else if (vhost.getDirectoryListing(resource)) { + logger.debug("directory listing") + DirListing( + req, + meta = "text/gemini", + bodyPath = Some(resource), + uriPath = path + ) + } else + NotFound(req) + case _ => + logger.debug("default: other resource type") + NotFound(req) + } + } + +} diff --git a/server/src/net/usebox/gemini/server/handlers/ProtocolHandler.scala b/server/src/net/usebox/gemini/server/handlers/ProtocolHandler.scala new file mode 100644 index 0000000..f36dc7f --- /dev/null +++ b/server/src/net/usebox/gemini/server/handlers/ProtocolHandler.scala @@ -0,0 +1,38 @@ +package net.usebox.gemini.server.handlers + +import java.net.URI +import java.nio.file.{Path, Files} + +import scala.util.Try + +import net.usebox.gemini.server.{ServiceConf, Response} + +abstract class ProtocolHandler(conf: ServiceConf) { + + private val defaultMimeType = conf.defaultMimeType + val vHosts = conf.virtualHosts + + def guessMimeType(path: Path, params: Option[String]): String = + conf.mimeTypes.fold { + List(".gmi", ".gemini") + .find(path.toString().endsWith(_)) + .fold { + Try(Files.probeContentType(path)).toOption match { + case Some(mime) if mime != null => mime + case _ => defaultMimeType + } + }(_ => "text/gemini") + } { types => + types + .find { + case (t, exts) => exts.exists(path.toString().endsWith(_)) + } + .fold(defaultMimeType) { case (t, _) => t } + } match { + case mime @ "text/gemini" => + params.fold(mime)(p => s"$mime; ${p.stripMargin(';').trim()}") + case mime => mime + } + + def handle(req: String, uri: URI, remoteAddr: String): Response +} diff --git a/server/test/src/ServerSpec.scala b/server/test/src/ServerSpec.scala index 7d8c1fa..a7a2db0 100644 --- a/server/test/src/ServerSpec.scala +++ b/server/test/src/ServerSpec.scala @@ -1,115 +1,11 @@ package net.usebox.gemini.server -import java.nio.file.FileSystems - -import scala.concurrent.duration._ - import org.scalatest.flatspec.AnyFlatSpec import org.scalatest.matchers.should.Matchers import akka.util.ByteString class ServerSpec extends AnyFlatSpec with Matchers { - def getPath(value: String) = FileSystems.getDefault().getPath(value) - - behavior of "validPath" - - it should "return true for the emtpy path" in { - Server(TestData.conf).validPath("") shouldBe true - } - - it should "return true for valid paths" in { - List("/", "/file", "/./", "/.", "/dir/", "/dir/../").foreach { p => - Server(TestData.conf).validPath(p) shouldBe true - } - } - - it should "return false for invalid paths" in { - List("/../", "/..", "/dir/../..", "/dir/../..", "/./../", "/./dir/.././../") - .foreach { p => - Server(TestData.conf).validPath(p) shouldBe false - } - } - - behavior of "guessMimeType using the internal resolver" - - it should "resolve a known MIME type" in { - Server(TestData.conf) - .guessMimeType( - getPath("file.html"), - None - ) shouldBe "text/html" - } - - it should "resolve de default MIME type for unknown types" in { - Server(TestData.conf) - .guessMimeType( - getPath("unknow"), - None - ) shouldBe TestData.conf.defaultMimeType - } - - it should "resolve gemini MIME type" in { - Server(TestData.conf) - .guessMimeType( - getPath("file.gmi"), - None - ) shouldBe "text/gemini" - Server(TestData.conf) - .guessMimeType( - getPath("file.gemini"), - None - ) shouldBe "text/gemini" - } - - it should "resolve gemini MIME type, including parameters" in { - Server(TestData.conf) - .guessMimeType( - getPath("file.gmi"), - Some("param") - ) shouldBe "text/gemini; param" - Server(TestData.conf) - .guessMimeType( - getPath("file.gemini"), - Some("param") - ) shouldBe "text/gemini; param" - } - - it should "gemini MIME type parameters are sanitized" in { - Server(TestData.conf) - .guessMimeType( - getPath("file.gmi"), - Some(" ; param") - ) shouldBe "text/gemini; param" - } - - behavior of "guessMimeType using the configured types" - - it should "resolve a known MIME type" in { - Server(TestData.conf.copy(mimeTypes = TestData.mimeTypes)) - .guessMimeType( - getPath("file.gmi"), - None - ) shouldBe "config" - } - - it should "include parameters for text/gemini MIME types" in { - Server( - TestData.conf.copy(mimeTypes = Some(Map("text/gemini" -> List(".gmi")))) - ).guessMimeType( - getPath("file.gmi"), - Some("param") - ) shouldBe "text/gemini; param" - } - - it should "resolve de default MIME type for unknown types" in { - Server(TestData.conf.copy(mimeTypes = TestData.mimeTypes)) - .guessMimeType( - getPath("unknow"), - None - ) shouldBe TestData.conf.defaultMimeType - } - behavior of "decodeUTF8" it should "return right on valid UTF-8 codes" in { @@ -706,109 +602,4 @@ class ServerSpec extends AnyFlatSpec with Matchers { cgi.body should include("GATEWAY_INTERFACE=CGI/1.1") cgi.body should include("PATH_INFO=/path/info") } - - object TestData { - - val host = "localhost" - val port = 1965 - val portStr = port.toString() - - val conf = ServiceConf( - address = "127.0.0.1", - port = port, - defaultMimeType = "text/plain", - idleTimeout = 10.seconds, - virtualHosts = List( - VirtualHost( - host = host, - root = getClass.getResource("/").getPath() - ) - ), - genCertValidFor = 1.day, - enabledProtocols = Nil, - enabledCipherSuites = Nil - ) - - val cgiConf = ServiceConf.initConf( - conf.copy(virtualHosts = - List( - conf - .virtualHosts(0) - .copy( - directoryListing = true, - directories = List( - Directory( - "dir/", - directoryListing = Some(false), - allowCgi = Some(true) - ) - ) - ) - ) - ) - ) - - val cgiPrefConf = ServiceConf.initConf( - conf.copy(virtualHosts = - List( - conf - .virtualHosts(0) - .copy( - directoryListing = true, - directories = List( - Directory( - "dir/", - directoryListing = Some(false), - allowCgi = Some(true) - ), - Directory( - "dir/sub/", - directoryListing = Some(false), - allowCgi = Some(true) - ) - ) - ) - ) - ) - ) - - val cgiEnvConf = cgiConf.copy(virtualHosts = - List( - cgiConf - .virtualHosts(0) - .copy( - environment = Some(Map("env1" -> "value")) - ) - ) - ) - - val cgiIndexConf = cgiConf.copy(virtualHosts = - List( - cgiConf - .virtualHosts(0) - .copy( - indexFile = "cgi" - ) - ) - ) - - val confUserDir = conf.copy(virtualHosts = - List( - conf - .virtualHosts(0) - .copy( - userDirectories = true, - userDirectoryPath = Some( - getClass.getResource("/").getPath() + "{user}/public_gemini/" - ) - ) - ) - ) - - val mimeTypes = Some( - Map( - "config" -> List(".gmi", ".gemini") - ) - ) - } } diff --git a/server/test/src/TestData.scala b/server/test/src/TestData.scala new file mode 100644 index 0000000..df3fbd6 --- /dev/null +++ b/server/test/src/TestData.scala @@ -0,0 +1,108 @@ +package net.usebox.gemini.server + +import scala.concurrent.duration._ + +object TestData { + + val host = "localhost" + val port = 1965 + val portStr = port.toString() + + val conf = ServiceConf( + address = "127.0.0.1", + port = port, + defaultMimeType = "text/plain", + idleTimeout = 10.seconds, + virtualHosts = List( + VirtualHost( + host = host, + root = getClass.getResource("/").getPath() + ) + ), + genCertValidFor = 1.day, + enabledProtocols = Nil, + enabledCipherSuites = Nil + ) + + val cgiConf = ServiceConf.initConf( + conf.copy(virtualHosts = + List( + conf + .virtualHosts(0) + .copy( + directoryListing = true, + directories = List( + Directory( + "dir/", + directoryListing = Some(false), + allowCgi = Some(true) + ) + ) + ) + ) + ) + ) + + val cgiPrefConf = ServiceConf.initConf( + conf.copy(virtualHosts = + List( + conf + .virtualHosts(0) + .copy( + directoryListing = true, + directories = List( + Directory( + "dir/", + directoryListing = Some(false), + allowCgi = Some(true) + ), + Directory( + "dir/sub/", + directoryListing = Some(false), + allowCgi = Some(true) + ) + ) + ) + ) + ) + ) + + val cgiEnvConf = cgiConf.copy(virtualHosts = + List( + cgiConf + .virtualHosts(0) + .copy( + environment = Some(Map("env1" -> "value")) + ) + ) + ) + + val cgiIndexConf = cgiConf.copy(virtualHosts = + List( + cgiConf + .virtualHosts(0) + .copy( + indexFile = "cgi" + ) + ) + ) + + val confUserDir = conf.copy(virtualHosts = + List( + conf + .virtualHosts(0) + .copy( + userDirectories = true, + userDirectoryPath = Some( + getClass.getResource("/").getPath() + "{user}/public_gemini/" + ) + ) + ) + ) + + val mimeTypes = Some( + Map( + "config" -> List(".gmi", ".gemini") + ) + ) +} diff --git a/server/test/src/URIUtilsSpec.scala b/server/test/src/URIUtilsSpec.scala new file mode 100644 index 0000000..ab00c86 --- /dev/null +++ b/server/test/src/URIUtilsSpec.scala @@ -0,0 +1,26 @@ +package net.usebox.gemini.server + +import org.scalatest.flatspec.AnyFlatSpec +import org.scalatest.matchers.should.Matchers + +import URIUtils._ + +class URIUtilsSpec extends AnyFlatSpec with Matchers { + + behavior of "validPath" + + it should "return true for the emtpy path" in { + "".isValidPath shouldBe true + } + + it should "return true for valid paths" in { + List("/", "/file", "/./", "/.", "/dir/", "/dir/../").foreach( + _.isValidPath shouldBe true + ) + } + + it should "return false for invalid paths" in { + List("/../", "/..", "/dir/../..", "/dir/../..", "/./../", "/./dir/.././../") + .foreach(_.isValidPath shouldBe false) + } +} diff --git a/server/test/src/handlers/ProtocolHandlerSpec.scala b/server/test/src/handlers/ProtocolHandlerSpec.scala new file mode 100644 index 0000000..d35c9f2 --- /dev/null +++ b/server/test/src/handlers/ProtocolHandlerSpec.scala @@ -0,0 +1,100 @@ +package net.usebox.gemini.server.handlers + +import java.nio.file.FileSystems +import java.net.URI + +import org.scalatest.flatspec.AnyFlatSpec +import org.scalatest.matchers.should.Matchers + +import net.usebox.gemini.server.{ServiceConf, Response} +import net.usebox.gemini.server.TestData + +class ProtocolHandlerSpec extends AnyFlatSpec with Matchers { + + def getPath(value: String) = FileSystems.getDefault().getPath(value) + + class TestHandler(conf: ServiceConf) extends ProtocolHandler(conf) { + def handle(req: String, uri: URI, remoteAddr: String): Response = ??? + } + + val handler = new TestHandler(TestData.conf) + + behavior of "guessMimeType using the internal resolver" + + it should "resolve a known MIME type" in { + handler + .guessMimeType( + getPath("file.html"), + None + ) shouldBe "text/html" + } + + it should "resolve de default MIME type for unknown types" in { + handler + .guessMimeType( + getPath("unknow"), + None + ) shouldBe TestData.conf.defaultMimeType + } + + it should "resolve gemini MIME type" in { + handler + .guessMimeType( + getPath("file.gmi"), + None + ) shouldBe "text/gemini" + handler + .guessMimeType( + getPath("file.gemini"), + None + ) shouldBe "text/gemini" + } + + it should "resolve gemini MIME type, including parameters" in { + handler + .guessMimeType( + getPath("file.gmi"), + Some("param") + ) shouldBe "text/gemini; param" + handler + .guessMimeType( + getPath("file.gemini"), + Some("param") + ) shouldBe "text/gemini; param" + } + + it should "gemini MIME type parameters are sanitized" in { + handler + .guessMimeType( + getPath("file.gmi"), + Some(" ; param") + ) shouldBe "text/gemini; param" + } + + behavior of "guessMimeType using the configured types" + + it should "resolve a known MIME type" in { + new TestHandler(TestData.conf.copy(mimeTypes = TestData.mimeTypes)) + .guessMimeType( + getPath("file.gmi"), + None + ) shouldBe "config" + } + + it should "include parameters for text/gemini MIME types" in { + new TestHandler( + TestData.conf.copy(mimeTypes = Some(Map("text/gemini" -> List(".gmi")))) + ).guessMimeType( + getPath("file.gmi"), + Some("param") + ) shouldBe "text/gemini; param" + } + + it should "resolve de default MIME type for unknown types" in { + new TestHandler(TestData.conf.copy(mimeTypes = TestData.mimeTypes)) + .guessMimeType( + getPath("unknow"), + None + ) shouldBe TestData.conf.defaultMimeType + } +} -- cgit v1.2.3