AtlatestRepositorysigil-dbus

sigil-dbus / tree / testtest-transport.sgl

1(import (sigil dbus) (sigil dbus transport) (sigil socket)
2 (sigil async) (sigil process) (sigil io) (sigil test))
3
4;; A controlled peer exercises fragmentation and hostile framing without a
5;; bus daemon rewriting or rejecting the deliberately malformed messages.
6(define (peer-line socket)
7 (let loop ((bytes '()))
8 (let ((chunk (socket-read-bytevector socket 1)))
9 (cond
10 ((eof-object? chunk) (error "Unexpected test peer EOF"))
11 ((= 0 (bytevector-length chunk)) (await-readable socket) (loop bytes))
12 ((= 10 (bytevector-u8-ref chunk 0)) (reverse bytes))
13 (else (loop (cons (bytevector-u8-ref chunk 0) bytes)))))))
15(define (peer-send socket bytes start end)
16 (let loop ((offset start))
17 (when (< offset end)
18 (let ((n (socket-write socket bytes offset end)))
19 (if (and n (> n 0))
20 (loop (+ offset n))
21 (begin (await-writable socket) (loop offset)))))))
23(define (with-peer name handler client)
24 (let* ((path (string-append (getenv "DBUS_TEST_DIRECTORY") "/" name))
25 (listener (unix-listen path)) (peer #f) (transport #f) (peer-error #f) (peer-done #f))
26 (unless listener (error "Cannot create test peer"))
27 (socket-set-non-blocking! listener #t)
28 (go
29 (guard (e (else (set! peer-error e)))
30 (await-readable listener)
31 (set! peer (tcp-accept listener))
32 (socket-set-non-blocking! peer #t)
33 (peer-line peer)
34 (socket-write peer (string->utf8 "OK 00000000000000000000000000000000\r\n"))
35 (peer-line peer)
36 (handler peer))
37 (set! peer-done #t))
38 (dynamic-wind
39 (lambda () #t)
40 (lambda ()
41 (set! transport (dbus-open-transport (string-append "unix:path=" path) max-bytes: 1024))
42 (client transport)
43 (let loop () (unless peer-done (sleep 0.001) (loop)))
44 (when peer-error (raise peer-error)))
45 (lambda ()
46 (when transport (dbus-close-transport! transport))
47 (when peer (socket-close peer))
48 (socket-close listener)))))
50(define (reply text)
51 (dbus-encode-message
52 (dbus-message 2 1 (list (cons 5 (dbus-variant "u" 9))) "s" (list text))))
53(define (cleared? bytes)
54 (let loop ((i 0))
55 (or (= i (bytevector-length bytes))
56 (and (= 0 (bytevector-u8-ref bytes i)) (loop (+ i 1))))))
58(with-async
59 (test-group "stream transport"
60 (test "decoded receive frame is cleared without changing returned values"
61 (let ((bytes (reply "buffer-canary")))
62 (with-peer "clear-decoded"
63 (lambda (peer)
64 (peer-send peer bytes 0 (- (bytevector-length bytes) 1))
65 (sleep 0.05)
66 (peer-send peer bytes (- (bytevector-length bytes) 1) (bytevector-length bytes)))
67 (lambda (transport)
68 (assert-false (dbus-transport-read! transport timeout-ms: 5))
69 (let ((frame (vector-ref transport 1)))
70 (assert-true (> (bytevector-length frame) 16))
71 (assert-equal '("buffer-canary")
72 (dbus-message-body (dbus-transport-read! transport timeout-ms: 300)))
73 (assert-true (cleared? frame)))))))
74 (test "malformed decoded receive frame is cleared on rejection"
75 (let ((bytes (reply "buffer-canary")))
76 (bytevector-u8-set! bytes (- (bytevector-length bytes) 1) 1)
77 (with-peer "clear-rejected"
78 (lambda (peer)
79 (peer-send peer bytes 0 (- (bytevector-length bytes) 1))
80 (sleep 0.05)
81 (peer-send peer bytes (- (bytevector-length bytes) 1) (bytevector-length bytes)))
82 (lambda (transport)
83 (assert-false (dbus-transport-read! transport timeout-ms: 5))
84 (let ((frame (vector-ref transport 1)))
85 (assert-error (dbus-transport-read! transport timeout-ms: 300))
86 (assert-true (cleared? frame)))))))
87 (test "closing clears an incomplete receive frame"
88 (let ((bytes (reply "buffer-canary")))
89 (with-peer "clear-partial"
90 (lambda (peer) (peer-send peer bytes 0 (- (bytevector-length bytes) 1)))
91 (lambda (transport)
92 (assert-false (dbus-transport-read! transport timeout-ms: 5))
93 (let ((frame (vector-ref transport 1)))
94 (dbus-close-transport! transport)
95 (assert-true (cleared? frame)))))))
96 (test "fragmented fixed header and body survive read timeouts"
97 (let ((bytes (reply "fragmented")))
98 (with-peer "fragments"
99 (lambda (peer)
100 (peer-send peer bytes 0 3)
101 (sleep 0.02)
102 (peer-send peer bytes 3 16)
103 (sleep 0.02)
104 (peer-send peer bytes 16 (- (bytevector-length bytes) 2))
105 (sleep 0.02)
106 (peer-send peer bytes (- (bytevector-length bytes) 2) (bytevector-length bytes)))
107 (lambda (transport)
108 (assert-false (dbus-transport-read! transport timeout-ms: 5))
109 (assert-equal '("fragmented")
110 (dbus-message-body (dbus-transport-read! transport timeout-ms: 300)))))))
111 (test "coalesced messages keep separate boundaries"
112 (with-peer "coalesced"
113 (lambda (peer)
114 (let ((bytes (bytevector-append (reply "one") (reply "two"))))
115 (peer-send peer bytes 0 (bytevector-length bytes))))
116 (lambda (transport)
117 (assert-equal '("one") (dbus-message-body (dbus-transport-read! transport)))
118 (assert-equal '("two") (dbus-message-body (dbus-transport-read! transport))))))
119 (test "oversized advertised frame rejected before its body arrives"
120 (with-peer "oversized"
121 (lambda (peer)
122 (let ((prefix (bytevector 108 2 0 1 0 0 0 127 1 0 0 0 0 0 0 0)))
123 (peer-send peer prefix 0 16)))
124 (lambda (transport) (assert-error (dbus-transport-read! transport)))))
125 (test "write backpressure has a deadline and closes partial frames"
126 (with-peer "backpressure"
127 (lambda (peer) (sleep 0.05))
128 (lambda (transport)
129 (assert-error (dbus-transport-write! transport (make-bytevector 1048576 1) timeout-ms: 5))
130 (assert-true (dbus-transport-closed? transport)))))
131 (test "EOF in partial fixed header is a clean error"
132 (with-peer "eof"
133 (lambda (peer) (socket-write peer (bytevector 108 2)) (socket-close peer))
134 (lambda (transport) (assert-error (dbus-transport-read! transport))))))
135 (unless (run-tests) (exit 1)))