vncserver.cc revision 12020:9f290c45493f 
1/*
2 * Copyright (c) 2010, 2015 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 <cstddef>
64#include <cstdio>
65
66#include "base/atomicio.hh"
67#include "base/bitmap.hh"
68#include "base/misc.hh"
69#include "base/output.hh"
70#include "base/socket.hh"
71#include "base/trace.hh"
72#include "debug/VNC.hh"
73#include "sim/byteswap.hh"
74#include "sim/core.hh"
75
76using namespace std;
77
78const PixelConverter VncServer::pixelConverter(
79    4,        // 4 bytes / pixel
80    16, 8, 0, // R in [23, 16], G in [15, 8], B in [7, 0]
81    8, 8, 8,  // 8 bits / channel
82    LittleEndianByteOrder);
83
84/** @file
85 * Implementiation of a VNC server
86 */
87
88/**
89 * Poll event for the listen socket
90 */
91VncServer::ListenEvent::ListenEvent(VncServer *vs, int fd, int e)
92    : PollEvent(fd, e), vncserver(vs)
93{
94}
95
96void
97VncServer::ListenEvent::process(int revent)
98{
99    vncserver->accept();
100}
101
102/**
103 * Poll event for the data socket
104 */
105VncServer::DataEvent::DataEvent(VncServer *vs, int fd, int e)
106    : PollEvent(fd, e), vncserver(vs)
107{
108}
109
110void
111VncServer::DataEvent::process(int revent)
112{
113    if (revent & POLLIN)
114        vncserver->data();
115    else if (revent & POLLNVAL)
116        vncserver->detach();
117}
118
119/**
120 * VncServer
121 */
122VncServer::VncServer(const Params *p)
123    : VncInput(p), listenEvent(NULL), dataEvent(NULL), number(p->number),
124      dataFd(-1), sendUpdate(false),
125      supportsRawEnc(false), supportsResizeEnc(false)
126{
127    if (p->port)
128        listen(p->port);
129
130    curState = WaitForProtocolVersion;
131
132    // We currently only support one pixel format. Extract the pixel
133    // representation from our PixelConverter instance and keep it
134    // around for telling the client and making sure it cooperates
135    pixelFormat.bpp = 8 * pixelConverter.length;
136    pixelFormat.depth = pixelConverter.depth;
137    pixelFormat.bigendian = pixelConverter.byte_order == BigEndianByteOrder;
138    pixelFormat.truecolor = 1;
139    pixelFormat.redmax = pixelConverter.ch_r.mask;
140    pixelFormat.greenmax = pixelConverter.ch_g.mask;
141    pixelFormat.bluemax = pixelConverter.ch_b.mask;
142    pixelFormat.redshift = pixelConverter.ch_r.offset;
143    pixelFormat.greenshift = pixelConverter.ch_g.offset;
144    pixelFormat.blueshift = pixelConverter.ch_b.offset;
145
146    DPRINTF(VNC, "Vnc server created at port %d\n", p->port);
147}
148
149VncServer::~VncServer()
150{
151    if (dataFd != -1)
152        ::close(dataFd);
153
154    if (listenEvent)
155        delete listenEvent;
156
157    if (dataEvent)
158        delete dataEvent;
159}
160
161
162//socket creation and vnc client attach
163void
164VncServer::listen(int port)
165{
166    if (ListenSocket::allDisabled()) {
167        warn_once("Sockets disabled, not accepting vnc client connections");
168        return;
169    }
170
171    while (!listener.listen(port, true)) {
172        DPRINTF(VNC,
173                "can't bind address vnc server port %d in use PID %d\n",
174                port, getpid());
175        port++;
176    }
177
178    int p1, p2;
179    p2 = name().rfind('.') - 1;
180    p1 = name().rfind('.', p2);
181    ccprintf(cerr, "Listening for %s connection on port %d\n",
182             name().substr(p1 + 1, p2 - p1), port);
183
184    listenEvent = new ListenEvent(this, listener.getfd(), POLLIN);
185    pollQueue.schedule(listenEvent);
186}
187
188// attach a vnc client
189void
190VncServer::accept()
191{
192    // As a consequence of being called from the PollQueue, we might
193    // have been called from a different thread. Migrate to "our"
194    // thread.
195    EventQueue::ScopedMigration migrate(eventQueue());
196
197    if (!listener.islistening())
198        panic("%s: cannot accept a connection if not listening!", name());
199
200    int fd = listener.accept(true);
201    if (fd < 0) {
202        warn("%s: failed to accept VNC connection!", name());
203        return;
204    }
205
206    if (dataFd != -1) {
207        char message[] = "vnc server already attached!\n";
208        atomic_write(fd, message, sizeof(message));
209        ::close(fd);
210        return;
211    }
212
213    dataFd = fd;
214
215    // Send our version number to the client
216    write((uint8_t *)vncVersion(), strlen(vncVersion()));
217
218    // read the client response
219    dataEvent = new DataEvent(this, dataFd, POLLIN);
220    pollQueue.schedule(dataEvent);
221
222    inform("VNC client attached\n");
223}
224
225// data called by data event
226void
227VncServer::data()
228{
229    // We have new data, see if we can handle it
230    DPRINTF(VNC, "Vnc client message recieved\n");
231
232    switch (curState) {
233      case WaitForProtocolVersion:
234        checkProtocolVersion();
235        break;
236      case WaitForSecurityResponse:
237        checkSecurity();
238        break;
239      case WaitForClientInit:
240        // Don't care about shared, just need to read it out of the socket
241        uint8_t shared;
242        if (!read(&shared))
243            return;
244
245        // Send our idea of the frame buffer
246        sendServerInit();
247
248        break;
249      case NormalPhase:
250        uint8_t message_type;
251        if (!read(&message_type))
252            return;
253
254        switch (message_type) {
255          case ClientSetPixelFormat:
256            setPixelFormat();
257            break;
258          case ClientSetEncodings:
259            setEncodings();
260            break;
261          case ClientFrameBufferUpdate:
262            requestFbUpdate();
263            break;
264          case ClientKeyEvent:
265            recvKeyboardInput();
266            break;
267          case ClientPointerEvent:
268            recvPointerInput();
269            break;
270          case ClientCutText:
271            recvCutText();
272            break;
273          default:
274            warn("Unimplemented message type recv from client: %d\n",
275                 message_type);
276            detach();
277            break;
278        }
279        break;
280      default:
281        panic("Unknown vnc server state\n");
282    }
283}
284
285
286// read from socket
287bool
288VncServer::read(uint8_t *buf, size_t len)
289{
290    if (dataFd < 0)
291        panic("vnc not properly attached.\n");
292
293    size_t ret;
294    do {
295        ret = ::read(dataFd, buf, len);
296    } while (ret == -1 && errno == EINTR);
297
298
299    if (ret != len) {
300        DPRINTF(VNC, "Read failed %d.\n", ret);
301        detach();
302        return false;
303    }
304
305    return true;
306}
307
308bool
309VncServer::read1(uint8_t *buf, size_t len)
310{
311    return read(buf + 1, len - 1);
312}
313
314
315template<typename T>
316bool
317VncServer::read(T* val)
318{
319    return read((uint8_t *)val, sizeof(T));
320}
321
322// write to socket
323bool
324VncServer::write(const uint8_t *buf, size_t len)
325{
326    if (dataFd < 0)
327        panic("Vnc client not properly attached.\n");
328
329    ssize_t ret = atomic_write(dataFd, buf, len);
330
331    if (ret != len) {
332        DPRINTF(VNC, "Write failed.\n");
333        detach();
334        return false;
335    }
336
337    return true;
338}
339
340template<typename T>
341bool
342VncServer::write(T* val)
343{
344    return write((uint8_t *)val, sizeof(T));
345}
346
347bool
348VncServer::write(const char* str)
349{
350    return write((uint8_t *)str, strlen(str));
351}
352
353// detach a vnc client
354void
355VncServer::detach()
356{
357    if (dataFd != -1) {
358        ::close(dataFd);
359        dataFd = -1;
360    }
361
362    if (!dataEvent || !dataEvent->queued())
363        return;
364
365    pollQueue.remove(dataEvent);
366    delete dataEvent;
367    dataEvent = NULL;
368    curState = WaitForProtocolVersion;
369
370    inform("VNC client detached\n");
371    DPRINTF(VNC, "detach vnc client %d\n", number);
372}
373
374void
375VncServer::sendError(const char* error_msg)
376{
377   uint32_t len = strlen(error_msg);
378   if (!write(&len))
379       return;
380   write(error_msg);
381}
382
383void
384VncServer::checkProtocolVersion()
385{
386    assert(curState == WaitForProtocolVersion);
387
388    size_t len M5_VAR_USED;
389    char version_string[13];
390
391    // Null terminate the message so it's easier to work with
392    version_string[12] = 0;
393
394    if (!read((uint8_t *)version_string, sizeof(version_string) - 1)) {
395        warn("Failed to read protocol version.");
396        return;
397    }
398
399    uint32_t major, minor;
400
401    // Figure out the major/minor numbers
402    if (sscanf(version_string, "RFB %03d.%03d\n", &major, &minor) != 2) {
403        warn(" Malformed protocol version %s\n", version_string);
404        sendError("Malformed protocol version\n");
405        detach();
406        return;
407    }
408
409    DPRINTF(VNC, "Client request protocol version %d.%d\n", major, minor);
410
411    // If it's not 3.X we don't support it
412    if (major != 3 || minor < 2) {
413        warn("Unsupported VNC client version... disconnecting\n");
414        uint8_t err = AuthInvalid;
415        write(&err);
416        detach();
417        return;
418    }
419    // Auth is different based on version number
420    if (minor < 7) {
421        uint32_t sec_type = htobe((uint32_t)AuthNone);
422        if (!write(&sec_type))
423            return;
424    } else {
425        uint8_t sec_cnt = 1;
426        uint8_t sec_type = htobe((uint8_t)AuthNone);
427        if (!write(&sec_cnt) || !write(&sec_type))
428            return;
429    }
430
431    // Wait for client to respond
432    curState = WaitForSecurityResponse;
433}
434
435void
436VncServer::checkSecurity()
437{
438    assert(curState == WaitForSecurityResponse);
439
440    uint8_t security_type;
441    if (!read(&security_type))
442        return;
443
444    if (security_type != AuthNone) {
445        warn("Unknown VNC security type\n");
446        sendError("Unknown security type\n");
447    }
448
449    DPRINTF(VNC, "Sending security auth OK\n");
450
451    uint32_t success = htobe(VncOK);
452    if (!write(&success))
453        return;
454    curState = WaitForClientInit;
455}
456
457void
458VncServer::sendServerInit()
459{
460    ServerInitMsg msg;
461
462    DPRINTF(VNC, "Sending server init message to client\n");
463
464    msg.fbWidth = htobe(videoWidth());
465    msg.fbHeight = htobe(videoHeight());
466
467    msg.px.bpp = htobe(pixelFormat.bpp);
468    msg.px.depth = htobe(pixelFormat.depth);
469    msg.px.bigendian = htobe(pixelFormat.bigendian);
470    msg.px.truecolor = htobe(pixelFormat.truecolor);
471    msg.px.redmax = htobe(pixelFormat.redmax);
472    msg.px.greenmax = htobe(pixelFormat.greenmax);
473    msg.px.bluemax = htobe(pixelFormat.bluemax);
474    msg.px.redshift = htobe(pixelFormat.redshift);
475    msg.px.greenshift = htobe(pixelFormat.greenshift);
476    msg.px.blueshift = htobe(pixelFormat.blueshift);
477    memset(msg.px.padding, 0, 3);
478    msg.namelen = 2;
479    msg.namelen = htobe(msg.namelen);
480    memcpy(msg.name, "M5", 2);
481
482    if (!write(&msg))
483        return;
484    curState = NormalPhase;
485}
486
487void
488VncServer::setPixelFormat()
489{
490    DPRINTF(VNC, "Received pixel format from client message\n");
491
492    PixelFormatMessage pfm;
493    if (!read1((uint8_t *)&pfm, sizeof(PixelFormatMessage)))
494        return;
495
496    DPRINTF(VNC, " -- bpp = %d; depth = %d; be = %d\n", pfm.px.bpp,
497            pfm.px.depth, pfm.px.bigendian);
498    DPRINTF(VNC, " -- true color = %d red,green,blue max = %d,%d,%d\n",
499            pfm.px.truecolor, betoh(pfm.px.redmax), betoh(pfm.px.greenmax),
500                betoh(pfm.px.bluemax));
501    DPRINTF(VNC, " -- red,green,blue shift = %d,%d,%d\n", pfm.px.redshift,
502            pfm.px.greenshift, pfm.px.blueshift);
503
504    if (betoh(pfm.px.bpp) != pixelFormat.bpp ||
505        betoh(pfm.px.depth) != pixelFormat.depth ||
506        betoh(pfm.px.bigendian) != pixelFormat.bigendian ||
507        betoh(pfm.px.truecolor) != pixelFormat.truecolor ||
508        betoh(pfm.px.redmax) != pixelFormat.redmax ||
509        betoh(pfm.px.greenmax) != pixelFormat.greenmax ||
510        betoh(pfm.px.bluemax) != pixelFormat.bluemax ||
511        betoh(pfm.px.redshift) != pixelFormat.redshift ||
512        betoh(pfm.px.greenshift) != pixelFormat.greenshift ||
513        betoh(pfm.px.blueshift) != pixelFormat.blueshift) {
514        warn("VNC client doesn't support true color raw encoding\n");
515        detach();
516    }
517}
518
519void
520VncServer::setEncodings()
521{
522    DPRINTF(VNC, "Received supported encodings from client\n");
523
524    PixelEncodingsMessage pem;
525    if (!read1((uint8_t *)&pem, sizeof(PixelEncodingsMessage)))
526        return;
527
528    pem.num_encodings = betoh(pem.num_encodings);
529
530    DPRINTF(VNC, " -- %d encoding present\n", pem.num_encodings);
531    supportsRawEnc = supportsResizeEnc = false;
532
533    for (int x = 0; x < pem.num_encodings; x++) {
534        int32_t encoding;
535        if (!read(&encoding))
536            return;
537        DPRINTF(VNC, " -- supports %d\n", betoh(encoding));
538
539        switch (betoh(encoding)) {
540          case EncodingRaw:
541            supportsRawEnc = true;
542            break;
543          case EncodingDesktopSize:
544            supportsResizeEnc = true;
545            break;
546        }
547    }
548
549    if (!supportsRawEnc) {
550        warn("VNC clients must always support raw encoding\n");
551        detach();
552    }
553}
554
555void
556VncServer::requestFbUpdate()
557{
558    DPRINTF(VNC, "Received frame buffer update request from client\n");
559
560    FrameBufferUpdateReq fbr;
561    if (!read1((uint8_t *)&fbr, sizeof(FrameBufferUpdateReq)))
562        return;
563
564    fbr.x = betoh(fbr.x);
565    fbr.y = betoh(fbr.y);
566    fbr.width = betoh(fbr.width);
567    fbr.height = betoh(fbr.height);
568
569    DPRINTF(VNC, " -- x = %d y = %d w = %d h = %d\n", fbr.x, fbr.y, fbr.width,
570            fbr.height);
571
572    sendFrameBufferUpdate();
573}
574
575void
576VncServer::recvKeyboardInput()
577{
578    DPRINTF(VNC, "Received keyboard input from client\n");
579    KeyEventMessage kem;
580    if (!read1((uint8_t *)&kem, sizeof(KeyEventMessage)))
581        return;
582
583    kem.key = betoh(kem.key);
584    DPRINTF(VNC, " -- received key code %d (%s)\n", kem.key, kem.down_flag ?
585            "down" : "up");
586
587    if (keyboard)
588        keyboard->keyPress(kem.key, kem.down_flag);
589}
590
591void
592VncServer::recvPointerInput()
593{
594    DPRINTF(VNC, "Received pointer input from client\n");
595    PointerEventMessage pem;
596
597    if (!read1((uint8_t *)&pem, sizeof(PointerEventMessage)))
598        return;
599
600    pem.x = betoh(pem.x);
601    pem.y = betoh(pem.y);
602    DPRINTF(VNC, " -- pointer at x = %d y = %d buttons = %#x\n", pem.x, pem.y,
603            pem.button_mask);
604
605    if (mouse)
606        mouse->mouseAt(pem.x, pem.y, pem.button_mask);
607}
608
609void
610VncServer::recvCutText()
611{
612    DPRINTF(VNC, "Received client copy buffer message\n");
613
614    ClientCutTextMessage cct;
615    if (!read1((uint8_t *)&cct, sizeof(ClientCutTextMessage)))
616        return;
617
618    char str[1025];
619    size_t data_len = betoh(cct.length);
620    DPRINTF(VNC, "String length %d\n", data_len);
621    while (data_len > 0) {
622        size_t bytes_to_read = data_len > 1024 ? 1024 : data_len;
623        if (!read((uint8_t *)&str, bytes_to_read))
624            return;
625        str[bytes_to_read] = 0;
626        data_len -= bytes_to_read;
627        DPRINTF(VNC, "Buffer: %s\n", str);
628    }
629
630}
631
632
633void
634VncServer::sendFrameBufferUpdate()
635{
636
637    if (dataFd <= 0 || curState != NormalPhase || !sendUpdate) {
638        DPRINTF(VNC, "NOT sending framebuffer update\n");
639        return;
640    }
641
642    // The client will request data constantly, unless we throttle it
643    sendUpdate = false;
644
645    DPRINTF(VNC, "Sending framebuffer update\n");
646
647    FrameBufferUpdate fbu;
648    FrameBufferRect fbr;
649
650    fbu.type = ServerFrameBufferUpdate;
651    fbu.num_rects = 1;
652    fbr.x = 0;
653    fbr.y = 0;
654    fbr.width = videoWidth();
655    fbr.height = videoHeight();
656    fbr.encoding = EncodingRaw;
657
658    // fix up endian
659    fbu.num_rects = htobe(fbu.num_rects);
660    fbr.x = htobe(fbr.x);
661    fbr.y = htobe(fbr.y);
662    fbr.width = htobe(fbr.width);
663    fbr.height = htobe(fbr.height);
664    fbr.encoding = htobe(fbr.encoding);
665
666    // send headers to client
667    if (!write(&fbu) || !write(&fbr))
668        return;
669
670    assert(fb);
671
672    std::vector<uint8_t> line_buffer(pixelConverter.length * fb->width());
673    for (int y = 0; y < fb->height(); ++y) {
674        // Convert and send a line at a time
675        uint8_t *raw_pixel(line_buffer.data());
676        for (unsigned x = 0; x < fb->width(); ++x) {
677            pixelConverter.fromPixel(raw_pixel, fb->pixel(x, y));
678            raw_pixel += pixelConverter.length;
679        }
680
681        if (!write(line_buffer.data(), line_buffer.size()))
682            return;
683    }
684}
685
686void
687VncServer::sendFrameBufferResized()
688{
689    assert(fb && dataFd > 0 && curState == NormalPhase);
690    DPRINTF(VNC, "Sending framebuffer resize\n");
691
692    FrameBufferUpdate fbu;
693    FrameBufferRect fbr;
694
695    fbu.type = ServerFrameBufferUpdate;
696    fbu.num_rects = 1;
697    fbr.x = 0;
698    fbr.y = 0;
699    fbr.width = videoWidth();
700    fbr.height = videoHeight();
701    fbr.encoding = EncodingDesktopSize;
702
703    // fix up endian
704    fbu.num_rects = htobe(fbu.num_rects);
705    fbr.x = htobe(fbr.x);
706    fbr.y = htobe(fbr.y);
707    fbr.width = htobe(fbr.width);
708    fbr.height = htobe(fbr.height);
709    fbr.encoding = htobe(fbr.encoding);
710
711    // send headers to client
712    if (!write(&fbu))
713        return;
714    write(&fbr);
715
716    // No actual data is sent in this message
717}
718
719void
720VncServer::setDirty()
721{
722    VncInput::setDirty();
723
724    sendUpdate = true;
725    sendFrameBufferUpdate();
726}
727
728void
729VncServer::frameBufferResized()
730{
731    if (dataFd > 0 && curState == NormalPhase) {
732        if (supportsResizeEnc)
733            sendFrameBufferResized();
734        else
735            // The frame buffer changed size and we can't update the client
736            detach();
737    }
738}
739
740// create the VNC server object
741VncServer *
742VncServerParams::create()
743{
744    return new VncServer(this);
745}
746
747