X-Git-Url: http://git.joshuawise.com/netwatch.git/blobdiff_plain/b496c2b16e66ba34a8725fb49a1bf27f0588939c..3368351a230f70d5daf36464b2a473e4a8c74c8a:/net/rfb.c?ds=sidebyside diff --git a/net/rfb.c b/net/rfb.c index 5fe1a11..de81688 100644 --- a/net/rfb.c +++ b/net/rfb.c @@ -1,13 +1,24 @@ +/* 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 #include #include #include - -#include "../aseg-paging/keyboard.h" +#include +#include #include "lwip/tcp.h" +#include "lwip/stats.h" -#include "rfb.h" +#define RFB_PORT 5900 #define SET_PIXEL_FORMAT 0 #define SET_ENCODINGS 2 @@ -16,9 +27,9 @@ #define POINTER_EVENT 5 #define CLIENT_CUT_TEXT 6 -#define RFB_BUF_SIZE 64 +#define RFB_BUF_SIZE 1536 -#define SCREEN_CHUNKS_X 16 +#define SCREEN_CHUNKS_X 8 #define SCREEN_CHUNKS_Y 8 struct pixel_format { @@ -93,7 +104,7 @@ struct update_header { struct rfb_state { enum { - ST_BEGIN, + ST_BEGIN = 0, ST_CLIENTINIT, ST_MAIN } state; @@ -110,12 +121,12 @@ struct rfb_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 checksums[SCREEN_CHUNKS_Y][SCREEN_CHUNKS_X]; + uint32_t checksums[SCREEN_CHUNKS_X][SCREEN_CHUNKS_Y]; uint32_t chunk_xnum; uint32_t chunk_ynum; @@ -124,7 +135,14 @@ struct rfb_state { uint32_t chunk_width; uint32_t chunk_height; - uint32_t chunk_lindex; + 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; @@ -161,155 +179,157 @@ static void update_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 lines_left; - char * lptr; + 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; - } - - /* FALL THROUGH to SST_NEEDS_UPDATE */ + while(1) { - case SST_NEEDS_UPDATE: + switch (state->send_state) { - state->chunk_xnum = 0; - state->chunk_ynum = 0; - state->chunk_width = 0; - state->chunk_height = 0; - state->chunk_lindex = 0; - state->send_state = SST_SENDING; + case SST_IDLE: + /* Nothing to do */ - /* FALL THROUGH to 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 */ - case SST_SENDING: + case SST_HEADER: - while (1) { - lines_left = state->chunk_height - state->chunk_lindex; + /* 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. */ - if (lines_left == 0) { - outputf("RFB: (%d [%d], %d [%d]), advancing", - state->chunk_xnum, state->chunk_xpos, - state->chunk_ynum, state->chunk_ypos); + 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); + } - /* Advance to the next chunk if necessary. If - * state->chunk_height is zero, then we are - * arriving here for the first time from - * SST_NEEDS_UPDATE. */ + 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); + } - if (state->chunk_height != 0) { - state->chunk_xnum += 1; - } + /* 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_xnum == SCREEN_CHUNKS_X) { - state->chunk_ynum += 1; - state->chunk_xnum = 0; + if (state->chunk_checksum == state->checksums[state->chunk_xnum][state->chunk_ynum]) { + if (advance_chunk(state)) + return; + continue; } + /* Checksum gets set in data block, AFTER the data has been sent. */ + } - if (state->chunk_ynum == SCREEN_CHUNKS_Y) { - state->send_state = SST_IDLE; - break; - } + state->chunk_actually_sent = 1; - outputf("RFB send: sending header"); + /* 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); - /* 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. */ + err = tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY); - state->chunk_width = fb->curmode.xres / SCREEN_CHUNKS_X; - if (fb->curmode.xres % SCREEN_CHUNKS_X != 0) - state->chunk_width += 1; - 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 (err != ERR_OK) { + if (err != ERR_MEM) + outputf("RFB: header send error %d", err); - state->chunk_height = fb->curmode.yres / SCREEN_CHUNKS_Y; - if (fb->curmode.yres % SCREEN_CHUNKS_Y != 0) - state->chunk_height += 1; - 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); - } + /* Try again later. */ + return; + } - /* Send a header */ - hdr.msgtype = 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); - state->chunk_lindex = 0; - lines_left = state->chunk_height; - - 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); - - /* Crap. Reset chunk_height to 0 so that next time around, - * we'll recalculate this chunk (not advance) and try to - * send the header again. - */ - state->chunk_height = 0; - } + 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; } - do { - outputf("RFB: (%d [%d], %d [%d]), %d x %d, line %d", - state->chunk_xnum, state->chunk_xpos, - state->chunk_ynum, state->chunk_ypos, - state->chunk_width, state->chunk_height, - state->chunk_lindex); - - lptr = fb->fbaddr - + (fb->curmode.xres * fb->curmode.bytestride - * (state->chunk_ypos + state->chunk_lindex)) - + (state->chunk_xpos * fb->curmode.bytestride); - - /* The network card can't DMA from video RAM, - * so use TCP_WRITE_FLAG_COPY. */ - err = tcp_write(pcb, lptr, - fb->curmode.bytestride * state->chunk_width, - TCP_WRITE_FLAG_COPY); - - if (err == ERR_OK) { - state->chunk_lindex += 1; - } + /* That's enough. */ + if (bytes_left > 1400) { + bytes_left = 1400; + } - } while (err == ERR_OK && state->chunk_lindex < state->chunk_height); + err = tcp_write(pcb, state->blockbuf + state->chunk_bytes_sent, + bytes_left, TCP_WRITE_FLAG_COPY); - if (err != ERR_OK) { + if (err == ERR_OK) { + state->chunk_bytes_sent += bytes_left; + } else { if (err != ERR_MEM) outputf("RFB: send error %d", err); - outputf("RFB: that's all for now"); - break; + return; } if (tcp_sndbuf(pcb) == 0) { - break; + return; } } - - break; } if (tcp_output(pcb) != ERR_OK) @@ -322,12 +342,30 @@ 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 { @@ -339,10 +377,10 @@ 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; @@ -401,7 +439,6 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) { case ST_MAIN: if (state->writepos < 1) return NEEDMORE; - outputf("RFB: cmd %d", state->data[0]); switch (state->data[0]) { case SET_PIXEL_FORMAT: @@ -479,17 +516,18 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) { (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"); @@ -498,8 +536,9 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *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) @@ -522,8 +561,10 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb, 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); @@ -533,26 +574,19 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb, 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"); - - /* 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; + 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: @@ -562,38 +596,58 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb, 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); @@ -601,7 +655,7 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) { return ERR_OK; } -void rfb_init() { +static void rfb_init() { struct tcp_pcb *pcb; init_server_info(); @@ -611,3 +665,5 @@ void rfb_init() { pcb = tcp_listen(pcb); tcp_accept(pcb, rfb_accept); } + +PROTOCOL(rfb_init);