src/base/vnc/vncserver.cc

   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 <cstdio>
  46
  47 #include <sys/ioctl.h>
  48 #include <sys/termios.h>
  49 #include <errno.h>
  50 #include <poll.h>
  51 #include <unistd.h>
  52
  53 #include "base/atomicio.hh"
  54 #include "base/misc.hh"
  55 #include "base/socket.hh"
  56 #include "base/trace.hh"
  57 #include "base/vnc/vncserver.hh"
  58 #include "sim/byteswap.hh"
  59
  60 using namespace std;
  61
  62 /**
  63  * Poll event for the listen socket
  64  */
  65 VncServer::ListenEvent::ListenEvent(VncServer *vs, int fd, int e)
  66     : PollEvent(fd, e), vncserver(vs)
  67 {
  68 }
  69
  70 void
  71 VncServer::ListenEvent::process(int revent)
  72 {
  73     vncserver->accept();
  74 }
  75
  76 /**
  77  * Poll event for the data socket
  78  */
  79 VncServer::DataEvent::DataEvent(VncServer *vs, int fd, int e)
  80     : PollEvent(fd, e), vncserver(vs)
  81 {
  82 }
  83
  84 void
  85 VncServer::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  */
  96 VncServer::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
 127 VncServer::~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
 141 void
 142 VncServer::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
 167 void
 168 VncServer::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
 194 void
 195 VncServer::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
 259 size_t
 260 VncServer::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
 280 size_t
 281 VncServer::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
 290 template<typename T>
 291 size_t
 292 VncServer::read(T* val)
 293 {
 294     return read((uint8_t*)val, sizeof(T));
 295 }
 296
 297 // write to socket
 298 size_t
 299 VncServer::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
 313 template<typename T>
 314 size_t
 315 VncServer::write(T* val)
 316 {
 317     return write((uint8_t*)val, sizeof(T));
 318 }
 319
 320 size_t
 321 VncServer::write(const char* str)
 322 {
 323     return write((uint8_t*)str, strlen(str));
 324 }
 325
 326 // detach a vnc client
 327 void
 328 VncServer::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
 347 void
 348 VncServer::sendError(const char* error_msg)
 349 {
 350    uint32_t len = strlen(error_msg);
 351    write(&len);
 352    write(error_msg);
 353 }
 354
 355 void
 356 VncServer::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
 402 void
 403 VncServer::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
 424 void
 425 VncServer::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
 454 void
 455 VncServer::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
 483 void
 484 VncServer::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
 517 void
 518 VncServer::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
 536 void
 537 VncServer::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
 551 void
 552 VncServer::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
 568 void
 569 VncServer::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
 592 void
 593 VncServer::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
 639 void
 640 VncServer::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
 671 void
 672 VncServer::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
 699 VncServer *
 700 VncServerParams::create()
 701 {
 702     return new VncServer(this);
 703 }