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