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 <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
  67 using namespace std;
  68
  69 /** @file
  70  * Implementiation of a VNC server
  71  */
  72
  73 /**
  74  * Poll event for the listen socket
  75  */
  76 VncServer::ListenEvent::ListenEvent(VncServer *vs, int fd, int e)
  77     : PollEvent(fd, e), vncserver(vs)
  78 {
  79 }
  80
  81 void
  82 VncServer::ListenEvent::process(int revent)
  83 {
  84     vncserver->accept();
  85 }
  86
  87 /**
  88  * Poll event for the data socket
  89  */
  90 VncServer::DataEvent::DataEvent(VncServer *vs, int fd, int e)
  91     : PollEvent(fd, e), vncserver(vs)
  92 {
  93 }
  94
  95 void
  96 VncServer::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  */
 107 VncServer::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
 135 VncServer::~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
 149 void
 150 VncServer::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
 175 void
 176 VncServer::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
 209 void
 210 VncServer::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
 274 size_t
 275 VncServer::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
 295 size_t
 296 VncServer::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
 305 template<typename T>
 306 size_t
 307 VncServer::read(T* val)
 308 {
 309     return read((uint8_t*)val, sizeof(T));
 310 }
 311
 312 // write to socket
 313 size_t
 314 VncServer::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
 328 template<typename T>
 329 size_t
 330 VncServer::write(T* val)
 331 {
 332     return write((uint8_t*)val, sizeof(T));
 333 }
 334
 335 size_t
 336 VncServer::write(const char* str)
 337 {
 338     return write((uint8_t*)str, strlen(str));
 339 }
 340
 341 // detach a vnc client
 342 void
 343 VncServer::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
 362 void
 363 VncServer::sendError(const char* error_msg)
 364 {
 365    uint32_t len = strlen(error_msg);
 366    write(&len);
 367    write(error_msg);
 368 }
 369
 370 void
 371 VncServer::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
 417 void
 418 VncServer::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
 439 void
 440 VncServer::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
 468 void
 469 VncServer::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
 497 void
 498 VncServer::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
 531 void
 532 VncServer::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
 550 void
 551 VncServer::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
 565 void
 566 VncServer::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
 582 void
 583 VncServer::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
 606 void
 607 VncServer::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
 654 void
 655 VncServer::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
 686 void
 687 VncServer::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
 704 VncServer *
 705 VncServerParams::create()
 706 {
 707     return new VncServer(this);
 708 }
 709