+/* rfb.c
+ * Remote framebuffer server
+ * NetWatch system management mode administration console
+ *
+ * Copyright (c) 2008 Jacob Potter and Joshua Wise. All rights reserved.
+ * This program is free software; you can redistribute and/or modify it under
+ * the terms found in the file LICENSE in the root of this source tree.
+ *
+ */
+
#include <stdint.h>
#include <minilib.h>
#include <output.h>
#include <fb.h>
+#include <keyboard.h>
+#include <tables.h>
#include "lwip/tcp.h"
+#include "lwip/stats.h"
-#include "rfb.h"
+#define RFB_PORT 5900
#define SET_PIXEL_FORMAT 0
#define SET_ENCODINGS 2
#define POINTER_EVENT 5
#define CLIENT_CUT_TEXT 6
-#define RFB_BUF_SIZE 64
+#define RFB_BUF_SIZE 1536
+
+#define SCREEN_CHUNKS_X 8
+#define SCREEN_CHUNKS_Y 8
struct pixel_format {
uint8_t bpp;
struct rfb_state {
enum {
- ST_BEGIN,
+ ST_BEGIN = 0,
ST_CLIENTINIT,
ST_MAIN
} state;
struct fb_update_req client_interest_area;
enum {
- SST_IDLE,
- SST_NEEDS_UPDATE,
- SST_SENDING
+ SST_IDLE = 0,
+ SST_HEADER,
+ SST_DATA
} send_state;
- uint32_t update_pos;
- uint32_t frame_bytes;
+ uint32_t checksums[SCREEN_CHUNKS_X][SCREEN_CHUNKS_Y];
+
+ uint32_t chunk_xnum;
+ uint32_t chunk_ynum;
+ uint32_t chunk_xpos;
+ uint32_t chunk_ypos;
+ uint32_t chunk_width;
+ uint32_t chunk_height;
+
+ uint32_t chunk_bytes_sent;
+
+ uint32_t chunk_checksum;
+
+ int chunk_actually_sent;
+ int try_in_a_bit;
+
+ char * blockbuf;
};
static struct server_init_message server_info;
}
}
+static int advance_chunk(struct rfb_state *state) {
+
+ state->chunk_xnum += 1;
+
+ if (state->chunk_xnum == SCREEN_CHUNKS_X) {
+ state->chunk_ynum += 1;
+ state->chunk_xnum = 0;
+ }
+
+ if (state->chunk_ynum == SCREEN_CHUNKS_Y) {
+ state->chunk_ynum = 0;
+ state->send_state = SST_IDLE;
+ if (!(state->chunk_actually_sent))
+ state->try_in_a_bit = 1;
+ return 1;
+ }
+
+ return 0;
+}
+
+static int ceildiv(int a, int b) {
+ int res = a / b;
+ if (a % b != 0) {
+ res++;
+ }
+ return res;
+}
+
static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
struct update_header hdr;
- int left, sndlength;
+ int bytes_left;
+ int totaldim;
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;
- }
-
- /* potential FALL THROUGH */
-
- 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), 0);
- tcp_output(pcb);
+ while(1) {
- state->update_pos = 0;
- state->send_state = SST_SENDING;
+ switch (state->send_state) {
- /* FALL THROUGH */
+ case SST_IDLE:
+ /* Nothing to do */
- case SST_SENDING:
+ if (state->update_requested) {
+ outputf("RFB send: update requested");
+ state->update_requested = 0;
+ state->chunk_actually_sent = 0;
+ state->send_state = SST_HEADER;
+ } else {
+ return;
+ }
+
+ /* FALL THROUGH to SST_HEADER */
- while (1) {
- left = state->frame_bytes - state->update_pos;
+ case SST_HEADER:
- if (left == 0) {
- state->send_state = SST_IDLE;
- break;
+ /* Calculate the width and height for this chunk, remembering
+ * that if SCREEN_CHUNKS_[XY] do not evenly divide the width and
+ * height, we may need to have shorter chunks at the edge of
+ * the screen. */
+
+ state->chunk_width = ceildiv(fb->curmode.xres, SCREEN_CHUNKS_X);
+ state->chunk_xpos = state->chunk_width * state->chunk_xnum;
+ totaldim = state->chunk_width * (state->chunk_xnum + 1);
+ if (totaldim > fb->curmode.xres) {
+ state->chunk_width -= (totaldim - fb->curmode.xres);
}
- if (left > tcp_mss(pcb)) {
- sndlength = tcp_mss(pcb);
- } else {
- sndlength = left;
+ state->chunk_height = ceildiv(fb->curmode.yres, SCREEN_CHUNKS_Y);
+ state->chunk_ypos = state->chunk_height
+ * state->chunk_ynum;
+ totaldim = state->chunk_height * (state->chunk_ynum + 1);
+ if (totaldim > fb->curmode.yres) {
+ state->chunk_height -= (totaldim - fb->curmode.yres);
}
- do {
- err = tcp_write(pcb, fb->fbaddr + state->update_pos, sndlength, 0);
- if (err == ERR_MEM) {
- outputf("RFB: ERR_MEM sending %d", sndlength);
- sndlength /= 2;
+ /* Do we _actually_ need to send this chunk? */
+ if (fb->checksum_rect) {
+ state->chunk_checksum = fb->checksum_rect(state->chunk_xpos, state->chunk_ypos,
+ state->chunk_width, state->chunk_height);
+
+ if (state->chunk_checksum == state->checksums[state->chunk_xnum][state->chunk_ynum]) {
+ if (advance_chunk(state))
+ return;
+ continue;
}
- } while (err == ERR_MEM && sndlength > 1);
+ /* Checksum gets set in data block, AFTER the data has been sent. */
+ }
- if (err == ERR_OK) {
- outputf("RFB: attempting send %d", sndlength);
- } else {
- outputf("RFB: send error %d", err);
- break;
+ state->chunk_actually_sent = 1;
+
+ /* Send a header */
+ hdr.msgtype = 0;
+ state->chunk_bytes_sent = 0;
+ hdr.nrects = htons(1);
+ hdr.xpos = htons(state->chunk_xpos);
+ hdr.ypos = htons(state->chunk_ypos);
+ hdr.width = htons(state->chunk_width);
+ hdr.height= htons(state->chunk_height);
+ hdr.enctype = htonl(0);
+
+ err = tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY);
+
+ if (err != ERR_OK) {
+ if (err != ERR_MEM)
+ outputf("RFB: header send error %d", err);
+
+ /* Try again later. */
+ return;
}
- if (tcp_output(pcb) != ERR_OK) {
- outputf("RFB: tcp_output has had enough");
+ state->send_state = SST_DATA;
+
+ /* Snag the data. */
+ fb->copy_pixels(state->blockbuf,
+ state->chunk_xpos, state->chunk_ypos,
+ state->chunk_width, state->chunk_height);
+
+ /* FALL THROUGH to SST_DATA */
+
+ case SST_DATA:
+
+ bytes_left = 4 * state->chunk_width * state->chunk_height - state->chunk_bytes_sent;
+
+ if (bytes_left == 0) {
+ state->send_state = SST_HEADER;
+ state->checksums[state->chunk_xnum][state->chunk_ynum] = state->chunk_checksum;
+ if (advance_chunk(state))
+ return;
break;
}
- state->update_pos += sndlength;
+ /* That's enough. */
+ if (bytes_left > 1400) {
+ bytes_left = 1400;
+ }
+
+ err = tcp_write(pcb, state->blockbuf + state->chunk_bytes_sent,
+ bytes_left, TCP_WRITE_FLAG_COPY);
+ if (err == ERR_OK) {
+ state->chunk_bytes_sent += bytes_left;
+ } else {
+ if (err != ERR_MEM)
+ outputf("RFB: send error %d", err);
+
+ return;
+ }
+
if (tcp_sndbuf(pcb) == 0) {
- break;
+ return;
}
}
-
- 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) {
return ERR_OK;
}
+static err_t rfb_poll(void *arg, struct tcp_pcb *pcb) {
+ struct rfb_state *state = arg;
+ if (state->try_in_a_bit) {
+ state->try_in_a_bit--;
+ if (!(state->try_in_a_bit)) {
+ state->update_requested = 1;
+ }
+ }
+ send_fsm(pcb, state);
+/*
+ stats_display();
+*/
+ return ERR_OK;
+}
+
static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {
+ outputf("close_conn: bailing");
tcp_arg(pcb, NULL);
tcp_sent(pcb, NULL);
tcp_recv(pcb, NULL);
+ mem_free(state->blockbuf);
mem_free(state);
tcp_close(pcb);
+ outputf("close_conn: done");
}
enum fsm_result {
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;
state->state = ST_MAIN;
outputf("RFB: Sending server info", state->version);
- tcp_write(pcb, &server_info, sizeof(server_info), 0);
+ 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:
for (i = 0; i < ntohs(req->num); i++) {
outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
/* XXX ... */
-
}
state->readpos += pktsize;
case KEY_EVENT:
if (state->writepos < sizeof(struct key_event_pkt))
return NEEDMORE;
- outputf("RFB: Key");
- /* XXX stub */
+ struct key_event_pkt * p = (struct key_event_pkt *)state->data;
+
+ outputf("RFB: Key: %d (%c)", htonl(p->keysym), (htonl(p->keysym) & 0xFF));
+ kbd_inject_keysym(htonl(p->keysym), p->downflag);
state->readpos += sizeof(struct key_event_pkt);
return OK;
(struct text_event_pkt *)state->data;
if (state->writepos < sizeof(struct text_event_pkt)
- + pkt->length)
+ + pkt->length)
return NEEDMORE;
/* XXX stub */
state->readpos += sizeof(struct text_event_pkt)
- + pkt->length;
+ + pkt->length;
return OK;
default:
outputf("RFB: Bad command: %d", state->data[0]);
+ return FAIL;
}
default:
outputf("RFB: Bad state");
}
static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
- struct pbuf *p, err_t err) {
+ struct pbuf *p, err_t err) {
struct rfb_state *state = arg;
+ uint16_t copylen;
if (state == NULL)
return ERR_OK;
}
- outputf("RFB: Processing %d", p->tot_len);
- pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
+ copylen = pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
+
+ outputf("RFB: Processing %d, wp %d, cp %d", p->tot_len, state->writepos, copylen);
+
state->writepos += p->tot_len;
tcp_recved(pcb, p->tot_len);
switch (recv_fsm(pcb, state)) {
case NEEDMORE:
outputf("RFB FSM: blocking");
- /* Need more data */
- return ERR_OK;
+ goto doneprocessing;
case OK:
- outputf("RFB FSM: ok");
-
- /* Might as well send now... */
- 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;
+ goto doneprocessing;
} else {
memmove(state->data,
- state->data + state->readpos,
- state->writepos - state->readpos);
+ state->data + state->readpos,
+ state->writepos - state->readpos);
+ state->writepos -= state->readpos;
+ state->readpos = 0;
}
break;
case FAIL:
return ERR_OK;
}
}
+
+doneprocessing:
+
+ /* Kick off a send. */
+ if (state->send_state == SST_IDLE && state->update_requested) {
+ send_fsm(pcb, state);
+ }
+
+ return ERR_OK;
}
static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
struct rfb_state *state;
+ char * blockbuf;
LWIP_UNUSED_ARG(arg);
LWIP_UNUSED_ARG(err);
state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));
+ if (!state)
+ {
+ outputf("rfb_accept: out of memory\n");
+ return ERR_MEM;
+ }
+
+ memset(state, 0, sizeof(struct rfb_state));
+
+ blockbuf = mem_malloc(ceildiv(fb->curmode.xres, SCREEN_CHUNKS_X)
+ * ceildiv(fb->curmode.yres, SCREEN_CHUNKS_Y) * 4);
+
+ if (!blockbuf)
+ {
+ outputf("rfb_accept: out of memory allocating blockbuf\n");
+ mem_free(state);
+ return ERR_MEM;
+ }
+
+ state->blockbuf = blockbuf;
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_poll(pcb, rfb_poll, 1);
/*
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() {
+static void rfb_init() {
struct tcp_pcb *pcb;
init_server_info();
pcb = tcp_listen(pcb);
tcp_accept(pcb, rfb_accept);
}
+
+PROTOCOL(rfb_init);
git.joshuawise.com / netwatch.git / blobdiff