dymokomi/luce-server
Source of release 0.5.1
0.5.1 / src / internal / static_files.lucb
## Mounts retain an opened root. Each decoded path component is opened relative
## to the previous directory, refusing symlinks at every step. Open metadata,
## ranges and streaming reads refer to the same regular file descriptor.
import c
from luce_std import files
from internal.model import Exchange
import internal.responses
from internal.routes import Route
import internal.storage
from internal.storage import Buffer
import internal.url
from luce_std import paths
import strings
pub func media_type(path: str) -> str:
let extension = paths.extension(path)
if extension == ".html" or extension == ".htm": return "text/html; charset=utf-8"
if extension == ".css": return "text/css; charset=utf-8"
if extension == ".js" or extension == ".mjs": return "text/javascript; charset=utf-8"
if extension == ".json": return "application/json"
if extension == ".txt" or extension == ".md": return "text/plain; charset=utf-8"
if extension == ".svg": return "image/svg+xml"
if extension == ".png": return "image/png"
if extension == ".jpg" or extension == ".jpeg": return "image/jpeg"
if extension == ".gif": return "image/gif"
if extension == ".ico": return "image/x-icon"
if extension == ".pdf": return "application/pdf"
if extension == ".wasm": return "application/wasm"
if extension == ".woff2": return "font/woff2"
return "application/octet-stream"
func open_beneath(root: files.Directory*, relative: str) -> files.File!:
var owned: files.Directory
defer owned.destroy()
var parent = root
var at: usize = 0
while let part = url.segment(relative, &at):
if part == "." or part == ".." or part.length == 0:
error(storage.invalid, "invalid static path component")
let name = try storage.copy(part)
defer storage.release(name)
if at >= relative.length:
var opened = try parent.open_file((c.str)name, follow_symlinks = false, nonblocking = true)
errdefer opened.destroy()
let info = try opened.metadata()
if info.kind != files.FileKind.regular:
error(files.missing, "static content is not a regular file")
return opened
let child = try parent.open_directory((c.str)name, false)
owned.destroy()
owned = child
parent = &owned
error(files.missing, "static path has no filename")
func number(text: str) -> u64?:
if text.length == 0:
return none
var value: u64 = 0
for byte in text.bytes:
if byte < '0' or byte > '9':
return none
value = value *? 10 else return none
value = value +? (u64)(byte - '0') else return none
return value
## None denotes an unsatisfiable or unsupported range. Multiple ranges are
## ignored by serve(): this implementation sends one contiguous representation.
pub func byte_range(value: str, length: u64) -> (u64, u64)?:
if not strings.starts_with(value, "bytes=") or length == 0:
return none
let range = (str)value.bytes[6..]
let dash = strings.find(range, "-") else return none
if dash == 0:
let suffix = number((str)range.bytes[1..]) else return none
if suffix == 0:
return none
let count = suffix if suffix < length else length
return (length - count, count)
let start = number((str)range.bytes[..<dash]) else return none
if start >= length:
return none
let end_text = (str)range.bytes[dash + 1..]
let end = (number(end_text) else return none) if end_text.length > 0 else length - 1
if end < start:
return none
return (start, (end if end < length else length - 1) - start + 1)
func matches_tag(value: str, tag: str) -> bool:
let expected = (str)tag.bytes[2..] if strings.starts_with(tag, "W/") else tag
var at: usize = 0
while at < value.length:
let start = at
while at < value.length and value.bytes[at] != ',':
at += 1
var part = strings.trim((str)value.bytes[start..<at])
if strings.starts_with(part, "W/"):
part = (str)part.bytes[2..]
if part == "*" or part == expected:
return true
at += 1
return false
pub func serve(request: Exchange*, mount: Route*) -> !:
if request.http().head.method != "GET" and request.http().head.method != "HEAD":
try responses.content(request, 405, "text/plain; charset=utf-8", "method not allowed\n".bytes)
try responses.field(request, "Allow", "GET, HEAD")
return
var relative = Buffer(maximum = 8192)
defer relative.destroy()
var start = mount.pattern.length
if mount.pattern == "/":
start = 1
elif start < request.http().path.length and request.http().path.bytes[start] == '/':
start += 1
try relative.append(request.http().path.bytes[start..])
if relative.used == 0 or relative.data[relative.used - 1] == '/':
try relative.append("index.html".bytes)
let filename = (str)relative.view()
var opened = open_beneath(&mount.root, filename) catch failure:
if failure.code == files.missing or failure.code == files.not_directory or failure.code == files.symlink_loop or failure.code == files.permission_denied:
try responses.content(request, 404, "text/plain; charset=utf-8", "not found\n".bytes)
return
error(failure.code, failure.message)
errdefer opened.destroy()
let info = try opened.metadata()
if info.size < 0:
error(storage.invalid, "the static file has an invalid size")
let length = (u64)info.size
var tag_buffer: u8[160]
let tag = try strings.format(tag_buffer, f"W/\"{info.device}-{info.inode}-{info.size}-{info.modified.seconds}-{info.modified.nanoseconds}-{info.changed.seconds}-{info.changed.nanoseconds}\"")
try responses.content(request, 200, media_type(filename), "".bytes)
try responses.field(request, "ETag", tag)
try responses.field(request, "Accept-Ranges", "bytes")
if let condition = request.http().head.field("If-Match"):
# Metadata validators are weak; only an existence precondition can
# succeed. Never treat a weak validator as byte-for-byte equivalence.
if strings.trim(condition) != "*":
request.http().reply.status = 412
opened.destroy()
return
if let condition = request.http().head.field("If-None-Match"):
if matches_tag(condition, tag):
request.http().reply.status = 304
opened.destroy()
return
var offset: u64 = 0
var count = length
if request.http().head.method == "GET":
if let range = request.http().head.field("Range"):
let if_range = request.http().head.field("If-Range")
if if_range == none and strings.starts_with(range, "bytes=") and not strings.contains(range, ","):
var range_buffer: u8[96]
if let selected = byte_range(range, length):
offset = selected.0
count = selected.1
request.http().reply.status = 206
try responses.field(request, "Content-Range", try strings.format(range_buffer, f"bytes {offset}-{offset + count - 1}/{length}"))
else:
request.http().reply.status = 416
try responses.field(request, "Content-Range", try strings.format(range_buffer, f"bytes */{length}"))
opened.destroy()
return
_ = try opened.seek((i64)offset)
request.http().reply.file = opened
request.http().reply.file_length = count
request.http().reply.is_file = true