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