--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
--- /dev/null
+#!/usr/bin/env perl
+#
+# Copyright (c) 2012 by Marco Zanon <info@marcozanon.com>
+#
+# Mostly based on ultravnc_repeater.pl
+# Copyright (c) 2009-2012 by Karl J. Runge <runge@karlrunge.com>
+#
+# mz_ultravnc_repeater.pl is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or (at
+# your option) any later version.
+#
+# mz_ultravnc_repeater.pl is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with mz_ultravnc_repeater.pl; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA
+# or see <http://www.gnu.org/licenses/>.
+#
+
+my $usage = '
+mz_ultravnc_repeater.pl:
+ perl script implementing the ultravnc repeater
+ proxy protocol.
+
+protocol: Listen on one port for vnc clients (default 5900.)
+ Listen on one port for vnc servers (default 5500.)
+ Read 250 bytes from connecting vnc client or server.
+ Accept ID:<string> from clients and servers, connect them
+ together once both are present.
+
+ The string "RFB 000.000\n" is sent to the client (the client
+ must understand this means send ID:... or host:port.)
+
+ Also accept <host>:<port> from clients and make the
+ connection to the vnc server immediately.
+
+ Note it is up to the client whether to encrypt the subsequent VNC
+ session, etc.
+
+Usage: mz_ultravnc_repeater.pl [options] [client_port [server_port]]
+
+Options:
+
+Use -r to refuse new server/client connections when there is an existing
+server/client ID. The default is to close the previous one. (Same as
+setting the ULTRAVNC_REPEATER_REFUSE env. var.)
+
+Use -l to set the logfile (or set the ULTRAVNC_REPEATER_LOGFILE env. var.)
+E.g. "-l /var/log/repeater.log"
+
+To run an outer loop restarting the server if it exits use "-L" or "-L BG"
+(which are the same as setting the env. var. ULTRAVNC_REPEATER_LOOP=1
+or ULTRAVNC_REPEATER_LOOP=BG) The -L BG mode forks into the background.
+
+Use -p to set a file to store the master pid in for your own tracking
+(same as ULTRAVNC_REPEATER_PIDFILE). For example, a cronjob may supply
+a -p pidfile and check if the process id stored in the file is still
+running before deciding to run this script.
+
+Use -i to add a single ID to the list of valid ones (same as setting all
+valid IDs into ULTRAVNC_REPEATER_VALIDIDS). Note that if you don\'t use
+this option, every ID will be considered valid.
+
+Use -C or set ULTRAVNC_REPEATER_CLEAN=1 to have the script periodically
+check for and close initial connections that have gone away before the
+partner connects (currently only works on Linux.)
+
+Use -R or set ULTRAVNC_REPEATER_NO_RFB=1 to disable sending "RFB 000.000"
+to the client. Then this program acts as general TCP rendezvous tool.
+
+Set the env. var. ULTRAVNC_REPEATER_BUFSIZE to something other than 250
+bytes to modify the ultravnc proxy handshake buffer size for your own
+special application.
+
+You can also set client_port via -c and server_port via -s.
+
+Examples:
+
+ mz_ultravnc_repeater.pl
+ mz_ultravnc_repeater.pl -r
+ mz_ultravnc_repeater.pl -i 123456 -i 234567
+ mz_ultravnc_repeater.pl 5901
+ mz_ultravnc_repeater.pl 5901 5501
+
+ env ULTRAVNC_REPEATER_LOOP=BG ULTRAVNC_REPEATER_LOGFILE=/tmp/u.log mz_ultravnc_repeater.pl ...
+ mz_ultravnc_repeater.pl -L BG -l /tmp/u.log ...
+
+Any ULTRAVNC_REPEATER_* environment variables may also be set as the initial
+arguments on the command line.
+
+This program can also be launched via web server CGI. Please see the
+subroutine check_cgi() in the script for informtion about the query
+names and security issues.
+
+';
+
+use strict;
+
+if (@ARGV && $ARGV[0] =~ /-h/) {
+ print $usage;
+ exit 0;
+}
+
+if ($ENV{ULTRAVNC_REPEATER_DEBUG}) {
+ print STDERR "pwd: ", `pwd`;
+ print STDERR "zero: $0\n";
+ print STDERR "ls: ", `ls -l $0`;
+ print STDERR "perl: ", `sh -c 'type perl'`;
+}
+
+check_cgi();
+
+my $client_port0 = 5900;
+my $server_port0 = 5500;
+
+while (@ARGV) {
+ if ($ARGV[0] =~ /^-*(ULTRAVNC_REPEATER_\w+)=(.+)/) {
+ $ENV{$1} = $2;
+ shift;
+ } elsif ($ARGV[0] eq '-l') {
+ shift;
+ $ENV{ULTRAVNC_REPEATER_LOGFILE} = shift;
+ } elsif ($ARGV[0] eq '-p') {
+ shift;
+ $ENV{ULTRAVNC_REPEATER_PIDFILE} = shift;
+ } elsif ($ARGV[0] eq '-c') {
+ shift;
+ $ENV{ULTRAVNC_REPEATER_CLIENT_PORT} = shift;
+ } elsif ($ARGV[0] eq '-s') {
+ shift;
+ $ENV{ULTRAVNC_REPEATER_SERVER_PORT} = shift;
+ } elsif ($ARGV[0] eq '-L') {
+ shift;
+ if (@ARGV && $ARGV[0] =~ /^(1|0|BG)$/) {
+ $ENV{ULTRAVNC_REPEATER_LOOP} = shift;
+ } else {
+ $ENV{ULTRAVNC_REPEATER_LOOP} = '1';
+ }
+ } elsif ($ARGV[0] eq '-R') {
+ shift;
+ if (@ARGV && $ARGV[0] =~ /^(1|0)$/) {
+ $ENV{ULTRAVNC_REPEATER_NO_RFB} = shift;
+ } else {
+ $ENV{ULTRAVNC_REPEATER_NO_RFB} = '1';
+ }
+ } elsif ($ARGV[0] eq '-C') {
+ shift;
+ if (@ARGV && $ARGV[0] =~ /^(1|0)$/) {
+ $ENV{ULTRAVNC_REPEATER_CLEAN} = shift;
+ } else {
+ $ENV{ULTRAVNC_REPEATER_CLEAN} = '1';
+ }
+ } elsif ($ARGV[0] eq '-r') {
+ shift;
+ if (@ARGV && $ARGV[0] =~ /^(1|0)$/) {
+ $ENV{ULTRAVNC_REPEATER_REFUSE} = shift;
+ } else {
+ $ENV{ULTRAVNC_REPEATER_REFUSE} = '1';
+ }
+ } elsif ($ARGV[0] eq '-i') {
+ shift;
+ $ENV{ULTRAVNC_REPEATER_VALIDIDS} = $ENV{ULTRAVNC_REPEATER_VALIDIDS} . " " . shift;
+ } else {
+ last;
+ }
+}
+
+# Set up valid IDs array
+#
+my @valid_ids = ();
+if (length($ENV{ULTRAVNC_REPEATER_VALIDIDS}) > 0) {
+ # remove initial space
+ $ENV{ULTRAVNC_REPEATER_VALIDIDS} = substr $ENV{ULTRAVNC_REPEATER_VALIDIDS}, 1;
+ # split string
+ @valid_ids = split(/ /, $ENV{ULTRAVNC_REPEATER_VALIDIDS});
+}
+
+# Set up logging:
+#
+if (exists $ENV{ULTRAVNC_REPEATER_LOGFILE}) {
+ close STDOUT;
+ if (!open(STDOUT, ">>$ENV{ULTRAVNC_REPEATER_LOGFILE}")) {
+ die "mz_ultravnc_repeater.pl: $ENV{ULTRAVNC_REPEATER_LOGFILE} $!\n";
+ }
+ close STDERR;
+ open(STDERR, ">&STDOUT");
+}
+select(STDERR); $| = 1;
+select(STDOUT); $| = 1;
+
+# interrupt handler:
+#
+my $looppid = '';
+my $pidfile = '';
+#
+sub get_out {
+ lprint("$_[0]:\t$$ looppid=$looppid");
+ if ($looppid) {
+ kill 'TERM', $looppid;
+ fsleep(0.2);
+ }
+ unlink $pidfile if $pidfile;
+ cleanup();
+ exit 0;
+}
+
+# logging printer:
+#
+sub lprint {
+ print STDERR scalar(localtime), ": ", @_, "\n";
+}
+
+# These are overridden in actual server thread:
+#
+$SIG{INT} = \&get_out;
+$SIG{TERM} = \&get_out;
+
+# pidfile:
+#
+sub open_pidfile {
+ if (exists $ENV{ULTRAVNC_REPEATER_PIDFILE}) {
+ my $pf = $ENV{ULTRAVNC_REPEATER_PIDFILE};
+ if (open(PID, ">$pf")) {
+ print PID "$$\n";
+ close PID;
+ $pidfile = $pf;
+ } else {
+ lprint("could not open pidfile: $pf - $! - continuing...");
+ }
+ delete $ENV{ULTRAVNC_REPEATER_PIDFILE};
+ }
+}
+
+####################################################################
+# Set ULTRAVNC_REPEATER_LOOP=1 to have this script create an outer loop
+# restarting itself if it ever exits. Set ULTRAVNC_REPEATER_LOOP=BG to
+# do this in the background as a daemon. Same as -L option.
+
+if (exists $ENV{ULTRAVNC_REPEATER_LOOP}) {
+ my $csl = $ENV{ULTRAVNC_REPEATER_LOOP};
+ if ($csl ne 'BG' && $csl ne '1') {
+ die "mz_ultravnc_repeater.pl: invalid ULTRAVNC_REPEATER_LOOP.\n";
+ }
+ if ($csl eq 'BG') {
+ # go into bg as "daemon":
+ setpgrp(0, 0);
+ my $pid = fork();
+ if (! defined $pid) {
+ die "mz_ultravnc_repeater.pl: $!\n";
+ } elsif ($pid) {
+ wait;
+ exit 0;
+ }
+ if (fork) {
+ exit 0;
+ }
+ setpgrp(0, 0);
+ close STDIN;
+ if (! $ENV{ULTRAVNC_REPEATER_LOGFILE}) {
+ close STDOUT;
+ close STDERR;
+ }
+ }
+ # delete it so children will not do the same thing:
+ delete $ENV{ULTRAVNC_REPEATER_LOOP};
+
+ if (exists $ENV{ULTRAVNC_REPEATER_PIDFILE}) {
+ open_pidfile();
+ }
+
+ lprint("mz_ultravnc_repeater.pl: starting service. master-pid=$$");
+ while (1) {
+ $looppid = fork;
+ if (! defined $looppid) {
+ sleep 10;
+ } elsif ($looppid) {
+ wait;
+ } else {
+ if ($ENV{ULTRAVNC_REPEATER_DEBUG}) {
+ print STDERR "exec $0 ", join(' ', @ARGV), "\n";
+ }
+ exec $0, @ARGV;
+ exit 1;
+ }
+ lprint("mz_ultravnc_repeater.pl: re-starting service. master-pid=$$");
+ sleep 1;
+ }
+ exit 0;
+}
+if (exists $ENV{ULTRAVNC_REPEATER_PIDFILE}) {
+ open_pidfile();
+}
+
+# End of background/daemon stuff.
+####################################################################
+
+use warnings;
+use IO::Socket::INET;
+use IO::Select;
+
+# Test for INET6 support:
+#
+my $have_inet6 = 0;
+eval "use IO::Socket::INET6;";
+$have_inet6 = 1 if $@ eq "";
+print "perl module IO::Socket::INET6 not available: no IPv6 support.\n" if ! $have_inet6;
+
+my $prog = 'mz_ultravnc_repeater';
+my %ID;
+
+my $refuse = 0;
+my $init_timeout = 5;
+
+my $select_timeout = 15;
+
+if (exists $ENV{ULTRAVNC_REPEATER_REFUSE} && $ENV{ULTRAVNC_REPEATER_REFUSE}) {
+ $refuse = 1;
+ lprint("enabling refuse mode (-r).");
+}
+
+my $client_port = shift;
+my $server_port = shift;
+
+if (exists $ENV{ULTRAVNC_REPEATER_CLIENT_PORT}) {
+ $client_port0 = $ENV{ULTRAVNC_REPEATER_CLIENT_PORT};
+}
+if (exists $ENV{ULTRAVNC_REPEATER_SERVER_PORT}) {
+ $server_port0 = $ENV{ULTRAVNC_REPEATER_SERVER_PORT};
+}
+
+$client_port = $client_port0 unless $client_port;
+$server_port = $server_port0 unless $server_port;
+
+my $uname = `uname`;
+chomp $uname;
+
+my $repeater_bufsize = 250;
+$repeater_bufsize = $ENV{ULTRAVNC_REPEATER_BUFSIZE} if exists $ENV{ULTRAVNC_REPEATER_BUFSIZE};
+
+my ($RIN, $WIN, $EIN, $ROUT);
+
+my $client_listen = IO::Socket::INET->new(
+ Listen => 10,
+ LocalPort => $client_port,
+ ReuseAddr => 1,
+ Proto => "tcp"
+);
+my $err1 = $!;
+my $err2 = '';
+$client_listen = '' if ! $client_listen;
+
+my $client_listen6 = '';
+if ($have_inet6) {
+ eval {$client_listen6 = IO::Socket::INET6->new(
+ Listen => 10,
+ LocalPort => $client_port,
+ ReuseAddr => 1,
+ Domain => AF_INET6,
+ LocalAddr => "::",
+ Proto => "tcp"
+ );};
+ $err2 = $!;
+}
+if (! $client_listen && ! $client_listen6) {
+ cleanup();
+ die "$prog: error: client listen on port $client_port: $err1 - $err2\n";
+}
+
+my $server_listen = IO::Socket::INET->new(
+ Listen => 10,
+ LocalPort => $server_port,
+ ReuseAddr => 1,
+ Proto => "tcp"
+);
+$err1 = $!;
+$err2 = '';
+$server_listen = '' if ! $server_listen;
+
+my $server_listen6 = '';
+if ($have_inet6) {
+ eval {$server_listen6 = IO::Socket::INET6->new(
+ Listen => 10,
+ LocalPort => $server_port,
+ ReuseAddr => 1,
+ Domain => AF_INET6,
+ LocalAddr => "::",
+ Proto => "tcp"
+ );};
+ $err2 = $!;
+}
+if (! $server_listen && ! $server_listen6) {
+ cleanup();
+ die "$prog: error: server listen on port $server_port: $err1 - $err2\n";
+}
+
+my $select = new IO::Select();
+if (! $select) {
+ cleanup();
+ die "$prog: select $!\n";
+}
+
+$select->add($client_listen) if $client_listen;
+$select->add($client_listen6) if $client_listen6;
+$select->add($server_listen) if $server_listen;
+$select->add($server_listen6) if $server_listen6;
+
+$SIG{INT} = sub {cleanup(); exit;};
+$SIG{TERM} = sub {cleanup(); exit;};
+
+my $SOCK1 = '';
+my $SOCK2 = '';
+my $CURR = '';
+
+lprint("$prog: starting up. pid: $$");
+lprint("watching for IPv4 connections on $client_port/client.") if $client_listen;
+lprint("watching for IPv4 connections on $server_port/server.") if $server_listen;
+lprint("watching for IPv6 connections on $client_port/client.") if $client_listen6;
+lprint("watching for IPv6 connections on $server_port/server.") if $server_listen6;
+lprint("valid IDs: @valid_ids.") if (@valid_ids);
+
+my $alarm_sock = '';
+my $got_alarm = 0;
+sub alarm_handler {
+ lprint("$prog: got sig alarm.");
+ if ($alarm_sock ne '') {
+ close $alarm_sock;
+ }
+ $alarm_sock = '';
+ $got_alarm = 1;
+}
+
+while (1) {
+ my @ready = $select->can_read($select_timeout);
+ foreach my $fh (@ready) {
+ if (($client_listen && $fh == $client_listen) || ($client_listen6 && $fh == $client_listen6)) {
+ lprint("new vnc client connecting.");
+ } elsif (($server_listen && $fh == $server_listen) || ($server_listen6 && $fh == $server_listen6)) {
+ lprint("new vnc server connecting.");
+ }
+ my $sock = $fh->accept();
+ if (! $sock) {
+ lprint("$prog: accept $!");
+ next;
+ }
+ lprint("remote ip is ".$sock->peerhost());
+
+ if (($client_listen && $fh == $client_listen) || ($client_listen6 && $fh == $client_listen6)) {
+ if (exists $ENV{ULTRAVNC_REPEATER_NO_RFB} && $ENV{ULTRAVNC_REPEATER_NO_RFB}) {
+ lprint("ULTRAVNC_REPEATER_NO_RFB: not sending RFB 000.000");
+ } else {
+ my $str = "RFB 000.000\n";
+ my $len = length $str;
+ my $n = syswrite($sock, $str, $len, 0);
+ if ($n != $len) {
+ lprint("$prog: bad $str write: $n != $len $!");
+ close $sock;
+ }
+ }
+ }
+
+ my $buf = '';
+ my $size = $repeater_bufsize;
+ $size = 1024 unless $size;
+
+ $SIG{ALRM} = "alarm_handler";
+ $alarm_sock = $sock;
+ $got_alarm = 0;
+ alarm($init_timeout);
+ my $n = sysread($sock, $buf, $size);
+ alarm(0);
+
+ my $idx = index($buf, "\0");
+ if ($idx >= 0) {
+ $buf = substr($buf, 0, $idx);
+ }
+ $buf =~ s/\s*$//;
+
+ if ($got_alarm) {
+ lprint("$prog: read timed out: $!");
+ } elsif (! defined $n) {
+ lprint("$prog: read error: $!");
+ } elsif ($repeater_bufsize > 0 && $n != $size) {
+ lprint("$prog: short read $n != $size $!");
+ close $sock;
+ } elsif (($client_listen && $fh == $client_listen) || ($client_listen6 && $fh == $client_listen6)) {
+ do_new_client($sock, $buf);
+ } elsif (($server_listen && $fh == $server_listen) || ($server_listen6 && $fh == $server_listen6)) {
+ do_new_server($sock, $buf);
+ }
+ }
+ clean_connections();
+}
+
+sub clean_connections {
+ if (exists $ENV{ULTRAVNC_REPEATER_CLEAN} && $ENV{ULTRAVNC_REPEATER_CLEAN}) {
+ foreach my $id (keys %ID) {
+ next if !exists $ID{$id}{sock};
+ if (!established($ID{$id}{sock})) {
+ lprint("socket for ID:$id is no longer established, closing it.");
+ close $ID{$id}{sock};
+ delete $ID{$id};
+ }
+ }
+ }
+}
+
+sub do_new_client {
+ my ($sock, $buf) = @_;
+
+ if ($buf =~ /^ID:(\w+)/) {
+ my $id = $1;
+
+ if (@valid_ids) {
+ my $is_valid_id = 0;
+ for (my $i = 0; $i < ($#valid_ids + 1); $i++) {
+ if ($id == $valid_ids[$i]) {
+ $is_valid_id = 1;
+ last;
+ }
+ }
+ if (!$is_valid_id) {
+ lprint("refusing vnc client: ID:$id not considered valid.");
+ close $sock;
+ return;
+ }
+ }
+
+ if (exists $ID{$id} && exists $ID{$id}{client} && $ID{$id}{client} eq "0") {
+ if (!established($ID{$id}{sock})) {
+ lprint("server socket for ID:$id is no longer established, closing it.");
+ close $ID{$id}{sock};
+ delete $ID{$id};
+ } else {
+ lprint("server socket for ID:$id is still established.");
+ }
+ }
+ if (exists $ID{$id}) {
+ if ($ID{$id}{client}) {
+ my $ref = $refuse;
+ if ($ref && !established($ID{$id}{sock})) {
+ lprint("socket for ID:$id is no longer established, closing it.");
+ $ref = 0;
+ }
+ if ($ref) {
+ lprint("refusing extra vnc client for ID:$id.");
+ close $sock;
+ return;
+ } else {
+ lprint("closing and deleting previous vnc client with ID:$id.");
+ close $ID{$id}{sock};
+
+ lprint("storing new vnc client with ID:$id.");
+ $ID{$id}{client} = 1;
+ $ID{$id}{sock} = $sock;
+ }
+ } else {
+ lprint("hooking up new vnc client with existing vnc server for ID:$id.");
+ my $sock2 = $ID{$id}{sock};
+ delete $ID{$id};
+ hookup($sock, $sock2, "ID:$id");
+ }
+ } else {
+ lprint("storing new vnc client with ID:$id.");
+ $ID{$id}{client} = 1;
+ $ID{$id}{sock} = $sock;
+ }
+ } else {
+ if (@valid_ids) {
+ lprint("refusing vnc client: ID requested.");
+ close $sock;
+ return;
+ }
+
+ my $host = '';
+ my $port = '';
+ if ($buf =~ /^(.+):(-?\d+)/) {
+ $host = $1;
+ $port = $2;
+ } else {
+ $host = $buf;
+ $port = 5900;
+ }
+ if ($port < 0) {
+ my $pnew = -$port;
+ lprint("resetting port from $port to $pnew.");
+ $port = $pnew;
+ } elsif ($port < 200) {
+ my $pnew = $port + 5900;
+ lprint("resetting port from $port to $pnew.");
+ $port = $pnew;
+ }
+ lprint("making vnc client connection directly to vnc server host='$host' port='$port'.");
+ my $sock2 = IO::Socket::INET->new(
+ PeerAddr => $host,
+ PeerPort => $port,
+ Proto => "tcp"
+ );
+ if (! $sock2 && $have_inet6) {
+ lprint("IPv4 connect error: $!, trying IPv6 ...");
+ eval{$sock2 = IO::Socket::INET6->new(
+ PeerAddr => $host,
+ PeerPort => $port,
+ Proto => "tcp"
+ );};
+ lprint("IPv6 connect error: $!") if !$sock2;
+ } else {
+ lprint("IPv4 connect error: $!") if !$sock2;
+ }
+ if (!$sock2) {
+ lprint("failed to connect to $host:$port.");
+ close $sock;
+ return;
+ }
+ hookup($sock, $sock2, "$host:$port");
+ }
+}
+
+sub do_new_server {
+ my ($sock, $buf) = @_;
+
+ if ($buf =~ /^ID:(\w+)/) {
+ my $id = $1;
+
+ if (@valid_ids) {
+ my $is_valid_id = 0;
+ for (my $i = 0; $i < ($#valid_ids + 1); $i++) {
+ if ($id == $valid_ids[$i]) {
+ $is_valid_id = 1;
+ last;
+ }
+ }
+ if (!$is_valid_id) {
+ lprint("refusing vnc server: ID:$id not considered valid.");
+ close $sock;
+ return;
+ }
+ }
+
+ my $store = 1;
+ if (exists $ID{$id} && exists $ID{$id}{client} && $ID{$id}{client} eq "1") {
+ if (!established($ID{$id}{sock})) {
+ lprint("client socket for ID:$id is no longer established, closing it.");
+ close $ID{$id}{sock};
+ delete $ID{$id};
+ } else {
+ lprint("client socket for ID:$id is still established.");
+ }
+ }
+ if (exists $ID{$id}) {
+ if (! $ID{$id}{client}) {
+ my $ref = $refuse;
+ if ($ref && !established($ID{$id}{sock})) {
+ lprint("socket for ID:$id is no longer established, closing it.");
+ $ref = 0;
+ }
+ if ($ref) {
+ lprint("refusing extra vnc server for ID:$id.");
+ close $sock;
+ return;
+ } else {
+ lprint("closing and deleting previous vnc server with ID:$id.");
+ close $ID{$id}{sock};
+
+ lprint("storing new vnc server with ID:$id.");
+ $ID{$id}{client} = 0;
+ $ID{$id}{sock} = $sock;
+ }
+ } else {
+ lprint("hooking up new vnc server with existing vnc client for ID:$id.");
+ my $sock2 = $ID{$id}{sock};
+ delete $ID{$id};
+ hookup($sock, $sock2, "ID:$id");
+ }
+ } else {
+ lprint("storing new vnc server with ID:$id.");
+ $ID{$id}{client} = 0;
+ $ID{$id}{sock} = $sock;
+ }
+ } else {
+ lprint("invalid ID:NNNNN string for vnc server: $buf");
+ close $sock;
+ return;
+ }
+}
+
+sub established {
+ my $fh = shift;
+
+ return established_linux_proc($fh);
+
+ # not working:
+ my $est = 1;
+ my $str = "Z";
+ my $res;
+ #$res = recv($fh, $str, 1, MSG_PEEK | MSG_DONTWAIT);
+ if (defined($res)) {
+ lprint("established OK: $! '$str'.");
+ $est = 1;
+ } else {
+ # would check for EAGAIN here to decide ...
+ lprint("established err: $! '$str'.");
+ $est = 1;
+ }
+ return $est;
+}
+
+
+sub established_linux_proc {
+ # hack for Linux to see if remote side has gone away:
+ my $fh = shift;
+
+ # if we can't figure things out, we must return true.
+ if ($uname !~ /Linux/) {
+ return 1;
+ }
+
+ my @proc_net_tcp = ();
+ if (-e "/proc/net/tcp") {
+ push @proc_net_tcp, "/proc/net/tcp";
+ }
+ if (-e "/proc/net/tcp6") {
+ push @proc_net_tcp, "/proc/net/tcp6";
+ }
+ if (! @proc_net_tcp) {
+ return 1;
+ }
+
+ my $n = fileno($fh);
+ if (!defined($n)) {
+ return 1;
+ }
+
+ my $proc_fd = "/proc/$$/fd/$n";
+ if (! -e $proc_fd) {
+ return 1;
+ }
+
+ my $val = readlink($proc_fd);
+ if (! defined $val || $val !~ /socket:\[(\d+)\]/) {
+ return 1;
+ }
+ my $num = $1;
+
+ my $st = '';
+
+ foreach my $tcp (@proc_net_tcp) {
+ if (! open(TCP, "<$tcp")) {
+ next;
+ }
+ while (<TCP>) {
+ next if /^\s*[A-z]/;
+ chomp;
+ # sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode
+ # 170: 0102000A:170C FE02000A:87FA 01 00000000:00000000 00:00000000 00000000 1001 0 423294766 1 f6fa4100 21 4 4 2 -1
+ # 172: 0102000A:170C FE02000A:87FA 08 00000000:00000001 00:00000000 00000000 1001 0 423294766 1 f6fa4100 21 4 4 2 -1
+ my @items = split(' ', $_);
+ my $state = $items[3];
+ my $inode = $items[9];
+ if (!defined $state || $state !~ /^\d+$/) {
+ next;
+ }
+ if (!defined $inode || $inode !~ /^\d+$/) {
+ next;
+ }
+ if ($inode == $num) {
+ $st = $state;
+ last;
+ }
+ }
+ close TCP;
+ last if $st ne '';
+ }
+
+ if ($st ne '' && $st != 1) {
+ return 0;
+ }
+ return 1;
+}
+
+sub handler {
+ lprint("\[$$/$CURR] got SIGTERM.");
+ close $SOCK1 if $SOCK1;
+ close $SOCK2 if $SOCK2;
+ exit;
+}
+
+sub hookup {
+ my ($sock1, $sock2, $tag) = @_;
+
+ my $worker = fork();
+
+ if (! defined $worker) {
+ lprint("failed to fork worker: $!");
+ close $sock1;
+ close $sock2;
+ return;
+ } elsif ($worker) {
+ close $sock1;
+ close $sock2;
+ wait;
+ } else {
+ cleanup();
+ if (fork) {
+ exit 0;
+ }
+ setpgrp(0, 0);
+ $SOCK1 = $sock1;
+ $SOCK2 = $sock2;
+ $CURR = $tag;
+ $SIG{TERM} = "handler";
+ $SIG{INT} = "handler";
+ xfer_both($sock1, $sock2);
+ exit 0;
+ }
+}
+
+sub xfer {
+ my ($in, $out) = @_;
+
+ $RIN = $WIN = $EIN = "";
+ $ROUT = "";
+ vec($RIN, fileno($in), 1) = 1;
+ vec($WIN, fileno($in), 1) = 1;
+ $EIN = $RIN | $WIN;
+
+ my $buf;
+
+ while (1) {
+ my $nf = 0;
+ while (! $nf) {
+ $nf = select($ROUT=$RIN, undef, undef, undef);
+ }
+ my $len = sysread($in, $buf, 8192);
+ if (! defined($len)) {
+ next if $! =~ /^Interrupted/;
+ lprint("\[$$/$CURR] $!");
+ last;
+ } elsif ($len == 0) {
+ lprint("\[$$/$CURR] Input is EOF.");
+ last;
+ }
+ my $offset = 0;
+ my $quit = 0;
+ while ($len) {
+ my $written = syswrite($out, $buf, $len, $offset);
+ if (! defined $written) {
+ lprint("\[$$/$CURR] Output is EOF. $!");
+ $quit = 1;
+ last;
+ }
+ $len -= $written;
+ $offset += $written;
+ }
+ last if $quit;
+ }
+ close($out);
+ close($in);
+ lprint("\[$$/$CURR] finished xfer.");
+}
+
+sub xfer_both {
+ my ($sock1, $sock2) = @_;
+
+ my $parent = $$;
+
+ my $child = fork();
+
+ if (! defined $child) {
+ lprint("$prog\[$$/$CURR] failed to fork: $!");
+ return;
+ }
+
+ $SIG{TERM} = "handler";
+ $SIG{INT} = "handler";
+
+ if ($child) {
+ lprint("[$$/$CURR] parent 1 -> 2.");
+ xfer($sock1, $sock2);
+ select(undef, undef, undef, 0.25);
+ if (kill 0, $child) {
+ select(undef, undef, undef, 0.9);
+ if (kill 0, $child) {
+ lprint("\[$$/$CURR] kill TERM child $child");
+ kill "TERM", $child;
+ } else {
+ lprint("\[$$/$CURR] child $child gone.");
+ }
+ }
+ } else {
+ select(undef, undef, undef, 0.05);
+ lprint("[$$/$CURR] child 2 -> 1.");
+ xfer($sock2, $sock1);
+ select(undef, undef, undef, 0.25);
+ if (kill 0, $parent) {
+ select(undef, undef, undef, 0.8);
+ if (kill 0, $parent) {
+ lprint("\[$$/$CURR] kill TERM parent $parent.");
+ kill "TERM", $parent;
+ } else {
+ lprint("\[$$/$CURR] parent $parent gone.");
+ }
+ }
+ }
+}
+
+sub fsleep {
+ my ($time) = @_;
+ select(undef, undef, undef, $time) if $time;
+}
+
+sub cleanup {
+ close $client_listen if $client_listen;
+ close $client_listen6 if $client_listen6;
+ close $server_listen if $server_listen;
+ close $server_listen6 if $server_listen6;
+ foreach my $id (keys %ID) {
+ close $ID{$id}{sock};
+ }
+}
+
+sub url_decode {
+ # for CGI mode
+ foreach (@_) {
+ tr/+/ /;
+ s/%([\dA-F][\dA-F])/pack("c",hex($1))/ige;
+ }
+ @_;
+}
+
+sub check_cgi {
+ # check if called via CGI launcher
+ my $request = '';
+ if (!exists $ENV{REQUEST_METHOD}) {
+ ;
+ } elsif ($ENV{REQUEST_METHOD} eq 'POST' && exists $ENV{CONTENT_LENGTH}) {
+ read(STDIN, $request, $ENV{CONTENT_LENGTH});
+ } elsif ($ENV{REQUEST_METHOD} eq 'GET' && exists $ENV{QUERY_STRING}) {
+ $request = $ENV{QUERY_STRING};
+ }
+ delete $ENV{REQUEST_METHOD} if exists $ENV{REQUEST_METHOD};
+
+ return if $request =~ /^\s*$/;
+
+ my %req = &url_decode(split(/[&=]/, $request));
+
+ print "Content-type: text/html\n\n";
+
+ if (exists $req{help} && $req{help} =~ /^(true|1)$/i) {
+ print $usage;
+ exit 0;
+ }
+
+ # WARNING: There may be a CGI security problem here letting
+ # a remote user set logfile, pidfile, and perhaps the others.
+ # Consider the user the CGI process runs as. Can they write to
+ # important files? Do the following checks and open() calls
+ # prevent running arbitrary commands? Please audit for your
+ # configuration and add extra checks. Ideally use of this script
+ # would be username and password protected. Consider limiting
+ # logfile and pidfile to reside in a fixed directory and/or not
+ # letting the remote user set them.
+ #
+ $ENV{ULTRAVNC_REPEATER_LOGFILE} = $req{logfile} if exists $req{logfile} && $req{logfile} !~ /[|\/<>&*+]/;
+ $ENV{ULTRAVNC_REPEATER_PIDFILE} = $req{pidfile} if exists $req{pidfile} && $req{pidfile} !~ /[|\/<>&*+]/;
+ $ENV{ULTRAVNC_REPEATER_CLIENT_PORT} = $req{cport} if exists $req{cport} && $req{cport} =~ /^\d+$/;
+ $ENV{ULTRAVNC_REPEATER_SERVER_PORT} = $req{sport} if exists $req{sport} && $req{sport} =~ /^\d+$/;
+ $ENV{ULTRAVNC_REPEATER_LOOP} = $req{loop} if exists $req{loop} && $req{loop} =~ /^(BG|1|0)$/;
+ $ENV{ULTRAVNC_REPEATER_NO_RFB} = 1 if exists $req{norfb} && $req{norfb} =~ /^(true|1)$/i;
+ $ENV{ULTRAVNC_REPEATER_CLEAN} = 1 if exists $req{clean} && $req{clean} =~ /^(true|1)$/i;
+ $ENV{ULTRAVNC_REPEATER_REFUSE} = 1 if exists $req{refuse} && $req{refuse} =~ /^(true|1)$/i;
+}
projects / mz_ultravnc_repeater / commitdiff