vncserver.cc revision 10810 
1/*
2 * Copyright (c) 2010 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder.  You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are
16 * met: redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer;
18 * redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution;
21 * neither the name of the copyright holders nor the names of its
22 * contributors may be used to endorse or promote products derived from
23 * this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 * Authors: Ali Saidi
38 *          William Wang
39 */
40
41/** @file
42 * Implementiation of a VNC server
43 */
44
45#include <sys/ioctl.h>
46#include <sys/stat.h>
47
48#if defined(__FreeBSD__)
49#include <termios.h>
50
51#else
52#include <sys/termios.h>
53
54#endif
55#include "base/vnc/vncserver.hh"
56
57#include <fcntl.h>
58#include <poll.h>
59#include <sys/types.h>
60#include <unistd.h>
61
62#include <cerrno>
63#include <cstdio>
64
65#include "base/atomicio.hh"
66#include "base/bitmap.hh"
67#include "base/misc.hh"
68#include "base/output.hh"
69#include "base/socket.hh"
70#include "base/trace.hh"
71#include "debug/VNC.hh"
72#include "sim/byteswap.hh"
73#include "sim/core.hh"
74
75using namespace std;
76
77/** @file
78 * Implementiation of a VNC server
79 */
80
81/**
82 * Poll event for the listen socket
83 */
84VncServer::ListenEvent::ListenEvent(VncServer *vs, int fd, int e)
85    : PollEvent(fd, e), vncserver(vs)
86{
87}
88
89void
90VncServer::ListenEvent::process(int revent)
91{
92    vncserver->accept();
93}
94
95/**
96 * Poll event for the data socket
97 */
98VncServer::DataEvent::DataEvent(VncServer *vs, int fd, int e)
99    : PollEvent(fd, e), vncserver(vs)
100{
101}
102
103void
104VncServer::DataEvent::process(int revent)
105{
106    if (revent & POLLIN)
107        vncserver->data();
108    else if (revent & POLLNVAL)
109        vncserver->detach();
110}
111
112/**
113 * VncServer
114 */
115VncServer::VncServer(const Params *p)
116    : VncInput(p), listenEvent(NULL), dataEvent(NULL), number(p->number),
117      dataFd(-1), sendUpdate(false),
118      supportsRawEnc(false), supportsResizeEnc(false)
119{
120    if (p->port)
121        listen(p->port);
122
123    curState = WaitForProtocolVersion;
124
125    // currently we only support this one pixel format
126    // unpacked 32bit rgb (rgb888 + 8 bits of nothing/alpha)
127    // keep it around for telling the client and making
128    // sure the client cooperates
129    pixelFormat.bpp = 32;
130    pixelFormat.depth = 24;
131    pixelFormat.bigendian = 0;
132    pixelFormat.truecolor = 1;
133    pixelFormat.redmax = 0xff;
134    pixelFormat.greenmax = 0xff;
135    pixelFormat.bluemax = 0xff;
136    pixelFormat.redshift = 16;
137    pixelFormat.greenshift = 8;
138    pixelFormat.blueshift = 0;
139
140    DPRINTF(VNC, "Vnc server created at port %d\n", p->port);
141}
142
143VncServer::~VncServer()
144{
145    if (dataFd != -1)
146        ::close(dataFd);
147
148    if (listenEvent)
149        delete listenEvent;
150
151    if (dataEvent)
152        delete dataEvent;
153}
154
155
156//socket creation and vnc client attach
157void
158VncServer::listen(int port)
159{
160    if (ListenSocket::allDisabled()) {
161        warn_once("Sockets disabled, not accepting vnc client connections");
162        return;
163    }
164
165    while (!listener.listen(port, true)) {
166        DPRINTF(VNC,
167                "can't bind address vnc server port %d in use PID %d\n",
168                port, getpid());
169        port++;
170    }
171
172    int p1, p2;
173    p2 = name().rfind('.') - 1;
174    p1 = name().rfind('.', p2);
175    ccprintf(cerr, "Listening for %s connection on port %d\n",
176             name().substr(p1 + 1, p2 - p1), port);
177
178    listenEvent = new ListenEvent(this, listener.getfd(), POLLIN);
179    pollQueue.schedule(listenEvent);
180}
181
182// attach a vnc client
183void
184VncServer::accept()
185{
186    // As a consequence of being called from the PollQueue, we might
187    // have been called from a different thread. Migrate to "our"
188    // thread.
189    EventQueue::ScopedMigration migrate(eventQueue());
190
191    if (!listener.islistening())
192        panic("%s: cannot accept a connection if not listening!", name());
193
194    int fd = listener.accept(true);
195    fatal_if(fd < 0, "%s: failed to accept VNC connection!", name());
196
197    if (dataFd != -1) {
198        char message[] = "vnc server already attached!\n";
199        atomic_write(fd, message, sizeof(message));
200        ::close(fd);
201        return;
202    }
203
204    dataFd = fd;
205
206    // Send our version number to the client
207    write((uint8_t*)vncVersion(), strlen(vncVersion()));
208
209    // read the client response
210    dataEvent = new DataEvent(this, dataFd, POLLIN);
211    pollQueue.schedule(dataEvent);
212
213    inform("VNC client attached\n");
214}
215
216// data called by data event
217void
218VncServer::data()
219{
220    // We have new data, see if we can handle it
221    size_t len;
222    DPRINTF(VNC, "Vnc client message recieved\n");
223
224    switch (curState) {
225      case WaitForProtocolVersion:
226        checkProtocolVersion();
227        break;
228      case WaitForSecurityResponse:
229        checkSecurity();
230        break;
231      case WaitForClientInit:
232        // Don't care about shared, just need to read it out of the socket
233        uint8_t shared;
234        len = read(&shared);
235        assert(len == 1);
236
237        // Send our idea of the frame buffer
238        sendServerInit();
239
240        break;
241      case NormalPhase:
242        uint8_t message_type;
243        len = read(&message_type);
244        if (!len) {
245            detach();
246            return;
247        }
248        assert(len == 1);
249
250        switch (message_type) {
251          case ClientSetPixelFormat:
252            setPixelFormat();
253            break;
254          case ClientSetEncodings:
255            setEncodings();
256            break;
257          case ClientFrameBufferUpdate:
258            requestFbUpdate();
259            break;
260          case ClientKeyEvent:
261            recvKeyboardInput();
262            break;
263          case ClientPointerEvent:
264            recvPointerInput();
265            break;
266          case ClientCutText:
267            recvCutText();
268            break;
269          default:
270            panic("Unimplemented message type recv from client: %d\n",
271                  message_type);
272            break;
273        }
274        break;
275      default:
276        panic("Unknown vnc server state\n");
277    }
278}
279
280
281// read from socket
282size_t
283VncServer::read(uint8_t *buf, size_t len)
284{
285    if (dataFd < 0)
286        panic("vnc not properly attached.\n");
287
288    size_t ret;
289    do {
290        ret = ::read(dataFd, buf, len);
291    } while (ret == -1 && errno == EINTR);
292
293
294    if (ret <= 0){
295        DPRINTF(VNC, "Read failed.\n");
296        detach();
297        return 0;
298    }
299
300    return ret;
301}
302
303size_t
304VncServer::read1(uint8_t *buf, size_t len)
305{
306    size_t read_len M5_VAR_USED;
307    read_len = read(buf + 1, len - 1);
308    assert(read_len == len - 1);
309    return read_len;
310}
311
312
313template<typename T>
314size_t
315VncServer::read(T* val)
316{
317    return read((uint8_t*)val, sizeof(T));
318}
319
320// write to socket
321size_t
322VncServer::write(const uint8_t *buf, size_t len)
323{
324    if (dataFd < 0)
325        panic("Vnc client not properly attached.\n");
326
327    ssize_t ret;
328    ret = atomic_write(dataFd, buf, len);
329
330    if (ret < len)
331        detach();
332
333    return ret;
334}
335
336template<typename T>
337size_t
338VncServer::write(T* val)
339{
340    return write((uint8_t*)val, sizeof(T));
341}
342
343size_t
344VncServer::write(const char* str)
345{
346    return write((uint8_t*)str, strlen(str));
347}
348
349// detach a vnc client
350void
351VncServer::detach()
352{
353    if (dataFd != -1) {
354        ::close(dataFd);
355        dataFd = -1;
356    }
357
358    if (!dataEvent || !dataEvent->queued())
359        return;
360
361    pollQueue.remove(dataEvent);
362    delete dataEvent;
363    dataEvent = NULL;
364    curState = WaitForProtocolVersion;
365
366    inform("VNC client detached\n");
367    DPRINTF(VNC, "detach vnc client %d\n", number);
368}
369
370void
371VncServer::sendError(const char* error_msg)
372{
373   uint32_t len = strlen(error_msg);
374   write(&len);
375   write(error_msg);
376}
377
378void
379VncServer::checkProtocolVersion()
380{
381    assert(curState == WaitForProtocolVersion);
382
383    size_t len M5_VAR_USED;
384    char version_string[13];
385
386    // Null terminate the message so it's easier to work with
387    version_string[12] = 0;
388
389    len = read((uint8_t*)version_string, 12);
390    assert(len == 12);
391
392    uint32_t major, minor;
393
394    // Figure out the major/minor numbers
395    if (sscanf(version_string, "RFB %03d.%03d\n", &major, &minor) != 2) {
396        warn(" Malformed protocol version %s\n", version_string);
397        sendError("Malformed protocol version\n");
398        detach();
399    }
400
401    DPRINTF(VNC, "Client request protocol version %d.%d\n", major, minor);
402
403    // If it's not 3.X we don't support it
404    if (major != 3 || minor < 2) {
405        warn("Unsupported VNC client version... disconnecting\n");
406        uint8_t err = AuthInvalid;
407        write(&err);
408        detach();
409    }
410    // Auth is different based on version number
411    if (minor < 7) {
412        uint32_t sec_type = htobe((uint32_t)AuthNone);
413        write(&sec_type);
414    } else {
415        uint8_t sec_cnt = 1;
416        uint8_t sec_type = htobe((uint8_t)AuthNone);
417        write(&sec_cnt);
418        write(&sec_type);
419    }
420
421    // Wait for client to respond
422    curState = WaitForSecurityResponse;
423}
424
425void
426VncServer::checkSecurity()
427{
428    assert(curState == WaitForSecurityResponse);
429
430    uint8_t security_type;
431    size_t len M5_VAR_USED = read(&security_type);
432
433    assert(len == 1);
434
435    if (security_type != AuthNone) {
436        warn("Unknown VNC security type\n");
437        sendError("Unknown security type\n");
438    }
439
440    DPRINTF(VNC, "Sending security auth OK\n");
441
442    uint32_t success = htobe(VncOK);
443    write(&success);
444    curState = WaitForClientInit;
445}
446
447void
448VncServer::sendServerInit()
449{
450    ServerInitMsg msg;
451
452    DPRINTF(VNC, "Sending server init message to client\n");
453
454    msg.fbWidth = htobe(videoWidth());
455    msg.fbHeight = htobe(videoHeight());
456
457    msg.px.bpp = htobe(pixelFormat.bpp);
458    msg.px.depth = htobe(pixelFormat.depth);
459    msg.px.bigendian = htobe(pixelFormat.bigendian);
460    msg.px.truecolor = htobe(pixelFormat.truecolor);
461    msg.px.redmax = htobe(pixelFormat.redmax);
462    msg.px.greenmax = htobe(pixelFormat.greenmax);
463    msg.px.bluemax = htobe(pixelFormat.bluemax);
464    msg.px.redshift = htobe(pixelFormat.redshift);
465    msg.px.greenshift = htobe(pixelFormat.greenshift);
466    msg.px.blueshift = htobe(pixelFormat.blueshift);
467    memset(msg.px.padding, 0, 3);
468    msg.namelen = 2;
469    msg.namelen = htobe(msg.namelen);
470    memcpy(msg.name, "M5", 2);
471
472    write(&msg);
473    curState = NormalPhase;
474}
475
476void
477VncServer::setPixelFormat()
478{
479    DPRINTF(VNC, "Received pixel format from client message\n");
480
481    PixelFormatMessage pfm;
482    read1((uint8_t*)&pfm, sizeof(PixelFormatMessage));
483
484    DPRINTF(VNC, " -- bpp = %d; depth = %d; be = %d\n", pfm.px.bpp,
485            pfm.px.depth, pfm.px.bigendian);
486    DPRINTF(VNC, " -- true color = %d red,green,blue max = %d,%d,%d\n",
487            pfm.px.truecolor, betoh(pfm.px.redmax), betoh(pfm.px.greenmax),
488                betoh(pfm.px.bluemax));
489    DPRINTF(VNC, " -- red,green,blue shift = %d,%d,%d\n", pfm.px.redshift,
490            pfm.px.greenshift, pfm.px.blueshift);
491
492    if (betoh(pfm.px.bpp) != pixelFormat.bpp ||
493        betoh(pfm.px.depth) != pixelFormat.depth ||
494        betoh(pfm.px.bigendian) != pixelFormat.bigendian ||
495        betoh(pfm.px.truecolor) != pixelFormat.truecolor ||
496        betoh(pfm.px.redmax) != pixelFormat.redmax ||
497        betoh(pfm.px.greenmax) != pixelFormat.greenmax ||
498        betoh(pfm.px.bluemax) != pixelFormat.bluemax ||
499        betoh(pfm.px.redshift) != pixelFormat.redshift ||
500        betoh(pfm.px.greenshift) != pixelFormat.greenshift ||
501        betoh(pfm.px.blueshift) != pixelFormat.blueshift)
502        fatal("VNC client doesn't support true color raw encoding\n");
503}
504
505void
506VncServer::setEncodings()
507{
508    DPRINTF(VNC, "Received supported encodings from client\n");
509
510    PixelEncodingsMessage pem;
511    read1((uint8_t*)&pem, sizeof(PixelEncodingsMessage));
512
513    pem.num_encodings = betoh(pem.num_encodings);
514
515    DPRINTF(VNC, " -- %d encoding present\n", pem.num_encodings);
516    supportsRawEnc = supportsResizeEnc = false;
517
518    for (int x = 0; x < pem.num_encodings; x++) {
519        int32_t encoding;
520        size_t len M5_VAR_USED;
521        len = read(&encoding);
522        assert(len == sizeof(encoding));
523        DPRINTF(VNC, " -- supports %d\n", betoh(encoding));
524
525        switch (betoh(encoding)) {
526          case EncodingRaw:
527            supportsRawEnc = true;
528            break;
529          case EncodingDesktopSize:
530            supportsResizeEnc = true;
531            break;
532        }
533    }
534
535    if (!supportsRawEnc)
536        fatal("VNC clients must always support raw encoding\n");
537}
538
539void
540VncServer::requestFbUpdate()
541{
542    DPRINTF(VNC, "Received frame buffer update request from client\n");
543
544    FrameBufferUpdateReq fbr;
545    read1((uint8_t*)&fbr, sizeof(FrameBufferUpdateReq));
546
547    fbr.x = betoh(fbr.x);
548    fbr.y = betoh(fbr.y);
549    fbr.width = betoh(fbr.width);
550    fbr.height = betoh(fbr.height);
551
552    DPRINTF(VNC, " -- x = %d y = %d w = %d h = %d\n", fbr.x, fbr.y, fbr.width,
553            fbr.height);
554
555    sendFrameBufferUpdate();
556}
557
558void
559VncServer::recvKeyboardInput()
560{
561    DPRINTF(VNC, "Received keyboard input from client\n");
562    KeyEventMessage kem;
563    read1((uint8_t*)&kem, sizeof(KeyEventMessage));
564
565    kem.key = betoh(kem.key);
566    DPRINTF(VNC, " -- received key code %d (%s)\n", kem.key, kem.down_flag ?
567            "down" : "up");
568
569    if (keyboard)
570        keyboard->keyPress(kem.key, kem.down_flag);
571}
572
573void
574VncServer::recvPointerInput()
575{
576    DPRINTF(VNC, "Received pointer input from client\n");
577    PointerEventMessage pem;
578
579    read1((uint8_t*)&pem, sizeof(PointerEventMessage));;
580
581    pem.x = betoh(pem.x);
582    pem.y = betoh(pem.y);
583    DPRINTF(VNC, " -- pointer at x = %d y = %d buttons = %#x\n", pem.x, pem.y,
584            pem.button_mask);
585
586    if (mouse)
587        mouse->mouseAt(pem.x, pem.y, pem.button_mask);
588}
589
590void
591VncServer::recvCutText()
592{
593    DPRINTF(VNC, "Received client copy buffer message\n");
594
595    ClientCutTextMessage cct;
596    read1((uint8_t*)&cct, sizeof(ClientCutTextMessage));
597
598    char str[1025];
599    size_t data_len = betoh(cct.length);
600    DPRINTF(VNC, "String length %d\n", data_len);
601    while (data_len > 0) {
602        size_t len;
603        size_t bytes_to_read = data_len > 1024 ? 1024 : data_len;
604        len = read((uint8_t*)&str, bytes_to_read);
605        str[bytes_to_read] = 0;
606        assert(len >= data_len);
607        data_len -= len;
608        DPRINTF(VNC, "Buffer: %s\n", str);
609    }
610
611}
612
613
614void
615VncServer::sendFrameBufferUpdate()
616{
617
618    if (!fbPtr || dataFd <= 0 || curState != NormalPhase || !sendUpdate) {
619        DPRINTF(VNC, "NOT sending framebuffer update\n");
620        return;
621    }
622
623    assert(vc);
624
625    // The client will request data constantly, unless we throttle it
626    sendUpdate = false;
627
628    DPRINTF(VNC, "Sending framebuffer update\n");
629
630    FrameBufferUpdate fbu;
631    FrameBufferRect fbr;
632
633    fbu.type = ServerFrameBufferUpdate;
634    fbu.num_rects = 1;
635    fbr.x = 0;
636    fbr.y = 0;
637    fbr.width = videoWidth();
638    fbr.height = videoHeight();
639    fbr.encoding = EncodingRaw;
640
641    // fix up endian
642    fbu.num_rects = htobe(fbu.num_rects);
643    fbr.x = htobe(fbr.x);
644    fbr.y = htobe(fbr.y);
645    fbr.width = htobe(fbr.width);
646    fbr.height = htobe(fbr.height);
647    fbr.encoding = htobe(fbr.encoding);
648
649    // send headers to client
650    write(&fbu);
651    write(&fbr);
652
653    assert(fbPtr);
654
655    uint8_t *tmp = vc->convert(fbPtr);
656    uint64_t num_pixels = videoWidth() * videoHeight();
657    write(tmp, num_pixels * sizeof(uint32_t));
658    delete [] tmp;
659
660}
661
662void
663VncServer::sendFrameBufferResized()
664{
665    assert(fbPtr && dataFd > 0 && curState == NormalPhase);
666    DPRINTF(VNC, "Sending framebuffer resize\n");
667
668    FrameBufferUpdate fbu;
669    FrameBufferRect fbr;
670
671    fbu.type = ServerFrameBufferUpdate;
672    fbu.num_rects = 1;
673    fbr.x = 0;
674    fbr.y = 0;
675    fbr.width = videoWidth();
676    fbr.height = videoHeight();
677    fbr.encoding = EncodingDesktopSize;
678
679    // fix up endian
680    fbu.num_rects = htobe(fbu.num_rects);
681    fbr.x = htobe(fbr.x);
682    fbr.y = htobe(fbr.y);
683    fbr.width = htobe(fbr.width);
684    fbr.height = htobe(fbr.height);
685    fbr.encoding = htobe(fbr.encoding);
686
687    // send headers to client
688    write(&fbu);
689    write(&fbr);
690
691    // No actual data is sent in this message
692}
693
694void
695VncServer::setFrameBufferParams(VideoConvert::Mode mode, uint16_t width,
696    uint16_t height)
697{
698    VncInput::setFrameBufferParams(mode, width, height);
699
700    if (mode != videoMode || width != videoWidth() || height != videoHeight()) {
701        if (dataFd > 0 && fbPtr && curState == NormalPhase) {
702            if (supportsResizeEnc)
703                sendFrameBufferResized();
704            else
705                // The frame buffer changed size and we can't update the client
706                detach();
707        }
708    }
709}
710
711// create the VNC server object
712VncServer *
713VncServerParams::create()
714{
715    return new VncServer(this);
716}
717
718