git.maemo.org Git - presencevnc/blob - libvnc/libvncserver/sockets.c

   1 /*
   2  * sockets.c - deal with TCP & UDP sockets.
   3  *
   4  * This code should be independent of any changes in the RFB protocol.  It just
   5  * deals with the X server scheduling stuff, calling rfbNewClientConnection and
   6  * rfbProcessClientMessage to actually deal with the protocol.  If a socket
   7  * needs to be closed for any reason then rfbCloseClient should be called, and
   8  * this in turn will call rfbClientConnectionGone.  To make an active
   9  * connection out, call rfbConnect - note that this does _not_ call
  10  * rfbNewClientConnection.
  11  *
  12  * This file is divided into two types of function.  Those beginning with
  13  * "rfb" are specific to sockets using the RFB protocol.  Those without the
  14  * "rfb" prefix are more general socket routines (which are used by the http
  15  * code).
  16  *
  17  * Thanks to Karl Hakimian for pointing out that some platforms return EAGAIN
  18  * not EWOULDBLOCK.
  19  */
  20
  21 /*
  22  *  Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin
  23  *  OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
  24  *  Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge.
  25  *  All Rights Reserved.
  26  *
  27  *  This is free software; you can redistribute it and/or modify
  28  *  it under the terms of the GNU General Public License as published by
  29  *  the Free Software Foundation; either version 2 of the License, or
  30  *  (at your option) any later version.
  31  *
  32  *  This software is distributed in the hope that it will be useful,
  33  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  34  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35  *  GNU General Public License for more details.
  36  *
  37  *  You should have received a copy of the GNU General Public License
  38  *  along with this software; if not, write to the Free Software
  39  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
  40  *  USA.
  41  */
  42
  43 #include <rfb/rfb.h>
  44
  45 #ifdef LIBVNCSERVER_HAVE_SYS_TYPES_H
  46 #include <sys/types.h>
  47 #endif
  48
  49 #ifdef LIBVNCSERVER_HAVE_SYS_TIME_H
  50 #include <sys/time.h>
  51 #endif
  52 #ifdef LIBVNCSERVER_HAVE_SYS_SOCKET_H
  53 #include <sys/socket.h>
  54 #endif
  55 #ifdef LIBVNCSERVER_HAVE_NETINET_IN_H
  56 #include <netinet/in.h>
  57 #include <netinet/tcp.h>
  58 #include <netdb.h>
  59 #include <arpa/inet.h>
  60 #endif
  61 #ifdef LIBVNCSERVER_HAVE_UNISTD_H
  62 #include <unistd.h>
  63 #endif
  64
  65 #if defined(__linux__) && defined(NEED_TIMEVAL)
  66 struct timeval
  67 {
  68    long int tv_sec,tv_usec;
  69 }
  70 ;
  71 #endif
  72
  73 #ifdef LIBVNCSERVER_HAVE_FCNTL_H
  74 #include <fcntl.h>
  75 #endif
  76
  77 #include <errno.h>
  78
  79 #ifdef USE_LIBWRAP
  80 #include <syslog.h>
  81 #include <tcpd.h>
  82 int allow_severity=LOG_INFO;
  83 int deny_severity=LOG_WARNING;
  84 #endif
  85
  86 #if defined(WIN32)
  87 #ifndef __MINGW32__
  88 #pragma warning (disable: 4018 4761)
  89 #endif
  90 #define read(sock,buf,len) recv(sock,buf,len,0)
  91 #define EWOULDBLOCK WSAEWOULDBLOCK
  92 #define ETIMEDOUT WSAETIMEDOUT
  93 #define write(sock,buf,len) send(sock,buf,len,0)
  94 #else
  95 #define closesocket close
  96 #endif
  97
  98 int rfbMaxClientWait = 20000;   /* time (ms) after which we decide client has
  99                                    gone away - needed to stop us hanging */
 100
 101 /*
 102  * rfbInitSockets sets up the TCP and UDP sockets to listen for RFB
 103  * connections.  It does nothing if called again.
 104  */
 105
 106 void
 107 rfbInitSockets(rfbScreenInfoPtr rfbScreen)
 108 {
 109     in_addr_t iface = rfbScreen->listenInterface;
 110
 111     if (rfbScreen->socketState!=RFB_SOCKET_INIT)
 112         return;
 113
 114     rfbScreen->socketState = RFB_SOCKET_READY;
 115
 116     if (rfbScreen->inetdSock != -1) {
 117         const int one = 1;
 118
 119 #ifndef WIN32
 120         if (fcntl(rfbScreen->inetdSock, F_SETFL, O_NONBLOCK) < 0) {
 121             rfbLogPerror("fcntl");
 122             return;
 123         }
 124 #endif
 125
 126         if (setsockopt(rfbScreen->inetdSock, IPPROTO_TCP, TCP_NODELAY,
 127                        (char *)&one, sizeof(one)) < 0) {
 128             rfbLogPerror("setsockopt");
 129             return;
 130         }
 131
 132         FD_ZERO(&(rfbScreen->allFds));
 133         FD_SET(rfbScreen->inetdSock, &(rfbScreen->allFds));
 134         rfbScreen->maxFd = rfbScreen->inetdSock;
 135         return;
 136     }
 137
 138     if(rfbScreen->autoPort) {
 139         int i;
 140         rfbLog("Autoprobing TCP port \n");
 141         for (i = 5900; i < 6000; i++) {
 142             if ((rfbScreen->listenSock = rfbListenOnTCPPort(i, iface)) >= 0) {
 143                 rfbScreen->port = i;
 144                 break;
 145             }
 146         }
 147
 148         if (i >= 6000) {
 149             rfbLogPerror("Failure autoprobing");
 150             return;
 151         }
 152
 153         rfbLog("Autoprobing selected port %d\n", rfbScreen->port);
 154         FD_ZERO(&(rfbScreen->allFds));
 155         FD_SET(rfbScreen->listenSock, &(rfbScreen->allFds));
 156         rfbScreen->maxFd = rfbScreen->listenSock;
 157     }
 158     else if(rfbScreen->port>0) {
 159       rfbLog("Listening for VNC connections on TCP port %d\n", rfbScreen->port);
 160
 161       if ((rfbScreen->listenSock = rfbListenOnTCPPort(rfbScreen->port, iface)) < 0) {
 162         rfbLogPerror("ListenOnTCPPort");
 163         return;
 164       }
 165
 166       FD_ZERO(&(rfbScreen->allFds));
 167       FD_SET(rfbScreen->listenSock, &(rfbScreen->allFds));
 168       rfbScreen->maxFd = rfbScreen->listenSock;
 169     }
 170
 171     if (rfbScreen->udpPort != 0) {
 172         rfbLog("rfbInitSockets: listening for input on UDP port %d\n",rfbScreen->udpPort);
 173
 174         if ((rfbScreen->udpSock = rfbListenOnUDPPort(rfbScreen->udpPort, iface)) < 0) {
 175             rfbLogPerror("ListenOnUDPPort");
 176             return;
 177         }
 178         FD_SET(rfbScreen->udpSock, &(rfbScreen->allFds));
 179         rfbScreen->maxFd = max((int)rfbScreen->udpSock,rfbScreen->maxFd);
 180     }
 181 }
 182
 183 void rfbShutdownSockets(rfbScreenInfoPtr rfbScreen)
 184 {
 185     if (rfbScreen->socketState!=RFB_SOCKET_READY)
 186         return;
 187
 188     rfbScreen->socketState = RFB_SOCKET_SHUTDOWN;
 189
 190     if(rfbScreen->inetdSock>-1) {
 191         closesocket(rfbScreen->inetdSock);
 192         FD_CLR(rfbScreen->inetdSock,&rfbScreen->allFds);
 193         rfbScreen->inetdSock=-1;
 194     }
 195
 196     if(rfbScreen->listenSock>-1) {
 197         closesocket(rfbScreen->listenSock);
 198         FD_CLR(rfbScreen->listenSock,&rfbScreen->allFds);
 199         rfbScreen->listenSock=-1;
 200     }
 201
 202     if(rfbScreen->udpSock>-1) {
 203         closesocket(rfbScreen->udpSock);
 204         FD_CLR(rfbScreen->udpSock,&rfbScreen->allFds);
 205         rfbScreen->udpSock=-1;
 206     }
 207 }
 208
 209 /*
 210  * rfbCheckFds is called from ProcessInputEvents to check for input on the RFB
 211  * socket(s).  If there is input to process, the appropriate function in the
 212  * RFB server code will be called (rfbNewClientConnection,
 213  * rfbProcessClientMessage, etc).
 214  */
 215
 216 int
 217 rfbCheckFds(rfbScreenInfoPtr rfbScreen,long usec)
 218 {
 219     int nfds;
 220     fd_set fds;
 221     struct timeval tv;
 222     struct sockaddr_in addr;
 223     socklen_t addrlen = sizeof(addr);
 224     char buf[6];
 225     const int one = 1;
 226     int sock;
 227     rfbClientIteratorPtr i;
 228     rfbClientPtr cl;
 229     int result = 0;
 230
 231     if (!rfbScreen->inetdInitDone && rfbScreen->inetdSock != -1) {
 232         rfbNewClientConnection(rfbScreen,rfbScreen->inetdSock);
 233         rfbScreen->inetdInitDone = TRUE;
 234     }
 235
 236     do {
 237         memcpy((char *)&fds, (char *)&(rfbScreen->allFds), sizeof(fd_set));
 238         tv.tv_sec = 0;
 239         tv.tv_usec = usec;
 240         nfds = select(rfbScreen->maxFd + 1, &fds, NULL, NULL /* &fds */, &tv);
 241         if (nfds == 0) {
 242             /* timed out, check for async events */
 243             i = rfbGetClientIterator(rfbScreen);
 244             while((cl = rfbClientIteratorNext(i))) {
 245                 if (cl->onHold)
 246                     continue;
 247                 if (FD_ISSET(cl->sock, &(rfbScreen->allFds)))
 248                     rfbSendFileTransferChunk(cl);
 249             }
 250             rfbReleaseClientIterator(i);
 251             return result;
 252         }
 253
 254         if (nfds < 0) {
 255 #ifdef WIN32
 256             errno = WSAGetLastError();
 257 #endif
 258             if (errno != EINTR)
 259                 rfbLogPerror("rfbCheckFds: select");
 260             return -1;
 261         }
 262
 263         result += nfds;
 264
 265         if (rfbScreen->listenSock != -1 && FD_ISSET(rfbScreen->listenSock, &fds)) {
 266
 267             if ((sock = accept(rfbScreen->listenSock,
 268                             (struct sockaddr *)&addr, &addrlen)) < 0) {
 269                 rfbLogPerror("rfbCheckFds: accept");
 270                 return -1;
 271             }
 272
 273 #ifndef WIN32
 274             if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
 275                 rfbLogPerror("rfbCheckFds: fcntl");
 276                 closesocket(sock);
 277                 return -1;
 278             }
 279 #endif
 280
 281             if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
 282                         (char *)&one, sizeof(one)) < 0) {
 283                 rfbLogPerror("rfbCheckFds: setsockopt");
 284                 closesocket(sock);
 285                 return -1;
 286             }
 287
 288 #ifdef USE_LIBWRAP
 289             if(!hosts_ctl("vnc",STRING_UNKNOWN,inet_ntoa(addr.sin_addr),
 290                         STRING_UNKNOWN)) {
 291                 rfbLog("Rejected connection from client %s\n",
 292                         inet_ntoa(addr.sin_addr));
 293                 closesocket(sock);
 294                 return -1;
 295             }
 296 #endif
 297
 298             rfbLog("Got connection from client %s\n", inet_ntoa(addr.sin_addr));
 299
 300             rfbNewClient(rfbScreen,sock);
 301
 302             FD_CLR(rfbScreen->listenSock, &fds);
 303             if (--nfds == 0)
 304                 return result;
 305         }
 306
 307         if ((rfbScreen->udpSock != -1) && FD_ISSET(rfbScreen->udpSock, &fds)) {
 308             if(!rfbScreen->udpClient)
 309                 rfbNewUDPClient(rfbScreen);
 310             if (recvfrom(rfbScreen->udpSock, buf, 1, MSG_PEEK,
 311                         (struct sockaddr *)&addr, &addrlen) < 0) {
 312                 rfbLogPerror("rfbCheckFds: UDP: recvfrom");
 313                 rfbDisconnectUDPSock(rfbScreen);
 314                 rfbScreen->udpSockConnected = FALSE;
 315             } else {
 316                 if (!rfbScreen->udpSockConnected ||
 317                         (memcmp(&addr, &rfbScreen->udpRemoteAddr, addrlen) != 0))
 318                 {
 319                     /* new remote end */
 320                     rfbLog("rfbCheckFds: UDP: got connection\n");
 321
 322                     memcpy(&rfbScreen->udpRemoteAddr, &addr, addrlen);
 323                     rfbScreen->udpSockConnected = TRUE;
 324
 325                     if (connect(rfbScreen->udpSock,
 326                                 (struct sockaddr *)&addr, addrlen) < 0) {
 327                         rfbLogPerror("rfbCheckFds: UDP: connect");
 328                         rfbDisconnectUDPSock(rfbScreen);
 329                         return -1;
 330                     }
 331
 332                     rfbNewUDPConnection(rfbScreen,rfbScreen->udpSock);
 333                 }
 334
 335                 rfbProcessUDPInput(rfbScreen);
 336             }
 337
 338             FD_CLR(rfbScreen->udpSock, &fds);
 339             if (--nfds == 0)
 340                 return result;
 341         }
 342
 343         i = rfbGetClientIterator(rfbScreen);
 344         while((cl = rfbClientIteratorNext(i))) {
 345
 346             if (cl->onHold)
 347                 continue;
 348
 349             if (FD_ISSET(cl->sock, &(rfbScreen->allFds)))
 350             {
 351                 if (FD_ISSET(cl->sock, &fds))
 352                     rfbProcessClientMessage(cl);
 353                 else
 354                     rfbSendFileTransferChunk(cl);
 355             }
 356         }
 357         rfbReleaseClientIterator(i);
 358     } while(rfbScreen->handleEventsEagerly);
 359     return result;
 360 }
 361
 362
 363 void
 364 rfbDisconnectUDPSock(rfbScreenInfoPtr rfbScreen)
 365 {
 366   rfbScreen->udpSockConnected = FALSE;
 367 }
 368
 369
 370
 371 void
 372 rfbCloseClient(rfbClientPtr cl)
 373 {
 374     rfbExtensionData* extension;
 375
 376     for(extension=cl->extensions; extension; extension=extension->next)
 377         if(extension->extension->close)
 378             extension->extension->close(cl, extension->data);
 379
 380     LOCK(cl->updateMutex);
 381 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD
 382     if (cl->sock != -1)
 383 #endif
 384       {
 385         FD_CLR(cl->sock,&(cl->screen->allFds));
 386         if(cl->sock==cl->screen->maxFd)
 387           while(cl->screen->maxFd>0
 388                 && !FD_ISSET(cl->screen->maxFd,&(cl->screen->allFds)))
 389             cl->screen->maxFd--;
 390 #ifndef __MINGW32__
 391         shutdown(cl->sock,SHUT_RDWR);
 392 #endif
 393         closesocket(cl->sock);
 394         cl->sock = -1;
 395       }
 396     TSIGNAL(cl->updateCond);
 397     UNLOCK(cl->updateMutex);
 398 }
 399
 400
 401 /*
 402  * rfbConnect is called to make a connection out to a given TCP address.
 403  */
 404
 405 int
 406 rfbConnect(rfbScreenInfoPtr rfbScreen,
 407            char *host,
 408            int port)
 409 {
 410     int sock;
 411     int one = 1;
 412
 413     rfbLog("Making connection to client on host %s port %d\n",
 414            host,port);
 415
 416     if ((sock = rfbConnectToTcpAddr(host, port)) < 0) {
 417         rfbLogPerror("connection failed");
 418         return -1;
 419     }
 420
 421 #ifndef WIN32
 422     if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
 423         rfbLogPerror("fcntl failed");
 424         closesocket(sock);
 425         return -1;
 426     }
 427 #endif
 428
 429     if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
 430                    (char *)&one, sizeof(one)) < 0) {
 431         rfbLogPerror("setsockopt failed");
 432         closesocket(sock);
 433         return -1;
 434     }
 435
 436     /* AddEnabledDevice(sock); */
 437     FD_SET(sock, &rfbScreen->allFds);
 438     rfbScreen->maxFd = max(sock,rfbScreen->maxFd);
 439
 440     return sock;
 441 }
 442
 443 /*
 444  * ReadExact reads an exact number of bytes from a client.  Returns 1 if
 445  * those bytes have been read, 0 if the other end has closed, or -1 if an error
 446  * occurred (errno is set to ETIMEDOUT if it timed out).
 447  */
 448
 449 int
 450 rfbReadExactTimeout(rfbClientPtr cl, char* buf, int len, int timeout)
 451 {
 452     int sock = cl->sock;
 453     int n;
 454     fd_set fds;
 455     struct timeval tv;
 456
 457     while (len > 0) {
 458         n = read(sock, buf, len);
 459
 460         if (n > 0) {
 461
 462             buf += n;
 463             len -= n;
 464
 465         } else if (n == 0) {
 466
 467             return 0;
 468
 469         } else {
 470 #ifdef WIN32
 471             errno = WSAGetLastError();
 472 #endif
 473             if (errno == EINTR)
 474                 continue;
 475
 476 #ifdef LIBVNCSERVER_ENOENT_WORKAROUND
 477             if (errno != ENOENT)
 478 #endif
 479             if (errno != EWOULDBLOCK && errno != EAGAIN) {
 480                 return n;
 481             }
 482
 483             FD_ZERO(&fds);
 484             FD_SET(sock, &fds);
 485             tv.tv_sec = timeout / 1000;
 486             tv.tv_usec = (timeout % 1000) * 1000;
 487             n = select(sock+1, &fds, NULL, &fds, &tv);
 488             if (n < 0) {
 489                 rfbLogPerror("ReadExact: select");
 490                 return n;
 491             }
 492             if (n == 0) {
 493                 errno = ETIMEDOUT;
 494                 return -1;
 495             }
 496         }
 497     }
 498 #undef DEBUG_READ_EXACT
 499 #ifdef DEBUG_READ_EXACT
 500     rfbLog("ReadExact %d bytes\n",len);
 501     for(n=0;n<len;n++)
 502             fprintf(stderr,"%02x ",(unsigned char)buf[n]);
 503     fprintf(stderr,"\n");
 504 #endif
 505
 506     return 1;
 507 }
 508
 509 int rfbReadExact(rfbClientPtr cl,char* buf,int len)
 510 {
 511   return(rfbReadExactTimeout(cl,buf,len,rfbMaxClientWait));
 512 }
 513
 514 /*
 515  * WriteExact writes an exact number of bytes to a client.  Returns 1 if
 516  * those bytes have been written, or -1 if an error occurred (errno is set to
 517  * ETIMEDOUT if it timed out).
 518  */
 519
 520 int
 521 rfbWriteExact(rfbClientPtr cl,
 522               const char *buf,
 523               int len)
 524 {
 525     int sock = cl->sock;
 526     int n;
 527     fd_set fds;
 528     struct timeval tv;
 529     int totalTimeWaited = 0;
 530
 531 #undef DEBUG_WRITE_EXACT
 532 #ifdef DEBUG_WRITE_EXACT
 533     rfbLog("WriteExact %d bytes\n",len);
 534     for(n=0;n<len;n++)
 535             fprintf(stderr,"%02x ",(unsigned char)buf[n]);
 536     fprintf(stderr,"\n");
 537 #endif
 538
 539     LOCK(cl->outputMutex);
 540     while (len > 0) {
 541         n = write(sock, buf, len);
 542
 543         if (n > 0) {
 544
 545             buf += n;
 546             len -= n;
 547
 548         } else if (n == 0) {
 549
 550             rfbErr("WriteExact: write returned 0?\n");
 551             return 0;
 552
 553         } else {
 554 #ifdef WIN32
 555                         errno = WSAGetLastError();
 556 #endif
 557             if (errno == EINTR)
 558                 continue;
 559
 560             if (errno != EWOULDBLOCK && errno != EAGAIN) {
 561                 UNLOCK(cl->outputMutex);
 562                 return n;
 563             }
 564
 565             /* Retry every 5 seconds until we exceed rfbMaxClientWait.  We
 566                need to do this because select doesn't necessarily return
 567                immediately when the other end has gone away */
 568
 569             FD_ZERO(&fds);
 570             FD_SET(sock, &fds);
 571             tv.tv_sec = 5;
 572             tv.tv_usec = 0;
 573             n = select(sock+1, NULL, &fds, NULL /* &fds */, &tv);
 574             if (n < 0) {
 575                 if(errno==EINTR)
 576                     continue;
 577                 rfbLogPerror("WriteExact: select");
 578                 UNLOCK(cl->outputMutex);
 579                 return n;
 580             }
 581             if (n == 0) {
 582                 totalTimeWaited += 5000;
 583                 if (totalTimeWaited >= rfbMaxClientWait) {
 584                     errno = ETIMEDOUT;
 585                     UNLOCK(cl->outputMutex);
 586                     return -1;
 587                 }
 588             } else {
 589                 totalTimeWaited = 0;
 590             }
 591         }
 592     }
 593     UNLOCK(cl->outputMutex);
 594     return 1;
 595 }
 596
 597 /* currently private, called by rfbProcessArguments() */
 598 int
 599 rfbStringToAddr(char *str, in_addr_t *addr)  {
 600     if (str == NULL || *str == '\0' || strcmp(str, "any") == 0) {
 601         *addr = htonl(INADDR_ANY);
 602     } else if (strcmp(str, "localhost") == 0) {
 603         *addr = htonl(INADDR_LOOPBACK);
 604     } else {
 605         struct hostent *hp;
 606         if ((*addr = inet_addr(str)) == htonl(INADDR_NONE)) {
 607             if (!(hp = gethostbyname(str))) {
 608                 return 0;
 609             }
 610             *addr = *(unsigned long *)hp->h_addr;
 611         }
 612     }
 613     return 1;
 614 }
 615
 616 int
 617 rfbListenOnTCPPort(int port,
 618                    in_addr_t iface)
 619 {
 620     struct sockaddr_in addr;
 621     int sock;
 622     int one = 1;
 623
 624     memset(&addr, 0, sizeof(addr));
 625     addr.sin_family = AF_INET;
 626     addr.sin_port = htons(port);
 627     addr.sin_addr.s_addr = iface;
 628
 629     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 630         return -1;
 631     }
 632     if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 633                    (char *)&one, sizeof(one)) < 0) {
 634         closesocket(sock);
 635         return -1;
 636     }
 637     if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 638         closesocket(sock);
 639         return -1;
 640     }
 641     if (listen(sock, 5) < 0) {
 642         closesocket(sock);
 643         return -1;
 644     }
 645
 646     return sock;
 647 }
 648
 649 int
 650 rfbConnectToTcpAddr(char *host,
 651                     int port)
 652 {
 653     struct hostent *hp;
 654     int sock;
 655     struct sockaddr_in addr;
 656
 657     memset(&addr, 0, sizeof(addr));
 658     addr.sin_family = AF_INET;
 659     addr.sin_port = htons(port);
 660
 661     if ((addr.sin_addr.s_addr = inet_addr(host)) == htonl(INADDR_NONE))
 662     {
 663         if (!(hp = gethostbyname(host))) {
 664             errno = EINVAL;
 665             return -1;
 666         }
 667         addr.sin_addr.s_addr = *(unsigned long *)hp->h_addr;
 668     }
 669
 670     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 671         return -1;
 672     }
 673
 674     if (connect(sock, (struct sockaddr *)&addr, (sizeof(addr))) < 0) {
 675         closesocket(sock);
 676         return -1;
 677     }
 678
 679     return sock;
 680 }
 681
 682 int
 683 rfbListenOnUDPPort(int port,
 684                    in_addr_t iface)
 685 {
 686     struct sockaddr_in addr;
 687     int sock;
 688     int one = 1;
 689
 690     memset(&addr, 0, sizeof(addr));
 691     addr.sin_family = AF_INET;
 692     addr.sin_port = htons(port);
 693     addr.sin_addr.s_addr = iface;
 694
 695     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 696         return -1;
 697     }
 698     if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 699                    (char *)&one, sizeof(one)) < 0) {
 700         return -1;
 701     }
 702     if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 703         return -1;
 704     }
 705
 706     return sock;
 707 }