X-Git-Url: http://git.joshuawise.com/netwatch.git/blobdiff_plain/15521f07dc09a276839c46168201d31ee1ae4a97..53b39ad0d16a7375bc8356da990b2a30b82c9763:/net/rfb.c?ds=sidebyside diff --git a/net/rfb.c b/net/rfb.c index eac1bdd..cd813eb 100644 --- a/net/rfb.c +++ b/net/rfb.c @@ -3,7 +3,10 @@ #include #include +#include "../aseg-paging/keyboard.h" + #include "lwip/tcp.h" +#include "lwip/stats.h" #include "rfb.h" @@ -14,7 +17,10 @@ #define POINTER_EVENT 5 #define CLIENT_CUT_TEXT 6 -#define RFB_BUF_SIZE 64 +#define RFB_BUF_SIZE 512 + +#define SCREEN_CHUNKS_X 8 +#define SCREEN_CHUNKS_Y 8 struct pixel_format { uint8_t bpp; @@ -106,12 +112,24 @@ struct rfb_state { enum { SST_IDLE, - SST_NEEDS_UPDATE, - SST_SENDING + 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_lindex; + + uint32_t chunk_checksum; + + uint32_t chunk_actually_sent; }; static struct server_init_message server_info; @@ -148,75 +166,163 @@ 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->update_requested = 1; + return 1; + } + + return 0; +} + static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) { struct update_header hdr; - int left, sndlength; + int lines_left; + unsigned char * lptr; + 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; - } + while(1) { + + switch (state->send_state) { + + case SST_IDLE: + /* Nothing to do */ + + 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; + } - /* potential FALL THROUGH */ - - case SST_NEEDS_UPDATE: - outputf("RFB send: sending header"); - /* Send a header */ - state->frame_bytes = fb->curmode.xres * fb->curmode.yres * 3; /* XXX */ - 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); + /* FALL THROUGH to SST_HEADER */ + + case SST_HEADER: + + /* 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 = 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); + } - state->update_pos = 0; - state->send_state = SST_SENDING; + 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); + } - /* FALL THROUGH */ + outputf("rfb send: (%d [%d], %d [%d]) %d x %d", + state->chunk_xnum, state->chunk_xpos, + state->chunk_ynum, state->chunk_ypos, + state->chunk_width, state->chunk_height); + + /* 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]) { + outputf("!!!!!!! SKIPPING: %08x", state->chunk_checksum); + if (advance_chunk(state)) + return; + continue; + } + /* Checksum gets set in data block, AFTER the data has been sent. */ + } - case SST_SENDING: - left = state->frame_bytes - state->update_pos; + outputf("actually sent"); + state->chunk_actually_sent = 1; - if (left > tcp_sndbuf(pcb)) { - sndlength = tcp_sndbuf(pcb); - } else { - sndlength = left; - } + /* Send a header */ + hdr.msgtype = 0; + state->chunk_lindex = 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); + lines_left = state->chunk_height; + + err = tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY); - 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; + if (err != ERR_OK) { + if (err != ERR_MEM) + outputf("RFB: header send error %d", err); + + /* Try again later. */ + return; } - } while (err == ERR_MEM && sndlength > 1); - if (err == ERR_OK) { - outputf("RFB: sent %d", sndlength); - state->update_pos += sndlength; - } else { - outputf("RFB: send error %d", err); - } + state->send_state = SST_DATA; - tcp_output(pcb); + /* FALL THROUGH to SST_DATA */ - if (state->update_pos == state->frame_bytes) { - state->send_state = SST_IDLE; - } + case SST_DATA: + + lines_left = state->chunk_height - state->chunk_lindex; + + if (lines_left == 0) { + state->send_state = SST_HEADER; + state->checksums[state->chunk_xnum][state->chunk_ynum] = state->chunk_checksum; + if (advance_chunk(state)) + return; + break; + } + + 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; + } else { + if (err != ERR_MEM) + outputf("RFB: send error %d", err); - break; + return; + } + + if (tcp_sndbuf(pcb) == 0) { + return; + } + } } + + 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) { @@ -225,6 +331,15 @@ 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; + send_fsm(pcb, state); +/* + stats_display(); +*/ + return ERR_OK; +} + static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) { tcp_arg(pcb, NULL); tcp_sent(pcb, NULL); @@ -296,7 +411,7 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) { 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; @@ -334,7 +449,6 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) { for (i = 0; i < ntohs(req->num); i++) { outputf("RFB: Encoding: %d", ntohl(req->encodings[i])); /* XXX ... */ - } state->readpos += pktsize; @@ -355,9 +469,11 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) { 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; @@ -381,13 +497,13 @@ 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: @@ -400,7 +516,7 @@ 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; if (state == NULL) @@ -441,7 +557,7 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb, case OK: outputf("RFB FSM: ok"); - /* Might as well send now... */ + /* Kick off a send. */ if (state->send_state == SST_IDLE && state->update_requested) { send_fsm(pcb, state); @@ -453,8 +569,8 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb, return ERR_OK; } else { memmove(state->data, - state->data + state->readpos, - state->writepos - state->readpos); + state->data + state->readpos, + state->writepos - state->readpos); } break; case FAIL: @@ -479,6 +595,7 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) { state->writepos = 0; state->update_requested = 0; state->send_state = SST_IDLE; + memset(state->checksums, 0, sizeof(state->checksums)); /* XXX: update_server_info() should be called from the 64ms timer, and deal * with screen resizes appropriately. */ @@ -493,9 +610,9 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) { 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);