Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-mime

Source of release 0.6.0

0.6.0 / src / mime / params.lucb

#==============================================================================================
#
#   mime/params - Structured values: type/subtype and parameters
#
#   DESCRIPTION:
#       Content-Type and Content-Disposition are a leading value and `; name=value`
#       parameters (RFC 2045 ยง5.1), with comments allowed anywhere (RFC 5322 CFWS). A
#       parameter may be split into numbered pieces and carry its own charset (RFC 2231):
#       `title*0*=us-ascii'en'This%20is; title*1=" even more"`. Values that were written,
#       against the rules, as RFC 2047 encoded words inside quotes (as Outlook writes
#       file names) are decoded too.
#
#==============================================================================================

## The most pieces one RFC 2231 parameter may be split into.
let maximum_pieces: usize = 64

## Whether `byte` ends an RFC 2045 token.
func is_special(byte: u8) -> bool:
    return byte <= 32 or byte == 127 or index_of("()<>@,;:\\\"/[]?=".bytes, byte) != none

## A structured value read piece by piece, with comments and whitespace skipped.
struct Tokens:
    var data: const u8[]
    var index: usize

    ## Skip whitespace and comments, which may nest and hold quoted pairs.
    func skip():
        while self.index < self.data.length:
            let byte = self.data[self.index]
            if is_space(byte):
                self.index += 1
            elif byte == '(':
                var depth: usize = 0
                while self.index < self.data.length:
                    let inner = self.data[self.index]
                    if inner == '\\':
                        self.index += 1
                    elif inner == '(':
                        depth += 1
                    elif inner == ')':
                        depth -= 1
                        if depth == 0:
                            self.index += 1
                            break
                    self.index += 1
            else:
                return

    ## The next byte after skipping, without taking it.
    func peek() -> u8?:
        self.skip()
        if self.index < self.data.length:
            return self.data[self.index]
        return none

    ## Take `byte` when it is next.
    func take(byte: u8) -> bool:
        if let next = self.peek():
            if next == byte:
                self.index += 1
                return true
        return false

    ## The token that starts here; empty when none does.
    func token() -> const u8[]:
        self.skip()
        let start = self.index
        while self.index < self.data.length and not is_special(self.data[self.index]):
            self.index += 1
        return self.data[start..<self.index]

    ## A value: a quoted string, unescaped onto `out`, or a token. Whether it was quoted.
    func value(out: Bytes*) -> bool!:
        self.skip()
        if self.index < self.data.length and self.data[self.index] == '"':
            self.index += 1
            while self.index < self.data.length:
                var byte = self.data[self.index]
                if byte == '"':
                    self.index += 1
                    break
                if byte == '\\' and self.index + 1 < self.data.length:
                    self.index += 1
                    byte = self.data[self.index]
                if byte != '\r' and byte != '\n':
                    try out.byte(byte)
                self.index += 1
            return true
        # A lenient token: senders leave `/`, `?`, `=` and `@` unquoted in values.
        let start = self.index
        while self.index < self.data.length:
            let byte = self.data[self.index]
            if byte == ';' or is_space(byte) or byte == '"':
                break
            self.index += 1
        try out.put(self.data[start..<self.index])
        return false

    ## Skip to just past the next `;` that is outside quotes and comments.
    func next_parameter():
        while self.index < self.data.length:
            let byte = self.data[self.index]
            if byte == '"':
                self.index += 1
                while self.index < self.data.length:
                    let inner = self.data[self.index]
                    self.index += 2 if inner == '\\' else 1
                    if inner == '"':
                        break
                continue
            if byte == '(':
                self.skip()
                continue
            self.index += 1
            if byte == ';':
                return

## The type and subtype of a Content-Type value, as views; empty when it has none.
pub func media_type(value: const u8[]) -> (const u8[], const u8[]):
    var tokens = Tokens(data = value, index = 0)
    let kind = tokens.token()
    if kind.length == 0 or not tokens.take('/'):
        var empty: const u8[]
        return (empty, empty)
    return (kind, tokens.token())

## The leading token of a structured value, such as `attachment` in Content-Disposition.
pub func leading_token(value: const u8[]) -> const u8[]:
    var tokens = Tokens(data = value, index = 0)
    return tokens.token()

## One piece of an RFC 2231 parameter, its value held in a shared buffer.
struct Piece:
    var number: u32
    var extended: bool
    var start: usize
    var end: usize

## Append `data`'s %XX escapes decoded.
func percent_decode(data: const u8[], out: Bytes*) -> !:
    var index: usize = 0
    while index < data.length:
        if data[index] == '%' and index + 2 < data.length:
            if let high = hex_value(data[index + 1]):
                if let low = hex_value(data[index + 2]):
                    try out.byte((high << 4) | low)
                    index += 3
                    continue
        try out.byte(data[index])
        index += 1

## Append the value of parameter `name` of structured value `value` as UTF-8, answering
## whether it was there. RFC 2231 pieces are put together and decoded; a plain value has
## any encoded words in it decoded.
pub func parameter(value: const u8[], name: str, out: Bytes*) -> bool!:
    var tokens = Tokens(data = value, index = 0)
    tokens.next_parameter()
    var values: Bytes
    defer values.close()
    var pieces: Piece[64]
    var count: usize = 0
    var plain_start: usize = 0
    var plain_end: usize = 0
    var plain = false
    while tokens.index < tokens.data.length:
        let attribute = tokens.token()
        if attribute.length == 0 or not tokens.take('='):
            tokens.next_parameter()
            continue
        # `name`, `name*`, `name*N` or `name*N*`.
        var base = attribute
        var number: u32? = none
        var extended = false
        if let star = index_of(attribute, '*'):
            base = attribute[0..<star]
            var rest = attribute[star + 1..]
            if rest.length > 0 and rest[rest.length - 1] == '*':
                extended = true
                rest = rest[0..<rest.length - 1]
            elif rest.length == 0:
                extended = true
            if rest.length > 0:
                var parsed: u32 = 0
                for digit in rest:
                    if digit < '0' or digit > '9' or parsed > 1000:
                        parsed = 0xFFFFFFFF
                        break
                    parsed = parsed * 10 + (digit - '0')
                number = parsed
        let start = values.used
        _ = try tokens.value(&values)
        let end = values.used
        tokens.next_parameter()
        if not same(base, name.bytes):
            continue
        if let piece = number:
            if count < maximum_pieces and piece < 0xFFFFFFFF:
                pieces[count] = Piece(number = piece, extended = extended, start = start, end = end)
                count += 1
        elif extended:
            pieces[0] = Piece(number = 0, extended = true, start = start, end = end)
            count = 1
            break
        elif not plain:
            plain = true
            plain_start = start
            plain_end = end
    let held = values.view()
    if count == 0:
        if not plain:
            return false
        try decode_words(held[plain_start..<plain_end], out)
        return true
    # Pieces in their numbered order; an insertion sort, as there are few.
    for index in 1..<count:
        let piece = pieces[index]
        var at = index
        while at > 0 and pieces[at - 1].number > piece.number:
            pieces[at] = pieces[at - 1]
            at -= 1
        pieces[at] = piece
    # The first extended piece names the charset: `charset'language'text`.
    var charset: const u8[]
    var joined: Bytes
    defer joined.close()
    for index in 0..<count:
        var text = held[pieces[index].start..<pieces[index].end]
        if pieces[index].extended:
            if index == 0:
                if let first = index_of(text, '\''):
                    if let second = index_of(text, '\'', first + 1):
                        charset = text[0..<first]
                        text = text[second + 1..]
            try percent_decode(text, &joined)
        else:
            try joined.put(text)
    if charset.length > 0:
        try decode_charset(charset, joined.view(), out)
    else:
        try decode_words(joined.view(), out)
    return true