[netwatch.git] / net / rfb.c

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

#include "../aseg-paging/keyboard.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	64

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 update_header {
	uint8_t msgtype;
	uint8_t padding;
	uint16_t nrects;
	uint16_t xpos;
	uint16_t ypos;
	uint16_t width;
	uint16_t height;
	int32_t enctype;
};

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;
	char update_requested;

	struct fb_update_req client_interest_area;

	enum {
		SST_IDLE,
		SST_NEEDS_UPDATE,
		SST_SENDING
	} send_state;

	uint32_t update_pos;
	uint32_t frame_bytes;
};

static struct server_init_message server_info;

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

static void update_server_info() {
	if (fb != NULL) {
		outputf("RFB: setting fmt %d", fb->curmode.format);
		server_info.fb_width = htons(fb->curmode.xres);
		server_info.fb_height = htons(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 = htons(255);
			server_info.fmt.green_max = htons(255);
			server_info.fmt.blue_max = htons(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;
		}
	} else {
		outputf("RFB: fb null");
	}
}

static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
	struct update_header hdr;
	int left, sndlength;
	err_t err;

	switch (state->send_state) {
	case SST_IDLE:
		/* Nothing to do */
		if (state->update_requested) {
			outputf("RFB send: update requested");
			state->update_requested = 0;
			state->send_state = SST_NEEDS_UPDATE;
		} else {
			break;
		}
	
		/* FALL THROUGH to SST_NEEDS_UPDATE*/
	case SST_NEEDS_UPDATE:
		outputf("RFB send: sending header");
		/* Send a header */
		state->frame_bytes = fb->curmode.xres * fb->curmode.yres * fb->curmode.bytestride;
		hdr.msgtype = 0;
		hdr.nrects = htons(1);
		hdr.xpos = htons(0);
		hdr.ypos = htons(0);
		hdr.width = htons(fb->curmode.xres);
		hdr.height = htons(fb->curmode.yres);
		hdr.enctype = htonl(0);
		tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY);

		state->update_pos = 0;
		state->send_state = SST_SENDING;

		/* FALL THROUGH to SST_SENDING*/
	case SST_SENDING:
		while (1) {
			left = state->frame_bytes - state->update_pos;

			if (left == 0) {
				state->send_state = SST_IDLE;
				break;
			}
			
			if (left > 8192)	/* Sounds good enough to me. */
				left = 8192;

			sndlength = left;
			do {
				err = tcp_write(pcb, fb->fbaddr + state->update_pos, sndlength, TCP_WRITE_FLAG_COPY /* The card can't DMA from there. */);
				if (err == ERR_MEM)		/* Back down until lwip says we've got space. */
					sndlength /= 2;
			} while (err == ERR_MEM && sndlength > 1);

			if (err != ERR_OK) {
				if (err != ERR_MEM)
					outputf("RFB: send error %d", err);
				
				/* We'll just give up for now and come back when we have space later. */
				break;
			}

			state->update_pos += sndlength;

			if (tcp_sndbuf(pcb) == 0) {
				break;
			}
		}

		break;
	}
	
	if (tcp_output(pcb) != ERR_OK)
		outputf("RFB: tcp_output bailed in send_fsm?");
}

static err_t rfb_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {
	struct rfb_state *state = arg;
	send_fsm(pcb, state);
	return ERR_OK;
}

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) {
	int i;
	int pktsize;

	outputf("RFB FSM: st %d rp %d wp %d", state->state, state->readpos,
		state->writepos);

	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".
		 * Send that and SecurityResult. */
		if (state->version >= 7) {
			tcp_write(pcb, "\x01\x01\x00\x00\x00\x00", 6, 0);
		} else {
			tcp_write(pcb, "\x01\x00\x00\x00\x00", 5, 0);
		}

		tcp_output(pcb);

		return OK;

	case ST_CLIENTINIT:
		if (state->version >= 7) {
			/* Ignore the security type and ClientInit */
			if (state->writepos < 2) return NEEDMORE;
			state->readpos += 2;
		} else {
			/* Just ClientInit */
			if (state->writepos < 1) return NEEDMORE;
			state->readpos += 1;
		}

		state->state = ST_MAIN;

		outputf("RFB: Sending server info", state->version);
		tcp_write(pcb, &server_info, sizeof(server_info), TCP_WRITE_FLAG_COPY);
		tcp_output(pcb);

		return OK;

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

		outputf("RFB: cmd %d", state->data[0]);
		switch (state->data[0]) {

		case SET_PIXEL_FORMAT:
			/* SetPixelFormat */
			if (state->writepos < (sizeof(struct pixel_format) + 4))
				return NEEDMORE;
			outputf("RFB: SetPixelFormat");
/*
			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;

			pktsize = sizeof(struct set_encs_req) + (4 * ntohs(req->num));

			outputf("RFB: SetEncodings [%d]", ntohs(req->num));
			if (state->writepos < pktsize) return NEEDMORE;

			for (i = 0; i < ntohs(req->num); i++) {
				outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
				/* XXX ... */
			}

			state->readpos += pktsize;
			return OK;

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

			state->update_requested = 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;
			outputf("RFB: Key");

			struct key_event_pkt * p = (struct key_event_pkt *)state->data;
			kbd_inject_keysym(htonl(p->keysym), p->downflag);

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

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

			/* 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;
			outputf("RFB: Cut Text");

			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);
	state->writepos += p->tot_len;

	tcp_recved(pcb, p->tot_len);
	pbuf_free(p);

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

		case OK:
			outputf("RFB FSM: ok");

			/* Kick off a send. */
			if (state->send_state == SST_IDLE
			    && state->update_requested) {
				send_fsm(pcb, state);
			}

			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));

	state->state = ST_BEGIN;
	state->readpos = 0;
	state->writepos = 0;
	state->update_requested = 0;
	state->send_state = SST_IDLE;

	/* 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_sent(pcb, rfb_sent);
/*
	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
ec949d20 JP	6	#include "../aseg-paging/keyboard.h"
ec949d20 JP	7
7da36fbd JP	8	#include "lwip/tcp.h"
	9
	10	#include "rfb.h"
	11
	12	#define SET_PIXEL_FORMAT 0
	13	#define SET_ENCODINGS 2
	14	#define FB_UPDATE_REQUEST 3
	15	#define KEY_EVENT 4
	16	#define POINTER_EVENT 5
	17	#define CLIENT_CUT_TEXT 6
	18
80726808	19	#define RFB_BUF_SIZE 64
7da36fbd JP	20
	21	struct pixel_format {
	22	uint8_t bpp;
	23	uint8_t depth;
	24	uint8_t big_endian;
	25	uint8_t true_color;
	26	uint16_t red_max;
	27	uint16_t green_max;
	28	uint16_t blue_max;
	29	uint8_t red_shift;
	30	uint8_t green_shift;
	31	uint8_t blue_shift;
	32	uint8_t padding[3];
	33	};
	34
	35	struct server_init_message {
	36	uint16_t fb_width;
	37	uint16_t fb_height;
	38	struct pixel_format fmt;
	39	uint32_t name_length;
	40	char name_string[8];
	41	};
	42
	43	struct fb_update_req {
	44	uint8_t msgtype;
	45	uint8_t incremental;
	46	uint16_t xpos;
	47	uint16_t ypos;
	48	uint16_t width;
	49	uint16_t height;
	50	};
	51
	52	struct set_encs_req {
	53	uint8_t msgtype;
	54	uint8_t padding;
	55	uint16_t num;
	56	int32_t encodings[];
	57	};
	58
	59	struct key_event_pkt {
	60	uint8_t msgtype;
	61	uint8_t downflag;
	62	uint8_t pad[2];
	63	uint32_t keysym;
	64	};
	65
	66	struct pointer_event_pkt {
	67	uint8_t msgtype;
	68	uint8_t button_mask;
	69	uint16_t x;
	70	uint16_t y;
	71	};
	72
	73	struct text_event_pkt {
	74	uint8_t msgtype;
	75	uint8_t padding[3];
	76	uint32_t length;
	77	char text[];
	78	};
	79
8ceb0515 JP	80	struct update_header {
	81	uint8_t msgtype;
	82	uint8_t padding;
	83	uint16_t nrects;
	84	uint16_t xpos;
	85	uint16_t ypos;
	86	uint16_t width;
	87	uint16_t height;
	88	int32_t enctype;
	89	};
	90
7da36fbd JP	91	struct rfb_state {
	92	enum {
	93	ST_BEGIN,
	94	ST_CLIENTINIT,
	95	ST_MAIN
	96	} state;
	97	int version;
	98	int encs_remaining;
	99
	100	char data[RFB_BUF_SIZE];
	101	int readpos;
	102	int writepos;
	103
	104	char next_update_incremental;
8ceb0515 JP	105	char update_requested;
8ceb0515 JP	106
7da36fbd JP	107	struct fb_update_req client_interest_area;
7da36fbd JP	108
8ceb0515 JP	109	enum {
	110	SST_IDLE,
	111	SST_NEEDS_UPDATE,
	112	SST_SENDING
	113	} send_state;
	114
	115	uint32_t update_pos;
	116	uint32_t frame_bytes;
7da36fbd JP	117	};
	118
	119	static struct server_init_message server_info;
	120
	121	static void init_server_info() {
80726808	122	server_info.name_length = htonl(8);
7da36fbd JP	123	memcpy(server_info.name_string, "NetWatch", 8);
	124	}
	125
	126	static void update_server_info() {
	127	if (fb != NULL) {
80726808 JP	128	outputf("RFB: setting fmt %d", fb->curmode.format);
	129	server_info.fb_width = htons(fb->curmode.xres);
	130	server_info.fb_height = htons(fb->curmode.yres);
7da36fbd JP	131	switch (fb->curmode.format) {
	132	case FB_RGB888:
	133	server_info.fmt.bpp = 32;
	134	server_info.fmt.depth = 24;
	135	server_info.fmt.big_endian = 0;
	136	server_info.fmt.true_color = 1;
80726808 JP	137	server_info.fmt.red_max = htons(255);
	138	server_info.fmt.green_max = htons(255);
	139	server_info.fmt.blue_max = htons(255);
7da36fbd JP	140	server_info.fmt.red_shift = 0;
	141	server_info.fmt.green_shift = 8;
	142	server_info.fmt.blue_shift = 16;
	143	break;
	144	default:
	145	outputf("RFB: unknown fb fmt %d", fb->curmode.format);
	146	break;
	147	}
80726808 JP	148	} else {
80726808 JP	149	outputf("RFB: fb null");
7da36fbd JP	150	}
	151	}
	152
8ceb0515 JP	153	static void send_fsm(struct tcp_pcb pcb, struct rfb_state state) {
	154	struct update_header hdr;
	155	int left, sndlength;
	156	err_t err;
	157
	158	switch (state->send_state) {
	159	case SST_IDLE:
	160	/* Nothing to do */
	161	if (state->update_requested) {
	162	outputf("RFB send: update requested");
	163	state->update_requested = 0;
	164	state->send_state = SST_NEEDS_UPDATE;
	165	} else {
	166	break;
	167	}
	168
8cc40c4d	169	/* FALL THROUGH to SST_NEEDS_UPDATE*/
8ceb0515 JP	170	case SST_NEEDS_UPDATE:
	171	outputf("RFB send: sending header");
	172	/* Send a header */
bbfab433	173	state->frame_bytes = fb->curmode.xres * fb->curmode.yres * fb->curmode.bytestride;
8ceb0515 JP	174	hdr.msgtype = 0;
	175	hdr.nrects = htons(1);
	176	hdr.xpos = htons(0);
	177	hdr.ypos = htons(0);
	178	hdr.width = htons(fb->curmode.xres);
	179	hdr.height = htons(fb->curmode.yres);
	180	hdr.enctype = htonl(0);
075bbc71	181	tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY);
8ceb0515 JP	182
	183	state->update_pos = 0;
	184	state->send_state = SST_SENDING;
	185
8cc40c4d	186	/* FALL THROUGH to SST_SENDING*/
8ceb0515	187	case SST_SENDING:
bbfab433 JP	188	while (1) {
bbfab433 JP	189	left = state->frame_bytes - state->update_pos;
8ceb0515	190
bbfab433 JP	191	if (left == 0) {
	192	state->send_state = SST_IDLE;
	193	break;
8ceb0515	194	}
075bbc71	195
8cc40c4d	196	if (left > 8192) /* Sounds good enough to me. */
075bbc71	197	left = 8192;
8ceb0515	198
03bcc4db	199	sndlength = left;
bbfab433	200	do {
8cc40c4d	201	err = tcp_write(pcb, fb->fbaddr + state->update_pos, sndlength, TCP_WRITE_FLAG_COPY /* The card can't DMA from there. */);
03bcc4db	202	if (err == ERR_MEM) /* Back down until lwip says we've got space. */
bbfab433	203	sndlength /= 2;
bbfab433 JP	204	} while (err == ERR_MEM && sndlength > 1);
bbfab433 JP	205
03bcc4db	206	if (err != ERR_OK) {
8cc40c4d JW	207	if (err != ERR_MEM)
	208	outputf("RFB: send error %d", err);
	209
03bcc4db	210	/* We'll just give up for now and come back when we have space later. */
bbfab433 JP	211	break;
	212	}
	213
bbfab433 JP	214	state->update_pos += sndlength;
	215
	216	if (tcp_sndbuf(pcb) == 0) {
	217	break;
	218	}
8ceb0515 JP	219	}
	220
	221	break;
	222	}
075bbc71 JW	223
075bbc71 JW	224	if (tcp_output(pcb) != ERR_OK)
075bbc71	225	outputf("RFB: tcp_output bailed in send_fsm?");
8ceb0515 JP	226	}
	227
	228	static err_t rfb_sent(void arg, struct tcp_pcb pcb, uint16_t len) {
	229	struct rfb_state *state = arg;
	230	send_fsm(pcb, state);
	231	return ERR_OK;
80726808 JP	232	}
80726808 JP	233
7da36fbd JP	234	static void close_conn(struct tcp_pcb pcb, struct rfb_state state) {
	235	tcp_arg(pcb, NULL);
	236	tcp_sent(pcb, NULL);
	237	tcp_recv(pcb, NULL);
	238	mem_free(state);
	239	tcp_close(pcb);
	240	}
	241
	242	enum fsm_result {
	243	NEEDMORE,
	244	OK,
	245	FAIL
	246	};
	247
	248	static enum fsm_result recv_fsm(struct tcp_pcb pcb, struct rfb_state state) {
80726808 JP	249	int i;
	250	int pktsize;
	251
	252	outputf("RFB FSM: st %d rp %d wp %d", state->state, state->readpos,
	253	state->writepos);
7da36fbd JP	254
	255	switch(state->state) {
	256	case ST_BEGIN:
	257	if (state->writepos < 12) return NEEDMORE;
	258
	259	if (!strncmp(state->data, "RFB 003.003\n", 12)) {
	260	state->version = 3;
	261	} else if (!strncmp(state->data, "RFB 003.005\n", 12)) {
	262	/* Spec states that "RFB 003.005", an incorrect value,
	263	* should be treated by the server as 3.3. */
	264	state->version = 3;
	265	} else if (!strncmp(state->data, "RFB 003.007\n", 12)) {
	266	state->version = 7;
	267	} else if (!strncmp(state->data, "RFB 003.008\n", 12)) {
	268	state->version = 8;
	269	} else {
	270	outputf("RFB: Negotiation fail");
	271	return FAIL;
	272	}
	273
	274	outputf("RFB: Negotiated v3.%d", state->version);
	275
	276	state->readpos += 12;
	277	state->state = ST_CLIENTINIT;
	278
80726808 JP	279	/* We support one security type, currently "none".
80726808 JP	280	* Send that and SecurityResult. */
7da36fbd	281	if (state->version >= 7) {
80726808	282	tcp_write(pcb, "\x01\x01\x00\x00\x00\x00", 6, 0);
7da36fbd	283	} else {
80726808	284	tcp_write(pcb, "\x01\x00\x00\x00\x00", 5, 0);
7da36fbd JP	285	}
7da36fbd JP	286
7da36fbd JP	287	tcp_output(pcb);
	288
	289	return OK;
	290
	291	case ST_CLIENTINIT:
80726808 JP	292	if (state->version >= 7) {
	293	/* Ignore the security type and ClientInit */
	294	if (state->writepos < 2) return NEEDMORE;
	295	state->readpos += 2;
	296	} else {
	297	/* Just ClientInit */
	298	if (state->writepos < 1) return NEEDMORE;
	299	state->readpos += 1;
	300	}
	301
7da36fbd JP	302	state->state = ST_MAIN;
7da36fbd JP	303
80726808	304	outputf("RFB: Sending server info", state->version);
075bbc71	305	tcp_write(pcb, &server_info, sizeof(server_info), TCP_WRITE_FLAG_COPY);
7da36fbd JP	306	tcp_output(pcb);
	307
	308	return OK;
	309
	310	case ST_MAIN:
	311	if (state->writepos < 1) return NEEDMORE;
	312
80726808	313	outputf("RFB: cmd %d", state->data[0]);
7da36fbd JP	314	switch (state->data[0]) {
	315
	316	case SET_PIXEL_FORMAT:
	317	/* SetPixelFormat */
	318	if (state->writepos < (sizeof(struct pixel_format) + 4))
	319	return NEEDMORE;
80726808	320	outputf("RFB: SetPixelFormat");
7da36fbd JP	321	/*
	322	struct pixel_format * new_fmt =
	323	(struct pixel_format *)(&state->data[4]);
	324	*/
	325	/* XXX ... */
	326
	327	state->readpos += sizeof(struct pixel_format) + 4;
	328	return OK;
	329
	330	case SET_ENCODINGS:
	331	if (state->writepos < 4) return NEEDMORE;
	332
	333	struct set_encs_req * req = (struct set_encs_req *)state->data;
	334
80726808	335	pktsize = sizeof(struct set_encs_req) + (4 * ntohs(req->num));
7da36fbd	336
80726808 JP	337	outputf("RFB: SetEncodings [%d]", ntohs(req->num));
	338	if (state->writepos < pktsize) return NEEDMORE;
	339
	340	for (i = 0; i < ntohs(req->num); i++) {
	341	outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
	342	/* XXX ... */
80726808 JP	343	}
	344
	345	state->readpos += pktsize;
7da36fbd JP	346	return OK;
	347
	348	case FB_UPDATE_REQUEST:
	349	if (state->writepos < sizeof(struct fb_update_req))
	350	return NEEDMORE;
80726808	351	outputf("RFB: UpdateRequest");
7da36fbd	352
8ceb0515	353	state->update_requested = 1;
7da36fbd JP	354	memcpy(&state->client_interest_area, state->data,
	355	sizeof(struct fb_update_req));
	356
	357	state->readpos += sizeof(struct fb_update_req);
	358	return OK;
	359
	360	case KEY_EVENT:
	361	if (state->writepos < sizeof(struct key_event_pkt))
	362	return NEEDMORE;
80726808	363	outputf("RFB: Key");
7da36fbd	364
ec949d20 JP	365	struct key_event_pkt * p = (struct key_event_pkt *)state->data;
ec949d20 JP	366	kbd_inject_keysym(htonl(p->keysym), p->downflag);
7da36fbd JP	367
	368	state->readpos += sizeof(struct key_event_pkt);
	369	return OK;
	370
	371	case POINTER_EVENT:
	372	if (state->writepos < sizeof(struct pointer_event_pkt))
	373	return NEEDMORE;
80726808	374	outputf("RFB: Pointer");
7da36fbd JP	375
	376	/* XXX stub */
	377
	378	state->readpos += sizeof(struct pointer_event_pkt);
	379	return OK;
	380
	381	case CLIENT_CUT_TEXT:
	382	if (state->writepos < sizeof(struct text_event_pkt))
	383	return NEEDMORE;
80726808	384	outputf("RFB: Cut Text");
7da36fbd JP	385
	386	struct text_event_pkt * pkt =
	387	(struct text_event_pkt *)state->data;
	388
	389	if (state->writepos < sizeof(struct text_event_pkt)
	390	+ pkt->length)
	391	return NEEDMORE;
	392
	393	/* XXX stub */
	394
	395	state->readpos += sizeof(struct text_event_pkt)
	396	+ pkt->length;
	397	return OK;
	398
	399	default:
	400	outputf("RFB: Bad command: %d", state->data[0]);
	401	}
	402	default:
	403	outputf("RFB: Bad state");
	404	return FAIL;
	405	}
	406	}
	407
	408	static err_t rfb_recv(void arg, struct tcp_pcb pcb,
	409	struct pbuf *p, err_t err) {
	410	struct rfb_state *state = arg;
	411
	412	if (state == NULL)
	413
	414	if (err != ERR_OK) {
	415	outputf("RFB: recv err %d", err);
	416	/* FIXME do something better here? */
	417	return ERR_OK;
	418	}
	419
	420	if (p == NULL) {
	421	outputf("RFB: Connection closed");
	422	close_conn(pcb, state);
	423	return ERR_OK;
	424	}
	425
	426	if (p->tot_len > (RFB_BUF_SIZE - state->writepos)) {
	427	/* Overflow! */
	428	outputf("RFB: Overflow!");
	429	close_conn(pcb, state);
	430	return ERR_OK;
	431	}
	432
	433	outputf("RFB: Processing %d", p->tot_len);
	434	pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
80726808 JP	435	state->writepos += p->tot_len;
80726808 JP	436
7da36fbd JP	437	tcp_recved(pcb, p->tot_len);
	438	pbuf_free(p);
	439
	440	while (1) {
	441	switch (recv_fsm(pcb, state)) {
	442	case NEEDMORE:
80726808	443	outputf("RFB FSM: blocking");
7da36fbd JP	444	/* Need more data */
	445	return ERR_OK;
	446
	447	case OK:
80726808 JP	448	outputf("RFB FSM: ok");
80726808 JP	449
03bcc4db	450	/* Kick off a send. */
8ceb0515 JP	451	if (state->send_state == SST_IDLE
	452	&& state->update_requested) {
	453	send_fsm(pcb, state);
80726808 JP	454	}
80726808 JP	455
7da36fbd JP	456	if (state->readpos == state->writepos) {
	457	state->readpos = 0;
	458	state->writepos = 0;
	459	return ERR_OK;
	460	} else {
	461	memmove(state->data,
	462	state->data + state->readpos,
	463	state->writepos - state->readpos);
	464	}
	465	break;
	466	case FAIL:
	467	/* Shit */
	468	outputf("RFB: Protocol error");
	469	close_conn(pcb, state);
	470	return ERR_OK;
	471	}
	472	}
	473	}
	474
	475	static err_t rfb_accept(void arg, struct tcp_pcb pcb, err_t err) {
	476	struct rfb_state *state;
	477
	478	LWIP_UNUSED_ARG(arg);
	479	LWIP_UNUSED_ARG(err);
	480
	481	state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));
	482
80726808 JP	483	state->state = ST_BEGIN;
	484	state->readpos = 0;
	485	state->writepos = 0;
8ceb0515 JP	486	state->update_requested = 0;
8ceb0515 JP	487	state->send_state = SST_IDLE;
80726808	488
7da36fbd JP	489	/* XXX: update_server_info() should be called from the 64ms timer, and deal
	490	* with screen resizes appropriately. */
	491	update_server_info();
	492
	493	if (!state)
	494	{
	495	outputf("rfb_accept: out of memory\n");
	496	return ERR_MEM;
	497	}
	498
	499	tcp_arg(pcb, state);
	500	tcp_recv(pcb, rfb_recv);
8ceb0515	501	tcp_sent(pcb, rfb_sent);
7da36fbd JP	502	/*
	503	tcp_err(pcb, rfb_err);
	504	tcp_poll(pcb, rfb_poll, 2);
	505	*/
	506	tcp_write(pcb, "RFB 003.008\n", 12, 0);
	507	tcp_output(pcb);
	508
	509	return ERR_OK;
	510	}
	511
	512	void rfb_init() {
	513	struct tcp_pcb *pcb;
	514
	515	init_server_info();
	516
	517	pcb = tcp_new();
	518	tcp_bind(pcb, IP_ADDR_ANY, RFB_PORT);
	519	pcb = tcp_listen(pcb);
	520	tcp_accept(pcb, rfb_accept);
	521	}