[netwatch.git] / net / rfb.c

#include <stdint.h>
#include <minilib.h>
#include <output.h>
#include <fb.h>

#include "lwip/tcp.h"

#include "rfb.h"

#define SET_PIXEL_FORMAT	0
#define SET_ENCODINGS		2
#define FB_UPDATE_REQUEST	3
#define KEY_EVENT		4
#define POINTER_EVENT		5
#define CLIENT_CUT_TEXT		6

#define RFB_BUF_SIZE	2048

struct pixel_format {
	uint8_t bpp;
	uint8_t depth;
	uint8_t big_endian;
	uint8_t true_color;
	uint16_t red_max;
	uint16_t green_max;
	uint16_t blue_max;
	uint8_t red_shift;
	uint8_t green_shift;
	uint8_t blue_shift;
	uint8_t padding[3];
};

struct server_init_message {
	uint16_t fb_width;
	uint16_t fb_height;
	struct pixel_format fmt;
	uint32_t name_length;
	char name_string[8];
};

struct fb_update_req {
	uint8_t msgtype;
	uint8_t incremental;
	uint16_t xpos;
	uint16_t ypos;
	uint16_t width;
	uint16_t height;
};

struct set_encs_req {
	uint8_t msgtype;
	uint8_t padding;
	uint16_t num;
	int32_t encodings[];
};

struct key_event_pkt {
	uint8_t msgtype;
	uint8_t downflag;
	uint8_t pad[2];
	uint32_t keysym;
};

struct pointer_event_pkt {
	uint8_t msgtype;
	uint8_t button_mask;
	uint16_t x;
	uint16_t y;
};

struct text_event_pkt {
	uint8_t msgtype;
	uint8_t padding[3];
	uint32_t length;
	char text[];
};

struct rfb_state {
	enum {
		ST_BEGIN,
		ST_CLIENTINIT,
		ST_MAIN
	} state;
	int version;
	int encs_remaining;

	char data[RFB_BUF_SIZE];
	int readpos;
	int writepos;

	char next_update_incremental;
	struct fb_update_req client_interest_area;

	int needs_updated;
};

static struct server_init_message server_info;

static void init_server_info() {
	server_info.name_length = 8;
	memcpy(server_info.name_string, "NetWatch", 8);
}

static void update_server_info() {
	if (fb != NULL) {
		server_info.fb_width = fb->curmode.xres;
		server_info.fb_height = fb->curmode.yres;
		switch (fb->curmode.format) {
		case FB_RGB888:
			server_info.fmt.bpp = 32;
			server_info.fmt.depth = 24;
			server_info.fmt.big_endian = 0;
			server_info.fmt.true_color = 1;
			server_info.fmt.red_max = 255;
			server_info.fmt.green_max = 255;
			server_info.fmt.blue_max = 255;
			server_info.fmt.red_shift = 0;
			server_info.fmt.green_shift = 8;
			server_info.fmt.blue_shift = 16;
			break;
		default:
			outputf("RFB: unknown fb fmt %d", fb->curmode.format);
			break;
		}
	}
}

static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {
	tcp_arg(pcb, NULL);
	tcp_sent(pcb, NULL);
	tcp_recv(pcb, NULL);
	mem_free(state);
	tcp_close(pcb);
}

enum fsm_result {
	NEEDMORE,
	OK,
	FAIL
};

static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {

	switch(state->state) {
	case ST_BEGIN:
		if (state->writepos < 12) return NEEDMORE;

		if (!strncmp(state->data, "RFB 003.003\n", 12)) {
			state->version = 3;
		} else if (!strncmp(state->data, "RFB 003.005\n", 12)) {
			/* Spec states that "RFB 003.005", an incorrect value,
			 * should be treated by the server as 3.3. */
			state->version = 3;
		} else if (!strncmp(state->data, "RFB 003.007\n", 12)) {
			state->version = 7;
		} else if (!strncmp(state->data, "RFB 003.008\n", 12)) {
			state->version = 8;
		} else {
			outputf("RFB: Negotiation fail");
			return FAIL;
		}

		outputf("RFB: Negotiated v3.%d", state->version);

		state->readpos += 12;
		state->state = ST_CLIENTINIT;

		/* We support one security type, currently "none". */
		if (state->version >= 7) {
			tcp_write(pcb, "\x01\x01", 2, 0);
		} else {
			tcp_write(pcb, "\x01", 1, 0);
		}

		/* ... and go right ahead and send SecurityResult message. */
		tcp_write(pcb, "\x00\x00\x00\x01", 4, 0);
		tcp_output(pcb);

		return OK;

	case ST_CLIENTINIT:
		if (state->writepos < 1) return NEEDMORE;
		state->readpos += 1;
		state->state = ST_MAIN;

		tcp_write(pcb, &server_info, sizeof(server_info), 0);
		tcp_output(pcb);

		return OK;

	case ST_MAIN:
		if (state->writepos < 1) return NEEDMORE;

		switch (state->data[0]) {

		case SET_PIXEL_FORMAT:
			/* SetPixelFormat */
			if (state->writepos < (sizeof(struct pixel_format) + 4))
				return NEEDMORE;
/*
			struct pixel_format * new_fmt =
				(struct pixel_format *)(&state->data[4]);
*/
			/* XXX ... */

			state->readpos += sizeof(struct pixel_format) + 4;
			return OK;

		case SET_ENCODINGS:
			if (state->writepos < 4) return NEEDMORE;

			struct set_encs_req * req = (struct set_encs_req *)state->data;

			if (state->writepos < (sizeof(struct set_encs_req)
			                       + 4 * req->num))
				return NEEDMORE;

			/* XXX ... */

			state->readpos += (4 * req->num) + sizeof(struct set_encs_req);
			return OK;

		case FB_UPDATE_REQUEST:
			if (state->writepos < sizeof(struct fb_update_req))
				return NEEDMORE;

			state->needs_updated = 1;
			memcpy(&state->client_interest_area, state->data,
			       sizeof(struct fb_update_req)); 

			state->readpos += sizeof(struct fb_update_req);
			return OK;

		case KEY_EVENT:
			if (state->writepos < sizeof(struct key_event_pkt))
				return NEEDMORE;

			/* XXX stub */

			state->readpos += sizeof(struct key_event_pkt);
			return OK;

		case POINTER_EVENT:
			if (state->writepos < sizeof(struct pointer_event_pkt))
				return NEEDMORE;

			/* XXX stub */

			state->readpos += sizeof(struct pointer_event_pkt);
			return OK;

		case CLIENT_CUT_TEXT:
			if (state->writepos < sizeof(struct text_event_pkt))
				return NEEDMORE;

			struct text_event_pkt * pkt =
				(struct text_event_pkt *)state->data;

			if (state->writepos < sizeof(struct text_event_pkt)
			                      + pkt->length)
				return NEEDMORE;

			/* XXX stub */

			state->readpos += sizeof(struct text_event_pkt)
			                  + pkt->length;
			return OK;

		default:
			outputf("RFB: Bad command: %d", state->data[0]);
		}
	default:
		outputf("RFB: Bad state");
		return FAIL;
	}
}

static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
                      struct pbuf *p, err_t err) {
	struct rfb_state *state = arg;

	if (state == NULL) 

	if (err != ERR_OK) {
		outputf("RFB: recv err %d", err);
		/* FIXME do something better here? */
		return ERR_OK;
	}

	if (p == NULL) {
		outputf("RFB: Connection closed");
		close_conn(pcb, state);
		return ERR_OK;
	}

	if (p->tot_len > (RFB_BUF_SIZE - state->writepos)) {
		/* Overflow! */
		outputf("RFB: Overflow!");
		close_conn(pcb, state);
		return ERR_OK;
	}

	outputf("RFB: Processing %d", p->tot_len);
	pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
	tcp_recved(pcb, p->tot_len);
	pbuf_free(p);

	while (1) {
		switch (recv_fsm(pcb, state)) {
		case NEEDMORE:
			/* Need more data */
			return ERR_OK;

		case OK:
			if (state->readpos == state->writepos) {
				state->readpos = 0;
				state->writepos = 0;
				return ERR_OK;
			} else {
				memmove(state->data,
				        state->data + state->readpos,
				        state->writepos - state->readpos);
			}
			break;
		case FAIL:
			/* Shit */
			outputf("RFB: Protocol error");
			close_conn(pcb, state);
			return ERR_OK;
		}
	}
}	
		
static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
	struct rfb_state *state;

	LWIP_UNUSED_ARG(arg);
	LWIP_UNUSED_ARG(err);

	state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));

	/* XXX: update_server_info() should be called from the 64ms timer, and deal
	 * with screen resizes appropriately. */
	update_server_info();

	if (!state)
	{
		outputf("rfb_accept: out of memory\n");
		return ERR_MEM;
	}

	tcp_arg(pcb, state);
	tcp_recv(pcb, rfb_recv);
/*
	tcp_err(pcb, rfb_err);
	tcp_poll(pcb, rfb_poll, 2);
*/
	tcp_write(pcb, "RFB 003.008\n", 12, 0);
	tcp_output(pcb);

	return ERR_OK;
}

void rfb_init() {
	struct tcp_pcb *pcb;

	init_server_info();

	pcb = tcp_new();
	tcp_bind(pcb, IP_ADDR_ANY, RFB_PORT);
	pcb = tcp_listen(pcb);
	tcp_accept(pcb, rfb_accept);
}
Commit	Line	Data
7da36fbd JP	1	#include <stdint.h>
	2	#include <minilib.h>
	3	#include <output.h>
	4	#include <fb.h>
	5
	6	#include "lwip/tcp.h"
	7
	8	#include "rfb.h"
	9
	10	#define SET_PIXEL_FORMAT 0
	11	#define SET_ENCODINGS 2
	12	#define FB_UPDATE_REQUEST 3
	13	#define KEY_EVENT 4
	14	#define POINTER_EVENT 5
	15	#define CLIENT_CUT_TEXT 6
	16
	17	#define RFB_BUF_SIZE 2048
	18
	19	struct pixel_format {
	20	uint8_t bpp;
	21	uint8_t depth;
	22	uint8_t big_endian;
	23	uint8_t true_color;
	24	uint16_t red_max;
	25	uint16_t green_max;
	26	uint16_t blue_max;
	27	uint8_t red_shift;
	28	uint8_t green_shift;
	29	uint8_t blue_shift;
	30	uint8_t padding[3];
	31	};
	32
	33	struct server_init_message {
	34	uint16_t fb_width;
	35	uint16_t fb_height;
	36	struct pixel_format fmt;
	37	uint32_t name_length;
	38	char name_string[8];
	39	};
	40
	41	struct fb_update_req {
	42	uint8_t msgtype;
	43	uint8_t incremental;
	44	uint16_t xpos;
	45	uint16_t ypos;
	46	uint16_t width;
	47	uint16_t height;
	48	};
	49
	50	struct set_encs_req {
	51	uint8_t msgtype;
	52	uint8_t padding;
	53	uint16_t num;
	54	int32_t encodings[];
	55	};
	56
	57	struct key_event_pkt {
	58	uint8_t msgtype;
	59	uint8_t downflag;
	60	uint8_t pad[2];
	61	uint32_t keysym;
	62	};
	63
	64	struct pointer_event_pkt {
65	uint8_t msgtype;
66	uint8_t button_mask;
67	uint16_t x;
68	uint16_t y;
69	};
70
71	struct text_event_pkt {
72	uint8_t msgtype;
73	uint8_t padding[3];
74	uint32_t length;
75	char text[];
76	};
77
78	struct rfb_state {
79	enum {
80	ST_BEGIN,
81	ST_CLIENTINIT,
82	ST_MAIN
83	} state;
84	int version;
85	int encs_remaining;
86
87	char data[RFB_BUF_SIZE];
88	int readpos;
89	int writepos;
90
91	char next_update_incremental;
92	struct fb_update_req client_interest_area;
93
94	int needs_updated;
95	};
96
97	static struct server_init_message server_info;
98
99	static void init_server_info() {
100	server_info.name_length = 8;
101	memcpy(server_info.name_string, "NetWatch", 8);
102	}
103
104	static void update_server_info() {
105	if (fb != NULL) {
106	server_info.fb_width = fb->curmode.xres;
107	server_info.fb_height = fb->curmode.yres;
108	switch (fb->curmode.format) {
109	case FB_RGB888:
110	server_info.fmt.bpp = 32;
111	server_info.fmt.depth = 24;
112	server_info.fmt.big_endian = 0;
113	server_info.fmt.true_color = 1;
114	server_info.fmt.red_max = 255;
115	server_info.fmt.green_max = 255;
116	server_info.fmt.blue_max = 255;
117	server_info.fmt.red_shift = 0;
118	server_info.fmt.green_shift = 8;
119	server_info.fmt.blue_shift = 16;
120	break;
121	default:
122	outputf("RFB: unknown fb fmt %d", fb->curmode.format);
123	break;
124	}
125	}
126	}
127
128	static void close_conn(struct tcp_pcb pcb, struct rfb_state state) {
129	tcp_arg(pcb, NULL);
130	tcp_sent(pcb, NULL);
131	tcp_recv(pcb, NULL);
132	mem_free(state);
133	tcp_close(pcb);
134	}
135
136	enum fsm_result {
137	NEEDMORE,
138	OK,
139	FAIL
140	};
141
142	static enum fsm_result recv_fsm(struct tcp_pcb pcb, struct rfb_state state) {
143
144	switch(state->state) {
145	case ST_BEGIN:
146	if (state->writepos < 12) return NEEDMORE;
147
148	if (!strncmp(state->data, "RFB 003.003\n", 12)) {
149	state->version = 3;
150	} else if (!strncmp(state->data, "RFB 003.005\n", 12)) {
151	/* Spec states that "RFB 003.005", an incorrect value,
152	* should be treated by the server as 3.3. */
153	state->version = 3;
154	} else if (!strncmp(state->data, "RFB 003.007\n", 12)) {
155	state->version = 7;
156	} else if (!strncmp(state->data, "RFB 003.008\n", 12)) {
157	state->version = 8;
158	} else {
159	outputf("RFB: Negotiation fail");
160	return FAIL;
161	}
162
163	outputf("RFB: Negotiated v3.%d", state->version);
164
165	state->readpos += 12;
166	state->state = ST_CLIENTINIT;
167
168	/* We support one security type, currently "none". */
169	if (state->version >= 7) {
170	tcp_write(pcb, "\x01\x01", 2, 0);
171	} else {
172	tcp_write(pcb, "\x01", 1, 0);
173	}
174
175	/* ... and go right ahead and send SecurityResult message. */
176	tcp_write(pcb, "\x00\x00\x00\x01", 4, 0);
177	tcp_output(pcb);
178
179	return OK;
180
181	case ST_CLIENTINIT:
182	if (state->writepos < 1) return NEEDMORE;
183	state->readpos += 1;
184	state->state = ST_MAIN;
185
186	tcp_write(pcb, &server_info, sizeof(server_info), 0);
187	tcp_output(pcb);
188
189	return OK;
190
191	case ST_MAIN:
192	if (state->writepos < 1) return NEEDMORE;
193
194	switch (state->data[0]) {
195
196	case SET_PIXEL_FORMAT:
197	/* SetPixelFormat */
198	if (state->writepos < (sizeof(struct pixel_format) + 4))
199	return NEEDMORE;
200	/*
201	struct pixel_format * new_fmt =
202	(struct pixel_format *)(&state->data[4]);
203	*/
204	/* XXX ... */
205
206	state->readpos += sizeof(struct pixel_format) + 4;
207	return OK;
208
209	case SET_ENCODINGS:
210	if (state->writepos < 4) return NEEDMORE;
211
212	struct set_encs_req * req = (struct set_encs_req *)state->data;
213
214	if (state->writepos < (sizeof(struct set_encs_req)
215	+ 4 * req->num))
216	return NEEDMORE;
217
218	/* XXX ... */
219
220	state->readpos += (4 * req->num) + sizeof(struct set_encs_req);
221	return OK;
222
223	case FB_UPDATE_REQUEST:
224	if (state->writepos < sizeof(struct fb_update_req))
225	return NEEDMORE;
226
227	state->needs_updated = 1;
228	memcpy(&state->client_interest_area, state->data,
229	sizeof(struct fb_update_req));
230
231	state->readpos += sizeof(struct fb_update_req);
232	return OK;
233
234	case KEY_EVENT:
235	if (state->writepos < sizeof(struct key_event_pkt))
236	return NEEDMORE;
237
238	/* XXX stub */
239
240	state->readpos += sizeof(struct key_event_pkt);
241	return OK;
242
243	case POINTER_EVENT:
244	if (state->writepos < sizeof(struct pointer_event_pkt))
245	return NEEDMORE;
246
247	/* XXX stub */
248
249	state->readpos += sizeof(struct pointer_event_pkt);
250	return OK;
251
252	case CLIENT_CUT_TEXT:
253	if (state->writepos < sizeof(struct text_event_pkt))
254	return NEEDMORE;
255
256	struct text_event_pkt * pkt =
257	(struct text_event_pkt *)state->data;
258
259	if (state->writepos < sizeof(struct text_event_pkt)
260	+ pkt->length)
261	return NEEDMORE;
262
263	/* XXX stub */
264
265	state->readpos += sizeof(struct text_event_pkt)
266	+ pkt->length;
267	return OK;
268
269	default:
270	outputf("RFB: Bad command: %d", state->data[0]);
271	}
272	default:
273	outputf("RFB: Bad state");
274	return FAIL;
275	}
276	}
277
278	static err_t rfb_recv(void arg, struct tcp_pcb pcb,
279	struct pbuf *p, err_t err) {
280	struct rfb_state *state = arg;
281
282	if (state == NULL)
283
284	if (err != ERR_OK) {
285	outputf("RFB: recv err %d", err);
286	/* FIXME do something better here? */
287	return ERR_OK;
288	}
289
290	if (p == NULL) {
291	outputf("RFB: Connection closed");
292	close_conn(pcb, state);
293	return ERR_OK;
294	}
295
296	if (p->tot_len > (RFB_BUF_SIZE - state->writepos)) {
297	/* Overflow! */
298	outputf("RFB: Overflow!");
299	close_conn(pcb, state);
300	return ERR_OK;
301	}
302
303	outputf("RFB: Processing %d", p->tot_len);
304	pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
305	tcp_recved(pcb, p->tot_len);
306	pbuf_free(p);
307
308	while (1) {
309	switch (recv_fsm(pcb, state)) {
310	case NEEDMORE:
311	/* Need more data */
312	return ERR_OK;
313
314	case OK:
315	if (state->readpos == state->writepos) {
316	state->readpos = 0;
317	state->writepos = 0;
318	return ERR_OK;
319	} else {
320	memmove(state->data,
321	state->data + state->readpos,
322	state->writepos - state->readpos);
323	}
324	break;
325	case FAIL:
326	/* Shit */
327	outputf("RFB: Protocol error");
328	close_conn(pcb, state);
329	return ERR_OK;
330	}
331	}
332	}
333
334	static err_t rfb_accept(void arg, struct tcp_pcb pcb, err_t err) {
335	struct rfb_state *state;
336
337	LWIP_UNUSED_ARG(arg);
338	LWIP_UNUSED_ARG(err);
339
340	state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));
341
342	/* XXX: update_server_info() should be called from the 64ms timer, and deal
343	* with screen resizes appropriately. */
344	update_server_info();
345
346	if (!state)
347	{
348	outputf("rfb_accept: out of memory\n");
349	return ERR_MEM;
350	}
351
352	tcp_arg(pcb, state);
353	tcp_recv(pcb, rfb_recv);
354	/*
355	tcp_err(pcb, rfb_err);
356	tcp_poll(pcb, rfb_poll, 2);
357	*/
358	tcp_write(pcb, "RFB 003.008\n", 12, 0);
359	tcp_output(pcb);
360
361	return ERR_OK;
362	}
363
364	void rfb_init() {
365	struct tcp_pcb *pcb;
366
367	init_server_info();
368
369	pcb = tcp_new();
370	tcp_bind(pcb, IP_ADDR_ANY, RFB_PORT);
371	pcb = tcp_listen(pcb);
372	tcp_accept(pcb, rfb_accept);
373	}