Debian Codegraph @

net/uri/parse.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use ascii;
5 use encoding::utf8;
6 use io;
7 use memio;
8 use net::ip;
9 use strconv;
10 use strings;
11
12 // The URI provided to [[parse]] is invalid.
13 export type invalid = !void;
14
15 // Parses a URI string into [[uri]] structure. The return value must be freed
16 // using [[finish]].
17 export fn parse(in: str) (uri | invalid | nomem) = {
18 let success = false;
19 let in = strings::iter(in);
20
21 const scheme = parse_scheme(&in)?;
22 defer if (!success) free(scheme);
23
24 // Determine hier-part variant
25 let path = "";
26 let authority: ((str | ip::addr6), u16, str) = ("", 0u16, "");
27 defer if (!success) {
28 free(path);
29 free_host(authority.0);
30 free(authority.2);
31 };
32
33 match (strings::next(&in)) {
34 case let r: rune =>
35 switch (r) {
36 case '/' =>
37 // Either "//"+authority+path-abempty or path-absolute
38 match (strings::next(&in)) {
39 case let r: rune =>
40 switch(r) {
41 case '/' =>
42 // "//" + authority + path-abempty
43 authority = parse_authority(&in)?;
44 match (strings::next(&in)) {
45 case let r: rune =>
46 switch (r) {
47 case '?', '#' =>
48 // path-empty
49 strings::prev(&in);
50 case '/' =>
51 // path-absolute
52 strings::prev(&in);
53 path = parse_path(&in,
54 path_mode::ABSOLUTE)?;
55 case =>
56 return invalid;
57 };
58 case => void; // path-empty
59 };
60 case =>
61 // path-absolute
62 strings::prev(&in); // return current token
63 strings::prev(&in); // return leading slash
64 path = parse_path(&in, path_mode::ABSOLUTE)?;
65 };
66 case =>
67 // path-absolute (just '/')
68 strings::prev(&in); // return leading slash
69 path = parse_path(&in, path_mode::ABSOLUTE)?;
70 };
71 case =>
72 // path-rootless
73 strings::prev(&in);
74 path = parse_path(&in, path_mode::ROOTLESS)?;
75 };
76 case => void; // path-empty
77 };
78
79 let query = "";
80 defer if (!success) free(query);
81 match (strings::next(&in)) {
82 case let r: rune =>
83 if (r == '?') {
84 query = parse_query(&in)?;
85 } else {
86 strings::prev(&in);
87 };
88 case => void;
89 };
90
91 let fragment = "";
92 match (strings::next(&in)) {
93 case let r: rune =>
94 if (r == '#') {
95 fragment = parse_fragment(&in)?;
96 } else {
97 strings::prev(&in);
98 };
99 case => void;
100 };
101
102 success = true;
103 return uri {
104 scheme = scheme,
105
106 host = match (authority.0) {
107 case let ip: ip::addr6 =>
108 yield ip;
109 case let s: str =>
110 yield match (ip::parse(s)) {
111 case let a: ip::addr =>
112 free(s);
113 yield a;
114 case ip::invalid =>
115 yield s;
116 };
117 },
118 port = authority.1,
119 userinfo = authority.2,
120
121 path = path,
122 query = query,
123 fragment = fragment,
124 };
125 };
126
127 fn parse_scheme(in: *strings::iterator) (str | invalid | nomem) = {
128 let copy = *in;
129 for (let i = 0z; true; i += 1) {
130 const r = wantrune(in)?;
131 if (i > 0 && r == ':') {
132 strings::prev(in);
133 break;
134 };
135 if (i == 0) {
136 if (!ascii::isalpha(r)) {
137 return invalid;
138 };
139 } else {
140 if (!ascii::isalnum(r) && !strings::contains("+-.", r)) {
141 return invalid;
142 };
143 };
144 };
145 let s = strings::dup(strings::slice(&copy, in))?;
146 strings::next(in);
147 return s;
148 };
149
150 fn parse_authority(
151 in: *strings::iterator,
152 ) (((str | ip::addr6), u16, str) | invalid | nomem) = {
153 // Scan everything until '@' or ':' or '/', then decide what it is
154 let success = false;
155 let buf = memio::dynamic();
156 defer io::close(&buf)!;
157 let host: (str | ip::addr6) = "";
158 let port = 0u16;
159 let userinfo = "";
160 let has_userinfo = false;
161 defer if (!success) {
162 free_host(host);
163 free(userinfo);
164 };
165
166 for (let r => strings::next(in)) {
167 if (r == '[') {
168 if (len(memio::string(&buf)!) > 0) {
169 if (len(userinfo) > 0) {
170 return invalid;
171 } else {
172 userinfo = percent_decode(
173 memio::string(&buf)!)?;
174 };
175 };
176 memio::reset(&buf);
177
178 for (true) {
179 const r = wantrune(in)?;
180 if (r == ']') {
181 break;
182 };
183 if (memio::appendrune(&buf, r) is io::error) {
184 return nomem;
185 };
186 };
187
188 const addr = percent_decode(memio::string(&buf)!)?;
189 defer free(addr);
190 match (ip::parse(addr)) {
191 case let v6: ip::addr6 =>
192 host = v6;
193 case =>
194 return invalid;
195 };
196 } else if (r == ':' || !is_userinfo(r) && !is_host(r)) {
197 switch (r) {
198 case '@' =>
199 if (has_userinfo) {
200 return invalid;
201 };
202 // This was userinfo+host[+port]
203 userinfo = percent_decode(memio::string(&buf)!)?;
204 memio::reset(&buf);
205 has_userinfo = true;
206 case '/' =>
207 // This was just host
208 strings::prev(in);
209 host = percent_decode(memio::string(&buf)!)?;
210 break;
211 case ':' =>
212 // This was host+port
213 host = percent_decode(memio::string(&buf)!)?;
214 port = parse_port(in)?;
215 break;
216 case =>
217 return invalid;
218 };
219 } else {
220 if (memio::appendrune(&buf, r) is io::error) {
221 return nomem;
222 };
223 };
224 };
225
226 match (host) {
227 case let s: str =>
228 // In end of string case
229 if (len(s) == 0) {
230 host = percent_decode(memio::string(&buf)!)?;
231 };
232 case => void;
233 };
234
235 success = true;
236 return (host, port, userinfo);
237 };
238
239 type path_mode = enum {
240 ABSOLUTE,
241 ROOTLESS,
242 };
243
244 fn parse_path(in: *strings::iterator, mode: path_mode) (str | invalid | nomem) = {
245 let copy = *in;
246 // With rootless path, we need at least one segment
247 if (mode == path_mode::ROOTLESS) {
248 for (let i = 0z; true; i += 1) {
249 match (strings::next(in)) {
250 case let r: rune =>
251 if (r == '?' || r == '#') {
252 strings::prev(in);
253 break;
254 };
255 if (r == '/') {
256 if (i == 0) {
257 return invalid;
258 } else {
259 break;
260 };
261 };
262 if (!is_pchar(r)) {
263 return invalid;
264 };
265 case done =>
266 break;
267 };
268 };
269 };
270
271 for (let r => strings::next(in)) {
272 if (r == '?' || r == '#') {
273 strings::prev(in);
274 break;
275 };
276 if (!is_pchar(r) && r != '/') {
277 return invalid;
278 };
279 };
280
281 return percent_decode(strings::slice(&copy, in));
282 };
283
284 fn parse_query(in: *strings::iterator) (str | invalid | nomem) = {
285 let copy = *in;
286 for (let r => strings::next(in)) {
287 if (r == '#') {
288 strings::prev(in);
289 break;
290 };
291 if (!is_pchar(r) && r != '/' && r != '?') {
292 return invalid;
293 };
294 };
295 return strings::dup(strings::slice(&copy, in))?;
296 };
297
298 fn parse_fragment(in: *strings::iterator) (str | invalid | nomem) = {
299 let copy = *in;
300 for (let r => strings::next(in)) {
301 if (!is_pchar(r) && r != '/' && r != '?') {
302 return invalid;
303 };
304 };
305
306 return percent_decode(strings::slice(&copy, in))?;
307 };
308
309 fn parse_port(in: *strings::iterator) (u16 | invalid) = {
310 let copy = *in;
311 for (let r => strings::next(in)) {
312 if (!ascii::isdigit(r)) {
313 strings::prev(in);
314 break;
315 };
316 };
317
318 match (strconv::stou16(strings::slice(&copy, in))) {
319 case let port: u16 =>
320 if (port == 0) {
321 // There's no port 0
322 return invalid;
323 };
324 return port;
325 case =>
326 return invalid;
327 };
328 };
329
330 fn percent_decode(s: str) (str | invalid | nomem) = {
331 let buf = memio::dynamic();
332 let success = false;
333 defer if (!success) io::close(&buf)!;
334 percent_decode_static(&buf, s)?;
335 success = true;
336 return memio::string(&buf)!;
337 };
338
339 fn percent_decode_static(out: io::handle, s: str) (void | invalid | nomem) = {
340 let iter = strings::iter(s);
341 let tmp = memio::dynamic();
342 defer io::close(&tmp)!;
343 let percent_data: []u8 = [];
344 let success = false;
345 if (!success) free(percent_data);
346
347 for (true) {
348 match (strings::next(&iter)) {
349 case let r: rune =>
350 if (r == '%') {
351 memio::reset(&tmp);
352 for (let i = 0z; i < 2; i += 1) {
353 const r = wantrune(&iter)?;
354 if (memio::appendrune(&tmp, r)
355 is io::error) {
356 return nomem;
357 };
358 };
359
360 match (strconv::stou8(memio::string(&tmp)!,
361 strconv::base::HEX)) {
362 case let ord: u8 =>
363 append(percent_data, ord)?;
364 case =>
365 return invalid;
366 };
367 } else {
368 if(len(percent_data) > 0) {
369 match(strings::fromutf8(percent_data)) {
370 case let stro: str =>
371 if (memio::concat(out, stro)
372 is io::error) {
373 return nomem;
374 };
375 case utf8::invalid =>
376 return invalid;
377 };
378
379 free(percent_data);
380 percent_data = [];
381 };
382
383 if (memio::appendrune(out, r) is io::error) {
384 return nomem;
385 };
386 };
387 case done =>
388 if(len(percent_data) > 0) {
389 match(strings::fromutf8(percent_data)) {
390 case let stro: str =>
391 if (memio::concat(out, stro)
392 is io::error) {
393 return nomem;
394 };
395 case utf8::invalid =>
396 return invalid;
397 };
398
399 free(percent_data);
400 percent_data = [];
401 };
402
403 break;
404 };
405 };
406
407 success = true;
408 };
409
410 fn wantrune(iter: *strings::iterator) (rune | invalid) = {
411 match (strings::next(iter)) {
412 case let r: rune =>
413 return r;
414 case =>
415 return invalid;
416 };
417 };
418
419 fn free_host(in: (str | ip::addr6)) void = {
420 match (in) {
421 case let s: str =>
422 free(s);
423 case => void;
424 };
425 };
426
427 fn is_userinfo(r: rune) bool =
428 // unreserved + sub-delim + ":"
429 ascii::isalnum(r) || strings::contains("-._~!$&'()*+,;=:", r)
430 // %-encoded
431 || r == '%' || ascii::isxdigit(r);
432
433 fn is_host(r: rune) bool =
434 // unreserved + sub-delim
435 ascii::isalnum(r) || strings::contains("-._~!$&'()*+,;=", r)
436 // %-encoded
437 || r == '%' || ascii::isxdigit(r);
438
439 fn is_pchar(r: rune) bool =
440 // unreserved + sub-delim + ":"/"@"
441 ascii::isalnum(r) || strings::contains("-._~!$&'()*+,;=:@", r)
442 // %-encoded
443 || r == '%' || ascii::isxdigit(r);