| 1 |
// SPDX-License-Identifier: MPL-2.0 |
| 2 |
// (c) Hare authors <https://harelang.org> |
| 3 |
|
| 4 |
use endian; |
| 5 |
use errors; |
| 6 |
use fmt; |
| 7 |
|
| 8 |
type encoder = struct { |
| 9 |
buf: []u8, |
| 10 |
offs: size, |
| 11 |
}; |
| 12 |
|
| 13 |
// Encodes a DNS message, returning its size, or an error. |
| 14 |
export fn encode(buf: []u8, msg: *message) (size | error) = { |
| 15 |
let enc = encoder { buf = buf, offs = 0z }; |
| 16 |
encode_u16(&enc, msg.header.id)?; |
| 17 |
encode_u16(&enc, encode_op(&msg.header.op))?; |
| 18 |
encode_u16(&enc, msg.header.qdcount)?; |
| 19 |
encode_u16(&enc, msg.header.ancount)?; |
| 20 |
encode_u16(&enc, msg.header.nscount)?; |
| 21 |
encode_u16(&enc, msg.header.arcount)?; |
| 22 |
|
| 23 |
for (let i = 0z; i < len(msg.questions); i += 1) { |
| 24 |
question_encode(&enc, &msg.questions[i])?; |
| 25 |
}; |
| 26 |
for (let i = 0z; i < len(msg.answers); i += 1) { |
| 27 |
rrecord_encode(&enc, &msg.answers[i])?; |
| 28 |
}; |
| 29 |
for (let i = 0z; i < len(msg.authority); i += 1) { |
| 30 |
rrecord_encode(&enc, &msg.authority[i])?; |
| 31 |
}; |
| 32 |
for (let i = 0z; i < len(msg.additional); i += 1) { |
| 33 |
rrecord_encode(&enc, &msg.additional[i])?; |
| 34 |
}; |
| 35 |
|
| 36 |
return enc.offs; |
| 37 |
}; |
| 38 |
|
| 39 |
fn encode_u8(enc: *encoder, val: u8) (void | error) = { |
| 40 |
if (len(enc.buf) <= enc.offs + 1) { |
| 41 |
return errors::overflow; |
| 42 |
}; |
| 43 |
enc.buf[enc.offs] = val; |
| 44 |
enc.offs += 1; |
| 45 |
}; |
| 46 |
|
| 47 |
fn encode_u16(enc: *encoder, val: u16) (void | error) = { |
| 48 |
if (len(enc.buf) <= enc.offs + 2) { |
| 49 |
return errors::overflow; |
| 50 |
}; |
| 51 |
endian::beputu16(enc.buf[enc.offs..], val); |
| 52 |
enc.offs += 2; |
| 53 |
}; |
| 54 |
|
| 55 |
fn encode_u32(enc: *encoder, val: u32) (void | error) = { |
| 56 |
if (len(enc.buf) <= enc.offs + 4) { |
| 57 |
return errors::overflow; |
| 58 |
}; |
| 59 |
endian::beputu32(enc.buf[enc.offs..], val); |
| 60 |
enc.offs += 4; |
| 61 |
}; |
| 62 |
|
| 63 |
fn encode_raw(enc: *encoder, val: []u8) (void | error) = { |
| 64 |
let end = enc.offs + len(val); |
| 65 |
if (len(enc.buf) < end) { |
| 66 |
return errors::overflow; |
| 67 |
}; |
| 68 |
enc.buf[enc.offs..end] = val; |
| 69 |
enc.offs += len(val); |
| 70 |
}; |
| 71 |
|
| 72 |
fn encode_labels(enc: *encoder, names: []str) (void | error) = { |
| 73 |
// TODO: Assert that the labels are all valid ASCII? |
| 74 |
for (let i = 0z; i < len(names); i += 1) { |
| 75 |
if (len(names[i]) > 63) { |
| 76 |
return format; |
| 77 |
}; |
| 78 |
if (len(enc.buf) <= enc.offs + 1 + len(names[i])) { |
| 79 |
return errors::overflow; |
| 80 |
}; |
| 81 |
encode_u8(enc, len(names[i]): u8)?; |
| 82 |
let label = match (fmt::bsprintf( |
| 83 |
enc.buf[enc.offs..], "{}", names[i])) { |
| 84 |
case let label: str => |
| 85 |
yield label; |
| 86 |
case nomem => |
| 87 |
return errors::overflow; |
| 88 |
}; |
| 89 |
enc.offs += len(label); |
| 90 |
}; |
| 91 |
encode_u8(enc, 0)?; |
| 92 |
}; |
| 93 |
|
| 94 |
fn question_encode(enc: *encoder, q: *question) (void | error) = { |
| 95 |
encode_labels(enc, q.qname)?; |
| 96 |
encode_u16(enc, q.qtype)?; |
| 97 |
encode_u16(enc, q.qclass)?; |
| 98 |
}; |
| 99 |
|
| 100 |
fn rrecord_encode(enc: *encoder, r: *rrecord) (void | error) = { |
| 101 |
encode_labels(enc, r.name)?; |
| 102 |
encode_u16(enc, r.rtype)?; |
| 103 |
encode_u16(enc, r.class)?; |
| 104 |
encode_u32(enc, r.ttl)?; |
| 105 |
let ln_enc = *enc; // save state for rdata len |
| 106 |
encode_u16(enc, 0)?; // write dummy rdata len |
| 107 |
encode_rdata(enc, r.rdata)?; // write rdata |
| 108 |
let rdata_len = enc.offs - ln_enc.offs - 2; |
| 109 |
encode_u16(&ln_enc, rdata_len: u16)?; // write rdata len to its place |
| 110 |
}; |
| 111 |
|
| 112 |
fn encode_rdata(enc: *encoder, rdata: rdata) (void | error) = { |
| 113 |
match (rdata) { |
| 114 |
case let d: unknown_rdata => |
| 115 |
return encode_raw(enc, d); |
| 116 |
case let d: opt => |
| 117 |
return encode_opt(enc, d); |
| 118 |
case let d: txt => |
| 119 |
return encode_txt(enc, d); |
| 120 |
case => |
| 121 |
abort(); // TODO |
| 122 |
}; |
| 123 |
}; |
| 124 |
|
| 125 |
fn encode_opt(enc: *encoder, opt: opt) (void | error) = { |
| 126 |
for (let i = 0z; i < len(opt.options); i += 1) { |
| 127 |
if (len(opt.options[i].data) > 65535) { |
| 128 |
return errors::invalid; |
| 129 |
}; |
| 130 |
encode_u16(enc, opt.options[i].code)?; |
| 131 |
encode_u16(enc, len(opt.options[i].data): u16)?; |
| 132 |
encode_raw(enc, opt.options[i].data)?; |
| 133 |
}; |
| 134 |
}; |
| 135 |
|
| 136 |
fn encode_txt(enc: *encoder, txt: txt) (void | error) = { |
| 137 |
for (let i = 0z; i < len(txt); i += 1) { |
| 138 |
if (len(txt[i]) > 255) return errors::invalid; |
| 139 |
encode_u8(enc, len(txt[i]): u8)?; |
| 140 |
encode_raw(enc, txt[i])?; |
| 141 |
}; |
| 142 |
}; |
| 143 |
|
| 144 |
fn encode_op(op: *op) u16 = |
| 145 |
(op.qr: u16 << 15u16) | |
| 146 |
(op.opcode: u16 << 11u16) | |
| 147 |
(if (op.aa) 0b0000010000000000u16 else 0u16) | |
| 148 |
(if (op.tc) 0b0000001000000000u16 else 0u16) | |
| 149 |
(if (op.rd) 0b0000000100000000u16 else 0u16) | |
| 150 |
(if (op.ra) 0b0000000010000000u16 else 0u16) | |
| 151 |
op.rcode: u16; |
| 152 |
|
| 153 |
@test fn opcode() void = { |
| 154 |
let opcode = op { |
| 155 |
qr = qr::RESPONSE, |
| 156 |
opcode = opcode::IQUERY, |
| 157 |
aa = false, |
| 158 |
tc = true, |
| 159 |
rd = false, |
| 160 |
ra = true, |
| 161 |
rcode = rcode::SERVFAIL, |
| 162 |
}; |
| 163 |
let enc = encode_op(&opcode); |
| 164 |
let opcode2 = op { ... }; |
| 165 |
decode_op(enc, &opcode2); |
| 166 |
assert(opcode.qr == opcode2.qr && opcode.opcode == opcode2.opcode && |
| 167 |
opcode.aa == opcode2.aa && opcode.tc == opcode2.tc && |
| 168 |
opcode.rd == opcode2.rd && opcode.ra == opcode2.ra && |
| 169 |
opcode.rcode == opcode2.rcode); |
| 170 |
}; |