]> Joshua Wise's Git repositories - netwatch.git/blob - net/rfb.c
add top-level LICENSE
[netwatch.git] / net / rfb.c
1 #include <stdint.h>
2 #include <minilib.h>
3 #include <output.h>
4 #include <fb.h>
5 #include <keyboard.h>
6
7 #include "lwip/tcp.h"
8 #include "lwip/stats.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
19 #define RFB_BUF_SIZE    1536
20
21 #define SCREEN_CHUNKS_X 8
22 #define SCREEN_CHUNKS_Y 8
23
24 struct pixel_format {
25         uint8_t bpp;
26         uint8_t depth;
27         uint8_t big_endian;
28         uint8_t true_color;
29         uint16_t red_max;
30         uint16_t green_max;
31         uint16_t blue_max;
32         uint8_t red_shift;
33         uint8_t green_shift;
34         uint8_t blue_shift;
35         uint8_t padding[3];
36 };
37
38 struct server_init_message {
39         uint16_t fb_width;
40         uint16_t fb_height;
41         struct pixel_format fmt;
42         uint32_t name_length;
43         char name_string[8];
44 };
45
46 struct fb_update_req {
47         uint8_t msgtype;
48         uint8_t incremental;
49         uint16_t xpos;
50         uint16_t ypos;
51         uint16_t width;
52         uint16_t height;
53 };
54
55 struct set_encs_req {
56         uint8_t msgtype;
57         uint8_t padding;
58         uint16_t num;
59         int32_t encodings[];
60 };
61
62 struct key_event_pkt {
63         uint8_t msgtype;
64         uint8_t downflag;
65         uint8_t pad[2];
66         uint32_t keysym;
67 };
68
69 struct pointer_event_pkt {
70         uint8_t msgtype;
71         uint8_t button_mask;
72         uint16_t x;
73         uint16_t y;
74 };
75
76 struct text_event_pkt {
77         uint8_t msgtype;
78         uint8_t padding[3];
79         uint32_t length;
80         char text[];
81 };
82
83 struct update_header {
84         uint8_t msgtype;
85         uint8_t padding;
86         uint16_t nrects;
87         uint16_t xpos;
88         uint16_t ypos;
89         uint16_t width;
90         uint16_t height;
91         int32_t enctype;
92 };
93
94 struct rfb_state {
95         enum {
96                 ST_BEGIN = 0,
97                 ST_CLIENTINIT,
98                 ST_MAIN
99         } state;
100         int version;
101         int encs_remaining;
102
103         char data[RFB_BUF_SIZE];
104         int readpos;
105         int writepos;
106
107         char next_update_incremental;
108         char update_requested;
109
110         struct fb_update_req client_interest_area;
111
112         enum {
113                 SST_IDLE = 0,
114                 SST_HEADER,
115                 SST_DATA
116         } send_state;
117
118         uint32_t checksums[SCREEN_CHUNKS_X][SCREEN_CHUNKS_Y];
119
120         uint32_t chunk_xnum;
121         uint32_t chunk_ynum;
122         uint32_t chunk_xpos;
123         uint32_t chunk_ypos;
124         uint32_t chunk_width;
125         uint32_t chunk_height;
126
127         uint32_t chunk_bytes_sent;
128         
129         uint32_t chunk_checksum;
130
131         int chunk_actually_sent;
132         int try_in_a_bit;
133
134         char * blockbuf;
135 };
136
137 static struct server_init_message server_info;
138
139 static void init_server_info() {
140         server_info.name_length = htonl(8);
141         memcpy(server_info.name_string, "NetWatch", 8);
142 }
143
144 static void update_server_info() {
145         if (fb != NULL) {
146                 outputf("RFB: setting fmt %d", fb->curmode.format);
147                 server_info.fb_width = htons(fb->curmode.xres);
148                 server_info.fb_height = htons(fb->curmode.yres);
149                 switch (fb->curmode.format) {
150                 case FB_RGB888:
151                         server_info.fmt.bpp = 32;
152                         server_info.fmt.depth = 24;
153                         server_info.fmt.big_endian = 0;
154                         server_info.fmt.true_color = 1;
155                         server_info.fmt.red_max = htons(255);
156                         server_info.fmt.green_max = htons(255);
157                         server_info.fmt.blue_max = htons(255);
158                         server_info.fmt.red_shift = 0;
159                         server_info.fmt.green_shift = 8;
160                         server_info.fmt.blue_shift = 16;
161                         break;
162                 default:
163                         outputf("RFB: unknown fb fmt %d", fb->curmode.format);
164                         break;
165                 }
166         } else {
167                 outputf("RFB: fb null");
168         }
169 }
170
171 static int advance_chunk(struct rfb_state *state) {
172
173         state->chunk_xnum += 1;
174
175         if (state->chunk_xnum == SCREEN_CHUNKS_X) {
176                 state->chunk_ynum += 1;
177                 state->chunk_xnum = 0;
178         }
179
180         if (state->chunk_ynum == SCREEN_CHUNKS_Y) {
181                 state->chunk_ynum = 0;
182                 state->send_state = SST_IDLE;
183                 if (!(state->chunk_actually_sent))
184                         state->try_in_a_bit = 1;
185                         return 1;
186         }
187
188         return 0;
189 }
190
191 static int ceildiv(int a, int b) {
192         int res = a / b;
193         if (a % b != 0) {
194                 res++;
195         }
196         return res;
197 }
198         
199 static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
200         struct update_header hdr;
201         int bytes_left;
202         int totaldim;
203         err_t err;
204
205         while(1) {
206
207                 switch (state->send_state) {
208
209                 case SST_IDLE:
210                         /* Nothing to do */
211
212                         if (state->update_requested) {
213                                 outputf("RFB send: update requested");
214                                 state->update_requested = 0;
215                                 state->chunk_actually_sent = 0;
216                                 state->send_state = SST_HEADER;
217                         } else {
218                                 return;
219                         }
220         
221                         /* FALL THROUGH to SST_HEADER */
222
223                 case SST_HEADER:
224
225                         /* Calculate the width and height for this chunk, remembering
226                          * that if SCREEN_CHUNKS_[XY] do not evenly divide the width and
227                          * height, we may need to have shorter chunks at the edge of
228                          * the screen. */
229
230                         state->chunk_width = ceildiv(fb->curmode.xres, SCREEN_CHUNKS_X);
231                         state->chunk_xpos = state->chunk_width * state->chunk_xnum;
232                         totaldim = state->chunk_width * (state->chunk_xnum + 1);
233                         if (totaldim > fb->curmode.xres) {
234                                 state->chunk_width -= (totaldim - fb->curmode.xres);
235                         }
236
237                         state->chunk_height = ceildiv(fb->curmode.yres, SCREEN_CHUNKS_Y);
238                         state->chunk_ypos = state->chunk_height
239                                                  * state->chunk_ynum;
240                         totaldim = state->chunk_height * (state->chunk_ynum + 1);
241                         if (totaldim > fb->curmode.yres) {
242                                 state->chunk_height -= (totaldim - fb->curmode.yres);
243                         }
244
245                         /* Do we _actually_ need to send this chunk? */
246                         if (fb->checksum_rect) {
247                                 state->chunk_checksum = fb->checksum_rect(state->chunk_xpos, state->chunk_ypos,
248                                                                 state->chunk_width, state->chunk_height);
249
250                                 if (state->chunk_checksum == state->checksums[state->chunk_xnum][state->chunk_ynum]) {
251                                         if (advance_chunk(state))
252                                                 return;
253                                         continue;
254                                 }
255                                 /* Checksum gets set in data block, AFTER the data has been sent. */
256                         }
257
258                         state->chunk_actually_sent = 1;
259
260                         /* Send a header */
261                         hdr.msgtype = 0;
262                         state->chunk_bytes_sent = 0;
263                         hdr.nrects = htons(1);
264                         hdr.xpos = htons(state->chunk_xpos);
265                         hdr.ypos = htons(state->chunk_ypos);
266                         hdr.width = htons(state->chunk_width);
267                         hdr.height= htons(state->chunk_height);
268                         hdr.enctype = htonl(0);
269
270                         err = tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY);
271
272                         if (err != ERR_OK) {
273                                 if (err != ERR_MEM)
274                                         outputf("RFB: header send error %d", err);
275
276                                 /* Try again later. */
277                                 return;
278                         }
279
280                         state->send_state = SST_DATA;
281
282                         /* Snag the data. */
283                         fb->copy_pixels(state->blockbuf,
284                                 state->chunk_xpos, state->chunk_ypos,
285                                 state->chunk_width, state->chunk_height);
286
287                         /* FALL THROUGH to SST_DATA */
288
289                 case SST_DATA:
290
291                         bytes_left = 4 * state->chunk_width * state->chunk_height - state->chunk_bytes_sent;
292
293                         if (bytes_left == 0) {
294                                 state->send_state = SST_HEADER;
295                                 state->checksums[state->chunk_xnum][state->chunk_ynum] = state->chunk_checksum;
296                                 if (advance_chunk(state))
297                                         return;
298                                 break;
299                         }
300
301                         /* That's enough. */
302                         if (bytes_left > 1400) {
303                                 bytes_left = 1400;
304                         }
305
306                         err = tcp_write(pcb, state->blockbuf + state->chunk_bytes_sent,
307                                 bytes_left, TCP_WRITE_FLAG_COPY);
308
309                         if (err == ERR_OK) {
310                                 state->chunk_bytes_sent += bytes_left;
311                         } else {
312                                 if (err != ERR_MEM)
313                                         outputf("RFB: send error %d", err);
314
315                                 return;
316                         }
317                                 
318                         if (tcp_sndbuf(pcb) == 0) {
319                                 return;
320                         }
321                 }
322         }
323         
324         if (tcp_output(pcb) != ERR_OK)
325                 outputf("RFB: tcp_output bailed in send_fsm?");
326 }
327
328 static err_t rfb_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {
329         struct rfb_state *state = arg;
330         send_fsm(pcb, state);
331         return ERR_OK;
332 }
333
334 static err_t rfb_poll(void *arg, struct tcp_pcb *pcb) {
335         struct rfb_state *state = arg;
336         if (state->try_in_a_bit) {
337                 state->try_in_a_bit--;
338                 if (!(state->try_in_a_bit)) {
339                         state->update_requested = 1;
340                 }
341         }
342         send_fsm(pcb, state);
343 /*
344         stats_display();
345 */
346         return ERR_OK;
347 }
348
349 static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {
350         outputf("close_conn: bailing");
351         tcp_arg(pcb, NULL);
352         tcp_sent(pcb, NULL);
353         tcp_recv(pcb, NULL);
354         mem_free(state->blockbuf);
355         mem_free(state);
356         tcp_close(pcb);
357         outputf("close_conn: done");
358 }
359
360 enum fsm_result {
361         NEEDMORE,
362         OK,
363         FAIL
364 };
365
366 static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
367         int i;
368         int pktsize;
369 /*
370         outputf("RFB FSM: st %d rp %d wp %d", state->state, state->readpos,
371                 state->writepos);
372 */
373         switch(state->state) {
374         case ST_BEGIN:
375                 if (state->writepos < 12) return NEEDMORE;
376
377                 if (!strncmp(state->data, "RFB 003.003\n", 12)) {
378                         state->version = 3;
379                 } else if (!strncmp(state->data, "RFB 003.005\n", 12)) {
380                         /* Spec states that "RFB 003.005", an incorrect value,
381                          * should be treated by the server as 3.3. */
382                         state->version = 3;
383                 } else if (!strncmp(state->data, "RFB 003.007\n", 12)) {
384                         state->version = 7;
385                 } else if (!strncmp(state->data, "RFB 003.008\n", 12)) {
386                         state->version = 8;
387                 } else {
388                         outputf("RFB: Negotiation fail");
389                         return FAIL;
390                 }
391
392                 outputf("RFB: Negotiated v3.%d", state->version);
393
394                 state->readpos += 12;
395                 state->state = ST_CLIENTINIT;
396
397                 /* We support one security type, currently "none".
398                  * Send that and SecurityResult. */
399                 if (state->version >= 7) {
400                         tcp_write(pcb, "\x01\x01\x00\x00\x00\x00", 6, 0);
401                 } else {
402                         tcp_write(pcb, "\x01\x00\x00\x00\x00", 5, 0);
403                 }
404
405                 tcp_output(pcb);
406
407                 return OK;
408
409         case ST_CLIENTINIT:
410                 if (state->version >= 7) {
411                         /* Ignore the security type and ClientInit */
412                         if (state->writepos < 2) return NEEDMORE;
413                         state->readpos += 2;
414                 } else {
415                         /* Just ClientInit */
416                         if (state->writepos < 1) return NEEDMORE;
417                         state->readpos += 1;
418                 }
419
420                 state->state = ST_MAIN;
421
422                 outputf("RFB: Sending server info", state->version);
423                 tcp_write(pcb, &server_info, sizeof(server_info), TCP_WRITE_FLAG_COPY);
424                 tcp_output(pcb);
425
426                 return OK;
427
428         case ST_MAIN:
429                 if (state->writepos < 1) return NEEDMORE;
430
431                 switch (state->data[0]) {
432
433                 case SET_PIXEL_FORMAT:
434                         /* SetPixelFormat */
435                         if (state->writepos < (sizeof(struct pixel_format) + 4))
436                                 return NEEDMORE;
437                         outputf("RFB: SetPixelFormat");
438 /*
439                         struct pixel_format * new_fmt =
440                                 (struct pixel_format *)(&state->data[4]);
441 */
442                         /* XXX ... */
443
444                         state->readpos += sizeof(struct pixel_format) + 4;
445                         return OK;
446
447                 case SET_ENCODINGS:
448                         if (state->writepos < 4) return NEEDMORE;
449
450                         struct set_encs_req * req = (struct set_encs_req *)state->data;
451
452                         pktsize = sizeof(struct set_encs_req) + (4 * ntohs(req->num));
453
454                         outputf("RFB: SetEncodings [%d]", ntohs(req->num));
455                         if (state->writepos < pktsize) return NEEDMORE;
456
457                         for (i = 0; i < ntohs(req->num); i++) {
458                                 outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
459                                 /* XXX ... */
460                         }
461
462                         state->readpos += pktsize;
463                         return OK;
464
465                 case FB_UPDATE_REQUEST:
466                         if (state->writepos < sizeof(struct fb_update_req))
467                                 return NEEDMORE;
468                         outputf("RFB: UpdateRequest");
469
470                         state->update_requested = 1;
471                         memcpy(&state->client_interest_area, state->data,
472                                sizeof(struct fb_update_req)); 
473
474                         state->readpos += sizeof(struct fb_update_req);
475                         return OK;
476
477                 case KEY_EVENT:
478                         if (state->writepos < sizeof(struct key_event_pkt))
479                                 return NEEDMORE;
480
481                         struct key_event_pkt * p = (struct key_event_pkt *)state->data;
482
483                         outputf("RFB: Key: %d (%c)", htonl(p->keysym), (htonl(p->keysym) & 0xFF));
484                         kbd_inject_keysym(htonl(p->keysym), p->downflag);
485
486                         state->readpos += sizeof(struct key_event_pkt);
487                         return OK;
488
489                 case POINTER_EVENT:
490                         if (state->writepos < sizeof(struct pointer_event_pkt))
491                                 return NEEDMORE;
492                         outputf("RFB: Pointer");
493
494                         /* XXX stub */
495
496                         state->readpos += sizeof(struct pointer_event_pkt);
497                         return OK;
498
499                 case CLIENT_CUT_TEXT:
500                         if (state->writepos < sizeof(struct text_event_pkt))
501                                 return NEEDMORE;
502                         outputf("RFB: Cut Text");
503
504                         struct text_event_pkt * pkt =
505                                 (struct text_event_pkt *)state->data;
506
507                         if (state->writepos < sizeof(struct text_event_pkt)
508                                               + pkt->length)
509                                 return NEEDMORE;
510
511                         /* XXX stub */
512
513                         state->readpos += sizeof(struct text_event_pkt)
514                                           + pkt->length;
515                         return OK;
516
517                 default:
518                         outputf("RFB: Bad command: %d", state->data[0]);
519                         return FAIL;
520                 }
521         default:
522                 outputf("RFB: Bad state");
523                 return FAIL;
524         }
525 }
526
527 static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
528                       struct pbuf *p, err_t err) {
529         struct rfb_state *state = arg;
530         uint16_t copylen;
531
532         if (state == NULL) 
533
534         if (err != ERR_OK) {
535                 outputf("RFB: recv err %d", err);
536                 /* FIXME do something better here? */
537                 return ERR_OK;
538         }
539
540         if (p == NULL) {
541                 outputf("RFB: Connection closed");
542                 close_conn(pcb, state);
543                 return ERR_OK;
544         }
545
546         if (p->tot_len > (RFB_BUF_SIZE - state->writepos)) {
547                 /* Overflow! */
548                 outputf("RFB: Overflow!");
549                 close_conn(pcb, state);
550                 return ERR_OK;
551         }
552
553         copylen = pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
554
555         outputf("RFB: Processing %d, wp %d, cp %d", p->tot_len, state->writepos, copylen);
556
557         state->writepos += p->tot_len;
558
559         tcp_recved(pcb, p->tot_len);
560         pbuf_free(p);
561
562         while (1) {
563                 switch (recv_fsm(pcb, state)) {
564                 case NEEDMORE:
565                         outputf("RFB FSM: blocking");
566                         goto doneprocessing;
567
568                 case OK:
569                         if (state->readpos == state->writepos) {
570                                 state->readpos = 0;
571                                 state->writepos = 0;
572                                 goto doneprocessing;
573                         } else {
574                                 memmove(state->data,
575                                         state->data + state->readpos,
576                                         state->writepos - state->readpos);
577                                 state->writepos -= state->readpos;
578                                 state->readpos = 0;
579                         }
580                         break;
581                 case FAIL:
582                         /* Shit */
583                         outputf("RFB: Protocol error");
584                         close_conn(pcb, state);
585                         return ERR_OK;
586                 }
587         }
588
589 doneprocessing:
590
591         /* Kick off a send. */
592         if (state->send_state == SST_IDLE && state->update_requested) {
593                 send_fsm(pcb, state);
594         }
595
596         return ERR_OK;
597 }       
598                 
599 static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
600         struct rfb_state *state;
601         char * blockbuf;
602
603         LWIP_UNUSED_ARG(arg);
604         LWIP_UNUSED_ARG(err);
605
606         state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));
607
608         if (!state)
609         {
610                 outputf("rfb_accept: out of memory\n");
611                 return ERR_MEM;
612         }
613
614         memset(state, 0, sizeof(struct rfb_state));
615
616         blockbuf = mem_malloc(ceildiv(fb->curmode.xres, SCREEN_CHUNKS_X)
617                             * ceildiv(fb->curmode.yres, SCREEN_CHUNKS_Y) * 4);
618
619         if (!blockbuf)
620         {
621                 outputf("rfb_accept: out of memory allocating blockbuf\n");
622                 mem_free(state);
623                 return ERR_MEM;
624         }
625
626         state->blockbuf = blockbuf;
627         state->state = ST_BEGIN;
628         state->send_state = SST_IDLE;
629
630         /* XXX: update_server_info() should be called from the 64ms timer, and deal
631          * with screen resizes appropriately. */
632         update_server_info();
633
634         tcp_arg(pcb, state);
635         tcp_recv(pcb, rfb_recv);
636         tcp_sent(pcb, rfb_sent);
637         tcp_poll(pcb, rfb_poll, 1);
638 /*
639         tcp_err(pcb, rfb_err);
640 */
641         tcp_write(pcb, "RFB 003.008\n", 12, 0);
642         tcp_output(pcb);
643
644         return ERR_OK;
645 }
646
647 void rfb_init() {
648         struct tcp_pcb *pcb;
649
650         init_server_info();
651
652         pcb = tcp_new();
653         tcp_bind(pcb, IP_ADDR_ANY, RFB_PORT);
654         pcb = tcp_listen(pcb);
655         tcp_accept(pcb, rfb_accept);
656 }
This page took 0.06144 seconds and 4 git commands to generate.