vncserver.cc revision 10422:148b96b7bc77 
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      supportsRawEnc(false), supportsResizeEnc(false)
111{
112    if (p->port)
113        listen(p->port);
114
115    curState = WaitForProtocolVersion;
116
117    // currently we only support this one pixel format
118    // unpacked 32bit rgb (rgb888 + 8 bits of nothing/alpha)
119    // keep it around for telling the client and making
120    // sure the client cooperates
121    pixelFormat.bpp = 32;
122    pixelFormat.depth = 24;
123    pixelFormat.bigendian = 0;
124    pixelFormat.truecolor = 1;
125    pixelFormat.redmax = 0xff;
126    pixelFormat.greenmax = 0xff;
127    pixelFormat.bluemax = 0xff;
128    pixelFormat.redshift = 16;
129    pixelFormat.greenshift = 8;
130    pixelFormat.blueshift = 0;
131
132    DPRINTF(VNC, "Vnc server created at port %d\n", p->port);
133}
134
135VncServer::~VncServer()
136{
137    if (dataFd != -1)
138        ::close(dataFd);
139
140    if (listenEvent)
141        delete listenEvent;
142
143    if (dataEvent)
144        delete dataEvent;
145}
146
147
148//socket creation and vnc client attach
149void
150VncServer::listen(int port)
151{
152    if (ListenSocket::allDisabled()) {
153        warn_once("Sockets disabled, not accepting vnc client connections");
154        return;
155    }
156
157    while (!listener.listen(port, true)) {
158        DPRINTF(VNC,
159                "can't bind address vnc server port %d in use PID %d\n",
160                port, getpid());
161        port++;
162    }
163
164    int p1, p2;
165    p2 = name().rfind('.') - 1;
166    p1 = name().rfind('.', p2);
167    ccprintf(cerr, "Listening for %s connection on port %d\n",
168             name().substr(p1 + 1, p2 - p1), port);
169
170    listenEvent = new ListenEvent(this, listener.getfd(), POLLIN);
171    pollQueue.schedule(listenEvent);
172}
173
174// attach a vnc client
175void
176VncServer::accept()
177{
178    // As a consequence of being called from the PollQueue, we might
179    // have been called from a different thread. Migrate to "our"
180    // thread.
181    EventQueue::ScopedMigration migrate(eventQueue());
182
183    if (!listener.islistening())
184        panic("%s: cannot accept a connection if not listening!", name());
185
186    int fd = listener.accept(true);
187    fatal_if(fd < 0, "%s: failed to accept VNC connection!", name());
188
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
468void
469VncServer::setPixelFormat()
470{
471    DPRINTF(VNC, "Received pixel format from client message\n");
472
473    PixelFormatMessage pfm;
474    read1((uint8_t*)&pfm, sizeof(PixelFormatMessage));
475
476    DPRINTF(VNC, " -- bpp = %d; depth = %d; be = %d\n", pfm.px.bpp,
477            pfm.px.depth, pfm.px.bigendian);
478    DPRINTF(VNC, " -- true color = %d red,green,blue max = %d,%d,%d\n",
479            pfm.px.truecolor, betoh(pfm.px.redmax), betoh(pfm.px.greenmax),
480                betoh(pfm.px.bluemax));
481    DPRINTF(VNC, " -- red,green,blue shift = %d,%d,%d\n", pfm.px.redshift,
482            pfm.px.greenshift, pfm.px.blueshift);
483
484    if (betoh(pfm.px.bpp) != pixelFormat.bpp ||
485        betoh(pfm.px.depth) != pixelFormat.depth ||
486        betoh(pfm.px.bigendian) != pixelFormat.bigendian ||
487        betoh(pfm.px.truecolor) != pixelFormat.truecolor ||
488        betoh(pfm.px.redmax) != pixelFormat.redmax ||
489        betoh(pfm.px.greenmax) != pixelFormat.greenmax ||
490        betoh(pfm.px.bluemax) != pixelFormat.bluemax ||
491        betoh(pfm.px.redshift) != pixelFormat.redshift ||
492        betoh(pfm.px.greenshift) != pixelFormat.greenshift ||
493        betoh(pfm.px.blueshift) != pixelFormat.blueshift)
494        fatal("VNC client doesn't support true color raw encoding\n");
495}
496
497void
498VncServer::setEncodings()
499{
500    DPRINTF(VNC, "Received supported encodings from client\n");
501
502    PixelEncodingsMessage pem;
503    read1((uint8_t*)&pem, sizeof(PixelEncodingsMessage));
504
505    pem.num_encodings = betoh(pem.num_encodings);
506
507    DPRINTF(VNC, " -- %d encoding present\n", pem.num_encodings);
508    supportsRawEnc = supportsResizeEnc = false;
509
510    for (int x = 0; x < pem.num_encodings; x++) {
511        int32_t encoding;
512        size_t len M5_VAR_USED;
513        len = read(&encoding);
514        assert(len == sizeof(encoding));
515        DPRINTF(VNC, " -- supports %d\n", betoh(encoding));
516
517        switch (betoh(encoding)) {
518          case EncodingRaw:
519            supportsRawEnc = true;
520            break;
521          case EncodingDesktopSize:
522            supportsResizeEnc = true;
523            break;
524        }
525    }
526
527    if (!supportsRawEnc)
528        fatal("VNC clients must always support raw encoding\n");
529}
530
531void
532VncServer::requestFbUpdate()
533{
534    DPRINTF(VNC, "Received frame buffer update request from client\n");
535
536    FrameBufferUpdateReq fbr;
537    read1((uint8_t*)&fbr, sizeof(FrameBufferUpdateReq));
538
539    fbr.x = betoh(fbr.x);
540    fbr.y = betoh(fbr.y);
541    fbr.width = betoh(fbr.width);
542    fbr.height = betoh(fbr.height);
543
544    DPRINTF(VNC, " -- x = %d y = %d w = %d h = %d\n", fbr.x, fbr.y, fbr.width,
545            fbr.height);
546
547    sendFrameBufferUpdate();
548}
549
550void
551VncServer::recvKeyboardInput()
552{
553    DPRINTF(VNC, "Received keyboard input from client\n");
554    KeyEventMessage kem;
555    read1((uint8_t*)&kem, sizeof(KeyEventMessage));
556
557    kem.key = betoh(kem.key);
558    DPRINTF(VNC, " -- received key code %d (%s)\n", kem.key, kem.down_flag ?
559            "down" : "up");
560
561    if (keyboard)
562        keyboard->keyPress(kem.key, kem.down_flag);
563}
564
565void
566VncServer::recvPointerInput()
567{
568    DPRINTF(VNC, "Received pointer input from client\n");
569    PointerEventMessage pem;
570
571    read1((uint8_t*)&pem, sizeof(PointerEventMessage));;
572
573    pem.x = betoh(pem.x);
574    pem.y = betoh(pem.y);
575    DPRINTF(VNC, " -- pointer at x = %d y = %d buttons = %#x\n", pem.x, pem.y,
576            pem.button_mask);
577
578    if (mouse)
579        mouse->mouseAt(pem.x, pem.y, pem.button_mask);
580}
581
582void
583VncServer::recvCutText()
584{
585    DPRINTF(VNC, "Received client copy buffer message\n");
586
587    ClientCutTextMessage cct;
588    read1((uint8_t*)&cct, sizeof(ClientCutTextMessage));
589
590    char str[1025];
591    size_t data_len = betoh(cct.length);
592    DPRINTF(VNC, "String length %d\n", data_len);
593    while (data_len > 0) {
594        size_t len;
595        size_t bytes_to_read = data_len > 1024 ? 1024 : data_len;
596        len = read((uint8_t*)&str, bytes_to_read);
597        str[bytes_to_read] = 0;
598        assert(len >= data_len);
599        data_len -= len;
600        DPRINTF(VNC, "Buffer: %s\n", str);
601    }
602
603}
604
605
606void
607VncServer::sendFrameBufferUpdate()
608{
609
610    if (!fbPtr || dataFd <= 0 || curState != NormalPhase || !sendUpdate) {
611        DPRINTF(VNC, "NOT sending framebuffer update\n");
612        return;
613    }
614
615    assert(vc);
616
617    // The client will request data constantly, unless we throttle it
618    sendUpdate = false;
619
620    DPRINTF(VNC, "Sending framebuffer update\n");
621
622    FrameBufferUpdate fbu;
623    FrameBufferRect fbr;
624
625    fbu.type = ServerFrameBufferUpdate;
626    fbu.num_rects = 1;
627    fbr.x = 0;
628    fbr.y = 0;
629    fbr.width = videoWidth();
630    fbr.height = videoHeight();
631    fbr.encoding = EncodingRaw;
632
633    // fix up endian
634    fbu.num_rects = htobe(fbu.num_rects);
635    fbr.x = htobe(fbr.x);
636    fbr.y = htobe(fbr.y);
637    fbr.width = htobe(fbr.width);
638    fbr.height = htobe(fbr.height);
639    fbr.encoding = htobe(fbr.encoding);
640
641    // send headers to client
642    write(&fbu);
643    write(&fbr);
644
645    assert(fbPtr);
646
647    uint8_t *tmp = vc->convert(fbPtr);
648    uint64_t num_pixels = videoWidth() * videoHeight();
649    write(tmp, num_pixels * sizeof(uint32_t));
650    delete [] tmp;
651
652}
653
654void
655VncServer::sendFrameBufferResized()
656{
657    assert(fbPtr && 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, uint16_t width,
688    uint16_t height)
689{
690    VncInput::setFrameBufferParams(mode, width, height);
691
692    if (mode != videoMode || width != videoWidth() || height != videoHeight()) {
693        if (dataFd > 0 && fbPtr && curState == NormalPhase) {
694            if (supportsResizeEnc)
695                sendFrameBufferResized();
696            else
697                // The frame buffer changed size and we can't update the client
698                detach();
699        }
700    }
701}
702
703// create the VNC server object
704VncServer *
705VncServerParams::create()
706{
707    return new VncServer(this);
708}
709
710