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