Be a little bit quieter, and consequentially be a lot bit faster.

[netwatch.git] / net / rfb.c

diff --git a/net/rfb.c b/net/rfb.c
index 65323d16a090ce24c6b48d434dc59802d55c2171..057c406fd2e90a1041baf645d16aa44304d94871 100644 (file)
--- a/net/rfb.c
+++ b/net/rfb.c
@@ -14,7 +14,7 @@
 #define POINTER_EVENT          5
 #define CLIENT_CUT_TEXT                6
 
 #define POINTER_EVENT          5
 #define CLIENT_CUT_TEXT                6
 

-#define RFB_BUF_SIZE   2048
+#define RFB_BUF_SIZE   64

 
 struct pixel_format {
        uint8_t bpp;
 
 struct pixel_format {
        uint8_t bpp;


@@ -75,6 +75,17 @@ struct text_event_pkt {
        char text[];
 };
 
        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,
 struct rfb_state {
        enum {
                ST_BEGIN,


@@ -89,31 +100,41 @@ struct rfb_state {
        int writepos;
 
        char next_update_incremental;
        int writepos;
 
        char next_update_incremental;

+       char update_requested;
+

        struct fb_update_req client_interest_area;
 
        struct fb_update_req client_interest_area;
 

-       int needs_updated;
+       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() {
 };
 
 static struct server_init_message server_info;
 
 static void init_server_info() {

-       server_info.name_length = 8;
+       server_info.name_length = htonl(8);

        memcpy(server_info.name_string, "NetWatch", 8);
 }
 
 static void update_server_info() {
        if (fb != NULL) {
        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;
+               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;
                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_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;
                        server_info.fmt.red_shift = 0;
                        server_info.fmt.green_shift = 8;
                        server_info.fmt.blue_shift = 16;


@@ -122,9 +143,98 @@ static void update_server_info() {
                        outputf("RFB: unknown fb fmt %d", fb->curmode.format);
                        break;
                }
                        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;
+               }
+       
+               /* 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), TCP_WRITE_FLAG_COPY);
+
+               state->update_pos = 0;
+               state->send_state = SST_SENDING;
+
+               /* FALL THROUGH */
+
+       case SST_SENDING:
+               while (1) {
+                       unsigned char mbuf[8192 /* XXX magic */];
+                       
+                       left = state->frame_bytes - state->update_pos;
+
+                       if (left == 0) {
+                               state->send_state = SST_IDLE;
+                               break;
+                       }
+                       
+                       if (left > 8192)
+                               left = 8192;
+
+                       memcpy(mbuf, fb->fbaddr + state->update_pos, left);     /* It's OK if it becomes smaller later. */
+                       
+                       sndlength = left;
+                       do {
+                               err = tcp_write(pcb, mbuf, sndlength, TCP_WRITE_FLAG_COPY /* This is my memory on the stack, thank you very much. */);
+                               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) {
+                               /* We'll just give up for now and come back when we have space later. */
+                               //outputf("RFB: send error %d", err);
+                               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);
 static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {
        tcp_arg(pcb, NULL);
        tcp_sent(pcb, NULL);


@@ -140,6 +250,11 @@ enum fsm_result {
 };
 
 static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
 };
 
 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:
 
        switch(state->state) {
        case ST_BEGIN:


@@ -165,25 +280,33 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                state->readpos += 12;
                state->state = ST_CLIENTINIT;
 
                state->readpos += 12;
                state->state = ST_CLIENTINIT;
 

-               /* We support one security type, currently "none". */
+               /* We support one security type, currently "none".
+                * Send that and SecurityResult. */

                if (state->version >= 7) {
                if (state->version >= 7) {

-                       tcp_write(pcb, "\x01\x01", 2, 0);
+                       tcp_write(pcb, "\x01\x01\x00\x00\x00\x00", 6, 0);

                } else {
                } else {

-                       tcp_write(pcb, "\x01", 1, 0);
+                       tcp_write(pcb, "\x01\x00\x00\x00\x00", 5, 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:
                tcp_output(pcb);
 
                return OK;
 
        case ST_CLIENTINIT:

-               if (state->writepos < 1) return NEEDMORE;
-               state->readpos += 1;
+               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;
 
                state->state = ST_MAIN;
 

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

                tcp_output(pcb);
 
                return OK;
                tcp_output(pcb);
 
                return OK;


@@ -191,12 +314,14 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
        case ST_MAIN:
                if (state->writepos < 1) return NEEDMORE;
 
        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;
                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]);
 /*
                        struct pixel_format * new_fmt =
                                (struct pixel_format *)(&state->data[4]);


@@ -211,20 +336,26 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
 
                        struct set_encs_req * req = (struct set_encs_req *)state->data;
 
 
                        struct set_encs_req * req = (struct set_encs_req *)state->data;
 

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

 
 

-                       /* XXX ... */
+                       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 += (4 * req->num) + sizeof(struct set_encs_req);
+                       state->readpos += pktsize;

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

+                       outputf("RFB: UpdateRequest");

 
 

-                       state->needs_updated = 1;
+                       state->update_requested = 1;

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


@@ -234,6 +365,7 @@ 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;
                case KEY_EVENT:
                        if (state->writepos < sizeof(struct key_event_pkt))
                                return NEEDMORE;

+                       outputf("RFB: Key");

 
                        /* XXX stub */
 
 
                        /* XXX stub */
 


@@ -243,6 +375,7 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                case POINTER_EVENT:
                        if (state->writepos < sizeof(struct pointer_event_pkt))
                                return NEEDMORE;
                case POINTER_EVENT:
                        if (state->writepos < sizeof(struct pointer_event_pkt))
                                return NEEDMORE;

+                       outputf("RFB: Pointer");

 
                        /* XXX stub */
 
 
                        /* XXX stub */
 


@@ -252,6 +385,7 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                case CLIENT_CUT_TEXT:
                        if (state->writepos < sizeof(struct text_event_pkt))
                                return NEEDMORE;
                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;
 
                        struct text_event_pkt * pkt =
                                (struct text_event_pkt *)state->data;


@@ -302,16 +436,27 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
 
        outputf("RFB: Processing %d", p->tot_len);
        pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
 
        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:
        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:
                        /* 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;
                        if (state->readpos == state->writepos) {
                                state->readpos = 0;
                                state->writepos = 0;


@@ -339,6 +484,12 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
 
        state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));
 
 
        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();
        /* XXX: update_server_info() should be called from the 64ms timer, and deal
         * with screen resizes appropriately. */
        update_server_info();


@@ -351,6 +502,7 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
 
        tcp_arg(pcb, state);
        tcp_recv(pcb, rfb_recv);
 
        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_err(pcb, rfb_err);
        tcp_poll(pcb, rfb_poll, 2);