Restructure and inotail

Makefile

@@ -13,9 +13,11 @@ all: $(addsuffix -all,$(SUBDIRS))
 install-bin: all
 	$(INSTALL) -m 755 -d    $(DESTDIR)/usr/bin
 	$(INSTALL) -m 755       src/radangel $(DESTDIR)/usr/bin
-	$(INSTALL) -m 755       src/contrib/websockify $(DESTDIR)/usr/bin
+	$(INSTALL) -m 755       src/websockify/websockify $(DESTDIR)/usr/bin
+	$(INSTALL) -m 755       src/inotail/inotail $(DESTDIR)/usr/bin
 	$(STRIP)   -s           $(DESTDIR)/usr/bin/radangel
 	$(STRIP)   -s           $(DESTDIR)/usr/bin/websockify
+	$(STRIP)   -s           $(DESTDIR)/usr/bin/inotail
 
 uninstall-bin:
 	rm -f $(DESTDIR)/usr/bin/radangel
@@ -38,16 +40,16 @@ install-config:
 	$(INSTALL) -m 644       service/radangel.service $(DESTDIR)/lib/systemd/system
 	$(INSTALL) -m 644       service/websockify.service $(DESTDIR)/lib/systemd/system
 	$(INSTALL) -m 755 -d    $(DESTDIR)/etc/nginx/conf.d
-	$(INSTALL) -m 644       config/nginx-default-datasrc-location.conf $(DESTDIR)/etc/nginx/conf.d
+	$(INSTALL) -m 644       config/radangel.conf $(DESTDIR)/etc/nginx/conf.d
 	$(INSTALL) -m 755 -d    $(DESTDIR)/etc/udev/rules.d
-	$(INSTALL) -m 644       config/60-kromek-radangel.rules $(DESTDIR)/etc/udev/rules.d
+	$(INSTALL) -m 644       config/60-radangel.rules $(DESTDIR)/etc/udev/rules.d
 
 uninstall-config:
 	rm -f $(DESTDIR)/lib/systemd/system/datasrc.service
 	rm -f $(DESTDIR)/lib/systemd/system/radangel.service
 	rm -f $(DESTDIR)/lib/systemd/system/websockify.service
-	rm -f $(DESTDIR)/etc/nginx/conf.d/nginx-default-datasrc-location.conf
-	rm -f $(DESTDIR)/etc/udev/rules.d/60-kromek-radangel.rules
+	rm -f $(DESTDIR)/etc/nginx/conf.d/radangel.conf
+	rm -f $(DESTDIR)/etc/udev/rules.d/60-radangel.rules
 
 install: install-bin install-html install-config
 

config/60-radangel.rules

@@ -0,0 +1 @@
+SUBSYSTEM=="usb", ATTR{idVendor}=="04d8", ATTR{idProduct}=="0100", MODE="0666"

config/radangel.conf

@@ -0,0 +1,42 @@
+server {
+	listen 81;
+	listen [::]:81;
+
+	root /usr/share/radangel/html;
+
+	index index.html index.htm;
+
+	server_name _;
+
+	location / {
+		try_files $uri $uri/ =404;
+	}
+
+	location /data/hist.tsv {
+		alias /tmp/stats.tsv;
+	}
+
+	location /data/stream.tsv { 
+		alias /tmp/event.tsv;
+	}
+
+	location /data/stream.ws {
+		proxy_http_version 1.1;
+		proxy_set_header Upgrade         $http_upgrade;
+		proxy_set_header Connection      "upgrade";
+
+		proxy_set_header Host            $host; # $http_host;
+		proxy_set_header X-Real-IP       $remote_addr;
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_set_header X-NginX-Proxy   true;
+
+		proxy_read_timeout 3600;
+		proxy_buffering off;
+		tcp_nodelay on;
+
+		error_page 502 = /data/stream.tsv; # serve http for non-ws clients
+
+		proxy_pass http://127.0.0.1:5800/websockify;
+	}
+
+}

debian/control

@@ -4,11 +4,11 @@ Priority: optional
 Maintainer: Peter Vivell <peter@vivell.de>
 Build-Depends: debhelper (>= 10)
 Standards-Version: 4.1.2
-Homepage: https://git.unino.de/pvivell/radangel/wiki
+Homepage: https://git.unino.de/pvivell/radangel
 #Vcs-Git: https://git.unino.de/pvivell/radangel.git
 #Vcs-Browser: https://git.unino.de/pvivell/radangel
 
 Package: radangel
 Architecture: amd64 arm64 armel armhf i386 mips mips64el mipsel powerpc ppc64el s390x
-Depends: ${shlibs:Depends}, ${misc:Depends}
+Depends: ${shlibs:Depends}, ${misc:Depends} socat nginx
 Description: Kromek Radangel gamma spectrometer daemon.

service/radangel.service

@@ -21,7 +21,7 @@ ExecStartPre=/bin/chmod o+r ${EVENT_FILE}
 ExecStartPre=/bin/chmod o+r ${STATS_FILE}
 
 WorkingDirectory=/opt/radangel
-ExecStart=/opt/radangel/radangel --verbose \
+ExecStart=/usr/bin/radangel --verbose \
 	--event ${EVENT_FILE}              \
 	--stats ${STATS_FILE}
 

service/websockify.service

@@ -20,7 +20,7 @@ ExecStartPre=/bin/sh -c '\
 	touch /var/run/websockify.pid; \
 	chown www-data:www-data /var/run/websockify.pid'
 WorkingDirectory=/tmp
-ExecStart=/opt/websockify/websockify --daemon --pid /var/run/websockify.pid \
+ExecStart=/usr/bin/websockify --daemon --pid /var/run/websockify.pid \
 	${LISTEN_HOST}:${LISTEN_PORT} \
 	${TARGET_HOST}:${TARGET_PORT}
 

src/inotail/.gitignore

@@ -0,0 +1,7 @@
+# binary files
+*.o
+inotail
+inotify-watchdir
+
+# other
+cscope.out

src/inotail/LICENSE

@@ -0,0 +1,339 @@
+		    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.

src/inotail/Makefile

@@ -0,0 +1,47 @@
+# Makefile for inotail
+#
+# Copyright (C) 2006-2007 Tobias Klauser <tklauser@distanz.ch>
+#
+# Licensed under the terms of the GNU General Public License; version 2 or later.
+
+VERSION	= 0.5
+
+# Paths
+prefix	= /usr/local
+BINDIR	= $(prefix)/bin
+MANDIR	= $(prefix)/share/man/man1
+
+CC	:= gcc
+CFLAGS	:= $(CFLAGS) -pipe -D_USE_SOURCE -DVERSION="\"$(VERSION)\"" -W -Wall \
+	   -Wstrict-prototypes -Wsign-compare -Wshadow -Wchar-subscripts \
+	   -Wmissing-declarations -Wpointer-arith -Wcast-align -Wmissing-prototypes
+
+# Compile with 'make DEBUG=true' to enable debugging
+DEBUG = false
+ifeq ($(strip $(DEBUG)),true)
+	CFLAGS  += -g -DDEBUG
+endif
+
+all: inotail
+inotail: inotail.o
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $< -o $@
+
+install: inotail
+	install -m 775 -D inotail $(BINDIR)/inotail
+	install -m 644 -D inotail.1 $(MANDIR)/inotail.1
+	gzip -9 $(MANDIR)/inotail.1
+
+uninstall:
+	rm $(BINDIR)/inotail $(MANDIR)/inotail.1*
+
+cscope:
+	cscope -b
+
+release:
+	git-archive --format=tar --prefix=inotail-$(VERSION)/ HEAD | gzip -9v > ../inotail-$(VERSION).tar.gz
+	git-archive --format=tar --prefix=inotail-$(VERSION)/ HEAD | bzip2 -9v > ../inotail-$(VERSION).tar.bz2
+
+clean:
+	rm -f inotail *.o cscope.*

src/inotail/README

@@ -0,0 +1,46 @@
+ inotail - inotify enhanced tail
+o===============================o
+
+inotail is a replacement for the 'tail' program found in the base installation
+of every Linux/UNIX system. It makes use of the inotify infrastructure in recent
+versions of the Linux kernel to speed up tailing files in the follow mode (the
+'-f' option). Standard tail polls the file every second by default while inotail
+listens to special events sent by the kernel through the inotify API to
+determine whether a file needs to be reread.
+
+Currently inotail is not fully compatible to neither POSIX or GNU tail but might
+be in the future.
+
+Requirements
+------------
+- Linux kernel 2.6.13 or higher with CONFIG_INOTIFY enabled
+- Standard C Library (tested with GNU libc but might work with others too)
+- GCC (other compilers might work but are not tested)
+
+Building and installing inotail
+-------------------------------
+To build inotail type:
+
+	$ make
+
+By default, inotail is installed to /usr/local/bin/, the manpage is installed to
+/usr/local/share/man/man1/. To install the inotail files to these locations type:
+
+	$ make install
+
+To change these locations just set the prefix variable. E.g. to install the
+inotail binary to /usr/ and the manpage to /usr/share/man/ respectively type:
+
+	$ make prefix=/usr install
+
+License
+-------
+inotail is licensed under the terms of the GNU General Public License version 2
+or later. You can find the full text in the file LICENSE in the source tree of
+inotail.
+
+The files inotify.h and inotify-syscalls.h were taken from the source tree of
+the Linux kernel and slightly altered. Both are licensed under the terms of the
+GNU General Public License version 2.
+
+-- Tobias Klauser <tklauser@distanz.ch>

src/inotail/changelog

@@ -0,0 +1,34 @@
+inotail 0.5
+
+  * Output verbose file headers correctly when used in a pipe
+  * Small code cleanups
+
+  -- Tobias Klauser <tklauser@distanz.ch> 2007-09-07 13:30
+
+inotail 0.4
+
+  * Use dynamic buffers of optimal size (st_blksize in struct stat) for
+    filesystem I/O (patch by Folkert van Heusden)
+  * Added handling of EINTR/EAGAIN while watching files for changes (patch by
+    Anthony Martinez)
+  * Better error checking and handling (patch by Folkert van Heusden)
+  * Various cleanups
+
+  -- Tobias Klauser <tklauser@distanz.ch> 2007-06-20 15:00
+
+inotail 0.3
+
+  * Follow files even if they were moved
+  * Fix a problem when tailing more than 4096 bytes/chars at once
+  * Only print the filename once when the -v option is specified
+  * Various small fixes and cleanups
+
+  -- Tobias Klauser <tklauser@distanz.ch> 2007-04-17 13:44
+
+inotail 0.2
+
+  * Support for the -n/-c +<num> options (tail relative to start of file)
+  * Copyright and license cleanup
+  * Various fixes
+
+  -- Tobias Klauser <tklauser@distanz.ch.ch> 2006-11-30 17:56

src/inotail/inotail.1

@@ -0,0 +1,59 @@
+'\" t
+.\" ** The above line should force tbl to be a preprocessor **
+.\" Man page for inotail
+.\"
+.\" Copyright (c) 2006 Tobias Klauser <tklauser@distanz.ch>
+.\"
+.\" You may distribute under the terms of the GNU General Public
+.\" License as specified in the file COPYING that comes with
+.\" inotail.
+
+.pc
+.TH INOTAIL 1 "2006-08-13" "" "Inotify enhanced tail"
+.SH NAME
+inotail \- A fast and lightweight version of tail using inotify
+.SH SYNOPSIS
+.B inotail
+[OPTION]... [FILE]...
+.SH DESCRIPTION
+.B inotail
+is a replacement for the 'tail' program found in the base installation of every
+Linux/UNIX system. It makes use of the inotify infrastructure in recent versions
+of the Linux kernel to speed up tailing files in the follow mode (the '\-f'
+option). Standard tail polls the file every second by default while inotail
+listens to special events sent by the kernel through the inotify API to
+determine whether a file needs to be reread. \fINote:\fR inotail will not work
+on systems running a kernel without inotify. To enable inotify, please set
+CONFIG_INOTIFY=y in your Linux kernel configuration and recompile it.
+.PP
+Currently inotail is not fully compatible to neither POSIX or GNU tail but might
+be in the future.
+.SH OPTIONS
+.TP
+.B \-c \fIN\fR, \fB\-\-bytes\fR=\fIN\fR
+output the last N bytes. If the first character of N is a '+', begin printing
+with the Nth character from the start of each file.
+.TP
+.B \-f, \fB\-\-follow
+keep the file(s) open and print appended data as the file grows
+.TP
+.B \-n \fIN\fR, \fB\-\-lines\fR=\fIN\fR
+output the last N lines (default: 10) If the first character of N is a '+',
+begin printing with the Nth line from the start of each file.
+.TP
+.B \-v, \fB\-\-verbose
+print headers with file names
+.TP
+.B \-h, \fB\-\-help
+show help and exit
+.TP
+.B \-V, \fB\-\-version
+show inotail version and exit
+.SH AUTHOR
+.PP
+Written by Tobias Klauser
+<tklauser@distanz.ch>
+.SH SEE ALSO
+.PP
+.BR tail(1),
+.BR inotify(7)

src/inotail/inotail.c

@@ -0,0 +1,545 @@
+/*
+ * inotail.c
+ * A fast implementation of tail which uses the inotify API present in
+ * recent versions of the Linux kernel.
+ *
+ * Copyright (C) 2005-2007, Tobias Klauser <tklauser@distanz.ch>
+ *
+ * The idea was taken from turbotail.
+ *
+ * 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, 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.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "inotify.h"
+#include "inotify-syscalls.h"
+
+#include "inotail.h"
+
+#define PROGRAM_NAME "inotail"
+#define DEFAULT_BUFFER_SIZE 4096
+/* inotify event buffer length for one file */
+#define INOTIFY_BUFLEN (4 * sizeof(struct inotify_event))
+
+/* Print header with filename before tailing the file? */
+static char verbose = 0;
+
+/* Tailing relative to begin or end of file */
+static char from_begin = 0;
+
+/* Number of ignored files */
+static int n_ignored = 0;
+
+/* Command line options */
+static const struct option long_opts[] = {
+	{ "bytes", required_argument, NULL, 'c' },
+	{ "follow", optional_argument, NULL, 'f' },
+	{ "lines", required_argument, NULL, 'n' },
+	{ "verbose", no_argument, NULL, 'v' },
+	{ "help", no_argument, NULL, 'h' },
+	{ "version", no_argument, NULL, 'V' },
+	{ NULL, 0, NULL, 0 }
+};
+
+static void *emalloc(size_t size)
+{
+	void *ret = malloc(size);
+
+	if (unlikely(!ret)) {
+		fprintf(stderr, "Error: Failed to allocate %d bytes of memory (%s)\n", (int) size, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	return ret;
+}
+
+static void usage(const int status)
+{
+	fprintf(stdout, "Usage: %s [OPTION]... [FILE]...\n\n"
+			"  -c N, --bytes=N    output the last N bytes\n"
+			"  -f,   --follow     output as the file grows\n"
+			"  -n N, --lines=N    output the last N lines (default: %d)\n"
+			"  -v,   --verbose    print headers with file names\n"
+			"  -h,   --help       show this help and exit\n"
+			"  -V,   --version    show version and exit\n\n"
+			"If the first character of N (the number of bytes or lines) is a `+',\n"
+			"begin printing with the Nth item from the start of each file, otherwise,\n"
+			"print the last N items in the file.\n", PROGRAM_NAME, DEFAULT_N_LINES);
+
+	exit(status);
+}
+
+static inline void setup_file(struct file_struct *f)
+{
+	f->fd = f->i_watch = -1;
+	f->size = 0;
+	f->blksize = DEFAULT_BUFFER_SIZE;
+	f->ignore = 0;
+}
+
+static void ignore_file(struct file_struct *f)
+{
+	if (f->fd != -1) {
+		close(f->fd);
+		f->fd = -1;
+	}
+	f->ignore = 1;
+	n_ignored++;
+}
+
+static inline char *pretty_name(char *filename)
+{
+	return (strcmp(filename, "-") == 0) ? "standard input" : filename;
+}
+
+static void write_header(char *filename)
+{
+	static unsigned short first_file = 1;
+	static char *last = NULL;
+
+	if (last != filename) {
+		fprintf(stdout, "%s==> %s <==\n", (first_file ? "" : "\n"), pretty_name(filename));
+		fflush(stdout);		/* Make sure the header is printed before the content */
+	}
+
+	first_file = 0;
+	last = filename;
+}
+
+static off_t lines_to_offset_from_end(struct file_struct *f, unsigned long n_lines)
+{
+	off_t offset = f->size;
+	char *buf = emalloc(f->blksize);
+
+	n_lines++;	/* We also count the last \n */
+
+	while (offset > 0 && n_lines > 0) {
+		int i;
+		ssize_t rc, block_size = f->blksize;	/* Size of the current block we're reading */
+
+		if (offset < block_size)
+			block_size = offset;
+
+		/* Start of current block */
+		offset -= block_size;
+
+		if (lseek(f->fd, offset, SEEK_SET) == (off_t) -1) {
+			fprintf(stderr, "Error: Could not seek in file '%s' (%s)\n", f->name, strerror(errno));
+			free(buf);
+			return -1;
+		}
+
+		rc = read(f->fd, buf, block_size);
+		if (unlikely(rc < 0)) {
+			fprintf(stderr, "Error: Could not read from file '%s' (%s)\n", f->name, strerror(errno));
+			free(buf);
+			return -1;
+		}
+
+		for (i = block_size - 1; i > 0; i--) {
+			if (buf[i] == '\n') {
+				if (--n_lines == 0) {
+					free(buf);
+					return offset += i + 1; /* We don't want the first \n */
+				}
+			}
+		}
+	}
+
+	free(buf);
+	return offset;
+}
+
+static off_t lines_to_offset_from_begin(struct file_struct *f, unsigned long n_lines)
+{
+	char *buf;
+	off_t offset = 0;
+
+	/* tail everything for 'inotail -n +0' */
+	if (n_lines == 0)
+		return 0;
+
+	n_lines--;
+	buf = emalloc(f->blksize);
+
+	while (offset <= f->size && n_lines > 0) {
+		int i;
+		ssize_t rc, block_size = f->blksize;
+
+		if (lseek(f->fd, offset, SEEK_SET) == (off_t) -1) {
+			fprintf(stderr, "Error: Could not seek in file '%s' (%s)\n", f->name, strerror(errno));
+			free(buf);
+			return -1;
+		}
+
+		rc = read(f->fd, buf, block_size);
+		if (unlikely(rc < 0)) {
+			fprintf(stderr, "Error: Could not read from file '%s' (%s)\n", f->name, strerror(errno));
+			free(buf);
+			return -1;
+		} else if (rc < block_size)
+			block_size = rc;
+
+		for (i = 0; i < block_size; i++) {
+			if (buf[i] == '\n') {
+				if (--n_lines == 0) {
+					free(buf);
+					return offset + i + 1;
+				}
+			}
+		}
+
+		offset += block_size;
+	}
+
+	free(buf);
+	return offset;
+}
+
+static off_t lines_to_offset(struct file_struct *f, unsigned long n_lines)
+{
+	if (from_begin)
+		return lines_to_offset_from_begin(f, n_lines);
+	else
+		return lines_to_offset_from_end(f, n_lines);
+}
+
+static off_t bytes_to_offset(struct file_struct *f, unsigned long n_bytes)
+{
+	off_t offset = 0;
+
+	/* tail everything for 'inotail -c +0' */
+	if (from_begin) {
+		if (n_bytes > 0)
+			offset = (off_t) n_bytes - 1;
+	} else if ((off_t) n_bytes < f->size)
+		offset = f->size - (off_t) n_bytes;
+
+	return offset;
+}
+
+static ssize_t tail_pipe(struct file_struct *f)
+{
+	ssize_t rc;
+	char *buf = emalloc(f->blksize);
+
+	if (verbose)
+		write_header(f->name);
+
+	/* We will just tail everything here */
+	while ((rc = read(f->fd, buf, f->blksize)) > 0) {
+		if (write(STDOUT_FILENO, buf, (size_t) rc) <= 0) {
+			/* e.g. when writing to a pipe which gets closed */
+			fprintf(stderr, "Error: Could not write to stdout (%s)\n", strerror(errno));
+			rc = -1;
+			break;
+		}
+	}
+
+	free(buf);
+	return rc;
+}
+
+static int tail_file(struct file_struct *f, unsigned long n_units, char mode, char forever)
+{
+	ssize_t bytes_read = 0;
+	off_t offset = 0;
+	char *buf;
+	struct stat finfo;
+
+	if (strcmp(f->name, "-") == 0)
+		f->fd = STDIN_FILENO;
+	else {
+		f->fd = open(f->name, O_RDONLY);
+		if (unlikely(f->fd < 0)) {
+			fprintf(stderr, "Error: Could not open file '%s' (%s)\n", f->name, strerror(errno));
+			ignore_file(f);
+			return -1;
+		}
+	}
+
+	if (fstat(f->fd, &finfo) < 0) {
+		fprintf(stderr, "Error: Could not stat file '%s' (%s)\n", f->name, strerror(errno));
+		ignore_file(f);
+		return -1;
+	}
+
+	if (!IS_TAILABLE(finfo.st_mode)) {
+		fprintf(stderr, "Error: '%s' of unsupported file type (%s)\n", f->name, strerror(errno));
+		ignore_file(f);
+		return -1;
+	}
+
+	/* Cannot seek on these */
+	if (IS_PIPELIKE(finfo.st_mode) || f->fd == STDIN_FILENO)
+		return tail_pipe(f);
+
+	f->size = finfo.st_size;
+	f->blksize = finfo.st_blksize;	/* TODO: Can this value be 0? */
+
+	if (mode == M_LINES)
+		offset = lines_to_offset(f, n_units);
+	else
+		offset = bytes_to_offset(f, n_units);
+
+	/* We only get negative offsets on errors */
+	if (unlikely(offset < 0)) {
+		ignore_file(f);
+		return -1;
+	}
+
+	if (verbose)
+		write_header(f->name);
+
+	if (lseek(f->fd, offset, SEEK_SET) == (off_t) -1) {
+		fprintf(stderr, "Error: Could not seek in file '%s' (%s)\n", f->name, strerror(errno));
+		return -1;
+	}
+
+	buf = emalloc(f->blksize);
+
+	while ((bytes_read = read(f->fd, buf, f->blksize)) > 0)
+		write(STDOUT_FILENO, buf, (size_t) bytes_read);
+
+	if (!forever) {
+		if (close(f->fd) < 0) {
+			fprintf(stderr, "Error: Could not close file '%s' (%s)\n", f->name, strerror(errno));
+			free(buf);
+			return -1;
+		}
+	} /* Let the fd open otherwise, we'll need it */
+
+	free(buf);
+	return 0;
+}
+
+static int handle_inotify_event(struct inotify_event *inev, struct file_struct *f)
+{
+	int ret = 0;
+
+	if (inev->mask & IN_MODIFY) {
+		char *fbuf;
+		ssize_t rc;
+		struct stat finfo;
+
+		if (verbose)
+			write_header(f->name);
+
+		/* Seek to old file size */
+		if (lseek(f->fd, f->size, SEEK_SET) == (off_t) -1) {
+			fprintf(stderr, "Error: Could not seek in file '%s' (%s)\n", f->name, strerror(errno));
+			ret = -1;
+			goto ignore;
+		}
+
+		fbuf = emalloc(f->blksize);
+
+		while ((rc = read(f->fd, fbuf, f->blksize)) != 0)
+			write(STDOUT_FILENO, fbuf, (size_t) rc);
+
+		if (fstat(f->fd, &finfo) < 0) {
+			fprintf(stderr, "Error: Could not stat file '%s' (%s)\n", f->name, strerror(errno));
+			ret = -1;
+			free(fbuf);
+			goto ignore;
+		}
+
+		f->size = finfo.st_size;
+
+		free(fbuf);
+		return ret;
+	} else if (inev->mask & IN_DELETE_SELF) {
+		fprintf(stderr, "File '%s' deleted.\n", f->name);
+	} else if (inev->mask & IN_MOVE_SELF) {
+		fprintf(stderr, "File '%s' moved.\n", f->name);
+		return 0;
+	} else if (inev->mask & IN_UNMOUNT) {
+		fprintf(stderr, "Device containing file '%s' unmounted.\n", f->name);
+	}
+
+ignore:
+	ignore_file(f);
+	return ret;
+}
+
+static int watch_files(struct file_struct *files, int n_files)
+{
+	int ifd, i;
+	char buf[n_files * INOTIFY_BUFLEN];
+
+	ifd = inotify_init();
+	if (errno == ENOSYS) {
+		fprintf(stderr, "Error: inotify is not supported by the kernel you're currently running.\n");
+		exit(EXIT_FAILURE);
+	} else if (unlikely(ifd < 0)) {
+		fprintf(stderr, "Error: Could not initialize inotify (%s)\n", strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	for (i = 0; i < n_files; i++) {
+		if (!files[i].ignore) {
+			files[i].i_watch = inotify_add_watch(ifd, files[i].name,
+						IN_MODIFY|IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT);
+
+			if (files[i].i_watch < 0) {
+				fprintf(stderr, "Error: Could not create inotify watch on file '%s' (%s)\n",
+						files[i].name, strerror(errno));
+				ignore_file(&files[i]);
+			}
+		}
+	}
+
+	while (n_ignored < n_files) {
+		ssize_t len;
+		int ev_idx = 0;
+
+		len = read(ifd, buf, (n_files * INOTIFY_BUFLEN));
+		if (unlikely(len < 0)) {
+			/* Some signal, likely ^Z/fg's STOP and CONT interrupted the inotify read, retry */
+			if (errno == EINTR || errno == EAGAIN)
+				continue;
+			else {
+				fprintf(stderr, "Error: Could not read inotify events (%s)\n", strerror(errno));
+				exit(EXIT_FAILURE);
+			}
+		}
+
+		while (ev_idx < len) {
+			struct inotify_event *inev;
+			struct file_struct *f = NULL;
+
+			inev = (struct inotify_event *) &buf[ev_idx];
+
+			/* Which file has produced the event? */
+			for (i = 0; i < n_files; i++) {
+				if (!files[i].ignore
+						&& files[i].fd >= 0
+						&& files[i].i_watch == inev->wd) {
+					f = &files[i];
+					break;
+				}
+			}
+
+			if (unlikely(!f))
+				break;
+
+			if (handle_inotify_event(inev, f) < 0)
+				break;
+
+			ev_idx += sizeof(struct inotify_event) + inev->len;
+		}
+	}
+
+	close(ifd);
+	return -1;
+}
+
+int main(int argc, char **argv)
+{
+	int i, c, ret = 0;
+	int n_files;
+	unsigned long n_units = DEFAULT_N_LINES;
+	char forever = 0, mode = M_LINES;
+	char **filenames;
+	struct file_struct *files = NULL;
+
+	while ((c = getopt_long(argc, argv, "c:n:fvVh", long_opts, NULL)) != -1) {
+		switch (c) {
+		case 'c':
+			mode = M_BYTES;
+			/* fall through */
+		case 'n':
+			if (*optarg == '+') {
+				from_begin = 1;
+				optarg++;
+			} else if (*optarg == '-')
+				optarg++;
+
+			if (!is_digit(*optarg)) {
+				fprintf(stderr, "Error: Invalid number of units: %s\n", optarg);
+				exit(EXIT_FAILURE);
+			}
+			n_units = strtoul(optarg, NULL, 0);
+			break;
+                case 'f':
+			forever = 1;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		case 'V':
+			fprintf(stdout, "%s %s\n", PROGRAM_NAME, VERSION);
+			exit(EXIT_SUCCESS);
+		case 'h':
+			usage(EXIT_SUCCESS);
+			break;
+		default:
+			usage(EXIT_FAILURE);
+		}
+	}
+
+	/* Do we have some files to read from? */
+	if (optind < argc) {
+		n_files = argc - optind;
+		filenames = argv + optind;
+	} else {
+		/* It must be stdin then */
+		static char *dummy_stdin = "-";
+		n_files = 1;
+		filenames = &dummy_stdin;
+
+		/* POSIX says that -f is ignored if no file operand is
+		   specified and standard input is a pipe. */
+		if (forever) {
+			struct stat finfo;
+			int rc = fstat(STDIN_FILENO, &finfo);
+
+			if (unlikely(rc == -1)) {
+				fprintf(stderr, "Error: Could not stat stdin (%s)\n", strerror(errno));
+				exit(EXIT_FAILURE);
+			}
+
+			if (rc == 0 && IS_PIPELIKE(finfo.st_mode))
+				forever = 0;
+		}
+	}
+
+	files = emalloc(n_files * sizeof(struct file_struct));
+
+	for (i = 0; i < n_files; i++) {
+		files[i].name = filenames[i];
+		setup_file(&files[i]);
+		ret = tail_file(&files[i], n_units, mode, forever);
+		if (ret < 0)
+			ignore_file(&files[i]);
+	}
+
+	if (forever)
+		ret = watch_files(files, n_files);
+
+	free(files);
+
+	return ret;
+}

src/inotail/inotail.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2005-2007, Tobias Klauser <tklauser@distanz.ch>
+ *
+ * Licensed under the terms of the GNU General Public License; version 2 or later.
+ */
+
+#ifndef _INOTAIL_H
+#define _INOTAIL_H
+
+#include <sys/types.h>
+
+/* Number of items to tail. */
+#define DEFAULT_N_LINES 10
+
+/* tail modes */
+enum { M_LINES, M_BYTES };
+
+/* Every tailed file is represented as a file_struct */
+struct file_struct {
+	char *name;		/* Name of file (or '-' for stdin) */
+	int fd;			/* File descriptor (or -1 if file is not open */
+	off_t size;		/* File size */
+	blksize_t blksize;	/* Blocksize for filesystem I/O */
+	unsigned ignore;	/* Whether to ignore the file in further processing */
+	int i_watch;		/* Inotify watch associated with file_struct */
+};
+
+#define IS_PIPELIKE(mode) \
+	(S_ISFIFO(mode) || S_ISSOCK(mode))
+
+/* inotail works on these file types */
+#define IS_TAILABLE(mode) \
+	(S_ISREG(mode) || IS_PIPELIKE(mode) || S_ISCHR(mode))
+
+#define is_digit(c) ((c) >= '0' && (c) <= '9')
+
+#ifdef DEBUG
+# define dprintf(fmt, args...) fprintf(stderr, fmt, ##args)
+#else
+# define dprintf(fmt, args...)
+#endif /* DEBUG */
+
+#ifdef __GNUC__
+# define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+# define unlikely(x) (x)
+#endif /* __GNUC__ */
+
+#endif /* _INOTAIL_H */

src/inotail/inotify-syscalls.h

@@ -0,0 +1,102 @@
+/*
+ * Inotify syscall numbers
+ * Taken from the Linux kernel source tree
+ *
+ * Licensed under the terms of the GNU General Public License Version 2.
+ *
+ * Copyright (c) 2006-2007 Tobias Klauser <tklauser@distanz.ch>
+ */
+
+#ifndef _LINUX_INOTIFY_SYSCALLS_H
+#define _LINUX_INOTIFY_SYSCALLS_H
+
+#include <sys/syscall.h>
+/* glibc already defines them for some architectures */
+#ifndef __NR_inotify_init
+#if defined(__i386__)
+# define __NR_inotify_init	291
+# define __NR_inotify_add_watch	292
+# define __NR_inotify_rm_watch	293
+#elif defined(__x86_64__)
+# define __NR_inotify_init	253
+# define __NR_inotify_add_watch	254
+# define __NR_inotify_rm_watch	255
+#elif defined(__powerpc__) || defined(__powerpc64__)
+# define __NR_inotify_init	275
+# define __NR_inotify_add_watch	276
+# define __NR_inotify_rm_watch	277
+#elif defined (__ia64__)
+# define __NR_inotify_init	1277
+# define __NR_inotify_add_watch	1278
+# define __NR_inotify_rm_watch	1279
+#elif defined (__s390__)
+# define __NR_inotify_init	284
+# define __NR_inotify_add_watch	285
+# define __NR_inotify_rm_watch	286
+#elif defined (__alpha__)
+# define __NR_inotify_init	444
+# define __NR_inotify_add_watch	445
+# define __NR_inotify_rm_watch	446
+#elif defined (__sparc__) || defined (__sparc64__)
+# define __NR_inotify_init	151
+# define __NR_inotify_add_watch	152
+# define __NR_inotify_rm_watch	156
+#elif defined (__arm__)
+# define __NR_inotify_init	(__NR_SYSCALL_BASE + 316)
+# define __NR_inotify_add_watch	(__NR_SYSCALL_BASE + 317)
+# define __NR_inotify_rm_watch	(__NR_SYSCALL_BASE + 318)
+#elif defined (__sh__)
+# define __NR_inotify_init	290
+# define __NR_inotify_add_watch	291
+# define __NR_inotify_rm_watch	292
+#elif defined (__m32r__)
+# define __NR_inotify_init      290
+# define __NR_inotify_add_watch	291
+# define __NR_inotify_rm_watch	292
+#elif defined (__hppa__)
+# define __NR_inotify_init	269
+# define __NR_inotify_add_watch	270
+# define __NR_inotify_rm_watch	271
+#elif defined (__mips__)
+# include <sgidefs.h>
+# if _MIPS_SIM == _MIPS_SIM_ABI32
+#  define __NR_Linux			4000
+#  define __NR_inotify_init		(__NR_Linux + 284)
+#  define __NR_inotify_add_watch	(__NR_Linux + 285)
+#  define __NR_inotify_rm_watch		(__NR_Linux + 286)
+# elif _MIPS_SIM == _MIPS_SIM_ABI64
+#  define __NR_Linux			5000
+#  define __NR_inotify_init		(__NR_Linux + 243)
+#  define __NR_inotify_add_watch	(__NR_Linux + 244)
+#  define __NR_inotify_rm_watch		(__NR_Linux + 245)
+# elif _MIPS_SIM == _MIPS_SIM_NABI32
+#  define __NR_Linux			6000
+#  define __NR_inotify_init		(__NR_Linux + 247)
+#  define __NR_inotify_add_watch	(__NR_Linux + 248)
+#  define __NR_inotify_rm_watch		(__NR_Linux + 249)
+# endif
+#elif defined (__m68k__)
+# define __NR_inotify_init	284
+# define __NR_inotify_add_watch	285
+# define __NR_inotify_rm_watch	286
+#else
+# error "inotify not supported on this architecture!"
+#endif
+#endif	/* __NR_inotify_init */
+
+static inline int inotify_init(void)
+{
+	return syscall(__NR_inotify_init);
+}
+
+static inline int inotify_add_watch(int fd, const char *name, __u32 mask)
+{
+	return syscall(__NR_inotify_add_watch, fd, name, mask);
+}
+
+static inline int inotify_rm_watch(int fd, __u32 wd)
+{
+	return syscall(__NR_inotify_rm_watch, fd, wd);
+}
+
+#endif /* _LINUX_INOTIFY_SYSCALLS_H */

src/inotail/inotify.h

@@ -0,0 +1,69 @@
+/*
+ * Inode based directory notification for Linux
+ * Taken from the Linux kernel source tree
+ *
+ * Licensed under the terms of the GNU General Public License Version 2.
+ *
+ * Copyright (C) 2005 John McCutchan
+ */
+
+#ifndef _LINUX_INOTIFY_H
+#define _LINUX_INOTIFY_H
+
+#include <linux/types.h>
+
+/*
+ * struct inotify_event - structure read from the inotify device for each event
+ *
+ * When you are watching a directory, you will receive the filename for events
+ * such as IN_CREATE, IN_DELETE, IN_OPEN, IN_CLOSE, ..., relative to the wd.
+ */
+struct inotify_event {
+	__s32		wd;		/* watch descriptor */
+	__u32		mask;		/* watch mask */
+	__u32		cookie;		/* cookie to synchronize two events */
+	__u32		len;		/* length (including nulls) of name */
+	char		name[0];	/* stub for possible name */
+};
+
+/* the following are legal, implemented events that user-space can watch for */
+#define IN_ACCESS		0x00000001	/* File was accessed */
+#define IN_MODIFY		0x00000002	/* File was modified */
+#define IN_ATTRIB		0x00000004	/* Metadata changed */
+#define IN_CLOSE_WRITE		0x00000008	/* Writtable file was closed */
+#define IN_CLOSE_NOWRITE	0x00000010	/* Unwrittable file closed */
+#define IN_OPEN			0x00000020	/* File was opened */
+#define IN_MOVED_FROM		0x00000040	/* File was moved from X */
+#define IN_MOVED_TO		0x00000080	/* File was moved to Y */
+#define IN_CREATE		0x00000100	/* Subfile was created */
+#define IN_DELETE		0x00000200	/* Subfile was deleted */
+#define IN_DELETE_SELF		0x00000400	/* Self was deleted */
+#define IN_MOVE_SELF		0x00000800	/* Self was moved */
+
+/* the following are legal events.  they are sent as needed to any watch */
+#define IN_UNMOUNT		0x00002000	/* Backing fs was unmounted */
+#define IN_Q_OVERFLOW		0x00004000	/* Event queued overflowed */
+#define IN_IGNORED		0x00008000	/* File was ignored */
+
+/* helper events */
+#define IN_CLOSE		(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* close */
+#define IN_MOVE			(IN_MOVED_FROM | IN_MOVED_TO) /* moves */
+
+/* special flags */
+#define IN_ONLYDIR		0x01000000	/* only watch the path if it is a directory */
+#define IN_DONT_FOLLOW		0x02000000	/* don't follow a sym link */
+#define IN_MASK_ADD		0x20000000	/* add to the mask of an already existing watch */
+#define IN_ISDIR		0x40000000	/* event occurred against dir */
+#define IN_ONESHOT		0x80000000	/* only send event once */
+
+/*
+ * All of the events - we build the list by hand so that we can add flags in
+ * the future and not break backward compatibility.  Apps will get only the
+ * events that they originally wanted.  Be sure to add new events here!
+ */
+#define IN_ALL_EVENTS	(IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | \
+			 IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | \
+			 IN_MOVED_TO | IN_DELETE | IN_CREATE | IN_DELETE_SELF | \
+			 IN_MOVE_SELF)
+
+#endif	/* _LINUX_INOTIFY_H */

src/websockify/Makefile

@@ -0,0 +1,14 @@
+TARGETS=websockify
+CFLAGS += -fPIC
+
+all: $(TARGETS)
+
+websockify: websockify.o websocket.o
+	$(CC) $(LDFLAGS) $^ -lssl -lcrypto -o $@
+
+websocket.o: websocket.c websocket.h
+websockify.o: websockify.c websocket.h
+
+clean:
+	rm -f websockify *.o
+

src/websockify/websocket.c

@@ -0,0 +1,914 @@
+/*
+ * WebSocket lib with support for "wss://" encryption.
+ * Copyright 2010 Joel Martin
+ * Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
+ *
+ * You can make a cert/key with openssl using:
+ * openssl req -new -x509 -days 365 -nodes -out self.pem -keyout self.pem
+ * as taken from http://docs.python.org/dev/library/ssl.html#certificates
+ */
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h> 
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <signal.h> // daemonizing
+#include <fcntl.h>  // daemonizing
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <openssl/bio.h> /* base64 encode/decode */
+#include <openssl/md5.h> /* md5 hash */
+#include <openssl/sha.h> /* sha1 hash */
+#include "websocket.h"
+
+/*
+ * Global state
+ *
+ *   Warning: not thread safe
+ */
+int ssl_initialized = 0;
+int pipe_error = 0;
+settings_t settings;
+
+
+void traffic(const char * token) {
+    if ((settings.verbose) && (! settings.daemon)) {
+        fprintf(stdout, "%s", token);
+        fflush(stdout);
+    }
+}
+
+void error(char *msg)
+{
+    perror(msg);
+}
+
+void fatal(char *msg)
+{
+    perror(msg);
+    exit(1);
+}
+
+/* resolve host with also IP address parsing */ 
+int resolve_host(struct in_addr *sin_addr, const char *hostname) 
+{ 
+    if (!inet_aton(hostname, sin_addr)) { 
+        struct addrinfo *ai, *cur; 
+        struct addrinfo hints; 
+        memset(&hints, 0, sizeof(hints)); 
+        hints.ai_family = AF_INET; 
+        if (getaddrinfo(hostname, NULL, &hints, &ai)) 
+            return -1; 
+        for (cur = ai; cur; cur = cur->ai_next) { 
+            if (cur->ai_family == AF_INET) { 
+                *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr; 
+                freeaddrinfo(ai); 
+                return 0; 
+            } 
+        } 
+        freeaddrinfo(ai); 
+        return -1; 
+    } 
+    return 0; 
+} 
+
+
+/*
+ * SSL Wrapper Code
+ */
+
+ssize_t ws_recv(ws_ctx_t *ctx, void *buf, size_t len) {
+    if (ctx->ssl) {
+        //handler_msg("SSL recv\n");
+        return SSL_read(ctx->ssl, buf, len);
+    } else {
+        return recv(ctx->sockfd, buf, len, 0);
+    }
+}
+
+ssize_t ws_send(ws_ctx_t *ctx, const void *buf, size_t len) {
+    if (ctx->ssl) {
+        //handler_msg("SSL send\n");
+        return SSL_write(ctx->ssl, buf, len);
+    } else {
+        return send(ctx->sockfd, buf, len, 0);
+    }
+}
+
+ws_ctx_t *alloc_ws_ctx() {
+    ws_ctx_t *ctx;
+    if (! (ctx = malloc(sizeof(ws_ctx_t))) )
+        { fatal("malloc()"); }
+
+    if (! (ctx->cin_buf = malloc(BUFSIZE)) )
+        { fatal("malloc of cin_buf"); }
+    if (! (ctx->cout_buf = malloc(BUFSIZE)) )
+        { fatal("malloc of cout_buf"); }
+    if (! (ctx->tin_buf = malloc(BUFSIZE)) )
+        { fatal("malloc of tin_buf"); }
+    if (! (ctx->tout_buf = malloc(BUFSIZE)) )
+        { fatal("malloc of tout_buf"); }
+
+    ctx->headers = malloc(sizeof(headers_t));
+    ctx->ssl = NULL;
+    ctx->ssl_ctx = NULL;
+    return ctx;
+}
+
+void free_ws_ctx(ws_ctx_t *ctx) {
+    free(ctx->cin_buf);
+    free(ctx->cout_buf);
+    free(ctx->tin_buf);
+    free(ctx->tout_buf);
+    free(ctx);
+}
+
+ws_ctx_t *ws_socket(ws_ctx_t *ctx, int socket) {
+    ctx->sockfd = socket;
+    return ctx;
+}
+
+ws_ctx_t *ws_socket_ssl(ws_ctx_t *ctx, int socket, char * certfile, char * keyfile) {
+    int ret;
+    char msg[1024];
+    char * use_keyfile;
+    ws_socket(ctx, socket);
+
+    if (keyfile && (keyfile[0] != '\0')) {
+        // Separate key file
+        use_keyfile = keyfile;
+    } else {
+        // Combined key and cert file
+        use_keyfile = certfile;
+    }
+
+    // Initialize the library
+    if (! ssl_initialized) {
+        SSL_library_init();
+        OpenSSL_add_all_algorithms();
+        SSL_load_error_strings();
+        ssl_initialized = 1;
+
+    }
+
+    //ctx->ssl_ctx = SSL_CTX_new(TLSv1_server_method());
+    ctx->ssl_ctx = SSL_CTX_new(TLS_server_method());
+    if (ctx->ssl_ctx == NULL) {
+        ERR_print_errors_fp(stderr);
+        fatal("Failed to configure SSL context");
+    }
+
+    if (SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, use_keyfile,
+                                    SSL_FILETYPE_PEM) <= 0) {
+        sprintf(msg, "Unable to load private key file %s\n", use_keyfile);
+        fatal(msg);
+    }
+
+    if (SSL_CTX_use_certificate_chain_file(ctx->ssl_ctx, certfile) <= 0) {
+        sprintf(msg, "Unable to load certificate file %s\n", certfile);
+        fatal(msg);
+    }
+
+//    if (SSL_CTX_set_cipher_list(ctx->ssl_ctx, "DEFAULT") != 1) {
+//        sprintf(msg, "Unable to set cipher\n");
+//        fatal(msg);
+//    }
+
+    // Associate socket and ssl object
+    ctx->ssl = SSL_new(ctx->ssl_ctx);
+    SSL_set_fd(ctx->ssl, socket);
+
+    ret = SSL_accept(ctx->ssl);
+    if (ret < 0) {
+        ERR_print_errors_fp(stderr);
+        return NULL;
+    }
+
+    return ctx;
+}
+
+void ws_socket_free(ws_ctx_t *ctx) {
+    if (ctx->ssl) {
+        SSL_free(ctx->ssl);
+        ctx->ssl = NULL;
+    }
+    if (ctx->ssl_ctx) {
+        SSL_CTX_free(ctx->ssl_ctx);
+        ctx->ssl_ctx = NULL;
+    }
+    if (ctx->sockfd) {
+        shutdown(ctx->sockfd, SHUT_RDWR);
+        close(ctx->sockfd);
+        ctx->sockfd = 0;
+    }
+}
+
+int ws_b64_ntop(const unsigned char const * src, size_t srclen, char * dst, size_t dstlen) {
+    int len = 0;
+    int total_len = 0;
+
+    BIO *buff, *b64f;
+    BUF_MEM *ptr;
+
+    b64f = BIO_new(BIO_f_base64());
+    buff = BIO_new(BIO_s_mem());
+    buff = BIO_push(b64f, buff);
+
+    BIO_set_flags(buff, BIO_FLAGS_BASE64_NO_NL);
+    BIO_set_close(buff, BIO_CLOSE);
+    do {
+        len = BIO_write(buff, src + total_len, srclen - total_len);
+        if (len > 0)
+            total_len += len;
+    } while (len && BIO_should_retry(buff));
+
+    BIO_flush(buff);
+
+    BIO_get_mem_ptr(buff, &ptr);
+    len = ptr->length;
+
+    memcpy(dst, ptr->data, dstlen < len ? dstlen : len);
+    dst[dstlen < len ? dstlen : len] = '\0';
+
+    BIO_free_all(buff);
+
+    if (dstlen < len)
+        return -1;
+
+    return len;
+}
+
+int ws_b64_pton(const char const * src, unsigned char * dst, size_t dstlen) {
+    int len = 0;
+    int total_len = 0;
+    int pending = 0;
+
+    BIO *buff, *b64f;
+
+    b64f = BIO_new(BIO_f_base64());
+    buff = BIO_new_mem_buf(src, -1);
+    buff = BIO_push(b64f, buff);
+
+    BIO_set_flags(buff, BIO_FLAGS_BASE64_NO_NL);
+    BIO_set_close(buff, BIO_CLOSE);
+    do {
+        len = BIO_read(buff, dst + total_len, dstlen - total_len);
+        if (len > 0)
+            total_len += len;
+    } while (len && BIO_should_retry(buff));
+
+    dst[total_len] = '\0';
+
+    pending = BIO_ctrl_pending(buff);
+
+    BIO_free_all(buff);
+
+    if (pending)
+        return -1;
+
+    return len;
+}
+
+/* ------------------------------------------------------- */
+
+
+int encode_hixie(u_char const *src, size_t srclength,
+                 char *target, size_t targsize) {
+    int sz = 0, len = 0;
+    target[sz++] = '\x00';
+    len = ws_b64_ntop(src, srclength, target+sz, targsize-sz);
+    if (len < 0) {
+        return len;
+    }
+    sz += len;
+    target[sz++] = '\xff';
+    return sz;
+}
+
+int decode_hixie(char *src, size_t srclength,
+                 u_char *target, size_t targsize,
+                 unsigned int *opcode, unsigned int *left) {
+    char *start, *end, cntstr[4];
+    int i, len, framecount = 0, retlen = 0;
+    unsigned char chr;
+    if ((src[0] != '\x00') || (src[srclength-1] != '\xff')) {
+        handler_emsg("WebSocket framing error\n");
+        return -1;
+    }
+    *left = srclength;
+
+    if (srclength == 2 &&
+        (src[0] == '\xff') && 
+        (src[1] == '\x00')) {
+        // client sent orderly close frame
+        *opcode = 0x8; // Close frame
+        return 0;
+    }
+    *opcode = 0x1; // Text frame
+
+    start = src+1; // Skip '\x00' start
+    do {
+        /* We may have more than one frame */
+        end = (char *)memchr(start, '\xff', srclength);
+        *end = '\x00';
+        len = ws_b64_pton(start, target+retlen, targsize-retlen);
+        if (len < 0) {
+            return len;
+        }
+        retlen += len;
+        start = end + 2; // Skip '\xff' end and '\x00' start 
+        framecount++;
+    } while (end < (src+srclength-1));
+    if (framecount > 1) {
+        //snprintf(cntstr, 3, "%d", framecount);
+        snprintf(cntstr, 4, "%d",  framecount > 999 ? 999 : framecount);
+        traffic(cntstr);
+    }
+    *left = 0;
+    return retlen;
+}
+
+int encode_hybi(u_char const *src, size_t srclength,
+                char *target, size_t targsize, unsigned int opcode)
+{
+    unsigned long long payload_offset = 2;
+    int len = 0;
+
+    if (opcode != OPCODE_TEXT && opcode != OPCODE_BINARY) {
+        handler_emsg("Invalid opcode. Opcode must be 0x01 for text mode, or 0x02 for binary mode.\n");
+        return -1;
+    }
+
+    target[0] = (char)((opcode & 0x0F) | 0x80);
+
+    if ((int)srclength <= 0) {
+        return 0;
+    }
+
+    if (opcode & OPCODE_TEXT) {
+        len = ((srclength - 1) / 3) * 4 + 4;
+    } else {
+        len = srclength;
+    }
+
+    if (len <= 125) {
+        target[1] = (char) len;
+        payload_offset = 2;
+    } else if ((len > 125) && (len < 65536)) {
+        target[1] = (char) 126;
+        *(u_short*)&(target[2]) = htons(len);
+        payload_offset = 4;
+    } else {
+        handler_emsg("Sending frames larger than 65535 bytes not supported\n");
+        return -1;
+        //target[1] = (char) 127;
+        //*(u_long*)&(target[2]) = htonl(b64_sz);
+        //payload_offset = 10;
+    }
+
+    if (opcode & OPCODE_TEXT) {
+        len = ws_b64_ntop(src, srclength, target+payload_offset, targsize-payload_offset);
+    } else {
+        memcpy(target+payload_offset, src, srclength);
+        len = srclength;
+    }
+
+    if (len < 0) {
+        return len;
+    }
+
+    return len + payload_offset;
+}
+
+int decode_hybi(unsigned char *src, size_t srclength,
+                u_char *target, size_t targsize,
+                unsigned int *opcode, unsigned int *left)
+{
+    unsigned char *frame, *mask, *payload, save_char;
+    char cntstr[4];
+    int masked = 0;
+    int i = 0, len, framecount = 0;
+    size_t remaining;
+    unsigned int target_offset = 0, hdr_length = 0, payload_length = 0;
+    
+    *left = srclength;
+    frame = src;
+
+    //printf("Deocde new frame\n");
+    while (1) {
+        // Need at least two bytes of the header
+        // Find beginning of next frame. First time hdr_length, masked and
+        // payload_length are zero
+        frame += hdr_length + 4*masked + payload_length;
+        //printf("frame[0..3]: 0x%x 0x%x 0x%x 0x%x (tot: %d)\n",
+        //       (unsigned char) frame[0],
+        //       (unsigned char) frame[1],
+        //       (unsigned char) frame[2],
+        //       (unsigned char) frame[3], srclength);
+
+        if (frame > src + srclength) {
+            //printf("Truncated frame from client, need %d more bytes\n", frame - (src + srclength) );
+            break;
+        }
+        remaining = (src + srclength) - frame;
+        if (remaining < 2) {
+            //printf("Truncated frame header from client\n");
+            break;
+        }
+        framecount ++;
+
+        *opcode = frame[0] & 0x0f;
+        masked = (frame[1] & 0x80) >> 7;
+
+        if (*opcode == 0x8) {
+            // client sent orderly close frame
+            break;
+        }
+
+        payload_length = frame[1] & 0x7f;
+        if (payload_length < 126) {
+            hdr_length = 2;
+            //frame += 2 * sizeof(char);
+        } else if (payload_length == 126) {
+            payload_length = (frame[2] << 8) + frame[3];
+            hdr_length = 4;
+        } else {
+            handler_emsg("Receiving frames larger than 65535 bytes not supported\n");
+            return -1;
+        }
+        if ((hdr_length + 4*masked + payload_length) > remaining) {
+            continue;
+        }
+        //printf("    payload_length: %u, raw remaining: %u\n", payload_length, remaining);
+        payload = frame + hdr_length + 4*masked;
+
+        if (*opcode != OPCODE_TEXT && *opcode != OPCODE_BINARY) {
+            handler_msg("Ignoring non-data frame, opcode 0x%x\n", *opcode);
+            continue;
+        }
+
+        if (payload_length == 0) {
+            handler_msg("Ignoring empty frame\n");
+            continue;
+        }
+
+        if ((payload_length > 0) && (!masked)) {
+            handler_emsg("Received unmasked payload from client\n");
+            return -1;
+        }
+
+        // Terminate with a null for base64 decode
+        save_char = payload[payload_length];
+        payload[payload_length] = '\0';
+
+        // unmask the data
+        mask = payload - 4;
+        for (i = 0; i < payload_length; i++) {
+            payload[i] ^= mask[i%4];
+        }
+
+        if (*opcode & OPCODE_TEXT) {
+            // base64 decode the data
+            len = ws_b64_pton((const char*)payload, target+target_offset, targsize);
+        } else {
+            memcpy(target+target_offset, payload, payload_length);
+            len = payload_length;
+        }
+
+        // Restore the first character of the next frame
+        payload[payload_length] = save_char;
+        if (len < 0) {
+            handler_emsg("Base64 decode error code %d", len);
+            return len;
+        }
+        target_offset += len;
+
+        //printf("    len %d, raw %s\n", len, frame);
+    }
+
+    if (framecount > 1) {
+        //snprintf(cntstr, 3, "%d", framecount);
+        snprintf(cntstr, 4, "%d",  framecount > 999 ? 999 : framecount);
+        traffic(cntstr);
+    }
+    
+    *left = remaining;
+    return target_offset;
+}
+
+
+
+int parse_handshake(ws_ctx_t *ws_ctx, char *handshake) {
+    char *start, *end;
+    headers_t *headers = ws_ctx->headers;
+
+    headers->key1[0] = '\0';
+    headers->key2[0] = '\0';
+    headers->key3[0] = '\0';
+    
+    if ((strlen(handshake) < 92) || (bcmp(handshake, "GET ", 4) != 0)) {
+        return 0;
+    }
+    start = handshake+4;
+    end = strstr(start, " HTTP/1.1");
+    if (!end) { return 0; }
+    strncpy(headers->path, start, end-start);
+    headers->path[end-start] = '\0';
+
+    start = strstr(handshake, "\r\nHost: ");
+    if (!start) { return 0; }
+    start += 8;
+    end = strstr(start, "\r\n");
+    strncpy(headers->host, start, end-start);
+    headers->host[end-start] = '\0';
+
+    headers->origin[0] = '\0';
+    start = strstr(handshake, "\r\nOrigin: ");
+    if (start) {
+        start += 10;
+    } else {
+        start = strstr(handshake, "\r\nSec-WebSocket-Origin: ");
+        if (!start) { return 0; }
+        start += 24;
+    }
+    end = strstr(start, "\r\n");
+    strncpy(headers->origin, start, end-start);
+    headers->origin[end-start] = '\0';
+   
+    start = strstr(handshake, "\r\nSec-WebSocket-Version: ");
+    if (start) {
+        // HyBi/RFC 6455
+        start += 25;
+        end = strstr(start, "\r\n");
+        strncpy(headers->version, start, end-start);
+        headers->version[end-start] = '\0';
+        ws_ctx->hixie = 0;
+        ws_ctx->hybi = strtol(headers->version, NULL, 10);
+
+        start = strstr(handshake, "\r\nSec-WebSocket-Key: ");
+        if (!start) { return 0; }
+        start += 21;
+        end = strstr(start, "\r\n");
+        strncpy(headers->key1, start, end-start);
+        headers->key1[end-start] = '\0';
+   
+        start = strstr(handshake, "\r\nConnection: ");
+        if (!start) { return 0; }
+        start += 14;
+        end = strstr(start, "\r\n");
+        strncpy(headers->connection, start, end-start);
+        headers->connection[end-start] = '\0';
+   
+        start = strstr(handshake, "\r\nSec-WebSocket-Protocol: ");
+        if (!start) { return 0; }
+        start += 26;
+        end = strstr(start, "\r\n");
+        strncpy(headers->protocols, start, end-start);
+        headers->protocols[end-start] = '\0';
+    } else {
+        // Hixie 75 or 76
+        ws_ctx->hybi = 0;
+
+        start = strstr(handshake, "\r\n\r\n");
+        if (!start) { return 0; }
+        start += 4;
+        if (strlen(start) == 8) {
+            ws_ctx->hixie = 76;
+            strncpy(headers->key3, start, 8);
+            headers->key3[8] = '\0';
+
+            start = strstr(handshake, "\r\nSec-WebSocket-Key1: ");
+            if (!start) { return 0; }
+            start += 22;
+            end = strstr(start, "\r\n");
+            strncpy(headers->key1, start, end-start);
+            headers->key1[end-start] = '\0';
+        
+            start = strstr(handshake, "\r\nSec-WebSocket-Key2: ");
+            if (!start) { return 0; }
+            start += 22;
+            end = strstr(start, "\r\n");
+            strncpy(headers->key2, start, end-start);
+            headers->key2[end-start] = '\0';
+        } else {
+            ws_ctx->hixie = 75;
+        }
+
+    }
+
+    return 1;
+}
+
+int parse_hixie76_key(char * key) {
+    unsigned long i, spaces = 0, num = 0;
+    for (i=0; i < strlen(key); i++) {
+        if (key[i] == ' ') {
+            spaces += 1;
+        }
+        if ((key[i] >= 48) && (key[i] <= 57)) {
+            num = num * 10 + (key[i] - 48);
+        }
+    }
+    return num / spaces;
+}
+
+int gen_md5(headers_t *headers, char *target) {
+    unsigned long key1 = parse_hixie76_key(headers->key1);
+    unsigned long key2 = parse_hixie76_key(headers->key2);
+    char *key3 = headers->key3;
+
+    MD5_CTX c;
+    char in[HIXIE_MD5_DIGEST_LENGTH] = {
+        key1 >> 24, key1 >> 16, key1 >> 8, key1,
+        key2 >> 24, key2 >> 16, key2 >> 8, key2,
+        key3[0], key3[1], key3[2], key3[3],
+        key3[4], key3[5], key3[6], key3[7]
+    };
+
+    MD5_Init(&c);
+    MD5_Update(&c, (void *)in, sizeof in);
+    MD5_Final((void *)target, &c);
+
+    target[HIXIE_MD5_DIGEST_LENGTH] = '\0';
+
+    return 1;
+}
+
+static void gen_sha1(headers_t *headers, char *target) {
+    SHA_CTX c;
+    unsigned char hash[SHA_DIGEST_LENGTH];
+    int r;
+
+    SHA1_Init(&c);
+    SHA1_Update(&c, headers->key1, strlen(headers->key1));
+    SHA1_Update(&c, HYBI_GUID, 36);
+    SHA1_Final(hash, &c);
+
+    r = ws_b64_ntop(hash, sizeof hash, target, HYBI10_ACCEPTHDRLEN);
+    //assert(r == HYBI10_ACCEPTHDRLEN - 1);
+}
+
+
+ws_ctx_t *do_handshake(int sock) {
+    char handshake[4096], response[4096], sha1[29], trailer[17];
+    char *scheme, *pre;
+    headers_t *headers;
+    int len, ret, i, offset;
+    ws_ctx_t * ws_ctx;
+    char *response_protocol;
+
+    // Peek, but don't read the data
+    len = recv(sock, handshake, 1024, MSG_PEEK);
+    handshake[len] = 0;
+    if (len == 0) {
+        handler_msg("ignoring empty handshake\n");
+        return NULL;
+    } else if ((bcmp(handshake, "\x16", 1) == 0) ||
+               (bcmp(handshake, "\x80", 1) == 0)) {
+        // SSL
+        if (!settings.cert) {
+            handler_msg("SSL connection but no cert specified\n");
+            return NULL;
+        } else if (access(settings.cert, R_OK) != 0) {
+            handler_msg("SSL connection but '%s' not found\n",
+                        settings.cert);
+            return NULL;
+        }
+        ws_ctx = alloc_ws_ctx();
+        ws_socket_ssl(ws_ctx, sock, settings.cert, settings.key);
+        if (! ws_ctx) { return NULL; }
+        scheme = "wss";
+        handler_msg("using SSL socket\n");
+    } else if (settings.ssl_only) {
+        handler_msg("non-SSL connection disallowed\n");
+        return NULL;
+    } else {
+        ws_ctx = alloc_ws_ctx();
+        ws_socket(ws_ctx, sock);
+        if (! ws_ctx) { return NULL; }
+        scheme = "ws";
+        handler_msg("using plain (not SSL) socket\n");
+    }
+    offset = 0;
+    for (i = 0; i < 10; i++) {
+        /* (offset + 1): reserve one byte for the trailing '\0' */
+        if (0 > (len = ws_recv(ws_ctx, handshake + offset, sizeof(handshake) - (offset + 1)))) {
+            handler_emsg("Read error during handshake: %m\n");
+            free_ws_ctx(ws_ctx);
+            return NULL;
+        } else if (0 == len) {
+            handler_emsg("Client closed during handshake\n");
+            free_ws_ctx(ws_ctx);
+            return NULL;
+        }
+        offset += len;
+        handshake[offset] = 0;
+        if (strstr(handshake, "\r\n\r\n")) {
+            break;
+        } else if (sizeof(handshake) <= (size_t)(offset + 1)) {
+            handler_emsg("Oversized handshake\n");
+            free_ws_ctx(ws_ctx);
+            return NULL;
+        } else if (9 == i) {
+            handler_emsg("Incomplete handshake\n");
+            free_ws_ctx(ws_ctx);
+            return NULL;
+        }
+        usleep(10);
+    }
+
+    //handler_msg("handshake: %s\n", handshake);
+    if (!parse_handshake(ws_ctx, handshake)) {
+        handler_emsg("Invalid WS request\n");
+        free_ws_ctx(ws_ctx);
+        return NULL;
+    }
+
+    headers = ws_ctx->headers;
+
+    response_protocol = strtok(headers->protocols, ",");
+    if (!response_protocol || !strlen(response_protocol)) {
+        ws_ctx->opcode = OPCODE_BINARY;
+        response_protocol = "null";
+    } else if (!strcmp(response_protocol, "base64")) {
+      ws_ctx->opcode = OPCODE_TEXT;
+    } else {
+        ws_ctx->opcode = OPCODE_BINARY;
+    }
+
+    if (ws_ctx->hybi > 0) {
+        handler_msg("using protocol HyBi/IETF 6455 %d\n", ws_ctx->hybi);
+        gen_sha1(headers, sha1);
+        snprintf(response, sizeof(response), SERVER_HANDSHAKE_HYBI, sha1, response_protocol);
+    } else {
+        if (ws_ctx->hixie == 76) {
+            handler_msg("using protocol Hixie 76\n");
+            gen_md5(headers, trailer);
+            pre = "Sec-";
+        } else {
+            handler_msg("using protocol Hixie 75\n");
+            trailer[0] = '\0';
+            pre = "";
+        }
+        snprintf(response, sizeof(response), SERVER_HANDSHAKE_HIXIE, pre, headers->origin,
+                 pre, scheme, headers->host, headers->path, pre, "base64", trailer);
+    }
+    
+    //handler_msg("response: %s\n", response);
+    ws_send(ws_ctx, response, strlen(response));
+
+    return ws_ctx;
+}
+
+void signal_handler(int sig) {
+    switch (sig) {
+        case SIGHUP: break; // ignore for now
+        case SIGPIPE: pipe_error = 1; break; // handle inline
+        case SIGTERM: exit(0); break;
+    }
+}
+
+void daemonize(int keepfd) {
+    int pid, i;
+
+    umask(0);
+    if (!chdir("/")) { handler_emsg("Unable to chdir(\"/\").\n"); }
+    if (!setgid(getgid())) { handler_emsg("Unable to setgid().\n"); }
+    if (!setuid(getuid())) { handler_emsg("Unable to setuid().\n"); }
+
+    /* Double fork to daemonize */
+    pid = fork();
+    if (pid<0) { fatal("fork error"); }
+    if (pid>0) { exit(0); }  // parent exits
+    setsid();                // Obtain new process group
+    pid = fork();
+    if (pid<0) { fatal("fork error"); }
+    if (pid>0) { exit(0); }  // parent exits
+
+    /* Signal handling */
+    signal(SIGHUP, signal_handler);   // catch HUP
+    signal(SIGTERM, signal_handler);  // catch kill
+
+    /* Close open files */
+    for (i=getdtablesize(); i>=0; --i) {
+        if (i != keepfd) {
+            close(i);
+        } else if (settings.verbose) {
+            printf("keeping fd %d\n", keepfd);
+        }
+    }
+    i=open("/dev/null", O_RDWR);  // Redirect stdin
+    if (!dup(i)) { handler_emsg("Unable redirect stdout.\n"); } // Redirect stdout
+    if (!dup(i)) { handler_emsg("Unable redirect stderr.\n"); } // Redirect stderr
+}
+
+
+void start_server() {
+    int lsock, csock, pid, sopt = 1, i;
+    struct sockaddr_in serv_addr, cli_addr;
+    socklen_t clilen;
+    ws_ctx_t *ws_ctx;
+
+
+    /* Initialize buffers */
+    lsock = socket(AF_INET, SOCK_STREAM, 0);
+    if (lsock < 0) { error("ERROR creating listener socket"); }
+    bzero((char *) &serv_addr, sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_port = htons(settings.listen_port);
+
+    /* Resolve listen address */
+    if (settings.listen_host && (settings.listen_host[0] != '\0')) {
+        if (resolve_host(&serv_addr.sin_addr, settings.listen_host) < -1) {
+            fatal("Could not resolve listen address");
+        }
+    } else {
+        serv_addr.sin_addr.s_addr = INADDR_ANY;
+    }
+
+    setsockopt(lsock, SOL_SOCKET, SO_REUSEADDR, (char *)&sopt, sizeof(sopt));
+    if (bind(lsock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
+        fatal("ERROR on binding listener socket");
+    }
+    listen(lsock,100);
+
+    signal(SIGPIPE, signal_handler);  // catch pipe
+
+    if (settings.daemon) {
+        daemonize(lsock);
+    }
+
+
+    // Reep zombies
+    signal(SIGCHLD, SIG_IGN);
+
+    printf("Waiting for connections on %s:%d\n",
+            settings.listen_host, settings.listen_port);
+
+    while (1) {
+        clilen = sizeof(cli_addr);
+        pipe_error = 0;
+        pid = 0;
+        csock = accept(lsock, 
+                       (struct sockaddr *) &cli_addr, 
+                       &clilen);
+        if (csock < 0) {
+            error("ERROR on accept");
+            continue;
+        }
+        handler_msg("got client connection from %s\n",
+                    inet_ntoa(cli_addr.sin_addr));
+
+        if (!settings.run_once) {
+            handler_msg("forking handler process\n");
+            pid = fork();
+        }
+
+        if (pid == 0) {  // handler process
+            ws_ctx = do_handshake(csock);
+            if (settings.run_once) {
+                if (ws_ctx == NULL) {
+                    // Not a real WebSocket connection
+                    continue;
+                } else {
+                    // Successful connection, stop listening for new
+                    // connections
+                    close(lsock);
+                }
+            }
+            if (ws_ctx == NULL) {
+                handler_msg("No connection after handshake\n");
+                break;   // Child process exits
+            }
+
+            settings.handler(ws_ctx);
+            if (pipe_error) {
+                handler_emsg("Closing due to SIGPIPE\n");
+            }
+            break;   // Child process exits
+        } else {         // parent process
+            settings.handler_id += 1;
+            close(csock);
+        }
+    }
+    if (pid == 0) {
+        if (ws_ctx) {
+            ws_socket_free(ws_ctx);
+            free_ws_ctx(ws_ctx);
+        } else {
+            shutdown(csock, SHUT_RDWR);
+            close(csock);
+        }
+        handler_msg("handler exit\n");
+    } else {
+        handler_msg("websockify exit\n");
+    }
+
+}
+

src/websockify/websocket.h

@@ -0,0 +1,104 @@
+#include <openssl/ssl.h>
+
+#define BUFSIZE 65536
+#define DBUFSIZE (BUFSIZE * 3) / 4 - 20
+
+#define SERVER_HANDSHAKE_HIXIE "HTTP/1.1 101 Web Socket Protocol Handshake\r\n\
+Upgrade: WebSocket\r\n\
+Connection: Upgrade\r\n\
+%sWebSocket-Origin: %s\r\n\
+%sWebSocket-Location: %s://%s%s\r\n\
+%sWebSocket-Protocol: %s\r\n\
+\r\n%s"
+
+#define SERVER_HANDSHAKE_HYBI "HTTP/1.1 101 Switching Protocols\r\n\
+Upgrade: websocket\r\n\
+Connection: Upgrade\r\n\
+Sec-WebSocket-Accept: %s\r\n\
+Sec-WebSocket-Protocol: %s\r\n\
+\r\n"
+
+#define HYBI_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+#define HYBI10_ACCEPTHDRLEN 29
+
+#define HIXIE_MD5_DIGEST_LENGTH 16
+
+#define POLICY_RESPONSE "<cross-domain-policy><allow-access-from domain=\"*\" to-ports=\"*\" /></cross-domain-policy>\n"
+
+#define OPCODE_TEXT    0x01
+#define OPCODE_BINARY  0x02
+
+typedef struct {
+    char path[1024+1];
+    char host[1024+1];
+    char origin[1024+1];
+    char version[1024+1];
+    char connection[1024+1];
+    char protocols[1024+1];
+    char key1[1024+1];
+    char key2[1024+1];
+    char key3[8+1];
+} headers_t;
+
+typedef struct {
+    int        sockfd;
+    SSL_CTX   *ssl_ctx;
+    SSL       *ssl;
+    int        hixie;
+    int        hybi;
+    int        opcode;
+    headers_t *headers;
+    char      *cin_buf;
+    char      *cout_buf;
+    char      *tin_buf;
+    char      *tout_buf;
+} ws_ctx_t;
+
+typedef struct {
+    int verbose;
+    char listen_host[256];
+    int listen_port;
+    void (*handler)(ws_ctx_t*);
+    int handler_id;
+    char *cert;
+    char *key;
+    int ssl_only;
+    int daemon;
+    int run_once;
+} settings_t;
+
+
+int resolve_host(struct in_addr *sin_addr, const char *hostname);
+
+ssize_t ws_recv(ws_ctx_t *ctx, void *buf, size_t len);
+
+ssize_t ws_send(ws_ctx_t *ctx, const void *buf, size_t len);
+
+/* base64.c declarations */
+//int b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize);
+//int b64_pton(char const *src, u_char *target, size_t targsize);
+
+#define gen_handler_msg(stream, ...) \
+    if (! settings.daemon) { \
+        fprintf(stream, "  %d: ", settings.handler_id); \
+        fprintf(stream, __VA_ARGS__); \
+    }
+
+#define handler_msg(...) gen_handler_msg(stdout, __VA_ARGS__);
+#define handler_emsg(...) gen_handler_msg(stderr, __VA_ARGS__);
+
+void traffic(const char * token);
+
+int encode_hixie(u_char const *src, size_t srclength,
+                 char *target, size_t targsize);
+int decode_hixie(char *src, size_t srclength,
+                 u_char *target, size_t targsize,
+                 unsigned int *opcode, unsigned int *left);
+int encode_hybi(u_char const *src, size_t srclength,
+                char *target, size_t targsize, unsigned int opcode);
+int decode_hybi(unsigned char *src, size_t srclength,
+                u_char *target, size_t targsize,
+                unsigned int *opcode, unsigned int *left);
+
+void start_server();

src/websockify/websockify.c

@@ -0,0 +1,388 @@
+/*
+ * A WebSocket to TCP socket proxy with support for "wss://" encryption.
+ * Copyright 2010 Joel Martin
+ * Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
+ *
+ * You can make a cert/key with openssl using:
+ * openssl req -new -x509 -days 365 -nodes -out self.pem -keyout self.pem
+ * as taken from http://docs.python.org/dev/library/ssl.html#certificates
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <limits.h>
+#include <getopt.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <sys/select.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "websocket.h"
+
+char traffic_legend[] = "\n\
+Traffic Legend:\n\
+    }  - Client receive\n\
+    }. - Client receive partial\n\
+    {  - Target receive\n\
+\n\
+    >  - Target send\n\
+    >. - Target send partial\n\
+    <  - Client send\n\
+    <. - Client send partial\n\
+";
+
+char USAGE[] = "Usage: [options] " \
+               "[source_addr:]source_port target_addr:target_port\n\n" \
+               "  --verbose|-v       verbose messages and per frame traffic\n" \
+               "  --daemon|-D        become a daemon (background process)\n" \
+               "  --run-once         handle a single WebSocket connection and exit\n" \
+               "  --cert CERT        SSL certificate file\n" \
+               "  --key KEY          SSL key file (if separate from cert)\n" \
+               "  --ssl-only         disallow non-encrypted connections";
+
+#define usage(fmt, args...) \
+    fprintf(stderr, "%s\n\n", USAGE); \
+    fprintf(stderr, fmt , ## args); \
+    exit(1);
+
+char target_host[256];
+int target_port;
+
+extern int pipe_error;
+extern settings_t settings;
+
+void do_proxy(ws_ctx_t *ws_ctx, int target) {
+    fd_set rlist, wlist, elist;
+    struct timeval tv;
+    int i, maxfd, client = ws_ctx->sockfd;
+    unsigned int opcode, left, ret;
+    unsigned int tout_start, tout_end, cout_start, cout_end;
+    unsigned int tin_start, tin_end;
+    ssize_t len, bytes;
+
+    tout_start = tout_end = cout_start = cout_end;
+    tin_start = tin_end = 0;
+    maxfd = client > target ? client+1 : target+1;
+
+    while (1) {
+        tv.tv_sec = 1;
+        tv.tv_usec = 0;
+
+        FD_ZERO(&rlist);
+        FD_ZERO(&wlist);
+        FD_ZERO(&elist);
+
+        FD_SET(client, &elist);
+        FD_SET(target, &elist);
+
+        if (tout_end == tout_start) {
+            // Nothing queued for target, so read from client
+            FD_SET(client, &rlist);
+        } else {
+            // Data queued for target, so write to it
+            FD_SET(target, &wlist);
+        }
+        if (cout_end == cout_start) {
+            // Nothing queued for client, so read from target
+            FD_SET(target, &rlist);
+        } else {
+            // Data queued for client, so write to it
+            FD_SET(client, &wlist);
+        }
+
+        ret = select(maxfd, &rlist, &wlist, &elist, &tv);
+        if (pipe_error) { break; }
+
+        if (FD_ISSET(target, &elist)) {
+            handler_emsg("target exception\n");
+            break;
+        }
+        if (FD_ISSET(client, &elist)) {
+            handler_emsg("client exception\n");
+            break;
+        }
+
+        if (ret == -1) {
+            handler_emsg("select(): %s\n", strerror(errno));
+            break;
+        } else if (ret == 0) {
+            //handler_emsg("select timeout\n");
+            continue;
+        }
+
+        if (FD_ISSET(target, &wlist)) {
+            len = tout_end-tout_start;
+            bytes = send(target, ws_ctx->tout_buf + tout_start, len, 0);
+            if (pipe_error) { break; }
+            if (bytes < 0) {
+                handler_emsg("target connection error: %s\n",
+                             strerror(errno));
+                break;
+            }
+            tout_start += bytes;
+            if (tout_start >= tout_end) {
+                tout_start = tout_end = 0;
+                traffic(">");
+            } else {
+                traffic(">.");
+            }
+        }
+
+        if (FD_ISSET(client, &wlist)) {
+            len = cout_end-cout_start;
+            bytes = ws_send(ws_ctx, ws_ctx->cout_buf + cout_start, len);
+            if (pipe_error) { break; }
+            if (len < 3) {
+                handler_emsg("len: %d, bytes: %d: %d\n",
+                             (int) len, (int) bytes,
+                             (int) *(ws_ctx->cout_buf + cout_start));
+            }
+            cout_start += bytes;
+            if (cout_start >= cout_end) {
+                cout_start = cout_end = 0;
+                traffic("<");
+            } else {
+                traffic("<.");
+            }
+        }
+
+        if (FD_ISSET(target, &rlist)) {
+            bytes = recv(target, ws_ctx->cin_buf, DBUFSIZE , 0);
+            if (pipe_error) { break; }
+            if (bytes <= 0) {
+                handler_emsg("target closed connection\n");
+                break;
+            }
+            cout_start = 0;
+            if (ws_ctx->hybi) {
+                cout_end = encode_hybi(ws_ctx->cin_buf, bytes,
+                                   ws_ctx->cout_buf, BUFSIZE, ws_ctx->opcode);
+            } else {
+                cout_end = encode_hixie(ws_ctx->cin_buf, bytes,
+                                    ws_ctx->cout_buf, BUFSIZE);
+            }
+            /*
+            printf("encoded: ");
+            for (i=0; i< cout_end; i++) {
+                printf("%u,", (unsigned char) *(ws_ctx->cout_buf+i));
+            }
+            printf("\n");
+            */
+            if (cout_end < 0) {
+                handler_emsg("encoding error\n");
+                break;
+            }
+            traffic("{");
+        }
+
+        if (FD_ISSET(client, &rlist)) {
+            bytes = ws_recv(ws_ctx, ws_ctx->tin_buf + tin_end, BUFSIZE-1);
+            if (pipe_error) { break; }
+            if (bytes <= 0) {
+                handler_emsg("client closed connection\n");
+                break;
+            }
+            tin_end += bytes;
+            /*
+            printf("before decode: ");
+            for (i=0; i< bytes; i++) {
+                printf("%u,", (unsigned char) *(ws_ctx->tin_buf+i));
+            }
+            printf("\n");
+            */
+            if (ws_ctx->hybi) {
+                len = decode_hybi(ws_ctx->tin_buf + tin_start,
+                                  tin_end-tin_start,
+                                  ws_ctx->tout_buf, BUFSIZE-1,
+                                  &opcode, &left);
+            } else {
+                len = decode_hixie(ws_ctx->tin_buf + tin_start,
+                                   tin_end-tin_start,
+                                   ws_ctx->tout_buf, BUFSIZE-1,
+                                   &opcode, &left);
+            }
+
+            if (opcode == 8) {
+                handler_msg("client sent orderly close frame\n");
+                break;
+            }
+
+            /*
+            printf("decoded: ");
+            for (i=0; i< len; i++) {
+                printf("%u,", (unsigned char) *(ws_ctx->tout_buf+i));
+            }
+            printf("\n");
+            */
+            if (len < 0) {
+                handler_emsg("decoding error\n");
+                break;
+            }
+            if (left) {
+                tin_start = tin_end - left;
+                //printf("partial frame from client");
+            } else {
+                tin_start = 0;
+                tin_end = 0;
+            }
+
+            traffic("}");
+            tout_start = 0;
+            tout_end = len;
+        }
+    }
+}
+
+void proxy_handler(ws_ctx_t *ws_ctx) {
+    int tsock = 0;
+    struct sockaddr_in taddr;
+
+    handler_msg("connecting to: %s:%d\n", target_host, target_port);
+
+    tsock = socket(AF_INET, SOCK_STREAM, 0);
+    if (tsock < 0) {
+        handler_emsg("Could not create target socket: %s\n",
+                     strerror(errno));
+        return;
+    }
+    bzero((char *) &taddr, sizeof(taddr));
+    taddr.sin_family = AF_INET;
+    taddr.sin_port = htons(target_port);
+
+    /* Resolve target address */
+    if (resolve_host(&taddr.sin_addr, target_host) < -1) {
+        handler_emsg("Could not resolve target address: %s\n",
+                     strerror(errno));
+    }
+
+    if (connect(tsock, (struct sockaddr *) &taddr, sizeof(taddr)) < 0) {
+        handler_emsg("Could not connect to target: %s\n",
+                     strerror(errno));
+        close(tsock);
+        return;
+    }
+
+    if ((settings.verbose) && (! settings.daemon)) {
+        printf("%s", traffic_legend);
+    }
+
+    do_proxy(ws_ctx, tsock);
+
+    shutdown(tsock, SHUT_RDWR);
+    close(tsock);
+}
+
+int main(int argc, char *argv[])
+{
+    int fd, c, option_index = 0;
+    static int ssl_only = 0, daemon = 0, run_once = 0, verbose = 0;
+    char *found;
+    static struct option long_options[] = {
+        {"verbose",    no_argument,       &verbose,    'v'},
+        {"ssl-only",   no_argument,       &ssl_only,    1 },
+        {"daemon",     no_argument,       &daemon,     'D'},
+        /* ---- */
+        {"run-once",   no_argument,       0,           'r'},
+        {"cert",       required_argument, 0,           'c'},
+        {"key",        required_argument, 0,           'k'},
+        {0, 0, 0, 0}
+    };
+
+    settings.cert = realpath("self.pem", NULL);
+    if (!settings.cert) {
+        /* Make sure it's always set to something */
+        settings.cert = "self.pem";
+    }
+    settings.key = "";
+
+    while (1) {
+        c = getopt_long (argc, argv, "vDrc:k:",
+                         long_options, &option_index);
+
+        /* Detect the end */
+        if (c == -1) { break; }
+
+        switch (c) {
+            case 0:
+                break; // ignore
+            case 1:
+                break; // ignore
+            case 'v':
+                verbose = 1;
+                break;
+            case 'D':
+                daemon = 1;
+                break;
+            case 'r':
+                run_once = 1;
+                break;
+            case 'c':
+                settings.cert = realpath(optarg, NULL);
+                if (! settings.cert) {
+                    usage("No cert file at %s\n", optarg);
+                }
+                break;
+            case 'k':
+                settings.key = realpath(optarg, NULL);
+                if (! settings.key) {
+                    usage("No key file at %s\n", optarg);
+                }
+                break;
+            default:
+                usage("\n");
+        }
+    }
+    settings.verbose      = verbose;
+    settings.ssl_only     = ssl_only;
+    settings.daemon       = daemon;
+    settings.run_once     = run_once;
+
+    if ((argc-optind) != 2) {
+        usage("Invalid number of arguments\n");
+    }
+
+    found = strstr(argv[optind], ":");
+    if (found) {
+        memcpy(settings.listen_host, argv[optind], found-argv[optind]);
+        settings.listen_port = strtol(found+1, NULL, 10);
+    } else {
+        settings.listen_host[0] = '\0';
+        settings.listen_port = strtol(argv[optind], NULL, 10);
+    }
+    optind++;
+    if (settings.listen_port == 0) {
+        usage("Could not parse listen_port\n");
+    }
+
+    found = strstr(argv[optind], ":");
+    if (found) {
+        memcpy(target_host, argv[optind], found-argv[optind]);
+        target_port = strtol(found+1, NULL, 10);
+    } else {
+        usage("Target argument must be host:port\n");
+    }
+    if (target_port == 0) {
+        usage("Could not parse target port\n");
+    }
+
+    if (ssl_only) {
+        if (access(settings.cert, R_OK) != 0) {
+            usage("SSL only and cert file '%s' not found\n", settings.cert);
+        }
+    } else if (access(settings.cert, R_OK) != 0) {
+        fprintf(stderr, "Warning: '%s' not found\n", settings.cert);
+    }
+
+    //printf("  verbose: %d\n",   settings.verbose);
+    //printf("  ssl_only: %d\n",  settings.ssl_only);
+    //printf("  daemon: %d\n",    settings.daemon);
+    //printf("  run_once: %d\n",  settings.run_once);
+    //printf("  cert: %s\n",      settings.cert);
+    //printf("  key: %s\n",       settings.key);
+
+    settings.handler = proxy_handler; 
+    start_server();
+
+}