3 ;; Copyright (C) 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
5 ;; This library is free software; you can redistribute it and/or
6 ;; modify it under the terms of the GNU Lesser General Public
7 ;; License as published by the Free Software Foundation; either
8 ;; version 3 of the License, or (at your option) any later version.
10 ;; This library is distributed in the hope that it will be useful,
11 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 ;; Lesser General Public License for more details.
15 ;; You should have received a copy of the GNU Lesser General Public
16 ;; License along with this library; if not, write to the Free Software
17 ;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 ;;; This module has a number of routines to parse textual
23 ;;; representations of HTTP data into native Scheme data structures.
25 ;;; It tries to follow RFCs fairly strictly---the road to perdition
26 ;;; being paved with compatibility hacks---though some allowances are
27 ;;; made for not-too-divergent texts (like a quality of .2 which should
32 (define-module (web http)
33 #:use-module ((srfi srfi-1) #:select (append-map! map!))
34 #:use-module (srfi srfi-9)
35 #:use-module (srfi srfi-19)
36 #:use-module (ice-9 rdelim)
37 #:use-module (ice-9 q)
38 #:use-module (ice-9 binary-ports)
39 #:use-module (rnrs bytevectors)
40 #:use-module (web uri)
41 #:export (string->header
45 declare-opaque-header!
68 make-chunked-input-port
69 make-chunked-output-port
72 set-http-proxy-port?!))
75 (define (string->header name)
76 "Parse NAME to a symbolic header name."
77 (string->symbol (string-downcase name)))
79 (define-record-type <header-decl>
80 (make-header-decl name parser validator writer multiple?)
82 (name header-decl-name)
83 (parser header-decl-parser)
84 (validator header-decl-validator)
85 (writer header-decl-writer)
86 (multiple? header-decl-multiple?))
89 (define *declared-headers* (make-hash-table))
91 (define (lookup-header-decl sym)
92 (hashq-ref *declared-headers* sym))
94 (define* (declare-header! name
99 "Declare a parser, validator, and writer for a given header."
100 (if (and (string? name) parser validator writer)
101 (let ((decl (make-header-decl name parser validator writer multiple?)))
102 (hashq-set! *declared-headers* (string->header name) decl)
104 (error "bad header decl" name parser validator writer multiple?)))
106 (define (header->string sym)
107 "Return the string form for the header named SYM."
108 (let ((decl (lookup-header-decl sym)))
110 (header-decl-name decl)
111 (string-titlecase (symbol->string sym)))))
113 (define (known-header? sym)
114 "Return ‘#t’ iff SYM is a known header, with associated
115 parsers and serialization procedures."
116 (and (lookup-header-decl sym) #t))
118 (define (header-parser sym)
119 "Return the value parser for headers named SYM. The result is a
120 procedure that takes one argument, a string, and returns the parsed
121 value. If the header isn't known to Guile, a default parser is returned
122 that passes through the string unchanged."
123 (let ((decl (lookup-header-decl sym)))
125 (header-decl-parser decl)
128 (define (header-validator sym)
129 "Return a predicate which returns ‘#t’ if the given value is valid
130 for headers named SYM. The default validator for unknown headers
132 (let ((decl (lookup-header-decl sym)))
134 (header-decl-validator decl)
137 (define (header-writer sym)
138 "Return a procedure that writes values for headers named SYM to a
139 port. The resulting procedure takes two arguments: a value and a port.
140 The default writer is ‘display’."
141 (let ((decl (lookup-header-decl sym)))
143 (header-decl-writer decl)
146 (define (read-line* port)
147 (let* ((pair (%read-line port))
150 (if (and (string? line) (char? delim))
151 (let ((orig-len (string-length line)))
152 (let lp ((len orig-len))
154 (char-whitespace? (string-ref line (1- len))))
158 (substring line 0 len)))))
159 (bad-header '%read line))))
161 (define (read-continuation-line port val)
162 (if (or (eqv? (peek-char port) #\space)
163 (eqv? (peek-char port) #\tab))
164 (read-continuation-line port
170 (define *eof* (call-with-input-string "" read))
172 (define (read-header port)
173 "Read one HTTP header from PORT. Return two values: the header
174 name and the parsed Scheme value. May raise an exception if the header
175 was known but the value was invalid.
177 Returns the end-of-file object for both values if the end of the message
178 body was reached (i.e., a blank line)."
179 (let ((line (read-line* port)))
180 (if (or (string-null? line)
181 (string=? line "\r"))
183 (let* ((delim (or (string-index line #\:)
184 (bad-header '%read line)))
185 (sym (string->header (substring line 0 delim))))
190 (read-continuation-line
192 (string-trim-both line char-set:whitespace (1+ delim)))))))))
194 (define (parse-header sym val)
195 "Parse VAL, a string, with the parser registered for the header
196 named SYM. Returns the parsed value."
197 ((header-parser sym) val))
199 (define (valid-header? sym val)
200 "Returns a true value iff VAL is a valid Scheme value for the
201 header with name SYM."
203 ((header-validator sym) val)
204 (error "header name not a symbol" sym)))
206 (define (write-header sym val port)
207 "Write the given header name and value to PORT, using the writer
208 from ‘header-writer’."
209 (display (header->string sym) port)
211 ((header-writer sym) val port)
212 (display "\r\n" port))
214 (define (read-headers port)
215 "Read the headers of an HTTP message from PORT, returning them
216 as an ordered alist."
217 (let lp ((headers '()))
218 (call-with-values (lambda () (read-header port))
222 (lp (acons k v headers)))))))
224 (define (write-headers headers port)
225 "Write the given header alist to PORT. Doesn't write the final
226 ‘\\r\\n’, as the user might want to add another header."
227 (let lp ((headers headers))
230 (write-header (caar headers) (cdar headers) port)
231 (lp (cdr headers))))))
240 (define (bad-header sym val)
241 (throw 'bad-header sym val))
242 (define (bad-header-component sym val)
243 (throw 'bad-header-component sym val))
245 (define (bad-header-printer port key args default-printer)
248 (format port "Bad ~a header: ~a\n" (header->string sym) val))
249 (_ (default-printer)))
251 (define (bad-header-component-printer port key args default-printer)
254 (format port "Bad ~a header component: ~a\n" sym val))
255 (_ (default-printer)))
257 (set-exception-printer! 'bad-header bad-header-printer)
258 (set-exception-printer! 'bad-header-component bad-header-component-printer)
260 (define (parse-opaque-string str)
262 (define (validate-opaque-string val)
264 (define (write-opaque-string val port)
267 (define separators-without-slash
268 (string->char-set "[^][()<>@,;:\\\"?= \t]"))
269 (define (validate-media-type str)
270 (let ((idx (string-index str #\/)))
271 (and idx (= idx (string-rindex str #\/))
272 (not (string-index str separators-without-slash)))))
273 (define (parse-media-type str)
274 (if (validate-media-type str)
276 (bad-header-component 'media-type str)))
278 (define* (skip-whitespace str #:optional (start 0) (end (string-length str)))
280 (if (and (< i end) (char-whitespace? (string-ref str i)))
284 (define* (trim-whitespace str #:optional (start 0) (end (string-length str)))
286 (if (and (< start i) (char-whitespace? (string-ref str (1- i))))
290 (define* (split-and-trim str #:optional (delim #\,)
291 (start 0) (end (string-length str)))
294 (let* ((idx (string-index str delim i end))
295 (tok (string-trim-both str char-set:whitespace i (or idx end))))
296 (cons tok (split-and-trim str delim (if idx (1+ idx) end) end)))
299 (define (list-of-strings? val)
300 (list-of? val string?))
302 (define (write-list-of-strings val port)
303 (write-list val port display ", "))
305 (define (split-header-names str)
306 (map string->header (split-and-trim str)))
308 (define (list-of-header-names? val)
309 (list-of? val symbol?))
311 (define (write-header-list val port)
314 (display (header->string x) port))
317 (define (collect-escaped-string from start len escapes)
318 (let ((to (make-string len)))
319 (let lp ((start start) (i 0) (escapes escapes))
322 (substring-move! from start (+ start (- len i)) to i)
324 (let* ((e (car escapes))
325 (next-start (+ start (- e i) 2)))
326 (substring-move! from start (- next-start 2) to i)
327 (string-set! to e (string-ref from (- next-start 1)))
328 (lp next-start (1+ e) (cdr escapes)))))))
330 ;; in incremental mode, returns two values: the string, and the index at
331 ;; which the string ended
332 (define* (parse-qstring str #:optional
333 (start 0) (end (trim-whitespace str start))
335 (if (and (< start end) (eqv? (string-ref str start) #\"))
336 (let lp ((i (1+ start)) (qi 0) (escapes '()))
338 (case (string-ref str i)
340 (lp (+ i 2) (1+ qi) (cons qi escapes)))
342 (let ((out (collect-escaped-string str (1+ start) qi escapes)))
347 (bad-header-component 'qstring str)))))
349 (lp (1+ i) (1+ qi) escapes)))
350 (bad-header-component 'qstring str)))
351 (bad-header-component 'qstring str)))
353 (define (write-list l port write-item delim)
356 (write-item (car l) port)
362 (define (write-qstring str port)
364 (if (string-index str #\")
366 (write-list (string-split str #\") port display "\\\"")
370 (define* (parse-quality str #:optional (start 0) (end (string-length str)))
371 (define (char->decimal c)
372 (let ((i (- (char->integer c) (char->integer #\0))))
373 (if (and (<= 0 i) (< i 10))
375 (bad-header-component 'quality str))))
378 (bad-header-component 'quality str))
379 ((eqv? (string-ref str start) #\1)
380 (if (or (string= str "1" start end)
381 (string= str "1." start end)
382 (string= str "1.0" start end)
383 (string= str "1.00" start end)
384 (string= str "1.000" start end))
386 (bad-header-component 'quality str)))
387 ((eqv? (string-ref str start) #\0)
388 (if (or (string= str "0" start end)
389 (string= str "0." start end))
391 (if (< 2 (- end start) 6)
392 (let lp ((place 1) (i (+ start 4)) (q 0))
394 (if (eqv? (string-ref str (1+ start)) #\.)
396 (bad-header-component 'quality str))
397 (lp (* 10 place) (1- i)
399 (+ q (* place (char->decimal (string-ref str i))))
401 (bad-header-component 'quality str))))
402 ;; Allow the nonstandard .2 instead of 0.2.
403 ((and (eqv? (string-ref str start) #\.)
404 (< 1 (- end start) 5))
405 (let lp ((place 1) (i (+ start 3)) (q 0))
408 (lp (* 10 place) (1- i)
410 (+ q (* place (char->decimal (string-ref str i))))
413 (bad-header-component 'quality str))))
415 (define (valid-quality? q)
416 (and (non-negative-integer? q) (<= q 1000)))
418 (define (write-quality q port)
419 (define (digit->char d)
420 (integer->char (+ (char->integer #\0) d)))
421 (display (digit->char (modulo (quotient q 1000) 10)) port)
423 (display (digit->char (modulo (quotient q 100) 10)) port)
424 (display (digit->char (modulo (quotient q 10) 10)) port)
425 (display (digit->char (modulo q 10)) port))
427 (define (list-of? val pred)
431 (list-of? (cdr val) pred))))
433 (define* (parse-quality-list str)
436 ((string-rindex part #\;)
438 (let ((qpart (string-trim-both part char-set:whitespace (1+ idx))))
439 (if (string-prefix? "q=" qpart)
440 (cons (parse-quality qpart 2)
441 (string-trim-both part char-set:whitespace 0 idx))
442 (bad-header-component 'quality qpart)))))
444 (cons 1000 (string-trim-both part char-set:whitespace)))))
445 (string-split str #\,)))
447 (define (validate-quality-list l)
451 (valid-quality? (car elt))
452 (string? (cdr elt))))))
454 (define (write-quality-list l port)
463 (write-quality q port)))))
466 (define* (parse-non-negative-integer val #:optional (start 0)
467 (end (string-length val)))
468 (define (char->decimal c)
469 (let ((i (- (char->integer c) (char->integer #\0))))
470 (if (and (<= 0 i) (< i 10))
472 (bad-header-component 'non-negative-integer val))))
473 (if (not (< start end))
474 (bad-header-component 'non-negative-integer val)
475 (let lp ((i start) (out 0))
478 (+ (* out 10) (char->decimal (string-ref val i))))
481 (define (non-negative-integer? code)
482 (and (number? code) (>= code 0) (exact? code) (integer? code)))
484 (define (default-val-parser k val)
487 (define (default-val-validator k val)
488 (or (not val) (string? val)))
490 (define (default-val-writer k val port)
491 (if (or (string-index val #\;)
492 (string-index val #\,)
493 (string-index val #\"))
494 (write-qstring val port)
497 (define* (parse-key-value-list str #:optional
498 (val-parser default-val-parser)
499 (start 0) (end (string-length str)))
500 (let lp ((i start) (out '()))
503 (let* ((i (skip-whitespace str i end))
504 (eq (string-index str #\= i end))
505 (comma (string-index str #\, i end))
506 (delim (min (or eq end) (or comma end)))
508 (substring str i (trim-whitespace str i delim)))))
511 (if (and eq (or (not comma) (< eq comma)))
512 (let ((i (skip-whitespace str (1+ eq) end)))
513 (if (and (< i end) (eqv? (string-ref str i) #\"))
514 (parse-qstring str i end #:incremental? #t)
515 (values (substring str i
516 (trim-whitespace str i
520 (lambda (v-str next-i)
521 (let ((v (val-parser k v-str))
522 (i (skip-whitespace str next-i end)))
523 (if (or (= i end) (eqv? (string-ref str i) #\,))
524 (lp (1+ i) (cons (if v (cons k v) k) out))
525 (bad-header-component 'key-value-list
526 (substring str start end))))))))))
528 (define* (key-value-list? list #:optional
529 (valid? default-val-validator))
542 (define* (write-key-value-list list port #:optional
543 (val-writer default-val-writer) (delim ", "))
547 (let ((k (if (pair? x) (car x) x))
548 (v (if (pair? x) (cdr x) #f)))
553 (val-writer k v port)))))
556 ;; param-component = token [ "=" (token | quoted-string) ] \
557 ;; *(";" token [ "=" (token | quoted-string) ])
559 (define param-delimiters (char-set #\, #\; #\=))
560 (define param-value-delimiters (char-set-adjoin char-set:whitespace #\, #\;))
561 (define* (parse-param-component str #:optional
562 (val-parser default-val-parser)
563 (start 0) (end (string-length str)))
564 (let lp ((i start) (out '()))
566 (values (reverse! out) end)
567 (let ((delim (string-index str param-delimiters i)))
568 (let ((k (string->symbol
569 (substring str i (trim-whitespace str i (or delim end)))))
570 (delimc (and delim (string-ref str delim))))
575 (let ((i (skip-whitespace str (1+ delim) end)))
576 (if (and (< i end) (eqv? (string-ref str i) #\"))
577 (parse-qstring str i end #:incremental? #t)
579 (or (string-index str param-value-delimiters
582 (values (substring str i delim)
584 (lambda (v-str next-i)
585 (let* ((v (val-parser k v-str))
586 (x (if v (cons k v) k))
587 (i (skip-whitespace str next-i end)))
588 (case (and (< i end) (string-ref str i))
590 (values (reverse! (cons x out)) end))
592 (lp (skip-whitespace str (1+ i) end)
594 (else ; including #\,
595 (values (reverse! (cons x out)) i)))))))
597 (let ((v (val-parser k #f)))
598 (lp (skip-whitespace str (1+ delim) end)
599 (cons (if v (cons k v) k) out))))
601 (else ;; either the end of the string or a #\,
602 (let ((v (val-parser k #f)))
603 (values (reverse! (cons (if v (cons k v) k) out))
604 (or delim end))))))))))
606 (define* (parse-param-list str #:optional
607 (val-parser default-val-parser)
608 (start 0) (end (string-length str)))
609 (let lp ((i start) (out '()))
611 (lambda () (parse-param-component str val-parser i end))
614 (if (eqv? (string-ref str i) #\,)
615 (lp (skip-whitespace str (1+ i) end)
617 (bad-header-component 'param-list str))
618 (reverse! (cons item out)))))))
620 (define* (validate-param-list list #:optional
621 (valid? default-val-validator))
624 (key-value-list? elt valid?))))
626 (define* (write-param-list list port #:optional
627 (val-writer default-val-writer))
631 (write-key-value-list item port val-writer ";"))
634 (define-syntax string-match?
637 ((_ str pat) (string? (syntax->datum #'pat))
638 (let ((p (syntax->datum #'pat)))
641 (= (string-length s) #,(string-length p))
642 #,@(let lp ((i 0) (tests '()))
643 (if (< i (string-length p))
644 (let ((c (string-ref p i)))
650 (cons #`(char-numeric? (string-ref s #,i))
653 (cons #`(char-alphabetic? (string-ref s #,i))
656 (cons #`(eqv? (string-ref s #,i) #,c)
660 ;; "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun"
661 ;; "Jul" | "Aug" | "Sep" | "Oct" | "Nov" | "Dec"
663 (define (parse-month str start end)
665 (bad-header-component 'month (substring str start end)))
666 (if (not (= (- end start) 3))
668 (let ((a (string-ref str (+ start 0)))
669 (b (string-ref str (+ start 1)))
670 (c (string-ref str (+ start 2))))
674 ((#\a) (case c ((#\n) 1) (else (bad))))
675 ((#\u) (case c ((#\n) 6) ((#\l) 7) (else (bad))))
679 ((#\e) (case c ((#\b) 2) (else (bad))))
683 ((#\a) (case c ((#\r) 3) ((#\y) 5) (else (bad))))
687 ((#\p) (case c ((#\r) 4) (else (bad))))
688 ((#\u) (case c ((#\g) 8) (else (bad))))
692 ((#\e) (case c ((#\p) 9) (else (bad))))
696 ((#\c) (case c ((#\t) 10) (else (bad))))
700 ((#\o) (case c ((#\v) 11) (else (bad))))
704 ((#\e) (case c ((#\c) 12) (else (bad))))
708 ;; "GMT" | "+" 4DIGIT | "-" 4DIGIT
710 ;; RFC 2616 requires date values to use "GMT", but recommends accepting
711 ;; the others as they are commonly generated by e.g. RFC 822 sources.
712 (define (parse-zone-offset str start)
713 (let ((s (substring str start)))
715 (bad-header-component 'zone-offset s))
721 ((string-match? s ".dddd")
722 (let ((sign (case (string-ref s 0)
726 (hours (parse-non-negative-integer s 1 3))
727 (minutes (parse-non-negative-integer s 3 5)))
728 (* sign 60 (+ (* 60 hours) minutes)))) ; seconds east of Greenwich
731 ;; RFC 822, updated by RFC 1123
733 ;; Sun, 06 Nov 1994 08:49:37 GMT
734 ;; 01234567890123456789012345678
736 (define (parse-rfc-822-date str space zone-offset)
737 ;; We could verify the day of the week but we don't.
738 (cond ((string-match? (substring str 0 space) "aaa, dd aaa dddd dd:dd:dd")
739 (let ((date (parse-non-negative-integer str 5 7))
740 (month (parse-month str 8 11))
741 (year (parse-non-negative-integer str 12 16))
742 (hour (parse-non-negative-integer str 17 19))
743 (minute (parse-non-negative-integer str 20 22))
744 (second (parse-non-negative-integer str 23 25)))
745 (make-date 0 second minute hour date month year zone-offset)))
746 ((string-match? (substring str 0 space) "aaa, d aaa dddd dd:dd:dd")
747 (let ((date (parse-non-negative-integer str 5 6))
748 (month (parse-month str 7 10))
749 (year (parse-non-negative-integer str 11 15))
750 (hour (parse-non-negative-integer str 16 18))
751 (minute (parse-non-negative-integer str 19 21))
752 (second (parse-non-negative-integer str 22 24)))
753 (make-date 0 second minute hour date month year zone-offset)))
755 (bad-header 'date str) ; prevent tail call
758 ;; RFC 850, updated by RFC 1036
759 ;; Sunday, 06-Nov-94 08:49:37 GMT
760 ;; 0123456789012345678901
762 (define (parse-rfc-850-date str comma space zone-offset)
763 ;; We could verify the day of the week but we don't.
764 (let ((tail (substring str (1+ comma) space)))
765 (if (not (string-match? tail " dd-aaa-dd dd:dd:dd"))
766 (bad-header 'date str))
767 (let ((date (parse-non-negative-integer tail 1 3))
768 (month (parse-month tail 4 7))
769 (year (parse-non-negative-integer tail 8 10))
770 (hour (parse-non-negative-integer tail 11 13))
771 (minute (parse-non-negative-integer tail 14 16))
772 (second (parse-non-negative-integer tail 17 19)))
773 (make-date 0 second minute hour date month
774 (let* ((now (date-year (current-date)))
775 (then (+ now year (- (modulo now 100)))))
776 (cond ((< (+ then 50) now) (+ then 100))
777 ((< (+ now 50) then) (- then 100))
781 ;; ANSI C's asctime() format
782 ;; Sun Nov 6 08:49:37 1994
783 ;; 012345678901234567890123
785 (define (parse-asctime-date str)
786 (if (not (string-match? str "aaa aaa .d dd:dd:dd dddd"))
787 (bad-header 'date str))
788 (let ((date (parse-non-negative-integer
790 (if (eqv? (string-ref str 8) #\space) 9 8)
792 (month (parse-month str 4 7))
793 (year (parse-non-negative-integer str 20 24))
794 (hour (parse-non-negative-integer str 11 13))
795 (minute (parse-non-negative-integer str 14 16))
796 (second (parse-non-negative-integer str 17 19)))
797 (make-date 0 second minute hour date month year 0)))
799 ;; Convert all date values to GMT time zone, as per RFC 2616 appendix C.
800 (define (normalize-date date)
801 (if (zero? (date-zone-offset date))
803 (time-utc->date (date->time-utc date) 0)))
805 (define (parse-date str)
806 (let* ((space (string-rindex str #\space))
807 (zone-offset (and space (false-if-exception
808 (parse-zone-offset str (1+ space))))))
811 (let ((comma (string-index str #\,)))
812 (cond ((not comma) (bad-header 'date str))
813 ((= comma 3) (parse-rfc-822-date str space zone-offset))
814 (else (parse-rfc-850-date str comma space zone-offset))))
815 (parse-asctime-date str)))))
817 (define (write-date date port)
818 (define (display-digits n digits port)
819 (define zero (char->integer #\0))
820 (let lp ((tens (expt 10 (1- digits))))
823 (display (integer->char (+ zero (modulo (truncate/ n tens) 10)))
825 (lp (floor/ tens 10))))))
826 (let ((date (if (zero? (date-zone-offset date))
828 (time-tai->date (date->time-tai date) 0))))
829 (display (case (date-week-day date)
830 ((0) "Sun, ") ((1) "Mon, ") ((2) "Tue, ")
831 ((3) "Wed, ") ((4) "Thu, ") ((5) "Fri, ")
832 ((6) "Sat, ") (else (error "bad date" date)))
834 (display-digits (date-day date) 2 port)
835 (display (case (date-month date)
836 ((1) " Jan ") ((2) " Feb ") ((3) " Mar ")
837 ((4) " Apr ") ((5) " May ") ((6) " Jun ")
838 ((7) " Jul ") ((8) " Aug ") ((9) " Sep ")
839 ((10) " Oct ") ((11) " Nov ") ((12) " Dec ")
840 (else (error "bad date" date)))
842 (display-digits (date-year date) 4 port)
843 (display #\space port)
844 (display-digits (date-hour date) 2 port)
846 (display-digits (date-minute date) 2 port)
848 (display-digits (date-second date) 2 port)
849 (display " GMT" port)))
851 (define (parse-entity-tag val)
852 (if (string-prefix? "W/" val)
853 (cons (parse-qstring val 2) #f)
854 (cons (parse-qstring val) #t)))
856 (define (entity-tag? val)
858 (string? (car val))))
860 (define (write-entity-tag val port)
863 (write-qstring (car val) port))
865 (define* (parse-entity-tag-list val #:optional
866 (start 0) (end (string-length val)))
867 (let ((strong? (not (string-prefix? "W/" val 0 2 start end))))
868 (call-with-values (lambda ()
869 (parse-qstring val (if strong? start (+ start 2))
870 end #:incremental? #t))
873 (let ((next (skip-whitespace val next end)))
875 (if (eqv? (string-ref val next) #\,)
876 (parse-entity-tag-list
878 (skip-whitespace val (1+ next) end)
880 (bad-header-component 'entity-tag-list val))
883 (define (entity-tag-list? val)
884 (list-of? val entity-tag?))
886 (define (write-entity-tag-list val port)
887 (write-list val port write-entity-tag ", "))
889 ;; credentials = auth-scheme #auth-param
890 ;; auth-scheme = token
891 ;; auth-param = token "=" ( token | quoted-string )
893 ;; That's what the spec says. In reality the Basic scheme doesn't have
894 ;; k-v pairs, just one auth token, so we give that token as a string.
896 (define* (parse-credentials str #:optional (val-parser default-val-parser)
897 (start 0) (end (string-length str)))
898 (let* ((start (skip-whitespace str start end))
899 (delim (or (string-index str char-set:whitespace start end) end)))
901 (bad-header-component 'authorization str))
902 (let ((scheme (string->symbol
903 (string-downcase (substring str start (or delim end))))))
906 (let* ((start (skip-whitespace str delim end)))
908 (cons scheme (substring str start end))
909 (bad-header-component 'credentials str))))
911 (cons scheme (parse-key-value-list str default-val-parser delim end)))))))
913 (define (validate-credentials val)
914 (and (pair? val) (symbol? (car val))
916 ((basic) (string? (cdr val)))
917 (else (key-value-list? (cdr val))))))
919 (define (write-credentials val port)
920 (display (car val) port)
921 (display #\space port)
923 ((basic) (display (cdr val) port))
924 (else (write-key-value-list (cdr val) port))))
926 ;; challenges = 1#challenge
927 ;; challenge = auth-scheme 1*SP 1#auth-param
929 ;; A pain to parse, as both challenges and auth params are delimited by
930 ;; commas, and qstrings can contain anything. We rely on auth params
931 ;; necessarily having "=" in them.
933 (define* (parse-challenge str #:optional
934 (start 0) (end (string-length str)))
935 (let* ((start (skip-whitespace str start end))
936 (sp (string-index str #\space start end))
938 (string->symbol (string-downcase (substring str start sp)))
939 (bad-header-component 'challenge str))))
940 (let lp ((i sp) (out (list scheme)))
942 (values (reverse! out) end)
943 (let* ((i (skip-whitespace str i end))
944 (eq (string-index str #\= i end))
945 (comma (string-index str #\, i end))
946 (delim (min (or eq end) (or comma end)))
947 (token-end (trim-whitespace str i delim)))
948 (if (string-index str #\space i token-end)
949 (values (reverse! out) i)
950 (let ((k (string->symbol (substring str i token-end))))
953 (if (and eq (or (not comma) (< eq comma)))
954 (let ((i (skip-whitespace str (1+ eq) end)))
955 (if (and (< i end) (eqv? (string-ref str i) #\"))
956 (parse-qstring str i end #:incremental? #t)
959 (trim-whitespace str i
964 (let ((i (skip-whitespace str next-i end)))
965 (if (or (= i end) (eqv? (string-ref str i) #\,))
966 (lp (1+ i) (cons (if v (cons k v) k) out))
967 (bad-header-component
969 (substring str start end)))))))))))))
971 (define* (parse-challenges str #:optional (val-parser default-val-parser)
972 (start 0) (end (string-length str)))
973 (let lp ((i start) (ret '()))
974 (let ((i (skip-whitespace str i end)))
976 (call-with-values (lambda () (parse-challenge str i end))
977 (lambda (challenge i)
978 (lp i (cons challenge ret))))
981 (define (validate-challenges val)
982 (list-of? val (lambda (x)
983 (and (pair? x) (symbol? (car x))
984 (key-value-list? (cdr x))))))
986 (define (write-challenge val port)
987 (display (car val) port)
988 (display #\space port)
989 (write-key-value-list (cdr val) port))
991 (define (write-challenges val port)
992 (write-list val port write-challenge ", "))
998 ;;; Request-Line and Response-Line
1002 (define (bad-request message . args)
1003 (throw 'bad-request message args))
1004 (define (bad-response message . args)
1005 (throw 'bad-response message args))
1007 (define *known-versions* '())
1009 (define* (parse-http-version str #:optional (start 0) (end (string-length str)))
1010 "Parse an HTTP version from STR, returning it as a major–minor
1011 pair. For example, ‘HTTP/1.1’ parses as the pair of integers,
1013 (or (let lp ((known *known-versions*))
1015 (if (string= str (caar known) start end)
1018 (let ((dot-idx (string-index str #\. start end)))
1019 (if (and (string-prefix? "HTTP/" str 0 5 start end)
1021 (= dot-idx (string-rindex str #\. start end)))
1022 (cons (parse-non-negative-integer str (+ start 5) dot-idx)
1023 (parse-non-negative-integer str (1+ dot-idx) end))
1024 (bad-header-component 'http-version (substring str start end))))))
1026 (define (write-http-version val port)
1027 "Write the given major-minor version pair to PORT."
1028 (display "HTTP/" port)
1029 (display (car val) port)
1031 (display (cdr val) port))
1035 (set! *known-versions*
1036 (acons v (parse-http-version v 0 (string-length v))
1038 '("HTTP/1.0" "HTTP/1.1"))
1041 ;; Request-URI = "*" | absoluteURI | abs_path | authority
1043 ;; The `authority' form is only permissible for the CONNECT method, so
1044 ;; because we don't expect people to implement CONNECT, we save
1045 ;; ourselves the trouble of that case, and disallow the CONNECT method.
1047 (define* (parse-http-method str #:optional (start 0) (end (string-length str)))
1048 "Parse an HTTP method from STR. The result is an upper-case
1049 symbol, like ‘GET’."
1051 ((string= str "GET" start end) 'GET)
1052 ((string= str "HEAD" start end) 'HEAD)
1053 ((string= str "POST" start end) 'POST)
1054 ((string= str "PUT" start end) 'PUT)
1055 ((string= str "DELETE" start end) 'DELETE)
1056 ((string= str "OPTIONS" start end) 'OPTIONS)
1057 ((string= str "TRACE" start end) 'TRACE)
1058 (else (bad-request "Invalid method: ~a" (substring str start end)))))
1060 (define* (parse-request-uri str #:optional (start 0) (end (string-length str)))
1061 "Parse a URI from an HTTP request line. Note that URIs in requests do
1062 not have to have a scheme or host name. The result is a URI object."
1065 (bad-request "Missing Request-URI"))
1066 ((string= str "*" start end)
1068 ((eq? (string-ref str start) #\/)
1069 (let* ((q (string-index str #\? start end))
1070 (f (string-index str #\# start end))
1071 (q (and q (or (not f) (< q f)) q)))
1073 #:path (substring str start (or q f end))
1074 #:query (and q (substring str (1+ q) (or f end)))
1075 #:fragment (and f (substring str (1+ f) end)))))
1077 (or (string->uri (substring str start end))
1078 (bad-request "Invalid URI: ~a" (substring str start end))))))
1080 (define (read-request-line port)
1081 "Read the first line of an HTTP request from PORT, returning
1082 three values: the method, the URI, and the version."
1083 (let* ((line (read-line* port))
1084 (d0 (string-index line char-set:whitespace)) ; "delimiter zero"
1085 (d1 (string-rindex line char-set:whitespace)))
1086 (if (and d0 d1 (< d0 d1))
1087 (values (parse-http-method line 0 d0)
1088 (parse-request-uri line (skip-whitespace line (1+ d0) d1) d1)
1089 (parse-http-version line (1+ d1) (string-length line)))
1090 (bad-request "Bad Request-Line: ~s" line))))
1092 (define (write-uri uri port)
1093 (when (uri-host uri)
1094 (when (uri-scheme uri)
1095 (display (uri-scheme uri) port)
1098 (when (uri-userinfo uri)
1099 (display (uri-userinfo uri) port)
1101 (display (uri-host uri) port)
1102 (let ((p (uri-port uri)))
1103 (when (and p (not (eqv? p 80)))
1106 (let* ((path (uri-path uri))
1107 (len (string-length path)))
1109 ((and (> len 0) (not (eqv? (string-ref path 0) #\/)))
1110 (bad-request "Non-absolute URI path: ~s" path))
1111 ((and (zero? len) (not (uri-host uri)))
1112 (bad-request "Empty path and no host for URI: ~s" uri))
1114 (display path port))))
1115 (when (uri-query uri)
1117 (display (uri-query uri) port)))
1119 (define (write-request-line method uri version port)
1120 "Write the first line of an HTTP request to PORT."
1121 (display method port)
1122 (display #\space port)
1123 (when (http-proxy-port? port)
1124 (let ((scheme (uri-scheme uri))
1125 (host (uri-host uri))
1126 (host-port (uri-port uri)))
1127 (when (and scheme host)
1128 (display scheme port)
1129 (display "://" port)
1130 (if (string-index host #\:)
1131 (begin (display #\[ port)
1134 (display host port))
1135 (unless ((@@ (web uri) default-port?) scheme host-port)
1137 (display host-port port)))))
1138 (let ((path (uri-path uri))
1139 (query (uri-query uri)))
1140 (if (string-null? path)
1142 (display path port))
1146 (display query port))))
1147 (display #\space port)
1148 (write-http-version version port)
1149 (display "\r\n" port))
1151 (define (read-response-line port)
1152 "Read the first line of an HTTP response from PORT, returning
1153 three values: the HTTP version, the response code, and the \"reason
1155 (let* ((line (read-line* port))
1156 (d0 (string-index line char-set:whitespace)) ; "delimiter zero"
1157 (d1 (and d0 (string-index line char-set:whitespace
1158 (skip-whitespace line d0)))))
1160 (values (parse-http-version line 0 d0)
1161 (parse-non-negative-integer line (skip-whitespace line d0 d1)
1163 (string-trim-both line char-set:whitespace d1))
1164 (bad-response "Bad Response-Line: ~s" line))))
1166 (define (write-response-line version code reason-phrase port)
1167 "Write the first line of an HTTP response to PORT."
1168 (write-http-version version port)
1169 (display #\space port)
1171 (display #\space port)
1172 (display reason-phrase port)
1173 (display "\r\n" port))
1179 ;;; Helpers for declaring headers
1182 ;; emacs: (put 'declare-header! 'scheme-indent-function 1)
1183 ;; emacs: (put 'declare-opaque!-header 'scheme-indent-function 1)
1184 (define (declare-opaque-header! name)
1185 "Declares a given header as \"opaque\", meaning that its value is not
1186 treated specially, and is just returned as a plain string."
1187 (declare-header! name
1188 parse-opaque-string validate-opaque-string write-opaque-string))
1190 ;; emacs: (put 'declare-date-header! 'scheme-indent-function 1)
1191 (define (declare-date-header! name)
1192 (declare-header! name
1193 parse-date date? write-date))
1195 ;; emacs: (put 'declare-string-list-header! 'scheme-indent-function 1)
1196 (define (declare-string-list-header! name)
1197 (declare-header! name
1198 split-and-trim list-of-strings? write-list-of-strings))
1200 ;; emacs: (put 'declare-symbol-list-header! 'scheme-indent-function 1)
1201 (define (declare-symbol-list-header! name)
1202 (declare-header! name
1204 (map string->symbol (split-and-trim str)))
1206 (list-of? v symbol?))
1208 (write-list v port display ", "))))
1210 ;; emacs: (put 'declare-header-list-header! 'scheme-indent-function 1)
1211 (define (declare-header-list-header! name)
1212 (declare-header! name
1213 split-header-names list-of-header-names? write-header-list))
1215 ;; emacs: (put 'declare-integer-header! 'scheme-indent-function 1)
1216 (define (declare-integer-header! name)
1217 (declare-header! name
1218 parse-non-negative-integer non-negative-integer? display))
1220 ;; emacs: (put 'declare-uri-header! 'scheme-indent-function 1)
1221 (define (declare-uri-header! name)
1222 (declare-header! name
1223 (lambda (str) (or (string->uri str) (bad-header-component 'uri str)))
1224 (@@ (web uri) absolute-uri?)
1227 ;; emacs: (put 'declare-uri-reference-header! 'scheme-indent-function 1)
1228 (define (declare-uri-reference-header! name)
1229 (declare-header! name
1231 (or (string->uri-reference str)
1232 (bad-header-component 'uri str)))
1236 ;; emacs: (put 'declare-quality-list-header! 'scheme-indent-function 1)
1237 (define (declare-quality-list-header! name)
1238 (declare-header! name
1239 parse-quality-list validate-quality-list write-quality-list))
1241 ;; emacs: (put 'declare-param-list-header! 'scheme-indent-function 1)
1242 (define* (declare-param-list-header! name #:optional
1243 (val-parser default-val-parser)
1244 (val-validator default-val-validator)
1245 (val-writer default-val-writer))
1246 (declare-header! name
1247 (lambda (str) (parse-param-list str val-parser))
1248 (lambda (val) (validate-param-list val val-validator))
1249 (lambda (val port) (write-param-list val port val-writer))))
1251 ;; emacs: (put 'declare-key-value-list-header! 'scheme-indent-function 1)
1252 (define* (declare-key-value-list-header! name #:optional
1253 (val-parser default-val-parser)
1254 (val-validator default-val-validator)
1255 (val-writer default-val-writer))
1256 (declare-header! name
1257 (lambda (str) (parse-key-value-list str val-parser))
1258 (lambda (val) (key-value-list? val val-validator))
1259 (lambda (val port) (write-key-value-list val port val-writer))))
1261 ;; emacs: (put 'declare-entity-tag-list-header! 'scheme-indent-function 1)
1262 (define (declare-entity-tag-list-header! name)
1263 (declare-header! name
1264 (lambda (str) (if (string=? str "*") '* (parse-entity-tag-list str)))
1265 (lambda (val) (or (eq? val '*) (entity-tag-list? val)))
1269 (write-entity-tag-list val port)))))
1271 ;; emacs: (put 'declare-credentials-header! 'scheme-indent-function 1)
1272 (define (declare-credentials-header! name)
1273 (declare-header! name
1274 parse-credentials validate-credentials write-credentials))
1276 ;; emacs: (put 'declare-challenge-list-header! 'scheme-indent-function 1)
1277 (define (declare-challenge-list-header! name)
1278 (declare-header! name
1279 parse-challenges validate-challenges write-challenges))
1288 ;; Cache-Control = 1#(cache-directive)
1289 ;; cache-directive = cache-request-directive | cache-response-directive
1290 ;; cache-request-directive =
1291 ;; "no-cache" ; Section 14.9.1
1292 ;; | "no-store" ; Section 14.9.2
1293 ;; | "max-age" "=" delta-seconds ; Section 14.9.3, 14.9.4
1294 ;; | "max-stale" [ "=" delta-seconds ] ; Section 14.9.3
1295 ;; | "min-fresh" "=" delta-seconds ; Section 14.9.3
1296 ;; | "no-transform" ; Section 14.9.5
1297 ;; | "only-if-cached" ; Section 14.9.4
1298 ;; | cache-extension ; Section 14.9.6
1299 ;; cache-response-directive =
1300 ;; "public" ; Section 14.9.1
1301 ;; | "private" [ "=" <"> 1#field-name <"> ] ; Section 14.9.1
1302 ;; | "no-cache" [ "=" <"> 1#field-name <"> ]; Section 14.9.1
1303 ;; | "no-store" ; Section 14.9.2
1304 ;; | "no-transform" ; Section 14.9.5
1305 ;; | "must-revalidate" ; Section 14.9.4
1306 ;; | "proxy-revalidate" ; Section 14.9.4
1307 ;; | "max-age" "=" delta-seconds ; Section 14.9.3
1308 ;; | "s-maxage" "=" delta-seconds ; Section 14.9.3
1309 ;; | cache-extension ; Section 14.9.6
1310 ;; cache-extension = token [ "=" ( token | quoted-string ) ]
1312 (declare-key-value-list-header! "Cache-Control"
1315 ((max-age min-fresh s-maxage)
1316 (parse-non-negative-integer v-str))
1318 (and v-str (parse-non-negative-integer v-str)))
1320 (and v-str (split-header-names v-str)))
1324 ((max-age min-fresh s-maxage)
1325 (non-negative-integer? v))
1327 (or (not v) (non-negative-integer? v)))
1329 (or (not v) (list-of-header-names? v)))
1330 ((no-store no-transform only-if-cache must-revalidate proxy-revalidate)
1333 (or (not v) (string? v)))))
1336 ((string? v) (default-val-writer k v port))
1339 (write-header-list v port)
1344 (bad-header-component 'cache-control v)))))
1346 ;; Connection = "Connection" ":" 1#(connection-token)
1347 ;; connection-token = token
1349 ;; Connection: close, Foo-Header
1351 (declare-header! "Connection"
1353 list-of-header-names?
1355 (write-list val port
1357 (display (if (eq? x 'close)
1363 ;; Date = "Date" ":" HTTP-date
1365 ;; Date: Tue, 15 Nov 1994 08:12:31 GMT
1367 (declare-date-header! "Date")
1369 ;; Pragma = "Pragma" ":" 1#pragma-directive
1370 ;; pragma-directive = "no-cache" | extension-pragma
1371 ;; extension-pragma = token [ "=" ( token | quoted-string ) ]
1373 (declare-key-value-list-header! "Pragma")
1375 ;; Trailer = "Trailer" ":" 1#field-name
1377 (declare-header-list-header! "Trailer")
1379 ;; Transfer-Encoding = "Transfer-Encoding" ":" 1#transfer-coding
1381 (declare-param-list-header! "Transfer-Encoding")
1383 ;; Upgrade = "Upgrade" ":" 1#product
1385 (declare-string-list-header! "Upgrade")
1387 ;; Via = "Via" ":" 1#( received-protocol received-by [ comment ] )
1388 ;; received-protocol = [ protocol-name "/" ] protocol-version
1389 ;; protocol-name = token
1390 ;; protocol-version = token
1391 ;; received-by = ( host [ ":" port ] ) | pseudonym
1392 ;; pseudonym = token
1394 (declare-header! "Via"
1397 write-list-of-strings
1400 ;; Warning = "Warning" ":" 1#warning-value
1402 ;; warning-value = warn-code SP warn-agent SP warn-text
1405 ;; warn-code = 3DIGIT
1406 ;; warn-agent = ( host [ ":" port ] ) | pseudonym
1407 ;; ; the name or pseudonym of the server adding
1408 ;; ; the Warning header, for use in debugging
1409 ;; warn-text = quoted-string
1410 ;; warn-date = <"> HTTP-date <">
1411 (declare-header! "Warning"
1413 (let ((len (string-length str)))
1414 (let lp ((i (skip-whitespace str 0)))
1415 (let* ((idx1 (string-index str #\space i))
1416 (idx2 (string-index str #\space (1+ idx1))))
1418 (let ((code (parse-non-negative-integer str i idx1))
1419 (agent (substring str (1+ idx1) idx2)))
1421 (lambda () (parse-qstring str (1+ idx2) #:incremental? #t))
1425 (let ((c (and (< i len) (string-ref str i))))
1430 (lambda () (parse-qstring str (1+ i)
1433 (values text (parse-date date) i))))
1435 (values text #f i)))))
1436 (lambda (text date i)
1437 (let ((w (list code agent text date))
1438 (c (and (< i len) (string-ref str i))))
1441 ((#\,) (cons w (lp (skip-whitespace str (1+ i)))))
1442 (else (bad-header 'warning str))))))))))))))
1448 (apply (lambda (code host text date)
1449 (and (non-negative-integer? code) (< code 1000)
1452 (or (not date) (date? date))))
1459 (lambda (code host text date)
1461 (display #\space port)
1463 (display #\space port)
1464 (write-qstring text port)
1467 (display #\space port)
1468 (write-date date port))))
1482 (declare-symbol-list-header! "Allow")
1484 ;; Content-Disposition = disposition-type *( ";" disposition-parm )
1485 ;; disposition-type = "attachment" | disp-extension-token
1486 ;; disposition-parm = filename-parm | disp-extension-parm
1487 ;; filename-parm = "filename" "=" quoted-string
1488 ;; disp-extension-token = token
1489 ;; disp-extension-parm = token "=" ( token | quoted-string )
1491 (declare-header! "Content-Disposition"
1493 (let ((disposition (parse-param-list str default-val-parser)))
1494 ;; Lazily reuse the param list parser.
1495 (unless (and (pair? disposition)
1496 (null? (cdr disposition)))
1497 (bad-header-component 'content-disposition str))
1504 (and (pair? x) (symbol? (car x)) (string? (cdr x)))))))
1506 (write-param-list (list val) port)))
1508 ;; Content-Encoding = 1#content-coding
1510 (declare-symbol-list-header! "Content-Encoding")
1512 ;; Content-Language = 1#language-tag
1514 (declare-string-list-header! "Content-Language")
1516 ;; Content-Length = 1*DIGIT
1518 (declare-integer-header! "Content-Length")
1520 ;; Content-Location = URI-reference
1522 (declare-uri-reference-header! "Content-Location")
1524 ;; Content-MD5 = <base64 of 128 bit MD5 digest as per RFC 1864>
1526 (declare-opaque-header! "Content-MD5")
1528 ;; Content-Range = content-range-spec
1529 ;; content-range-spec = byte-content-range-spec
1530 ;; byte-content-range-spec = bytes-unit SP
1531 ;; byte-range-resp-spec "/"
1532 ;; ( instance-length | "*" )
1533 ;; byte-range-resp-spec = (first-byte-pos "-" last-byte-pos)
1535 ;; instance-length = 1*DIGIT
1537 (declare-header! "Content-Range"
1539 (let ((dash (string-index str #\-))
1540 (slash (string-index str #\/)))
1541 (if (and (string-prefix? "bytes " str) slash)
1546 (parse-non-negative-integer str 6 dash)
1547 (parse-non-negative-integer str (1+ dash) slash)))
1548 ((string= str "*" 6 slash)
1551 (bad-header 'content-range str)))
1552 (if (string= str "*" (1+ slash))
1554 (parse-non-negative-integer str (1+ slash))))
1555 (bad-header 'content-range str))))
1557 (and (list? val) (= (length val) 3)
1559 (let ((x (cadr val)))
1562 (non-negative-integer? (car x))
1563 (non-negative-integer? (cdr x)))))
1564 (let ((x (caddr val)))
1566 (non-negative-integer? x)))))
1568 (display (car val) port)
1569 (display #\space port)
1570 (if (eq? (cadr val) '*)
1573 (display (caadr val) port)
1575 (display (caadr val) port)))
1576 (if (eq? (caddr val) '*)
1578 (display (caddr val) port))))
1580 ;; Content-Type = media-type
1582 (declare-header! "Content-Type"
1584 (let ((parts (string-split str #\;)))
1585 (cons (parse-media-type (car parts))
1587 (let ((eq (string-index x #\=)))
1588 (if (and eq (= eq (string-rindex x #\=)))
1591 (string-trim x char-set:whitespace 0 eq))
1592 (string-trim-right x char-set:whitespace (1+ eq)))
1593 (bad-header 'content-type str))))
1600 (and (pair? x) (symbol? (car x)) (string? (cdr x)))))))
1602 (display (car val) port)
1603 (if (pair? (cdr val))
1609 (display (car pair) port)
1611 (display (cdr pair) port))
1614 ;; Expires = HTTP-date
1616 (define *date-in-the-past* (parse-date "Thu, 01 Jan 1970 00:00:00 GMT"))
1618 (declare-header! "Expires"
1620 (if (member str '("0" "-1"))
1626 ;; Last-Modified = HTTP-date
1628 (declare-date-header! "Last-Modified")
1637 ;; Accept = #( media-range [ accept-params ] )
1638 ;; media-range = ( "*/*" | ( type "/" "*" ) | ( type "/" subtype ) )
1639 ;; *( ";" parameter )
1640 ;; accept-params = ";" "q" "=" qvalue *( accept-extension )
1641 ;; accept-extension = ";" token [ "=" ( token | quoted-string ) ]
1643 (declare-param-list-header! "Accept"
1644 ;; -> (type/subtype (sym-prop . str-val) ...) ...)
1646 ;; with the exception of prop `q', in which case the val will be a
1647 ;; valid quality value
1656 (or (not v) (string? v))))
1659 (write-quality v port)
1660 (default-val-writer k v port))))
1662 ;; Accept-Charset = 1#( ( charset | "*" )[ ";" "q" "=" qvalue ] )
1664 (declare-quality-list-header! "Accept-Charset")
1666 ;; Accept-Encoding = 1#( codings [ ";" "q" "=" qvalue ] )
1667 ;; codings = ( content-coding | "*" )
1669 (declare-quality-list-header! "Accept-Encoding")
1671 ;; Accept-Language = 1#( language-range [ ";" "q" "=" qvalue ] )
1672 ;; language-range = ( ( 1*8ALPHA *( "-" 1*8ALPHA ) ) | "*" )
1674 (declare-quality-list-header! "Accept-Language")
1676 ;; Authorization = credentials
1677 ;; credentials = auth-scheme #auth-param
1678 ;; auth-scheme = token
1679 ;; auth-param = token "=" ( token | quoted-string )
1681 (declare-credentials-header! "Authorization")
1683 ;; Expect = 1#expectation
1684 ;; expectation = "100-continue" | expectation-extension
1685 ;; expectation-extension = token [ "=" ( token | quoted-string )
1687 ;; expect-params = ";" token [ "=" ( token | quoted-string ) ]
1689 (declare-param-list-header! "Expect")
1693 ;; Should be an email address; we just pass on the string as-is.
1695 (declare-opaque-header! "From")
1697 ;; Host = host [ ":" port ]
1699 (declare-header! "Host"
1701 (let* ((rbracket (string-index str #\]))
1702 (colon (string-index str #\: (or rbracket 0)))
1705 (unless (eqv? (string-ref str 0) #\[)
1706 (bad-header 'host str))
1707 (substring str 1 rbracket))
1709 (substring str 0 colon))
1713 (parse-non-negative-integer str (1+ colon)))))
1719 (non-negative-integer? (cdr val)))))
1721 (if (string-index (car val) #\:)
1724 (display (car val) port)
1726 (display (car val) port))
1730 (display (cdr val) port)))))
1732 ;; If-Match = ( "*" | 1#entity-tag )
1734 (declare-entity-tag-list-header! "If-Match")
1736 ;; If-Modified-Since = HTTP-date
1738 (declare-date-header! "If-Modified-Since")
1740 ;; If-None-Match = ( "*" | 1#entity-tag )
1742 (declare-entity-tag-list-header! "If-None-Match")
1744 ;; If-Range = ( entity-tag | HTTP-date )
1746 (declare-header! "If-Range"
1748 (if (or (string-prefix? "\"" str)
1749 (string-prefix? "W/" str))
1750 (parse-entity-tag str)
1753 (or (date? val) (entity-tag? val)))
1756 (write-date val port)
1757 (write-entity-tag val port))))
1759 ;; If-Unmodified-Since = HTTP-date
1761 (declare-date-header! "If-Unmodified-Since")
1763 ;; Max-Forwards = 1*DIGIT
1765 (declare-integer-header! "Max-Forwards")
1767 ;; Proxy-Authorization = credentials
1769 (declare-credentials-header! "Proxy-Authorization")
1771 ;; Range = "Range" ":" ranges-specifier
1772 ;; ranges-specifier = byte-ranges-specifier
1773 ;; byte-ranges-specifier = bytes-unit "=" byte-range-set
1774 ;; byte-range-set = 1#( byte-range-spec | suffix-byte-range-spec )
1775 ;; byte-range-spec = first-byte-pos "-" [last-byte-pos]
1776 ;; first-byte-pos = 1*DIGIT
1777 ;; last-byte-pos = 1*DIGIT
1778 ;; suffix-byte-range-spec = "-" suffix-length
1779 ;; suffix-length = 1*DIGIT
1781 (declare-header! "Range"
1783 (if (string-prefix? "bytes=" str)
1787 (let ((dash (string-index x #\-)))
1790 (bad-header 'range str))
1792 (cons #f (parse-non-negative-integer x 1)))
1793 ((= dash (1- (string-length x)))
1794 (cons (parse-non-negative-integer x 0 dash) #f))
1796 (cons (parse-non-negative-integer x 0 dash)
1797 (parse-non-negative-integer x (1+ dash)))))))
1798 (string-split (substring str 6) #\,)))
1799 (bad-header 'range str)))
1806 (let ((x (car elt)) (y (cdr elt)))
1808 (or (not x) (non-negative-integer? x))
1809 (or (not y) (non-negative-integer? y)))))))))
1811 (display (car val) port)
1817 (display (car pair) port))
1820 (display (cdr pair) port)))
1823 ;; Referer = URI-reference
1825 (declare-uri-reference-header! "Referer")
1827 ;; TE = #( t-codings )
1828 ;; t-codings = "trailers" | ( transfer-extension [ accept-params ] )
1830 (declare-param-list-header! "TE")
1832 ;; User-Agent = 1*( product | comment )
1834 (declare-opaque-header! "User-Agent")
1843 ;; Accept-Ranges = acceptable-ranges
1844 ;; acceptable-ranges = 1#range-unit | "none"
1846 (declare-symbol-list-header! "Accept-Ranges")
1849 ;; age-value = delta-seconds
1851 (declare-integer-header! "Age")
1853 ;; ETag = entity-tag
1855 (declare-header! "ETag"
1860 ;; Location = URI-reference
1862 ;; In RFC 2616, Location was specified as being an absolute URI. This
1863 ;; was changed in RFC 7231 to permit URI references generally, which
1864 ;; matches web reality.
1866 (declare-uri-reference-header! "Location")
1868 ;; Proxy-Authenticate = 1#challenge
1870 (declare-challenge-list-header! "Proxy-Authenticate")
1872 ;; Retry-After = ( HTTP-date | delta-seconds )
1874 (declare-header! "Retry-After"
1876 (if (and (not (string-null? str))
1877 (char-numeric? (string-ref str 0)))
1878 (parse-non-negative-integer str)
1881 (or (date? val) (non-negative-integer? val)))
1884 (write-date val port)
1885 (display val port))))
1887 ;; Server = 1*( product | comment )
1889 (declare-opaque-header! "Server")
1891 ;; Vary = ( "*" | 1#field-name )
1893 (declare-header! "Vary"
1895 (if (equal? str "*")
1897 (split-header-names str)))
1899 (or (eq? val '*) (list-of-header-names? val)))
1903 (write-header-list val port))))
1905 ;; WWW-Authenticate = 1#challenge
1907 (declare-challenge-list-header! "WWW-Authenticate")
1910 ;; Chunked Responses
1911 (define (read-chunk-header port)
1912 (let* ((str (read-line port))
1913 (extension-start (string-index str (lambda (c) (or (char=? c #\;)
1914 (char=? c #\return)))))
1915 (size (string->number (if extension-start ; unnecessary?
1916 (substring str 0 extension-start)
1921 (define (read-chunk port)
1922 (let ((size (read-chunk-header port)))
1923 (read-chunk-body port size)))
1925 (define (read-chunk-body port size)
1926 (let ((bv (get-bytevector-n port size)))
1931 (define* (make-chunked-input-port port #:key (keep-alive? #f))
1932 "Returns a new port which translates HTTP chunked transfer encoded
1933 data from PORT into a non-encoded format. Returns eof when it has
1934 read the final chunk from PORT. This does not necessarily mean
1935 that there is no more data on PORT. When the returned port is
1936 closed it will also close PORT, unless the KEEP-ALIVE? is true."
1937 (define (next-chunk)
1939 (define finished? #f)
1943 (define buffer #vu8())
1944 (define buffer-size 0)
1945 (define buffer-pointer 0)
1946 (define (read! bv idx to-read)
1947 (define (loop to-read num-read)
1948 (cond ((or finished? (zero? to-read))
1950 ((<= to-read (- buffer-size buffer-pointer))
1951 (bytevector-copy! buffer buffer-pointer
1954 (set! buffer-pointer (+ buffer-pointer to-read))
1955 (loop 0 (+ num-read to-read)))
1957 (let ((n (- buffer-size buffer-pointer)))
1958 (bytevector-copy! buffer buffer-pointer
1961 (set! buffer (next-chunk))
1962 (set! buffer-pointer 0)
1963 (set! buffer-size (bytevector-length buffer))
1964 (set! finished? (= buffer-size 0))
1968 (make-custom-binary-input-port "chunked input port" read! #f #f close))
1970 (define* (make-chunked-output-port port #:key (keep-alive? #f))
1971 "Returns a new port which translates non-encoded data into a HTTP
1972 chunked transfer encoded data and writes this to PORT. Data
1973 written to this port is buffered until the port is flushed, at which
1974 point it is all sent as one chunk. Take care to close the port when
1975 done, as it will output the remaining data, and encode the final zero
1976 chunk. When the port is closed it will also close PORT, unless
1977 KEEP-ALIVE? is true."
1978 (define (q-for-each f q)
1979 (while (not (q-empty? q))
1981 (define queue (make-q))
1982 (define (put-char c)
1984 (define (put-string s)
1985 (string-for-each (lambda (c) (enq! queue c))
1988 ;; It is important that we do _not_ write a chunk if the queue is
1989 ;; empty, since it will be treated as the final chunk.
1990 (unless (q-empty? queue)
1991 (let ((len (q-length queue)))
1992 (display (number->string len 16) port)
1993 (display "\r\n" port)
1994 (q-for-each (lambda (elem) (write-char elem port))
1996 (display "\r\n" port))))
1999 (display "0\r\n" port)
2003 (make-soft-port (vector put-char put-string flush #f close) "w"))
2005 (define %http-proxy-port? (make-object-property))
2006 (define (http-proxy-port? port) (%http-proxy-port? port))
2007 (define (set-http-proxy-port?! port flag)
2008 (set! (%http-proxy-port? port) flag))