sshp Rewrite from JavaScript to C

Posted by Dave Eddy on May 20 2021 - tags: tech

In 2013, I wrote a program in Node.js called sshp. This was right around the time I was investing heavily into learning node, and honestly having a blast doing it. Node is quick and fun to write, and with only a couple hundred lines of code, I was able to write node-sshp.

node-sshp is a command line utility that acts as a parallelizer for ssh. It works by taking in a file containing a list of hosts to connect to and looping over each host firing off an ssh command in parallel (with a configurable maximum number of concurrent processes). The tool’s description is:

sshp manages multiple ssh processes and handles coalescing the output to the terminal. By default, sshp will read a file of newline-separated hostnames or IPs and fork ssh subprocesses for them, redirecting the stdout and stderr streams of the child line-by-line to stdout of sshp itself.

Writing this tool in Node was an obvious choice at the time: the company I was working for was using Node heavily, and this tool was written specifically to be used at my job. Managing multiple concurrent child processes and IO streams also made Node the obvious choice.


Super Mario 64 Decompilation on Void Linux

Posted by Dave Eddy on Sep 09 2020 - tags: tech

Super Mario 64 is one of my all-time favorite games. Last year, the source code for the decompilation project was made available to the public. I won’t go into detail on the decompilation project itself (see this post here for more information), but instead will focus on getting Super Mario 64 compiled on Void Linux.

Getting Started

A couple of dependencies will need to be installed that will be used throughout the installation process. Note that root privileges are only required in commands where sudo is used - the rest of the commands can be run as an unprivileged user.

sudo xbps-install git
sudo xbps-install make
sudo xbps-install wget

mkdir ~/dev ~/src

For this guide, the sm64 source code will be checked out into ~/dev, and the required dependencies that are installed manually will be in ~/src, of which there are 2:

  1. qemu-irix
  2. binutils-mips64


To install this package, I found it easiest to take the qemu-irix release as a .deb file from the n64decomp GitHub organization and extract the deb myself.


SmartOS COAL on Linux KVM with Virt Manager

Posted by Dave Eddy on Feb 12 2019 - tags: tech

COAL, or Cloud-on-a-Laptop, is an easy way to run and test SmartOS and the Triton Stack in a self-contained VM meant to be run on a laptop. The sdc-headnode repository makes a lot of assumptions when building a COAL image about using VMWare for virtualization on an OS X laptop. However, with some modifications it is possible to run COAL on Linux via KVM managed through virt-manager.

To get virt-manager setup and running on Void Linux, you can follow my guide KVM Virtualization with virt-manager on Void Linux.

Nested Virtualization (optional)

Before getting started with the COAL building process, you can choose to enable nested virtualization if your hardware supports it. This is required if you would like to run bhyve zones on your COAL setup. Note that this setup assumes an Intel CPU.

You can check if your CPU supports nested virtualization by running:

$ grep ^flags /proc/cpuinfo | grep -c ' vmx '


KVM Virtualization with virt-manager on Void Linux

Posted by Dave Eddy on Feb 11 2019 - tags: tech

Running and managing virtual machines on Linux is very easy using the virt-manager GUI program. Under the hood, the virtualization technology takes advantage of KVM (Kernel Virtal Machine) in the Linux kernel. The result of both of these together is fast and efficient hardware virtual machines with a really easy and straightforward GUI to manage them.

For this post, I’ll be using the following tools I’ve talked about in my blog post Using Void Linux as my Daily Driver:

  • vsv - Void Service Manager
  • vpm - Void Package Manager


Install the following packages to get started:

sudo vpm i virt-manager libvirt qemu

Start the services that are created by these packages:

sudo ln -s /etc/sv/libvirtd /var/service
sudo ln -s /etc/sv/virtlockd /var/service
sudo ln -s /etc/sv/virtlogd /var/service

Use vsv to check the status of the services:

sudo vsv status virt


Running a Bitcoin Full Node on SmartOS

Posted by Dave Eddy on Jan 20 2019 - tags: tech

Running a Bitcoin full node is a great way to ensure the health and integrity of the decentralized Bitcoin network. This blog post is meant to be a guide for compiling, running, and monitoring a Bitcoin full node on a server, and as such won’t delve too much into the specifics as to what the node does, or why it’s important to the network health. If you want to know more check out 6 Reasons To Run a Bitcoin Full Node.


Put simply, running a full node will add to the large number of full nodes running across the world to support the Bitcoin network. The nodes ensure the rules of the protocol and consensus algorithms in place are upheld and enforced, which is what fundamentally allows Bitcoin to work and function the way it should.

Miners create new blocks and submit them to the network for verification - it’s the job of the full nodes to verify these blocks (groups of transactions) and ultimately accept or reject them based on their validity. Every full node will verify the validity of any and all blocks submitted to the network and, for each block, decide if it will be the next new block in the chain or whether it should be thrown out in the case that it is invalid (by either a bug in the mining software or a bad actor trying to undermine the network). Full nodes are the final arbiters when it comes to determining which transactions are valid or invalid.

Provision the VM

I provisioned a fresh SmartOS 16Q4 LTS instance with the following JSON payload:


Run User Scripts on Suspend and Wakeup on Void Linux

Posted by Dave Eddy on Oct 01 2018 - tags: tech

While using Void Linux on my laptop, I wanted some way to trigger scripts as my user when the machine went to sleep and when it resumed. The main goal of this was to be able to lock my machine using i3lock on suspend.

I currently use xss-lock to register i3lock to be called whenever the screensaver is activated with this command (run at session start):

xss-lock -- ~/bin/i3lock-retry -enfi ~/Pictures/lock.png

With xss-lock running, I set my machine to lock automatically after 600 seconds (10 minutes) of inactivity with:

xset s 600

And locking my machine can be done manually by activating the screensaver with:

xset s activate

Note: i3lock-retry is a simple wrapper-script that calls i3lock continuously until it exits successfully (i.e. when the correct password has been entered). I’ve had some issues with i3lock crashing in the past and I just have this wrapper in place because of paranoia over ensuring my system locks correctly.


Logging for runit on Void Linux with svlogger

Posted by Dave Eddy on Sep 26 2018 - tags: tech

Update 10/01/2018

svlogger can be easily replicated with vlogger(8), which is shipped with void-runit. This comment from Duncaen on reddit explains it:

I wrote vlogger(8) which works similar, by default it logs to syslog and if /etc/vlogger is an executable file it will exec into /etc/vlogger with the service name as argument.

The script would be something like this:

exec svlogd /var/log/$1

The main idea is to make it simple to switch from logging to syslog to svlogd by just creating /etc/vlogger. Its part of the runit-void package and services could be shipped with this as default at some point.

I created /etc/vlogger as an executable with the following contents:

mkdir -p "$logdir"
exec svlogd -tt "$logdir"

Updated my existing log services with:

cd /var/service
for f in */log/run; do sudo ln -svf /usr/bin/vlogger "$f"; done

And restarted them with:

sudo sv restart /var/service/*/log

The rest of the post is left here for historical purposes.

I’ve been using Void Linux on my laptop for the last month or so and it has just been fantastic; using runit to manage services has been so incredibly easy. I wrote vsv to make the output a little more colorful and the usage slightly easier, but even just using sv directly has just been great.


vsv - Void Service Manager

Posted by Dave Eddy on Sep 20 2018 - tags: tech

In my previous post, Using Void Linux As My Daily Driver, I wrote that I used vpm as a wrapper for the xbps-* commands to manage packages on Void Linux. I like how convenient the tool is and how it works (it knows it’s a wrapper command and it doesn’t try to hide that fact). It also makes the output very colorful, which I do like a lot. I know that’s a bit of a simple reason, but I personally just like very colorful output (with the option to disable it of course).

Managing services on Void Linux is already fairly easy using the sv command; however, I felt a couple of things could be made simpler and that the output could be more obvious at a quick glance.

With that, vsv was born.

vsv is a bash script wrapper for the sv command that can be used to query and manage services via runit. It was made specifically for Void Linux but should theoretically work on any system using runit to manage services.

vsv was inspired by vpm. vsv is to sv what vpm is to the xbps-* commands. vsv is available under the MIT License on GitHub:


Using Void Linux As My Daily Driver

Posted by Dave Eddy on Sep 15 2018 - tags: tech

I’ve been using Void Linux on my laptop for the last couple of weeks and I have been absolutely loving it. The whole system feels lean, minimal, fast, and has amazing battery life. I’ve found a majority of the software that I’ve used previously on Arch Linux is either available or compiles just fine on Void. I’ve run into a couple of issues because I’m using the musl build of Void, but I’ve managed to deal with them without too much trouble.


vpm - Void Package Manager

On the basic usage page for XBPS, there are a number of example commands for installing a package, searching for a package, removing a package, etc.


Manage PATH Variable in Bash

Posted by Dave Eddy on Sep 12 2018 - tags: tech

Over the weekend I wrote what can only be described as a completely over-engineered solution to something that was really nothing more than a minor annoyance to me. I noticed that some paths in my $PATH environmental variable were duplicated, and some were there that didn’t exist on the filesystem, and over all it was just a bit of a mess.

I remember encountering the pathmunge bash function a couple years ago but I didn’t want something that relied on grep or any external commands - I wanted to be able to manage $PATH (and $MANPATH) with pure bash.

Introducing bash-path.

Functions to modify colon separated variables like $PATH or $MANPATH

All of the logic is in a single file and can be sourced or copied directly into a bashrc file to be used. I pulled in bash-path to my dotfiles with this simple commit


Given the following environment:

$ . path.bash
$ PATH='/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin'

You can add to $PATH using path_add (similar to pathmunge):

$ path_add /my/new/bin
$ path_add /my/new/sbin before
$ echo "$PATH"


Newer Posts 1 of 6 Older Posts »