Initial commit.

README.md

@@ -0,0 +1,52 @@
+
+# Radangel
+## Device: Kromek RadAngel
+The [Kromek RadAngel](https://www.kromek.com/product/radangel-czt-gamma-ray-spectrometer/) is an affordable CZT-based gamma-ray spectrometer device connecting via USB as HID device.
+
+RadAngel a small and portable gamma-ray spectrometer that can be utilised for educational purposes in teaching concepts of radiation as well as for training in the use of radiation sensors.
+
+Its compact size and quick set-up time make it ideally suited for individual or small group projects, laboratory-based teaching, classroom demonstrations and field studies.
+ 
+This instrument utilizes a Cadmium Zinc Telluride (CZT) solid state detector, which enables room temperature operation with excellent energy resolution (12 bits hence 4096 channels from ~30 keV to ~3 MeV). 
+The unit is completely self-contained, with a built-in detector, amplifiers, power supply and communications. 
+The digitized detector signals are sent to a PC via the mini-USB which also powers the unit, so no external supply is required.
+
+![Kromek RadAngel](docs/Kromek_RadAngel.png)
+
+## Daemon: radangel
+
+The `radangel` binary communicates with the RadAngel HID device (`04d8:0100`) via USB (`hidapi-libusb`) and uses threads (`pthreads`) to read events and push them in a queue, then pop them from the queue and write them into files.
+
+To grant permissions to the USB device, the udev system can be employed:
+
+ `echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="04d8", ATTR{idProduct}=="0100", MODE="0666"' | sudo tee /etc/udev/rules.d/99-kromek-radangel.rules`
+
+Compiling the radangel binary for the linux operating system is easy:
+Just run `make` in the `src` directory or
+
+`gcc -std=gnu99 -Wall radangel.c -o radangel -pthread -lm -lhidapi-libusb`
+
+The output of the `radangel` daemon consists of two files (time series and histogram):
+
+* `events.tsv` each line corresponds to one event with timestamp and channel (gamma-ray energy).
+* `stats.tsv`each line corresponds to one channel and displays the number of occurance (histogram).
+
+Running the binary with the appropriate arguments:
+
+`radangel --verbose --event events.tsv --stats stats.tsv`
+
+The daemon can be run as service with the `radangel.service` systemd file.
+
+## Web: service
+
+The changes in the output files from `radangel` daemon can be streamed to the browser in realtime with the two systemd units `datasrc.service`
+and `websockify.service`:
+
+*  `datasrc.service` systemd unit employs `inotail` to monitor the output files and streams the changes with `socat` into a tcp socket.
+*  `websockify.service` launches the `websockify` daemon which provides the websocket endpoint behind `nginx` webserver (see `nginx-datasrc-location.conf`) and translates between websocket and the plain tcp socket.
+
+To compile the `websockify` daemon just run `make` in the `src/contrib` directory.
+
+The web interface itself uses [Plotly.js](https://plot.ly/javascript/) to display the histogram of the channels in realtime by connecting to the websocket endpoint and provides a convenient user interface for exploring the details of the gamma-spectrum.
+
+![Background Gamma Spectrum](docs/background-gamma-spectrum.png)

config/nginx-datasrc-location.conf

@@ -0,0 +1,31 @@
+    ## <DATASRC> ##
+
+    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;
+    }
+
+    ## </DATASRC> ##
+

html/index.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<title>γ-Spectrum</title>
+	<meta http-equiv="X-UA-Compatible" content="IE=edge">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+	<!-- <link href="css/bootstrap.min.css" rel="stylesheet" media="screen"> -->
+	<style>
+		html,
+		body {
+			height: 100%;
+			max-height: 100%;
+			margin: 0;
+			padding: 0;
+			overflow: hidden;
+			background: black;
+		}
+
+		div.graph,
+		div.plot-container,
+		div.svg-container,
+		div.svg-container svg {
+			min-height: 100%;
+			/* height: auto !important; */
+			height: 100%;
+			margin: 0;
+			padding: 0;
+			overflow: hidden;
+		}
+	</style>
+	<script src="js/plotly-cartesian-latest.min.js"></script>
+	<script src="js/chroma.min.js"></script>
+	<script src="js/streamplot.js"></script>
+	<script>
+		function init(id) {
+			return createGraph(id, {
+				'src': {
+					'stream': '/data/stream.ws',
+					'init': '/data/hist.tsv'
+				},
+				'title': {
+					'plot': 'γ-Spectrum',
+					'xaxis': 'Energy / keV',
+					'yaxis': 'Events'
+				},
+				'colors': {
+					'graph': ['white', 'black'], // fg to bg
+					'lines': ['blue', 'cyan', 'lightgreen', 'yellow', 'red'] // cols left to right
+				},
+				'maxPoints': 4096,
+				'size': 2,
+				'scale': 1.5,
+				'shape': 'linear', // 'spline', // 'linear'
+				'smoothing': 2.0
+			});
+		}
+	</script>
+</head>
+
+<body onload="init('graph');">
+	<div id="graph" class="graph">
+	</div>
+</body>
+
+</html>

html/js/get.sh

@@ -0,0 +1,25 @@
+#/bin/sh
+
+# <!-- https://github.com/plotly/plotly.js/blob/master/dist/README.md -->
+#wget 'https://cdn.plot.ly/plotly-latest.js'
+#wget 'https://cdn.plot.ly/plotly-latest.min.js'
+#wget 'https://cdn.plot.ly/plotly-basic-latest.js'
+#wget 'https://cdn.plot.ly/plotly-basic-latest.min.js'
+wget 'https://cdn.plot.ly/plotly-cartesian-latest.js'
+wget 'https://cdn.plot.ly/plotly-cartesian-latest.min.js'
+#wget 'https://cdn.plot.ly/plotly-gl2d-latest.js'
+#wget 'https://cdn.plot.ly/plotly-gl2d-latest.min.js'
+
+#<!-- https://github.com/gka/chroma.js/blob/master/docs/src/index.md -->
+wget 'https://github.com/gka/chroma.js/raw/master/chroma.js'
+wget 'https://github.com/gka/chroma.js/raw/master/chroma.min.js'
+
+#<! -- http://bl.ocks.org/syntagmatic/raw/3341641/ -->
+#wget 'http://bl.ocks.org/syntagmatic/raw/3341641/render-queue.js'
+
+# Tone,js
+#wget 'https://tonejs.github.io/build/Tone.js'
+#wget 'https://tonejs.github.io/build/Tone.min.js'
+
+# nginx gzip_static on;
+for F in *.js ; do cat $F | gzip -9 > $F.gz ; done

html/js/streamplot.js

@@ -0,0 +1,402 @@
+function dataSrc(url, config) {
+  config = config || {};
+  url = url || [
+    location.protocol == 'https:' ? 'wss://' : 'ws://',
+    location.hostname,
+    location.protocol == 'https:' ? ':443' : ':80',
+    '/data/stream.ws'
+  ].join('');
+  var ctx = {
+    'url': url,
+    'ws': {},
+    'proto': 'binary',
+    'buffer': '',
+    'headers': [],
+    'data': [],
+    'separatorRows': config.separatorRows || "\n",
+    'separatorCols': config.separatorCols || "\t",
+    'ping': (function() {
+      var ac = new(window.AudioContext || window.webkitAudioContext)();
+      var osc = ac.createOscillator();
+      var gn = ac.createGain();
+      osc.connect(gn);
+      gn.connect(ac.destination);
+      gn.gain.setTargetAtTime(0.0, ac.currentTime, 0.0);
+      osc.start(ac.currentTime);
+      return function(freq) {
+        var d = [0.001, 0.01, 0.1]; // relative decay constants: freq < rise <  fall e.g. [0.001, 0.1, 0.2]
+        var t = 0.100 // 100 ms target time
+        var v = 0.25 // volume
+        function energy(channel) {
+          var c = [405, 4095];
+          var e = [29.5503, 3628.78];
+          return e[0] + (e[1] - e[0]) * (channel - c[0]) / (c[1] - c[0]);
+        };
+        var f = energy(freq);
+        osc.frequency.setTargetAtTime(f, ac.currentTime + d[0] * t, d[0] * t);
+        gn.gain.setTargetAtTime(v, ac.currentTime + d[1] * t, d[1] * t);
+        gn.gain.setTargetAtTime(0.0, ac.currentTime + d[2] * t, d[2] * t);
+      }
+    })()
+  };
+
+  function connect() {
+    if (ctx.proto == 'binary') {
+      ctx.ws = new WebSocket(ctx.url, 'binary');
+      ctx.ws.binaryType = 'arraybuffer';
+    } else {
+      ctx.ws = new WebSocket(ctx.url);
+    }
+    ctx.ws.onerror = function(evt) {
+      console.log('WS ERROR: ' + evt.data);
+    };
+    ctx.ws.onopen = function(evt) {
+      console.log('WS OPENED: ' + ctx.url)
+    };
+    ctx.ws.onmessage = function(evt) {
+      //console.log('WS DATA:');
+      ctx.buffer += ctx.proto == 'binary' ? String.fromCharCode.apply(null, new Uint8Array(evt.data)) : evt.data;
+      var rows = ctx.buffer.split(ctx.separatorRows);
+      ctx.buffer = rows.pop(); // buffer incomplete rows
+      for (var r = 0; r < rows.length; r++) {
+        var cols = rows[r].split(ctx.separatorCols);
+        var row = [];
+        for (var c = 0; c < cols.length; c++) {
+          row.push((function(str) {
+            var num = parseFloat(str);
+            c > 0 ? ctx.ping(num) : true;
+            return isNaN(num) ? str : num;
+          })(cols[c]));
+        }
+        if (ctx.headers.length == 0) {
+          ctx.headers = row;
+        } else {
+          ctx.data.push(row);
+        }
+      }
+    };
+    ctx.ws.onclose = function(evt) {
+      console.log('WS CLOSED:' + evt.code);
+      window.setTimeout(connect, 1000); // retry every 1000 ms
+    };
+  }
+  connect();
+  this.getHeaders = function() { // get headers strings array
+    return ctx.headers;
+  };
+  this.getData = function(len) { // get len datasets and delete old data
+    return ctx.data.splice(0).slice(-1 * (len || 1));
+  };
+  return this;
+}
+
+
+function makeData(src, len) {
+  //console.log('makeData(src,' + len + ')');
+  len = len || 100;
+  var rows = src.getData(len);
+  var cols = src.getHeaders();
+  var data = [];
+  var vals = [];
+  for (var c = 0; c < cols.length; c++) {
+    vals = [];
+    for (var r = 0; r < rows.length; r++) {
+      var val = typeof(rows[r][c]) != 'undefined' ? rows[r][c] : null
+      //console.log( cols[c] + '[' + r + '] = ' + val);
+      vals.push(val);
+    }
+    data.push(vals);
+  }
+  var time = data && data.length > 0 ? data.shift() : null;
+  return {
+    'x': (function(n) {
+      for (x = []; n--; x.push(time));
+      return x
+    })(cols.length - 1),
+    'y': data,
+    'i': (function(n) {
+      for (a = []; n--; a[n] = n);
+      return a;
+    })(cols.length - 1)
+  };
+}
+
+
+function formatNames(str, find, replace) {
+  str = str.toString();
+  find = find || '_';
+  replace = replace || ' ';
+  return str.replace(
+    new RegExp(
+      find.replace(
+        new RegExp(
+          '([.*+?^=!:${}()|\[\]\/\\])',
+          'g'
+        ),
+        '\\$1'
+      ),
+      'g'
+    ),
+    replace
+  );
+}
+
+
+function makePlot(ctx, hdr) {
+  //console.log(JSON.stringify(hdr, null, "\t"));
+  var data = [];
+  var cmap = chroma.scale(chroma.bezier(ctx.data.line.color)).mode('lab').correctLightness(false).colors(hdr.length - 1, null);
+  for (var i = 1; i < hdr.length; i++) {
+    var trace = JSON.parse(JSON.stringify(ctx.data))
+    trace['type'] = 'scatter';
+    trace['mode'] = 'lines';
+    trace['fill'] = 'tonexty'; // 'tozeroy';
+    trace['connectgaps'] = true;
+    trace['name'] = formatNames(hdr[i]);
+    trace['x'] = new Array(ctx.maxPoints);
+    trace['y'] = new Array(ctx.maxPoints);
+    trace['line']['width'] = 1;
+    trace['line']['color'] = cmap[i - 1].css();
+    trace['fillcolor'] = cmap[i - 1].alpha(0.2).css()
+    data.push(trace);
+  }
+  document.title = ctx.layout.title;
+  return Plotly.plot(ctx.id, data, ctx.layout, ctx.config); // https://github.com/plotly/plotly.js/blob/master/src/plot_api/plot_api.js#L53
+}
+
+
+function makeConfig(id, ctx) {
+  var cmap = chroma.bezier(ctx.colors.graph).scale().colors(5);
+  var data = {
+    'name': 'trace', // replaced by tsv column headers
+    'type': 'scatter',
+    'mode': 'lines', // 'lines+markers',
+    'line': {
+      'shape': ctx.shape,
+      'smoothing': ctx.smoothing,
+      'color': ctx.colors.lines, // interpolated by colormap function
+      'width': ctx.size
+    },
+    'marker': {
+      'color': cmap[2],
+      'size': 1.5 * ctx.size
+    },
+    'y': [0] // replaced by tsv column data
+  };
+  var layout = {
+    'title': ctx.title.plot,
+    'titlefont': {
+      'family': 'Courier New, monospace',
+      'size': 24,
+      'color': cmap[0]
+    },
+    'autosize': true,
+    // 'width': window.innerWidth,
+    // 'height': window.innerHeight,
+    'plot_bgcolor': cmap[4],
+    'paper_bgcolor': cmap[4],
+    'xaxis': {
+      'title': ctx.title.xaxis,
+      'range': [0, 3650],
+      'color': cmap[1],
+      'titlefont': {
+        'family': 'Courier New, monospace',
+        'size': 18,
+        'color': cmap[0]
+      },
+      'tickwidth': ctx.size,
+      'tickcolor': cmap[1],
+      'linecolor': cmap[1],
+      'gridcolor': cmap[3],
+      'zerolinecolor': cmap[1],
+      'mirror': true
+    },
+    'yaxis': {
+      'title': ctx.title.yaxis,
+      'type': 'log',
+      'autorange': true,
+      'color': cmap[1],
+      'titlefont': {
+        'family': 'Courier New, monospace',
+        'size': 18,
+        'color': cmap[0]
+      },
+      'tickwidth': ctx.size,
+      'tickcolor': cmap[1],
+      'linecolor': cmap[1],
+      'gridcolor': cmap[3],
+      'zerolinecolor': cmap[1],
+      'mirror': true
+    },
+    'margin': {
+      'l': 64,
+      'r': 32,
+      'b': 64,
+      't': 80,
+      'pad': 0
+    }
+  };
+  var config = {
+    'scrollZoom': true,
+    'showLink': false,
+    'displaylogo': false,
+    'modeBarButtonsToAdd': [
+      {
+        'name': 'Toggle Lin/Log',
+        'click': function(gd) {
+          Plotly.relayout(gd, 'yaxis.type', gd.layout.yaxis.type == 'log' ? 'linear' : 'log');
+        },
+        'icon': {
+          'width': 1000,
+          'ascent': 850,
+          'descent': 0,
+          'path': 'm 598.75596,109.5 c -8.63281,0 -15.62503,-6.99222 -15.62503,-15.624987 V 62.624975 c 0,-8.632812 6.99222,-15.624987 15.62503,-15.624987 H 770.63093 V -77.999996 H 598.75596 c -8.63281,0 -15.62503,-6.99221 -15.62503,-15.62499 v -31.250024 c 0,-8.63283 6.99222,-15.625 15.62503,-15.625 H 770.63093 V -265.49999 H 598.75596 c -8.63281,0 -15.62503,-6.99222 -15.62503,-15.625 v -31.25002 c 0,-8.63283 6.99222,-15.625 15.62503,-15.625 H 770.63093 V -452.99999 H 598.75596 c -8.63281,0 -15.62503,-6.99222 -15.62503,-15.625 v -31.25002 c 0,-8.63283 6.99222,-15.62499 15.62503,-15.62499 H 770.63093 V -640.49999 C 770.63093,-675.01175 742.64268,-703 708.13096,-703 h -375 c -34.51171,0 -62.50001,27.98825 -62.50001,62.50001 v 874.99998 c 0,34.51171 27.9883,62.50001 62.50001,62.50001 h 375 c 34.51172,0 62.49997,-27.9883 62.49997,-62.50001 V 109.5 Z'
+        }
+      }
+    ],
+    'mmodeBarButtonsToRemove': ['sendDataToCloud']
+  };
+  return {
+    'id': id,
+    'data': data,
+    'layout': layout,
+    'config': config,
+    'maxPoints': ctx.maxPoints
+  };
+}
+
+
+function createGraph(id, ctx) {
+  ctx = { // sane defaults
+    'src': {
+      'stream': ctx.src.stream || '/data/stream.ws',
+      'init': ctx.src.init || '/data/hist.tsv'
+    },
+    'title': {
+      'plot': ctx.title.plot || 'Plot Title',
+      'xaxis': ctx.title.xaxis || 'Time / s',
+      'yaxis': ctx.title.yaxis || 'Measured Entity / a.u.'
+    },
+    'colors': {
+      'graph': ctx.colors.graph || ['black', 'white'],
+      'lines': ctx.colors.lines || ['blue', 'cyan', 'lightgreen', 'yellow', 'red']
+    },
+    'maxPoints': ctx.maxPoints || 100,
+    'size': ctx.size || 2,
+    'scale': ctx.scale || 1.5,
+    'shape': ctx.shape || 'linear',
+    'smoothing': ctx.smoothing || 1
+  };
+
+  var src = dataSrc([
+    location.protocol == 'https:' ? 'wss://' : 'ws://',
+    location.hostname,
+    location.protocol == 'https:' ? ':443' : ':80',
+    ctx.src.stream
+  ].join(''));
+
+  var setup = window.setInterval(function() { // wait for headers to arrive
+    var headers = src.getHeaders();
+    if (headers.length > 0) {
+      clearInterval(setup);
+      makePlot(makeConfig(id, ctx), headers);
+
+      function loadInitData(dataUrl) {
+        var xmlhttp = new XMLHttpRequest();
+        xmlhttp.open("GET", dataUrl); // xmlhttp.open("GET", url, false);
+        xmlhttp.onreadystatechange = function() {
+          if ((xmlhttp.status == 200) && (xmlhttp.readyState == 4)) {
+            var maxPoints = ctx.maxPoints || 4096;
+
+            function energy(channel) {
+              var c = [405, 4095];
+              var e = [29.5503, 3628.78];
+              return e[0] + (e[1] - e[0]) * (channel - c[0]) / (c[1] - c[0]);
+            };
+
+            var data = {
+              'x': [(function(n) {
+                for (a = []; n--; a[n] = energy(n));
+                return a;
+              })(maxPoints)],
+              'y': [
+                []
+              ],
+              'i': [],
+              't': 0,
+              'e': 0
+            };
+
+            var initData = xmlhttp.responseText.split("\n").slice(0, maxPoints).map(parseFloat);
+            for (i = 0; i < maxPoints; i++) { // prefill initial data
+              var val = initData[i];
+              if (isNaN(val)) {
+                data.y[0][i] = 0;
+              } else {
+                data.y[0][i] = val;
+                data.e += val;
+              }
+            }
+            //console.log(data);
+
+            var res = true;
+            res &= Plotly.relayout(id, {
+              'title': ctx.title.plot + ' ' + data.t + 's',
+              'yaxis.title': ctx.title.yaxis + ' / ' + data.e
+            }).catch(function(e) {
+              //console.log('ERROR[Plotly.relayout()]: ' + e);
+            });
+
+            res &= Plotly.extendTraces(id, {
+              'x': data.x,
+              'y': data.y
+            }, [0], maxPoints).catch(function(e) {
+              //console.log('ERROR[Plotly.extendTraces()]: ' + e);
+            });
+
+            var update = window.setInterval(function() { // update plot in realtime
+
+              var rawdata = makeData(src, 1024 * 1024 * 1024); // get at most 1 GB of events
+
+              data.i = (function(n) {
+                for (a = []; n--; a[n] = n);
+                return a;
+              })(rawdata.y.length);
+
+              for (i = 0; i < rawdata.y.length; i++) {
+                for (j = 0; j < rawdata.y[i].length; j++) {
+                  data.y[i][rawdata.y[i][j]] += 1;
+                  data.e += 1
+                }
+              }
+
+              var evtTime = rawdata.x[0][rawdata.x[0].length - 1];
+              data.t = evtTime ? evtTime : data.t;
+
+              return data.i.length > 0 ? (function() {
+                var res = true;
+                res &= Plotly.relayout(id, {
+                  'title': ctx.title.plot + ' ' + data.t + 's',
+                  'yaxis.title': ctx.title.yaxis + ' / ' + data.e
+                }).catch(function(e) {
+                  //console.log('ERROR[Plotly.relayout()]: ' + e);
+                });
+
+                res &= Plotly.extendTraces(id, {
+                  'x': data.x,
+                  'y': data.y
+                }, data.i, maxPoints).catch(function(e) {
+                  //console.log('ERROR[Plotly.extendTraces()]: ' + e);
+                });
+                return res;
+
+              })() : true;
+            }, 500); // time resolution 500ms
+          }
+        };
+        xmlhttp.send();
+      }
+      loadInitData(ctx.src.init);
+    }
+  }, 500);
+}

service/datasrc.service

@@ -0,0 +1,34 @@
+[Unit]
+Description=Data Source
+After=multi-user.target
+
+[Service]
+Type=simple
+
+User=www-data
+Group=www-data
+
+Environment=LISTEN_HOST=127.0.0.1
+Environment=LISTEN_PORT=5900
+Environment=TARGET_FILE=/tmp/event.tsv
+Environment=DATA_MAX_SIZE=0
+#Environment=DATA_MAX_SIZE=1073741824
+#EnvironmentFile=/etc/default/datasrc
+
+PermissionsStartOnly=true
+ExecStartPre=/usr/bin/touch ${TARGET_FILE}
+ExecStartPre=/bin/chown www-data:www-data ${TARGET_FILE}
+
+WorkingDirectory=/tmp
+ExecStart=/usr/bin/socat \
+        TCP-LISTEN:${LISTEN_PORT},bind=${LISTEN_HOST},reuseaddr,fork \
+        "EXEC:/usr/bin/inotail -n ${DATA_MAX_SIZE} -f ${TARGET_FILE}"
+
+NoNewPrivileges=true
+RestartSec=5
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+
+

service/radangel.service

@@ -0,0 +1,35 @@
+[Unit]
+Description=RadAngel gamma spectrometer
+After=multi-user.target
+
+[Service]
+Type=simple
+
+User=www-data
+Group=www-data
+
+Environment=EVENT_FILE=/tmp/event.tsv
+Environment=STATS_FILE=/tmp/stats.tsv
+#EnvironmentFile=/etc/default/radangel
+
+PermissionsStartOnly=true
+ExecStartPre=/usr/bin/touch ${EVENT_FILE}
+ExecStartPre=/usr/bin/touch ${STATS_FILE}
+ExecStartPre=/bin/chown www-data:www-data ${EVENT_FILE}
+ExecStartPre=/bin/chown www-data:www-data ${STATS_FILE}
+ExecStartPre=/bin/chmod o+r ${EVENT_FILE}
+ExecStartPre=/bin/chmod o+r ${STATS_FILE}
+
+WorkingDirectory=/opt/radangel
+ExecStart=/opt/radangel/radangel --verbose \
+	--event ${EVENT_FILE}              \
+	--stats ${STATS_FILE}
+
+NoNewPrivileges=true
+RestartSec=5
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+
+

service/websockify.service

@@ -0,0 +1,35 @@
+[Unit]
+Description=Start websockify
+After=multi-user.target
+
+[Service]
+Type=forking
+
+User=www-data
+Group=www-data
+
+Environment=LISTEN_HOST=127.0.0.1
+Environment=LISTEN_PORT=5800
+Environment=TARGET_HOST=127.0.0.1
+Environment=TARGET_PORT=5900
+#EnvironmentFile=/etc/default/websockify
+
+PIDFile=/var/run/websockify.pid
+PermissionsStartOnly=true
+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 \
+	${LISTEN_HOST}:${LISTEN_PORT} \
+	${TARGET_HOST}:${TARGET_PORT}
+
+NoNewPrivileges=true
+RestartSec=5
+Restart=on-failure
+
+
+[Install]
+WantedBy=multi-user.target
+
+

src/Makefile

@@ -0,0 +1,13 @@
+TARGETS=radangel
+CFLAGS += -fPIC
+
+all: $(TARGETS)
+
+radangel: radangel.o
+	$(CC) -std=gnu99 -Wall $(LDFLAGS) $^ -pthread -lm -lhidapi-libusb -o $@
+
+radangel.o: radangel.c
+
+clean:
+	rm -f radangel *.o
+

src/contrib/Makefile

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

src/contrib/base64.c

@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) 1996-1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+/*
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#if !defined(LINT) && !defined(CODECENTER)
+static const char rcsid[] = "$BINDId: base64.c,v 8.7 1999/10/13 16:39:33 vixie Exp $";
+#endif /* not lint */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <ctype.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define Assert(Cond) if (!(Cond)) abort()
+
+static const char Base64[] =
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
+
+/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
+   The following encoding technique is taken from RFC 1521 by Borenstein
+   and Freed.  It is reproduced here in a slightly edited form for
+   convenience.
+
+   A 65-character subset of US-ASCII is used, enabling 6 bits to be
+   represented per printable character. (The extra 65th character, "=",
+   is used to signify a special processing function.)
+
+   The encoding process represents 24-bit groups of input bits as output
+   strings of 4 encoded characters. Proceeding from left to right, a
+   24-bit input group is formed by concatenating 3 8-bit input groups.
+   These 24 bits are then treated as 4 concatenated 6-bit groups, each
+   of which is translated into a single digit in the base64 alphabet.
+
+   Each 6-bit group is used as an index into an array of 64 printable
+   characters. The character referenced by the index is placed in the
+   output string.
+
+                         Table 1: The Base64 Alphabet
+
+      Value Encoding  Value Encoding  Value Encoding  Value Encoding
+          0 A            17 R            34 i            51 z
+          1 B            18 S            35 j            52 0
+          2 C            19 T            36 k            53 1
+          3 D            20 U            37 l            54 2
+          4 E            21 V            38 m            55 3
+          5 F            22 W            39 n            56 4
+          6 G            23 X            40 o            57 5
+          7 H            24 Y            41 p            58 6
+          8 I            25 Z            42 q            59 7
+          9 J            26 a            43 r            60 8
+         10 K            27 b            44 s            61 9
+         11 L            28 c            45 t            62 +
+         12 M            29 d            46 u            63 /
+         13 N            30 e            47 v
+         14 O            31 f            48 w         (pad) =
+         15 P            32 g            49 x
+         16 Q            33 h            50 y
+
+   Special processing is performed if fewer than 24 bits are available
+   at the end of the data being encoded.  A full encoding quantum is
+   always completed at the end of a quantity.  When fewer than 24 input
+   bits are available in an input group, zero bits are added (on the
+   right) to form an integral number of 6-bit groups.  Padding at the
+   end of the data is performed using the '=' character.
+
+   Since all base64 input is an integral number of octets, only the
+         -------------------------------------------------
+   following cases can arise:
+
+       (1) the final quantum of encoding input is an integral
+           multiple of 24 bits; here, the final unit of encoded
+	   output will be an integral multiple of 4 characters
+	   with no "=" padding,
+       (2) the final quantum of encoding input is exactly 8 bits;
+           here, the final unit of encoded output will be two
+	   characters followed by two "=" padding characters, or
+       (3) the final quantum of encoding input is exactly 16 bits;
+           here, the final unit of encoded output will be three
+	   characters followed by one "=" padding character.
+   */
+
+int
+ws_b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize) {
+	size_t datalength = 0;
+	u_char input[3];
+	u_char output[4];
+	size_t i;
+
+	while (2 < srclength) {
+		input[0] = *src++;
+		input[1] = *src++;
+		input[2] = *src++;
+		srclength -= 3;
+
+		output[0] = input[0] >> 2;
+		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+		output[3] = input[2] & 0x3f;
+		Assert(output[0] < 64);
+		Assert(output[1] < 64);
+		Assert(output[2] < 64);
+		Assert(output[3] < 64);
+
+		if (datalength + 4 > targsize)
+			return (-1);
+		target[datalength++] = Base64[output[0]];
+		target[datalength++] = Base64[output[1]];
+		target[datalength++] = Base64[output[2]];
+		target[datalength++] = Base64[output[3]];
+	}
+
+	/* Now we worry about padding. */
+	if (0 != srclength) {
+		/* Get what's left. */
+		input[0] = input[1] = input[2] = '\0';
+		for (i = 0; i < srclength; i++)
+			input[i] = *src++;
+
+		output[0] = input[0] >> 2;
+		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+		Assert(output[0] < 64);
+		Assert(output[1] < 64);
+		Assert(output[2] < 64);
+
+		if (datalength + 4 > targsize)
+			return (-1);
+		target[datalength++] = Base64[output[0]];
+		target[datalength++] = Base64[output[1]];
+		if (srclength == 1)
+			target[datalength++] = Pad64;
+		else
+			target[datalength++] = Base64[output[2]];
+		target[datalength++] = Pad64;
+	}
+	if (datalength >= targsize)
+		return (-1);
+	target[datalength] = '\0';	/* Returned value doesn't count \0. */
+	return (datalength);
+}
+//libresolv_hidden_def (b64_ntop)
+
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+int
+ws_b64_pton(char const *src, u_char *target, size_t targsize) {
+	int tarindex, state, ch;
+	char *pos;
+
+	state = 0;
+	tarindex = 0;
+
+	while ((ch = *src++) != '\0') {
+		if (isspace(ch))	/* Skip whitespace anywhere. */
+			continue;
+
+		if (ch == Pad64)
+			break;
+
+		pos = strchr(Base64, ch);
+		if (pos == 0) 		/* A non-base64 character. */
+			return (-1);
+
+		switch (state) {
+		case 0:
+			if (target) {
+				if ((size_t)tarindex >= targsize)
+					return (-1);
+				target[tarindex] = (pos - Base64) << 2;
+			}
+			state = 1;
+			break;
+		case 1:
+			if (target) {
+				if ((size_t)tarindex + 1 >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 4;
+				target[tarindex+1]  = ((pos - Base64) & 0x0f)
+							<< 4 ;
+			}
+			tarindex++;
+			state = 2;
+			break;
+		case 2:
+			if (target) {
+				if ((size_t)tarindex + 1 >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 2;
+				target[tarindex+1]  = ((pos - Base64) & 0x03)
+							<< 6;
+			}
+			tarindex++;
+			state = 3;
+			break;
+		case 3:
+			if (target) {
+				if ((size_t)tarindex >= targsize)
+					return (-1);
+				target[tarindex] |= (pos - Base64);
+			}
+			tarindex++;
+			state = 0;
+			break;
+		default:
+			abort();
+		}
+	}
+
+	/*
+	 * We are done decoding Base-64 chars.  Let's see if we ended
+	 * on a byte boundary, and/or with erroneous trailing characters.
+	 */
+
+	if (ch == Pad64) {		/* We got a pad char. */
+		ch = *src++;		/* Skip it, get next. */
+		switch (state) {
+		case 0:		/* Invalid = in first position */
+		case 1:		/* Invalid = in second position */
+			return (-1);
+
+		case 2:		/* Valid, means one byte of info */
+			/* Skip any number of spaces. */
+			for ((void)NULL; ch != '\0'; ch = *src++)
+				if (!isspace(ch))
+					break;
+			/* Make sure there is another trailing = sign. */
+			if (ch != Pad64)
+				return (-1);
+			ch = *src++;		/* Skip the = */
+			/* Fall through to "single trailing =" case. */
+			/* FALLTHROUGH */
+
+		case 3:		/* Valid, means two bytes of info */
+			/*
+			 * We know this char is an =.  Is there anything but
+			 * whitespace after it?
+			 */
+			for ((void)NULL; ch != '\0'; ch = *src++)
+				if (!isspace(ch))
+					return (-1);
+
+			/*
+			 * Now make sure for cases 2 and 3 that the "extra"
+			 * bits that slopped past the last full byte were
+			 * zeros.  If we don't check them, they become a
+			 * subliminal channel.
+			 */
+			if (target && target[tarindex] != 0)
+				return (-1);
+		}
+	} else {
+		/*
+		 * We ended by seeing the end of the string.  Make sure we
+		 * have no partial bytes lying around.
+		 */
+		if (state != 0)
+			return (-1);
+	}
+
+	return (tarindex);
+}

src/contrib/websocket.c

@@ -0,0 +1,866 @@
+/*
+ * 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 <strings.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/md5.h> /* md5 hash */
+#include <openssl/sha.h> /* sha1 hash */
+#include "websocket.h"
+
+int ws_b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize);
+int ws_b64_pton(char const *src, u_char *target, size_t targsize);
+
+/*
+ * 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());
+    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_file(ctx->ssl_ctx, certfile,
+                                     SSL_FILETYPE_PEM) <= 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 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);
+        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 b64_sz, len_offset = 1, 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);
+        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;
+
+    if (strstr(headers->protocols, "binary")) {
+      ws_ctx->opcode = OPCODE_BINARY;
+      response_protocol = "binary";
+    } else if (strstr(headers->protocols, "base64")) {
+      ws_ctx->opcode = OPCODE_TEXT;
+      response_protocol = "base64";
+    } else {
+      handler_emsg("Invalid protocol '%s', expecting 'binary' or 'base64'\n",
+          headers->protocols);
+      return NULL;
+    }
+
+    if (ws_ctx->hybi > 0) {
+        handler_msg("using protocol HyBi/IETF 6455 %d\n", ws_ctx->hybi);
+        gen_sha1(headers, sha1);
+        sprintf(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 = "";
+        }
+        sprintf(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:
+            if (settings.whitelist != NULL) {
+              load_whitelist();
+            }
+            break;
+        case SIGPIPE: pipe_error = 1; break; // handle inline
+        case SIGTERM:
+            remove(settings.pid);
+            exit(0);
+            break;
+    }
+}
+
+void daemonize(int keepfd) {
+    int pid, i;
+
+    umask(0);
+    chdir("/");
+    setgid(getgid());
+    setuid(getuid());
+
+    /* 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) {
+      // parent exits
+      FILE *pidf = fopen(settings.pid, "w");
+      if (pidf) {
+        fprintf(pidf, "%d", pid);
+        fclose(pidf);
+      } else {
+        fprintf(stderr, "Could not write daemon PID file '%s': %s\n", settings.pid, strerror(errno));
+      }
+      exit(0);
+    }
+
+    /* 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
+    dup(i);                       // Redirect stdout
+    dup(i);                       // 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;
+        }
+    }
+    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/contrib/websocket.h

@@ -0,0 +1,109 @@
+#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;
+    char *whitelist;
+    char *pattern;
+    char *pid;
+} settings_t;
+
+
+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__);
+
+/* forward declarations */
+void traffic(const char * token);
+int encode_hybi(u_char const *src, size_t srclength,
+                char *target, size_t targsize, unsigned int opcode);
+int encode_hixie(u_char const *src, size_t srclength,
+                 char *target, size_t targsize);
+int decode_hybi(unsigned char *src, size_t srclength,
+                u_char *target, size_t targsize,
+                unsigned int *opcode, unsigned int *left);
+int decode_hixie(char *src, size_t srclength,
+                 u_char *target, size_t targsize,
+                 unsigned int *opcode, unsigned int *left);
+int resolve_host(struct in_addr *sin_addr, const char *hostname);
+void start_server();
+
+
+int load_whitelist();
+

src/contrib/websockify.c

@@ -0,0 +1,499 @@
+/*
+ * 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 <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 <signal.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\n" \
+               "  --whitelist|-w LIST  new-line separated target port whitelist file\n" \
+               "                       (target_port is not required only with this option)\n" \
+               "  --pattern|-P         target port request pattern. Default: '/%d'\n" \
+               "  --pid|-p             desired path of pid file. Default: '/var/run/websockify.pid'";
+
+#define usage(fmt, args...) \
+    do { \
+        fprintf(stderr, "%s\n\n", USAGE); \
+        fprintf(stderr, fmt , ## args); \
+        exit(1); \
+    } while(0)
+
+char target_host[256];
+int target_port;
+int *target_ports;
+
+//extern pipe_error;
+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;
+
+    if (target_ports != NULL) {
+        if (sscanf(ws_ctx->headers->path, settings.pattern, &target_port) != 1) {
+        handler_emsg("Could not match pattern '%s' to request path '%s'\n",
+                     settings.pattern, ws_ctx->headers->path);
+        return;
+        }
+        int *p;
+        int found = 0;
+        for (p = target_ports; *p; p++) {
+            if (*p == target_port) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            handler_emsg("Rejecting connection to non-whitelisted port: '%d'\n",
+                         target_port);
+            return;
+        }
+    }
+
+    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 load_whitelist() {
+  printf("loading port whitelist '%s'\n", settings.whitelist);
+  FILE *whitelist = fopen(settings.whitelist, "r");
+  if (whitelist == NULL) {
+    fprintf(stderr, "Error opening whitelist file '%s':\n\t%s\n",
+          settings.whitelist, strerror(errno));
+    return -1;
+  }
+
+  const int tplen_grow = 512;
+  int tplen = tplen_grow, tpcount = 0;
+  target_ports = (int*)malloc(tplen*sizeof(int));
+  if (target_ports == NULL) {
+    fprintf(stderr, "Whitelist port malloc error");
+    return -2;
+  }
+
+  char *line = NULL;
+  ssize_t n = 0, nread = 0;
+  while ((nread = getline(&line, &n, whitelist)) > 0) {
+      if (line[0] == '\n') continue;
+      line[nread-1] = '\x00';
+      long int port = strtol(line, NULL, 10);
+      if (port < 1 || port > 65535) {
+          fprintf(stderr,
+            "Whitelist port '%s' is not between valid range 1 and 65535", line);
+          return -3;
+      }
+      tpcount++;
+      if (tpcount >= tplen) {
+          tplen += tplen_grow;
+          target_ports = (int*)realloc(target_ports, tplen*sizeof(int));
+          if (target_ports == NULL) {
+              fprintf(stderr, "Whitelist port realloc error");
+              return -2;
+          }
+      }
+      target_ports[tpcount-1] = port;
+  }
+  if (line != NULL) free(line);
+
+  if (tpcount == 0) {
+      fprintf(stderr, "0 ports read from whitelist file '%s'\n",
+                      settings.whitelist);
+      return -4;
+  }
+
+  target_ports = (int*)realloc(target_ports, (tpcount + 1)*sizeof(int));
+  if (target_ports == NULL) {
+      fprintf(stderr, "Whitelist port realloc error");
+      return -2;
+  }
+  target_ports[tpcount] = 0;
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+    int fd, c, option_index = 0;
+    char *found;
+    static struct option long_options[] = {
+        {"verbose",   no_argument,       0,                 'v'},
+        {"ssl-only",  no_argument,       &settings.ssl_only, 1 },
+        {"daemon",    no_argument,       0,                 'D'},
+        /* ---- */
+        {"run-once",  no_argument,       0,                 'r'},
+        {"cert",      required_argument, 0,                 'c'},
+        {"key",       required_argument, 0,                 'k'},
+        {"whitelist", required_argument, 0,                 'w'},
+        {"pattern",   required_argument, 0,                 'P'},
+        {"pid",       required_argument, 0,                 'p'},
+        {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 = "";
+    settings.pattern = "/%d";
+    settings.pid = "/var/run/websockify.pid";
+
+    while (1) {
+        c = getopt_long (argc, argv, "vDrc:k:w:p:P:",
+                         long_options, &option_index);
+
+        /* Detect the end */
+        if (c == -1) break;
+
+        switch (c) {
+            case 0:
+                break; // ignore
+            case 1:
+                break; // ignore
+            case 'v':
+                settings.verbose = 1;
+                break;
+            case 'D':
+                settings.daemon = 1;
+                break;
+            case 'r':
+                settings.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;
+            case 'w':
+                settings.whitelist = realpath(optarg, NULL);
+                if (! settings.whitelist) {
+                    usage("No whitelist file at %s\n", optarg);
+                }
+                break;
+            case 'P':
+                settings.pattern = optarg;
+                break;
+            case 'p':
+                settings.pid = optarg;
+                break;
+            default:
+                usage(" ");
+        }
+    }
+
+    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 && settings.whitelist == NULL) {
+        memcpy(target_host, argv[optind], found-argv[optind]);
+        target_port = strtol(found+1, NULL, 10);
+        target_ports = NULL;
+    } else if (!found && settings.whitelist != NULL) {
+        if (load_whitelist()) {
+          usage("Whitelist error.");
+        }
+        memcpy(target_host, argv[optind], strlen(argv[optind]));
+        target_port = -1;
+
+    } else {
+        usage("Target argument must be host:port or provide host and a port whitelist\n");
+    }
+    if (target_port == 0) {
+        usage("Could not parse target port\n");
+    }
+
+    if (settings.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();
+
+}

src/radangel.c

@@ -0,0 +1,474 @@
+/*
+ *	RadAngel gamma spectrometer USB HID device control and readout program
+ *
+ *	gcc -std=gnu99 -Wall radangel.c -o radangel -pthread -lm -lhidapi-libusb
+ *
+ *      strip -s radangel
+ *
+ *	echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="04d8", ATTR{idProduct}=="0100", MODE="0666"' | sudo tee /etc/udev/rules.d/99-kromek-radangel.rules
+ *
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <pthread.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/time.h>
+#include <hidapi/hidapi.h>
+#include <unistd.h> // usleep()
+
+
+#define MAX_STR 255
+#define MAX_CHANNEL 4096
+#define QUEUESIZE 1024
+#define DEV_VID 0x4d8
+#define DEV_PID 0x100
+#define LINE_MAX 4096
+
+// non blocking
+#define HID_TIMEOUT -1
+// 500 ms timeout
+//#define HID_TIMEOUT 500
+
+
+typedef struct {
+	struct timespec start_time;
+} config;
+
+typedef struct {
+	FILE* file;
+	char* name;
+} output;
+
+typedef struct {
+	hid_device* handle;
+	config config;
+	output event;
+	output stats;
+} context;
+
+typedef struct {
+	struct timespec event_time;
+	unsigned short channel;
+} data;
+
+typedef struct {
+	data data[QUEUESIZE];
+	long head, tail;
+	int full, empty;
+	pthread_mutex_t *mutex;
+	pthread_cond_t *not_full, *not_empty;
+	context context;
+} queue;
+
+void usage(char* name);
+void info(const char* fmt, ...);
+void timespec_diff(struct timespec *start, struct timespec *stop, struct timespec *result);
+queue *queue_init(void);
+void queue_free(queue *q);
+void queue_add(queue *q, data src);
+void queue_del(queue *q, data *dst);
+void *event_source(void *args);
+void *event_sink(void *args);
+//void *update_context(void *args);
+
+
+static int verbose_flag; // Flag set by -v | --verbose
+
+
+void usage(char* name) {
+        info("%s [<arguments>]\n\n", name);
+	info("\t-h          | --help             Usage message.\n");
+        info("\t-v          | --verbose          Verbose output.\n");
+	info("\t-e <string> | --event  <string>  Event data file path.\n");
+	info("\t-s <string> | --stats  <string>  Stats data file path.\n");
+	info("\n");
+}
+
+
+int main(int argc, char **argv) {
+	queue *fifo = NULL;
+	pthread_t pro, con;
+
+	struct timespec start_time = { 0, 0 };
+	int c;
+	int option_index = 0;
+
+	fifo = queue_init();
+	if (fifo ==  NULL) {
+		info("Error: main queue_init() failed.\n");
+		exit(1);
+	}
+	fifo->context.event.name = "-";
+	fifo->context.event.file = stdout;
+	fifo->context.stats.name = NULL;
+	fifo->context.stats.file = NULL;
+
+	while (1) {
+		static struct option long_options[] = {
+			{"verbose",	no_argument, 		&verbose_flag,	1  },
+			{"help", 	no_argument,		NULL, 		'h'},
+			{"event",	required_argument, 	NULL,		'e'},
+			{"stats",	required_argument, 	NULL,		's'},
+			{0, 		0, 			0, 		0  } // end of options
+		};
+		option_index = 0;
+		c = getopt_long(argc, argv, "he:s:", long_options, &option_index);
+		if (c == -1) { // end of options
+			break;
+		}
+		switch (c) {
+			case 0:
+				if (long_options[option_index].flag != 0) { // option sets a flag
+					break;
+				}
+				info("option %s", long_options[option_index].name);
+				if (optarg) {
+					info(" with arg %s", optarg);
+				}
+				info("\n");
+			break;
+			case 'e':
+				fifo->context.event.name = optarg;
+			break;
+			case 's':
+				fifo->context.stats.name = optarg;
+			break;
+			case 'h':
+				usage(argv[0]);
+				queue_free(fifo);
+				exit(1);
+			break;
+			case '?': // getopt_long already printed an error message.
+			break;
+			default:
+				abort();
+		}
+	}
+	if (optind < argc) { // remaining command line arguments (not options).
+		info("unknown argument: ");
+		while (optind < argc) {
+			info("%s ", argv[optind++]);
+		}
+		info("\n");
+		queue_free(fifo);
+		exit(1);
+	}
+
+
+	// ensure input
+ 	if (hid_init()) {
+		info("Error: unable to initialize hidapi.\n");
+		queue_free(fifo);
+		exit(1);
+	}
+	// open device later in read thread, might not be connected yet
+	// measurement start
+	clock_gettime(CLOCK_MONOTONIC, &start_time);
+	fifo->context.config.start_time = start_time;
+
+	// start the producer and consumer threads
+	pthread_create(&pro, NULL, event_source, fifo);
+	pthread_create(&con, NULL, event_sink, fifo);
+	pthread_join(pro, NULL);
+	pthread_join(con, NULL);
+
+	if (fifo->context.event.file != NULL) {
+		fclose(fifo->context.event.file);
+	}
+	if (fifo->context.stats.file != NULL) {
+		fclose(fifo->context.stats.file);
+	}
+	if (fifo->context.handle != NULL) {
+		hid_close(fifo->context.handle);
+	}
+	hid_exit(); // Free static HIDAPI objects
+	queue_free(fifo);
+
+	return 0;
+}
+
+
+void info(const char* fmt, ...) {
+	va_list args;
+	va_start(args, fmt);
+	if (verbose_flag) {
+		fprintf(stderr, fmt, args);
+	}
+	va_end(args);
+}
+
+
+queue *queue_init(void) {
+	queue *q;
+
+	q = (queue *) malloc (sizeof (queue));
+	if (q == NULL) return (NULL);
+
+	q->empty = 1;
+	q->full = 0;
+	q->head = 0;
+	q->tail = 0;
+
+	q->mutex = (pthread_mutex_t *) malloc (sizeof (pthread_mutex_t));
+	pthread_mutex_init(q->mutex, NULL);
+
+	q->not_full = (pthread_cond_t *) malloc (sizeof (pthread_cond_t));
+	pthread_cond_init(q->not_full, NULL);
+
+	q->not_empty = (pthread_cond_t *) malloc (sizeof (pthread_cond_t));
+	pthread_cond_init(q->not_empty, NULL);
+
+	return (q);
+}
+
+
+void queue_free(queue *q) {
+	pthread_mutex_destroy(q->mutex);
+	free(q->mutex);
+
+	pthread_cond_destroy(q->not_full);
+	free(q->not_full);
+
+	pthread_cond_destroy(q->not_empty);
+	free(q->not_empty);
+
+	free(q);
+}
+
+
+void queue_add(queue *q, data src) {
+	q->data[q->tail] = src;
+	q->tail++;
+
+	if (q->tail == QUEUESIZE) {
+		q->tail = 0;
+	}
+
+	if (q->tail == q->head) {
+		q->full = 1;
+	}
+
+	q->empty = 0;
+
+	return;
+}
+
+
+void queue_del(queue *q, data *dst) {
+	*dst = q->data[q->head];
+	q->head++;
+
+	if (q->head == QUEUESIZE) {
+		q->head = 0;
+	}
+
+	if (q->head == q->tail) {
+		q->empty = 1;
+	}
+
+	q->full = 0;
+
+	return;
+}
+
+
+void *event_source(void *q) {
+	queue *fifo;
+	fifo = (queue *)q;
+	data data;
+
+	hid_device* handle = fifo->context.handle;
+	unsigned char buffer[64];
+	int result;
+
+	struct timespec event_time = { 0, 0L };
+	struct timespec sleep_time = { 0, 500000000L}; // retry time
+
+	do { // read events loop
+		while (handle == NULL) { // try to aquire handle
+			handle = hid_open(DEV_VID, DEV_PID, NULL);
+			if (handle != NULL) {
+				fifo->context.handle = handle;
+			} else {
+				nanosleep(&sleep_time, NULL); // wait to retry
+			}
+		}
+		while (handle != NULL) { // try to read data
+			memset(buffer, 0, sizeof(buffer));
+			result = hid_read_timeout(handle, buffer, sizeof(buffer), HID_TIMEOUT);
+			if (result > 0) { // got some bytes
+				break;
+			} else if (result < 0) { // something went wrong: disconnect?
+				hid_close(handle);
+				handle = NULL; // invalidate handle for reaquire
+				fifo->context.handle = handle;
+			}
+		}
+
+		clock_gettime(CLOCK_MONOTONIC, &event_time);
+
+		if (buffer[0] == 4) { // got an event
+			data.channel = (((buffer[1] << 8) | buffer[2]) >> 4);
+			data.event_time = event_time;
+
+			// lock the queue, wait for space, push
+			pthread_mutex_lock(fifo->mutex);
+			while (fifo->full) { // queue is full, wait for consumer
+				pthread_cond_wait(fifo->not_full, fifo->mutex); // unlocks, block, relock
+			}
+			queue_add(fifo, data);
+			pthread_mutex_unlock(fifo->mutex);
+			pthread_cond_signal(fifo->not_empty);
+		}
+
+	} while (1); // read events loop
+
+	return (NULL);
+}
+
+
+void timespec_diff(struct timespec *start, struct timespec *stop, struct timespec *result) {
+    if ((stop->tv_nsec - start->tv_nsec) < 0) {
+        result->tv_sec = stop->tv_sec - start->tv_sec - 1;
+        result->tv_nsec = stop->tv_nsec - start->tv_nsec + 1000000000;
+    } else {
+        result->tv_sec = stop->tv_sec - start->tv_sec;
+        result->tv_nsec = stop->tv_nsec - start->tv_nsec;
+    }
+    return;
+}
+
+
+void *event_sink(void *q) {
+	queue *fifo;
+	fifo = (queue *)q;
+	data data;
+
+	char *events_filename = fifo->context.event.name;
+	char *stats_filename  = fifo->context.stats.name;
+	char *events_filemode = "a+";
+	char *stats_filemode  = "w";
+	FILE *events_file = events_filename ? ((strncmp(events_filename, "-", 1) == 0) ? stdout : fopen(events_filename, events_filemode)) : NULL;
+	FILE *stats_file  = stats_filename  ? ((strncmp(stats_filename,  "-", 1) == 0) ? stdout : fopen(stats_filename,  stats_filemode )) : NULL;
+	fifo->context.event.file = events_file;
+	fifo->context.stats.file = stats_file;
+
+	struct timespec start_time = fifo->context.config.start_time;
+	struct timespec event_time = { 0, 0L };
+	struct timespec sleep_time = { 0, 500000000L}; // retry time
+	long int tv_sec;
+	unsigned long int tv_nsec;
+
+	unsigned int  channel = 0;
+	unsigned long histogram[MAX_CHANNEL];
+	memset(histogram, 0, MAX_CHANNEL * sizeof(unsigned long));
+
+	const char event_header[] = "time\tchannel\n";
+	const char event_format[] = "%ld.%03ld\t%d\n";
+	const char stats_header[] = "channel\n";
+	const char stats_format[] = "%ld\n";
+	char line[LINE_MAX];
+
+	int i, result = 1;
+
+	// reconstruct event_time and histogram
+	if (events_filename && events_file && (events_file != stdout)) {
+		rewind(events_file);
+		while (fgets(line, LINE_MAX, events_file) != NULL) {
+			if(sscanf(line, event_format, &tv_sec, &tv_nsec, &channel) == 3) {
+				event_time.tv_sec = tv_sec;
+				event_time.tv_nsec = tv_nsec;
+				histogram[channel % MAX_CHANNEL] += 1; // update histogram
+			}
+		}
+	}
+	if (events_filename && events_file && ((events_file == stdout) || (ftell(events_file) == 0))) {
+		fprintf(events_file, event_header);
+	}
+
+	// readjust start_time
+	timespec_diff(&event_time, &start_time, &start_time);
+	fifo->context.config.start_time = start_time;
+
+
+	if (stats_file && stats_filename) {
+		stats_file  = (strncmp(stats_filename,  "-", 1) == 0) ? stdout : freopen(stats_filename,  stats_filemode, stats_file);
+		fifo->context.stats.file = stats_file;
+		result = !!stats_file;
+		if (stats_file) {
+			result = fprintf(stats_file, stats_header);
+			for (i = 0; i < MAX_CHANNEL; i++) {
+				result = result && (fprintf(stats_file, stats_format,
+					histogram[i]
+				) > 0);
+			}
+			fflush(stats_file);
+		}
+	}
+
+
+	do { // output loop
+		// lock the queue, wait for data, pull
+		pthread_mutex_lock(fifo->mutex);
+		while (fifo->empty) { // queue is empty, wait for producer
+			pthread_cond_wait(fifo->not_empty, fifo->mutex); // unlock, block, relock
+		}
+		queue_del(fifo, &data);
+		pthread_mutex_unlock (fifo->mutex);
+		pthread_cond_signal(fifo->not_full);
+
+		// event time since measurement start
+		event_time = data.event_time;
+		channel = data.channel;
+		timespec_diff(&start_time, &event_time, &event_time);
+
+		// update histogram
+		histogram[channel % MAX_CHANNEL] += 1;
+
+		if (events_file) {
+			result = (fprintf(events_file, event_format,
+				event_time.tv_sec,
+				event_time.tv_nsec / 1000000,
+				channel
+			) > 0);
+			fflush(events_file);
+		} else if (events_filename) {// try reopen
+			nanosleep(&sleep_time, NULL); // wait to retry
+			events_file = (strncmp(events_filename, "-", 1) == 0) ? stdout : freopen(events_filename, events_filemode, events_file);
+			fifo->context.event.file = events_file;
+			result = !!events_file;
+		}
+
+		if (stats_file && stats_filename) {
+			stats_file  = (strncmp(stats_filename,  "-", 1) == 0) ? stdout : freopen(stats_filename,  stats_filemode, stats_file);
+			fifo->context.stats.file = stats_file;
+			result = !!stats_file;
+			if (stats_file) {
+				for (i = 0; i < MAX_CHANNEL; i++) {
+					result = result && (fprintf(stats_file, stats_format,
+						histogram[i]
+					) > 0);
+				}
+				fflush(stats_file);
+			}
+		}
+
+	} while (result); // output loop
+
+	return (NULL);
+}
+
+
+/*
+void *update_context (void *q) {
+	queue *fifo;
+	fifo = (queue *)q;
+
+	return (NULL);
+}
+*/
+