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