Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-server

Source of release 0.5.1

0.5.1 / src / internal / url.lucb

## URL decoding and route segmentation have one interpretation throughout the
## server. Filesystem traversal never receives an undecoded request target.

import internal.storage
from internal.storage import Buffer
import strings
from luce_std import utf8

func hex_digit(byte: u8) -> u8!:
    if byte >= '0' and byte <= '9':
        return byte - '0'
    if byte >= 'a' and byte <= 'f':
        return byte - 'a' + 10
    if byte >= 'A' and byte <= 'F':
        return byte - 'A' + 10
    error(storage.invalid, "invalid URL escape")

pub func decode(input: str, output: Buffer*, path: bool = false) -> !:
    output.clear()
    var at: usize = 0
    var validator: utf8.Decoder
    while at < input.length:
        var byte = input.bytes[at]
        at += 1
        if byte == '%':
            if input.length - at < 2:
                error(storage.invalid, "truncated URL escape")
            byte = (try hex_digit(input.bytes[at])) * 16 + (try hex_digit(input.bytes[at + 1]))
            at += 2
            if path and (byte == '/' or byte == '\\'):
                error(storage.invalid, "escaped path separators are not accepted")
        elif byte == '+' and not path:
            byte = ' '
        if byte == 0 or byte < 32 or byte == 127 or (path and byte == '\\'):
            error(storage.invalid, "URL contains a forbidden byte")
        _ = try validator.push(byte)
        let one: u8[1] = [byte]
        try output.append(one)
    try validator.finish()

pub func request_path(target: str, output: Buffer*) -> str!:
    if target.length == 0 or target.bytes[0] != '/':
        error(storage.invalid, "this origin server requires an origin-form target")
    let end = strings.find(target, "?") else target.length
    try decode((str)target.bytes[..<end], output, true)
    let decoded = (str)output.view()
    var cursor: usize = 1
    while let part = segment(decoded, &cursor):
        if part == "." or part == ".." or part.length == 0:
            error(storage.invalid, "empty or relative path components are not accepted")
    return decoded

## cursor starts after the leading slash. A final slash has no extra segment.
pub func segment(path: str, cursor: usize*) -> str?:
    if *cursor >= path.length:
        return none
    let start = *cursor
    while *cursor < path.length and path.bytes[*cursor] != '/':
        *cursor += 1
    let part = (str)path.bytes[start..<*cursor]
    if *cursor < path.length:
        *cursor += 1
    return part

pub func parameter(part: str) -> str?:
    if part.length > 2 and part.bytes[0] == '{' and part.bytes[part.length - 1] == '}':
        return (str)part.bytes[1..<part.length - 1]
    return none

pub func validate_pattern(pattern: str) -> !:
    if pattern.length == 0 or pattern.bytes[0] != '/' or pattern.length > 4096:
        error(storage.invalid, "a route pattern must start with a slash")
    var cursor: usize = 1
    var names: str[32]
    var count: usize = 0
    while let part = segment(pattern, &cursor):
        if part.length == 0 or part == "." or part == "..":
            error(storage.invalid, "invalid route component")
        if let name = parameter(part):
            if count == names.length:
                error(storage.limit, "too many route parameters")
            if name.bytes[0] == '*':
                error(storage.invalid, "route parameters match one segment; use a static mount for subtrees")
            for byte in name.bytes:
                if not ((byte >= 'a' and byte <= 'z') or (byte >= 'A' and byte <= 'Z') or (byte >= '0' and byte <= '9') or byte == '_'):
                    error(storage.invalid, "invalid route parameter name")
            for prior in names[..<count]:
                if prior == name:
                    error(storage.invalid, "duplicate route parameter name")
            names[count] = name
            count += 1
        elif strings.contains(part, "{") or strings.contains(part, "}") or strings.contains(part, "?") or strings.contains(part, "%") or strings.contains(part, "\\"):
            error(storage.invalid, "invalid literal route component")

pub func matches(pattern: str, path: str) -> bool:
    if (pattern.bytes[pattern.length - 1] == '/') != (path.bytes[path.length - 1] == '/'):
        return false
    var wanted: usize = 1
    var actual: usize = 1
    while let part = segment(pattern, &wanted):
        let value = segment(path, &actual) else return false
        if parameter(part) == none and part != value:
            return false
    return segment(path, &actual) == none

pub func capture(pattern: str, path: str, name: str) -> str?:
    var wanted: usize = 1
    var actual: usize = 1
    while let part = segment(pattern, &wanted):
        let value = segment(path, &actual) else return none
        if parameter(part) == name:
            return value
    return none

pub func query(target: str, name: str, output: Buffer*) -> str?!:
    let mark = strings.find(target, "?") else return none
    var cursor = mark + 1
    var key = Buffer(maximum = 8192)
    defer key.destroy()
    while cursor < target.length:
        let start = cursor
        while cursor < target.length and target.bytes[cursor] != '&':
            cursor += 1
        let pair = (str)target.bytes[start..<cursor]
        let equal = strings.find(pair, "=") else pair.length
        try decode((str)pair.bytes[..<equal], &key)
        if (str)key.view() == name:
            let value = (str)pair.bytes[equal + 1..] if equal < pair.length else ""
            try decode(value, output)
            return (str)output.view()
        cursor += 1
    return none