github.com/ethereum/go-ethereum@v1.14.3/rpc/websocket_test.go (about) 1 // Copyright 2018 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package rpc 18 19 import ( 20 "context" 21 "errors" 22 "net" 23 "net/http" 24 "net/http/httptest" 25 "strings" 26 "testing" 27 "time" 28 29 "github.com/gorilla/websocket" 30 ) 31 32 func TestWebsocketClientHeaders(t *testing.T) { 33 t.Parallel() 34 35 endpoint, header, err := wsClientHeaders("wss://testuser:test-PASS_01@example.com:1234", "https://example.com") 36 if err != nil { 37 t.Fatalf("wsGetConfig failed: %s", err) 38 } 39 if endpoint != "wss://example.com:1234" { 40 t.Fatal("User should have been stripped from the URL") 41 } 42 if header.Get("authorization") != "Basic dGVzdHVzZXI6dGVzdC1QQVNTXzAx" { 43 t.Fatal("Basic auth header is incorrect") 44 } 45 if header.Get("origin") != "https://example.com" { 46 t.Fatal("Origin not set") 47 } 48 } 49 50 // This test checks that the server rejects connections from disallowed origins. 51 func TestWebsocketOriginCheck(t *testing.T) { 52 t.Parallel() 53 54 var ( 55 srv = newTestServer() 56 httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"http://example.com"})) 57 wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:") 58 ) 59 defer srv.Stop() 60 defer httpsrv.Close() 61 62 client, err := DialWebsocket(context.Background(), wsURL, "http://ekzample.com") 63 if err == nil { 64 client.Close() 65 t.Fatal("no error for wrong origin") 66 } 67 wantErr := wsHandshakeError{websocket.ErrBadHandshake, "403 Forbidden"} 68 if !errors.Is(err, wantErr) { 69 t.Fatalf("wrong error for wrong origin: %q", err) 70 } 71 72 // Connections without origin header should work. 73 client, err = DialWebsocket(context.Background(), wsURL, "") 74 if err != nil { 75 t.Fatalf("error for empty origin: %v", err) 76 } 77 client.Close() 78 } 79 80 // This test checks whether calls exceeding the request size limit are rejected. 81 func TestWebsocketLargeCall(t *testing.T) { 82 t.Parallel() 83 84 var ( 85 srv = newTestServer() 86 httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"*"})) 87 wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:") 88 ) 89 defer srv.Stop() 90 defer httpsrv.Close() 91 92 client, err := DialWebsocket(context.Background(), wsURL, "") 93 if err != nil { 94 t.Fatalf("can't dial: %v", err) 95 } 96 defer client.Close() 97 98 // This call sends slightly less than the limit and should work. 99 var result echoResult 100 arg := strings.Repeat("x", defaultBodyLimit-200) 101 if err := client.Call(&result, "test_echo", arg, 1); err != nil { 102 t.Fatalf("valid call didn't work: %v", err) 103 } 104 if result.String != arg { 105 t.Fatal("wrong string echoed") 106 } 107 108 // This call sends twice the allowed size and shouldn't work. 109 arg = strings.Repeat("x", defaultBodyLimit*2) 110 err = client.Call(&result, "test_echo", arg) 111 if err == nil { 112 t.Fatal("no error for too large call") 113 } 114 } 115 116 // This test checks whether the wsMessageSizeLimit option is obeyed. 117 func TestWebsocketLargeRead(t *testing.T) { 118 t.Parallel() 119 120 var ( 121 srv = newTestServer() 122 httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"*"})) 123 wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:") 124 ) 125 defer srv.Stop() 126 defer httpsrv.Close() 127 128 testLimit := func(limit *int64) { 129 opts := []ClientOption{} 130 expLimit := int64(wsDefaultReadLimit) 131 if limit != nil && *limit >= 0 { 132 opts = append(opts, WithWebsocketMessageSizeLimit(*limit)) 133 if *limit > 0 { 134 expLimit = *limit // 0 means infinite 135 } 136 } 137 client, err := DialOptions(context.Background(), wsURL, opts...) 138 if err != nil { 139 t.Fatalf("can't dial: %v", err) 140 } 141 defer client.Close() 142 // Remove some bytes for json encoding overhead. 143 underLimit := int(expLimit - 128) 144 overLimit := expLimit + 1 145 if expLimit == wsDefaultReadLimit { 146 // No point trying the full 32MB in tests. Just sanity-check that 147 // it's not obviously limited. 148 underLimit = 1024 149 overLimit = -1 150 } 151 var res string 152 // Check under limit 153 if err = client.Call(&res, "test_repeat", "A", underLimit); err != nil { 154 t.Fatalf("unexpected error with limit %d: %v", expLimit, err) 155 } 156 if len(res) != underLimit || strings.Count(res, "A") != underLimit { 157 t.Fatal("incorrect data") 158 } 159 // Check over limit 160 if overLimit > 0 { 161 err = client.Call(&res, "test_repeat", "A", expLimit+1) 162 if err == nil || err != websocket.ErrReadLimit { 163 t.Fatalf("wrong error with limit %d: %v expecting %v", expLimit, err, websocket.ErrReadLimit) 164 } 165 } 166 } 167 ptr := func(v int64) *int64 { return &v } 168 169 testLimit(ptr(-1)) // Should be ignored (use default) 170 testLimit(ptr(0)) // Should be ignored (use default) 171 testLimit(nil) // Should be ignored (use default) 172 testLimit(ptr(200)) 173 testLimit(ptr(wsDefaultReadLimit * 2)) 174 } 175 176 func TestWebsocketPeerInfo(t *testing.T) { 177 var ( 178 s = newTestServer() 179 ts = httptest.NewServer(s.WebsocketHandler([]string{"origin.example.com"})) 180 tsurl = "ws:" + strings.TrimPrefix(ts.URL, "http:") 181 ) 182 defer s.Stop() 183 defer ts.Close() 184 185 ctx := context.Background() 186 c, err := DialWebsocket(ctx, tsurl, "origin.example.com") 187 if err != nil { 188 t.Fatal(err) 189 } 190 defer c.Close() 191 192 // Request peer information. 193 var connInfo PeerInfo 194 if err := c.Call(&connInfo, "test_peerInfo"); err != nil { 195 t.Fatal(err) 196 } 197 198 if connInfo.RemoteAddr == "" { 199 t.Error("RemoteAddr not set") 200 } 201 if connInfo.Transport != "ws" { 202 t.Errorf("wrong Transport %q", connInfo.Transport) 203 } 204 if connInfo.HTTP.UserAgent != "Go-http-client/1.1" { 205 t.Errorf("wrong HTTP.UserAgent %q", connInfo.HTTP.UserAgent) 206 } 207 if connInfo.HTTP.Origin != "origin.example.com" { 208 t.Errorf("wrong HTTP.Origin %q", connInfo.HTTP.UserAgent) 209 } 210 } 211 212 // This test checks that client handles WebSocket ping frames correctly. 213 func TestClientWebsocketPing(t *testing.T) { 214 t.Parallel() 215 216 var ( 217 sendPing = make(chan struct{}) 218 server = wsPingTestServer(t, sendPing) 219 ctx, cancel = context.WithTimeout(context.Background(), 2*time.Second) 220 ) 221 defer cancel() 222 defer server.Shutdown(ctx) 223 224 client, err := DialContext(ctx, "ws://"+server.Addr) 225 if err != nil { 226 t.Fatalf("client dial error: %v", err) 227 } 228 defer client.Close() 229 230 resultChan := make(chan int) 231 sub, err := client.EthSubscribe(ctx, resultChan, "foo") 232 if err != nil { 233 t.Fatalf("client subscribe error: %v", err) 234 } 235 // Note: Unsubscribe is not called on this subscription because the mockup 236 // server can't handle the request. 237 238 // Wait for the context's deadline to be reached before proceeding. 239 // This is important for reproducing https://github.com/ethereum/go-ethereum/issues/19798 240 <-ctx.Done() 241 close(sendPing) 242 243 // Wait for the subscription result. 244 timeout := time.NewTimer(5 * time.Second) 245 defer timeout.Stop() 246 for { 247 select { 248 case err := <-sub.Err(): 249 t.Error("client subscription error:", err) 250 case result := <-resultChan: 251 t.Log("client got result:", result) 252 return 253 case <-timeout.C: 254 t.Error("didn't get any result within the test timeout") 255 return 256 } 257 } 258 } 259 260 // This checks that the websocket transport can deal with large messages. 261 func TestClientWebsocketLargeMessage(t *testing.T) { 262 var ( 263 srv = NewServer() 264 httpsrv = httptest.NewServer(srv.WebsocketHandler(nil)) 265 wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:") 266 ) 267 defer srv.Stop() 268 defer httpsrv.Close() 269 270 respLength := wsDefaultReadLimit - 50 271 srv.RegisterName("test", largeRespService{respLength}) 272 273 c, err := DialWebsocket(context.Background(), wsURL, "") 274 if err != nil { 275 t.Fatal(err) 276 } 277 defer c.Close() 278 279 var r string 280 if err := c.Call(&r, "test_largeResp"); err != nil { 281 t.Fatal("call failed:", err) 282 } 283 if len(r) != respLength { 284 t.Fatalf("response has wrong length %d, want %d", len(r), respLength) 285 } 286 } 287 288 // wsPingTestServer runs a WebSocket server which accepts a single subscription request. 289 // When a value arrives on sendPing, the server sends a ping frame, waits for a matching 290 // pong and finally delivers a single subscription result. 291 func wsPingTestServer(t *testing.T, sendPing <-chan struct{}) *http.Server { 292 var srv http.Server 293 shutdown := make(chan struct{}) 294 srv.RegisterOnShutdown(func() { 295 close(shutdown) 296 }) 297 srv.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 298 // Upgrade to WebSocket. 299 upgrader := websocket.Upgrader{ 300 CheckOrigin: func(r *http.Request) bool { return true }, 301 } 302 conn, err := upgrader.Upgrade(w, r, nil) 303 if err != nil { 304 t.Errorf("server WS upgrade error: %v", err) 305 return 306 } 307 defer conn.Close() 308 309 // Handle the connection. 310 wsPingTestHandler(t, conn, shutdown, sendPing) 311 }) 312 313 // Start the server. 314 listener, err := net.Listen("tcp", "127.0.0.1:0") 315 if err != nil { 316 t.Fatal("can't listen:", err) 317 } 318 srv.Addr = listener.Addr().String() 319 go srv.Serve(listener) 320 return &srv 321 } 322 323 func wsPingTestHandler(t *testing.T, conn *websocket.Conn, shutdown, sendPing <-chan struct{}) { 324 // Canned responses for the eth_subscribe call in TestClientWebsocketPing. 325 const ( 326 subResp = `{"jsonrpc":"2.0","id":1,"result":"0x00"}` 327 subNotify = `{"jsonrpc":"2.0","method":"eth_subscription","params":{"subscription":"0x00","result":1}}` 328 ) 329 330 // Handle subscribe request. 331 if _, _, err := conn.ReadMessage(); err != nil { 332 t.Errorf("server read error: %v", err) 333 return 334 } 335 if err := conn.WriteMessage(websocket.TextMessage, []byte(subResp)); err != nil { 336 t.Errorf("server write error: %v", err) 337 return 338 } 339 340 // Read from the connection to process control messages. 341 var pongCh = make(chan string) 342 conn.SetPongHandler(func(d string) error { 343 t.Logf("server got pong: %q", d) 344 pongCh <- d 345 return nil 346 }) 347 go func() { 348 for { 349 typ, msg, err := conn.ReadMessage() 350 if err != nil { 351 return 352 } 353 t.Logf("server got message (%d): %q", typ, msg) 354 } 355 }() 356 357 // Write messages. 358 var ( 359 wantPong string 360 timer = time.NewTimer(0) 361 ) 362 defer timer.Stop() 363 <-timer.C 364 for { 365 select { 366 case _, open := <-sendPing: 367 if !open { 368 sendPing = nil 369 } 370 t.Logf("server sending ping") 371 conn.WriteMessage(websocket.PingMessage, []byte("ping")) 372 wantPong = "ping" 373 case data := <-pongCh: 374 if wantPong == "" { 375 t.Errorf("unexpected pong") 376 } else if data != wantPong { 377 t.Errorf("got pong with wrong data %q", data) 378 } 379 wantPong = "" 380 timer.Reset(200 * time.Millisecond) 381 case <-timer.C: 382 t.Logf("server sending response") 383 conn.WriteMessage(websocket.TextMessage, []byte(subNotify)) 384 case <-shutdown: 385 conn.Close() 386 return 387 } 388 } 389 }