websocket 0.17.0

A WebSocket (RFC6455) library for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

extern crate websocket;
extern crate hyper;

use std::thread;
use std::io::Write;
use websocket::{Server, Message, Sender, Receiver};
use websocket::header::WebSocketProtocol;
use websocket::message::Type;
use hyper::Server as HttpServer;
use hyper::server::Handler;
use hyper::net::Fresh;
use hyper::server::request::Request;
use hyper::server::response::Response;

// The HTTP server handler
fn http_handler(_: Request, response: Response<Fresh>) {
	let mut response = response.start().unwrap();
	// Send a client webpage
	response.write_all(b"<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>WebSocket Test</title></head><body><script>var socket=new WebSocket(\"ws://127.0.0.1:2794\", \"rust-websocket\");socket.onmessage=function (event){var received=document.getElementById(\"received\");var br=document.createElement(\"BR\");var text=document.createTextNode(event.data);received.appendChild(br);received.appendChild(text);};function send(element){var input=document.getElementById(element);socket.send(input.value);input.value=\"\";}</script><p id=\"received\"><strong>Received Messages:</strong></p><form onsubmit=\"send('message'); return false\"><input type=\"text\" id=\"message\"><input type=\"submit\" value=\"Send\"></form></body></html>").unwrap();
	response.end().unwrap();
}

fn main() {
	// Start listening for http connections
	thread::spawn(move || {
		let http_server = HttpServer::http("127.0.0.1:8080").unwrap();
		http_server.handle(http_handler).unwrap();
	});

	// Start listening for WebSocket connections
	let ws_server = Server::bind("127.0.0.1:2794").unwrap();

	for connection in ws_server {
		// Spawn a new thread for each connection.
		thread::spawn(move || {
			let request = connection.unwrap().read_request().unwrap(); // Get the request
			let headers = request.headers.clone(); // Keep the headers so we can check them

			request.validate().unwrap(); // Validate the request

			let mut response = request.accept(); // Form a response

			if let Some(&WebSocketProtocol(ref protocols)) = headers.get() {
				if protocols.contains(&("rust-websocket".to_string())) {
					// We have a protocol we want to use
					response.headers.set(WebSocketProtocol(vec!["rust-websocket".to_string()]));
				}
			}

			let mut client = response.send().unwrap(); // Send the response

			let ip = client.get_mut_sender()
				.get_mut()
				.peer_addr()
				.unwrap();

			println!("Connection from {}", ip);

			let message = Message::text("Hello".to_string());
			client.send_message(&message).unwrap();

			let (mut sender, mut receiver) = client.split();

			for message in receiver.incoming_messages() {
				let message: Message = message.unwrap();

				match message.opcode {
					Type::Close => {
						let message = Message::close();
						sender.send_message(&message).unwrap();
						println!("Client {} disconnected", ip);
						return;
					},
					Type::Ping => {
						let message = Message::pong(message.payload);
						sender.send_message(&message).unwrap();
					},
					_ => sender.send_message(&message).unwrap(),
				}
			}
		});
	}
}