Rafael Cavalcanti - rafaelc.org

Running a web server while using Pi Hole

Wed, 18 Jul 2018 18:27:38 GMT

If you are running Pi Hole and want to deploy a web application to your Raspberry Pi, chances are that you’ll hit your head to the wall. That’s because Pi Hole installs and configures a web server (Lighttpd) for itself using port 80.

This way, Lighttpd:

Serves the admin dashboard at http://pi.hole/ and http://THE.PI.IP/admin.
Shows a "blocked" page whenever you bump at a blocked domain.

So what can you do?

(If you just want a step by step solution, you can cut through the talk and jump to part 2.)

There are many solutions to this, and, of course, which one suits you best depends on your specific situation. On this post, I’ll list some of them, their caveats, and explain what I did on my Pi.

First is the one I dislike more: buying another Raspberry Pi. Alright, that’s a no-brainer if those apps will be internet facing, but for LAN… Just why? Hell, this device can handle a lot more than Pi Hole. There’s no need to put more pressure to the environment and to our pockets.

Another solution is to bind your web server to a port other than 80. This can be fine for some situations, but in my case it doesn't make it. My Pi serves a bunch of web applications for the LAN. Instead of forcing the users to memorize different ports, or make them go through a menu, I assign friendly domain names. This intended ease of use on my LAN makes port 80 fundamental for me.

So going forward, you could edit the Lighttpd configuration set by Pi Hole. This way, you would make Lighttpd also serve your applications, for example choosing them according to the name on the request.

This one could sure do it, but it isn't a very clean approach. Why? You have to learn a bit of what Pi Hole expects the web server to do and not mess it up. Also, a possible change upstream will have to be merged into your configuration.

Another problem with this solution: what if you don’t want to use Lighttpd for your projects? Maybe you have a very complex Nginx or Apache setup and don’t see yourself rewriting it because of Pi Hole.

In this case, an alternative is to nuke the Lighttpd installation, install the web server of your choice and then proceed to do all the configuration – for your apps, and for Pi Hole. However, this solution has the same caveat of having to mess with the web configuration of Pi Hole.

Alright, so what did I come with for my Pi?

I decided to take a simpler and cleaner approach. Besides being easy to setup, using it for 20 months resulted in no headaches. This is:

set an additional IP for the Raspberry Pi
bind Lighttpd to the original IP
bind our app web server to the new IP

And we are done. This way you:

Can use port 80 however you want, all for you, as if Pi Hole wasn't installed.
Use whatever web server you pick for your apps, configuring it as you always did.
Barely have to touch whatever Pi Hole configured Lighttpd to do, so it works exactly as intended.
Don't have to perform any maintenance since Pi Hole 4.2.2 (on earlier versions you only had to do a minor edit on configuration at every update).

The caveat here is that you have to run two separate web servers. Maybe for your situation this won't be acceptable. But in my particular setup and typical load, there's no performance impact in any significant way.

The next post covers those steps in detail.

The motivation for PiFi Radio

Sat, 11 Aug 2018 01:36:17 GMT

PiFi Radio is a MPD web client focused on playing radio streamings. As I recently open sourced it, I'll try to explain what made me write it.

The need

I started this project in early 2017. At that time, I wanted to setup a Raspberry Pi for my parents to listen to internet radio and control it with ease.

That Pi also served other purposes, so installing an audio dedicated distro, such as Volumio, wasn't an option. I installed MPD on top of Raspbian and looked for a client. I needed:

A straight-forward user interface that wouldn't confuse them. Few taps to the desired actions and little room to mistakes.
The interface should, at least, present a list of stations from which to pick, and allow to control the volume and stop the current playback.
The administrator should have the ability to set a list of streams and make it available to all users.
The client should be usable at least from iOS and Android phones, but ideally everywhere.
It should be in their native language.

What I found at that time was the following.

Available MPD clients at the time

There were many great MPD clients available on Android, desktop and web. The "forgotten" platform was iOS, for which there was only one (paid) app on the AppStore. This was not a big of an issue, as I could still set up a web client for those devices.

However, I couldn't find a client that treated radios with much care. The majority of them privileged the music library, with streaming as a hacky, second class citizen (as you’ll see PiFi is the opposite).

The usual experience for radio listening

On most clients, to have a list of radio streams you need to create a playlist on the server and add the stations to it. Then, to choose a radio, the user has to find that playlist on the app and tap the desired streaming. This has many problems for me.

First of all, equating a list of radios to a playlist can be confusing to some users. Also, it has some unexpected behaviours. For example, if the user selects a station with a broken URL, MPD will start to play the next radio. So the user is confused: he asked for one station, but other one is playing. He will probably tap again and won't understand why this continues to happen.

Other problem is that you usually can’t set a friendly name to the stream. The playlist is presented to the user as a series of URLs or some badly formatted info that the station broadcasted. So, when choosing the radio playlist, the user is presented a list consisting of (possibly giant and frightening) URLs, random song names and, when he is lucky, ugly formatted station names. The same lack of clarity happens when the user open the app to check what station is currently playing.

I also didn't like that the playlists are editable by the users. This makes sense for song playlists, but I don't expect them to mess with radio streaming URLs. I wanted this to be reserved to the backend.

One more issue is that, since those clients are focused on the library, someone who uses them just to play radio finds the interface far from straight-forward, actually rather confusing. Many MPD clients are packed with features related to the music library. The result is the screen filled with options that radio listeners don’t care about. This could be very frustrating to them, specially because the same clients lack basic behaviours that you would expect from a radio app. My parents would actually have to memorize steps just to play a station. Not good.

The most promising contenders were some desktop applications. A couple of them had radio lists conveniently fetched from web services such as Soma FM, TuneIn, Shoutcast, etc, and even some sort of local radio bookmarks. However, I wanted the same "favourites" list to be available across all users and devices, and those apps still had the issue of confusing names for the playing stations. Worst of all, desktop wasn't my priority. So this couldn't do it.

Finally, few applications were translated to the language I needed. This could be remediable, but at this point it didn't matter anymore.

Conclusion

The bottom line: while there are tons of great MPD clients, you will hardly have a nice time using software for something it wasn't designed. Most clients are focused on the MPD music library, and at that time I couldn't find any that took streaming with care.

It was then obvious to me that I should create my own solution to my problem. I decided to code a simple web app and call it PiFi Radio, a MPD web client for listening to radio. You can see how it went on my Github.

A cause for error 0x80070057 on Windows 10

Wed, 21 Nov 2018 16:45:15 GMT

After years as a full-time Linux user, lately I decided to fiddle a bit more with Windows 10.

Just a couple of days passed from a clean Windows installation, and I faced a somewhat obscure bug. The solution I found might be helpful to someone else.

The issue was these operations would fail most of the time:

Installing or updating software via Windows Store
Installing Windows updates
Windows installing "new resources"
Updating Apple software

The error displayed was 0x80070057.

If you Google it, you'll see this error hasn't a single known cause, and attempting to fix it consists on trying multiple things, including nuking your whole Windows installation (and after reinstallation the error might still be there :-D).

In this beautiful scenario, I went to do some troubleshooting. I detected that, in my system, that error was related to a specific software I had installed and running: EncFSMP 0.11.1.

Simply unmonting all drives in this application makes the error go away.

I've filled a bug for it.

MIUI Notes trims text without warning

Tue, 30 Apr 2019 02:54:03 GMT

This entry is just a friendly warning if you happen to use the Notes app from Xiaomi.

These days I shared a few texts to it via Android's share menu. All seemed well. No error message and all texts were there as new notes, as expected.

However, later when I opened them, I realized that some ended abruptly. They were trimmed around 16,300 characters (which probably not by accident is close to 2¹⁴.

In order to know which app was to blame, I repeated the sharing but to other app instead of Notes. The result then was fine: the text was fully there.

So, this seems like MIUI Notes not taking proper action when receiving texts that exceed its character limit. Not even a warning to the user.

I filled a bug to Xiaomi, but while it is not fixed, be aware so this doesn't get you in trouble.

For the record, the MIUI Notes version is 1.5.2.

An anti-theft strategy on Xiaomi phones

Mon, 08 Jul 2019 02:00:21 GMT

In this post, I want to share an idea that I had last year and may help secure your data on Xiaomi phones.

The scenario

You may be faced with a situation in which someone, normally a thief, constrain you to give away your PIN. Needless to say, together your PIN, he'll have access to most of what you have on your phone.

A first approach

To protect against that kind of adversary, a first approach would be to add a second layer of protection to your most important apps and data.

For example, for apps you can use MIUI's App Lock. This asks for your fingerprint or face unlock before opening some apps. For data, you could use MIUI's password protection for specific folders.

However, that approach can quickly get out of hand, and make a pain to user your own phone. The strategy I will share protects your data further, while not impacting a lot on your daily phone use.

My solution

So you might know that MIUI has a feature called Second Space. That's basically Android letting you create a second user for your device.

However, Xiaomi's implementation has an interesting feature that is absent on AOSP - and I guess for many manufacturers. Whenever you unlock your phone, MIUI can take you to the first or to the second space depending on which PIN you type. Cool, uh?

On AOSP (at least until Android 9), you need to unlock the current user in order to switch to another one, through the notification shade.

Knowing that MIUI feature, we can use it to further protect our personal data.

Hands on

So let's set it.

Open the Settings. The Second Space configuration is placed in a different place depending on your MIUI version. On MIUI 11, it is under Special features -> Second Space. If you can't see it, try searching for "Second Space" on the search bar.
Tap "Turn on Second Space", wait for the completion, and then press "Continue".
A screen will show up asking if you want to switch between the spaces using a password or using a shortcut. Press "using a password".
You'll be asked for your first space password. Enter it, and you'll be asked to set the password for the second space. Obviously, use a different one.
You can skip setting a fingerprint.
Good. By now you should have landed on the Second Space. We'll further hide the fact that this isn't the main space, doing the following:
- Go to Settings -> Special Features -> Second Space (or wherever it is placed on your MIUI version).
- Under "Second Space Settings" disable both options: "Home screen shortcut" and "Show notifications from First Space".
- Under "Other settings" disable "Second Space icon".

And we are done.

Now you go on with your life, and just don't place any personal data in the Second Space.

If, at any time, someone constrains you for your PIN, just give the secondary one. The phone will unlock, making them probably happy, but without any access to your data and apps. Isn't it nice?

Caveats

So far, the only caveat I've experienced is the following. If you have been using your phone normally (in the First Space) and then coldly enter the secondary pin, the phone will take a longer time to unlock.

I hope this helps someone.

Digital reading, highlights and notes

Thu, 19 Sep 2019 16:39:51 GMT

When reading, I consider the ability of highlighting and taking notes a basic requirement. If I can't do it in some way, even with rudimentary copy and past, my reading experience becomes much less rich.

The possibilities

The arrival of digital reading should help us with annotations, improving them and opening new possibilities.

Some of the obvious improvements over analog include:

No need to be afraid to mess a book or document.
Write without being conscious about the length of the note or trying to fit a small blank space at the side of the page with tiny letters.
Easily and quickly delete the annotations, without damaging the pages.
Browse and search through all your annotations fast.

Besides that, we should also explore new ideas and possibilities, instead of just mirroring what we used to do in paper. On the other hand, obviously, not everything is progress: some analog features are difficult to replicate.

The actual state

However, the actual state of it always bothered me. After all these years, we still lack a standard way of handling annotations. They work in different ways depending on the file format, the platform you are using and other details. This causes many problems, such as:

Your annotations can easily get spread over all kinds of services, apps, etc.
Interoperability is nearly nonexistent. I can't browse the annotations I have in different platforms in a central place.
They can get vendor locked.
They are stored (and exported) in many different formats.
Importing annotations from one place to other varies from difficult to virtually impossible.
Good luck if you ever want (or need) to change software while reading a ton of books... You'll probably need to stick to both and go back and forward to see your annotations spread over them.

All that is inelegant and inefficient. We still get the benefits I listed above, but in a limited and messy way. Worse yet, we barely advanced in exploring new ideas. Consequently, we are far from taking advantage from all the possibilities the digital opened to us.

Storing and exporting

Let's see some examples of how things work currently.

PDFs: If you are reading PDFs, many software support that you annotate them directly on the file.
ePubs: In the case of ePubs, each reader stores the annotations internally. Some of them do allow exporting, with a varying degree of convenience. But to which format? Well, it also depends on the app. It can be a fancy docx, a messy txt, a well-formated markdown, etc.

In particular, Google Play Books stores your annotations with their copy of the book, and allows you to export it to a Google Docs file, which also gets automatically updated. (IMO one of the best solutions out there, yet far from ideal.)
DRM'ed books: For DRM'ed books, such as the ones you buy on Amazon, the situation is similar to what I just described for ePubs. With the glorious exception that you are stuck using their reader apps.
Kindle devices: About the Kindle, specifically, I talked on this post. TL;DR: also a mess.

A possible solution and more problems

We just saw that many software have some way to export your annotations. So we could think of a solution as the following:

It is just a matter of using applications that support exporting to a nice format. Use them to read the book and annotate it. Export the annotations when finishing the book. Store all them in a same folder.

This is more or less my current strategy (which I will detail next), but it is still far from ideal.

For example, what if you want to see your annotation IN the book? Let's say I want to build my digital library, and all my books would have my annotations, like in real life. How would a separate folder with tons of annotations would achieve that?

Worse than that. As I said, e-books annotations should give us more features, such as browsing the book by them, maybe searching them by genre, etc. None of those is given by a html or docx file with my highlights.

A second solution: books and annotations together

So what can we do to have a personal library with our digitally annotated books?

Well, since each app has their own internal method of storing the annotations, you'll have to pretty much stick with a particular software all your life. This has, at least, 4 problems:

First, the most obvious one.

You may want to switch to other software in the future, with features you consider useful.
You have to count to the software to be operational until your death.

For example, you may decide to use Play Books, and add all your books to there, but... If you ever stop using it or if it is discontinued, all you'll have are your Google documents. Your annotated library is gone. You cannot browse your ePub anymore with your annotations.
Migration is a pain.

Let's say, for the sake of the argument, that you found that perfect software, that you'll use forever, and it will surely never drop support or stop working. OK, let's just use it forever and all is solved, right? Not quite. How would it import the annotations for all the books you've read until today?
You may buy a different e-reader device.

If you buy a new e-reader you'll probably not be able to import the annotations from this software. Bye-bye, library.

So no luck.

My strategy

If you read until here, you're probably thinking "what a mess"! And I agree.

I'll try to shine some light with my current strategy to keep my digital annotations:

Pick an app/platform/e-reader and try to stick the most to it. E.g.: your Kindle, Google Play Books, etc.
Make sure to find a way to periodically export your annotations from it to a universal format, such as plaintext, PDF, etc.
Also convert the readings you do out of that platform to a universal format.
Keep everything stored and organized in a directory or database.

This aims to:

Have all your annotations in one place.
Have most of your content annotated (on the platform you pick).
Be safe against your annotations being vendor locked.

A big part of how you implement that strategy and how well it will work depends on your habits, and which formats and platforms you use. Here is one example of it in action:

Chosen platform: Google Play Books.
Do most of your reading there on Google Play Books.
Enable the built-in sync of annotations to Google Docs.
For your readings outside Play Books, save your annotations in markdown format and store in the same Google Drive folder.

It's a shame that, in 2019, the best strategy I developed for myself still has some important compromises. For the future, I hope we finally get a standardized way of doing all that.

Btw, if you happen to use a Kindle, this post might interest you.

Mounting KDE Connect filesystem via CLI

Sat, 03 Aug 2019 22:15:12 GMT

One of the multiple useful features from KDE Connect is browsing your phone files on your desktop. However, that's currently only available through the GUI, e.g., in KDE Connect tray icon or Dolphin's side panel. KDE Connect does have a command-line tool (kdeconnect-cli), but it lacks that option.

So if, for any reason, you need to do that mounting programatically, this guide should help you.

Getting what we need

First of all, let's gather the information we need. Mount the filesystem clicking KDE Connect's tray icon and selecting Browse device. Now run mount | grep kdeconnect, and you should get this:

kdeconnect@PHONE_IP:/ on /run/user/UID/PHONE_ID type fuse.sshfs (rw,nosuid,nodev,relatime,user_id=UID,group_id=GID)

This shows us that KDE Connect mounts the exposed filesystem through SFTP, connecting to a SSH server on our phone as the user kdeconnect.

So now we should find to which port it connects on our phone. With netstat, I found it to be the port 1740. Please check if your port is the same.

Finally, we should find KDE Connect private key to attempt the connection. This should be at ~/.config/kdeconnect/privateKey.pem.

Mounting the filesystem

With all that information, let's now try to mount our phone filesystem with sshfs. Replace ~/mnt with whatever mount-point you want, and PHONE_IP to your actual phone IP, and issue:

$ sshfs -o rw,nosuid,nodev,identityfile=$HOME/.config/kdeconnect/privateKey.pem,port=1740 kdeconnect@PHONE_IP:/ ~/mnt

If it went well, you're done. Now you can use that command to easily mount your phone filesystem via CLI.

A way to organize your Bash aliases on multiple hosts

Mon, 27 Aug 2018 14:34:25 GMT

If you use multiple systems, you probably have a method of syncing your dotfiles between them. But different systems also have different needs.

When we talk about Bash, not properly managing those differences could mean having tons of useless aliases polluting your environment, just because they are wanted on other machines. Or a very cluttered ~/.bash_aliases.

On this post, I'll talk about my approach to handle different Bash aliases on multiple machines.

Some solutions

A first try to handle the differences between hosts is, obviously, throwing some conditionals to your ~/.bash_aliases. For example, if you have aliases to cd to important directories, you could condition them to the existence of the folder. I do this to some extent and helps to keep the environment clean.

However, it only works to a certain point. When you deal with systems that serve totally different purposes, say a Raspberry Pi server vs. your laptop, this method becomes cumbersome. Your ~/.bash_aliases will be filled with conditionals, some maybe with difficult logic, and badly organized. Not to mention giant.

An alternative to this is to have multiple copies of your aliases file with the needed differences, and point each machine to the correspondent copy. The advantage here is that you have more readable files, but in the other hand, tons of duplication and management hell. Not nice either.

So, let's talk about my approach.

My approach

# ~/.bashrc

# Alias definitions.
if [ -f ~/.config/bash_aliases/$HOSTNAME ]; then
  . ~/.config/bash_aliases/$HOSTNAME
else
  . ~/.config/bash_aliases/default
fi

~/.config/bash_aliases
├── base        # Common aliases
├── default     # Aliases for generic hosts
├── foo         # Aliases for host foo
└── bar         # Aliases for host bar

First of all, we create a directory to store the aliases.

On ~/.bashrc, we search that path for a file named as the current hostname. If it doesn't exist, we source default.

We also create a file called base, which may be sourced by each of the other files.

Now let's dive into that directory.

The base file

In base, you place the aliases that you want to be available for every host.

In my case, this include things as simple as alias ll="ls -l" to more complex ones, and it is my biggest file.

I don't limit this file to which software I have available on all machines. My mindset here is to include everything that doesn't target any system specifically.

For example, mine has an alias (actually a function) to easily call snapper, although I don't have it installed on all my machines. It is there because, if someday I install snapper on whatever system, I'll probably want that alias.

So if something depends on the presence of a software, and not on which host I am, it probably belongs here on base, conditioned to the existence of the binaries on the system. Easy enough.

The host-specific files

The next step is to create a file for each system needing their own aliases. This file is named after their hostname.

Here you source base, and then set the additional aliases.

Other thing you might do here is to override some of the base aliases. "Why would I do that?" You might ask.

A example is if one of your systems uses Busybox instead of Coreutils. The former is a smaller version of the tools we are used to in Linux, and, as such, often has different (and less) command-line options. This breaks some of my aliases, such as rm -vI.

I solve it by overriding those aliases in my host-specific file for a "good enough" version of them. I think this makes more sense than removing the affected aliases from base.

Back to your host-specific files, they will be something like this:

# foo
# Aliases for a host called foo

# Source base
. ~/.config/bash_aliases/base

# Specific and overriding aliases for foo
...
...

The default file

Lastly, for the systems in which you don't need specific configuration, you have a fallback file called default.

Here you do the same thing as in the host-specific files, i.e., source base and then set or override aliases. The difference is that you are targeting the devices that won't match a specific hostname.

An alternative to write this file is to point those systems directly to base. For me, though, it makes sense to have a layer on top of base, to give me some flexibility.

Conclusion

I came with this approach to my aliases and it's serving me very well. I don't have duplicated code, my files are very readable and easily manageable. I also have a fair amount of flexibility.

I can think of many ways this solution could be modified and extended to better suit other particular cases. Feel free to adapt it to your needs.

Web server and Pi Hole - a how-to

Thu, 19 Jul 2018 16:39:23 GMT

In the previous post, we discussed how I set up a web server alongside Pi Hole. Now, I will guide you step by step on how to do it on Raspbian Stretch.

A word of caution. I think I don't need to remember you, but I will: please make a copy of the configuration files before editing. Also, be careful if doing this remotely, since we are changing the network configuration and a mistake could make you lose your connection to the Pi.

Step 1 – Set a secondary static IP

In this first step, we'll configure your Pi to have two static IP addresses, one for Pi Hole and other to be used by your web apps.

There are many ways to achieve it, and just this step could deserve a guide by itself. The method I describe here has worked best to me so far. Feel free to do your own research and come up with other (possibly better) ways.

Primary static IP

Let's make sure dhcpcd is instructed to use a static IP. Your /etc/dhcpcd.conf should have something similar to this:

# /etc/dhcpcd.conf

...

interface wlan0
static ip_address=10.0.0.10/24
static routers=10.0.0.1
static domain_name_servers=127.0.0.1

Replace the values on each line for the appropriate ones in your system. The IP in this example is 10.0.0.10. Be sure to pick an address no other device is using on your network.

The interface being configured is wlan0. If your Pi is connected by Ethernet, change it for eth0. We also set the DNS for 127.0.0.1, so the Pi uses the Pi Hole to resolve the names he needs. The gateway and the netmask should be set accordingly to your network.

Restart dhcpcd or reboot your system:

$ sudo systemctl daemon-reload
$ sudo systemctl restart networking
$ sudo systemctl restart dhcpcd

Issue ip a and check if the Pi got your chosen IP.

Secondary static IP

Now let's set the secondary IP. In the current times, this ideally should also be done on dhcpcd.conf. However, making it work properly has proven harder than it should.

My current approach is to bring up the second IP through /etc/network/interfaces.

Place a file under /etc/network/interfaces.d, and name it for example secondary_ip. Add the following lines, replacing the values with the appropriate ones:

# /etc/network/interfaces.d/secondary_ip

auto wlan0
iface wlan0 inet static
    address 10.0.0.11
    netmask 255.255.255.0
    dns-nameservers 127.0.0.1

In this example, I pick 10.0.0.11 as the secondary IP.

Have you done the proper configuration, restart your network or reboot. Your Pi should now have two static IPs. Let's check it.

$ ip a

If all went well, you'll see both IPs in two lines starting with inet. For our example:

...
inet 10.0.0.10/24 brd 192.168.0.255 scope global wlan0
  valid_lft forever preferred_lft forever
inet 10.0.0.11/24 brd 192.168.0.255 scope global secondary wlan0
  valid_lft forever preferred_lft forever
...

Step 2 - Bind Lighttpd to the primary IP

Now we're going to make Lighttpd bind only to the primary address. This will leave port 80 free for our webserver in the other address. This step is much more straight-forward.

Until recently, we achieve that editing /etc/lighttpd/lighttpd.conf. This had the inconvenience that whenever Pi Hole updated, the file would be overwritten and all the changes lost. So every month or so, we would have to revert the relevant lines.

However, since Pi Hole 4.2.2 that problem is gone. Now, the Lighttpd config done by Pi Hole sources a separate file, allowing us to permanently store our modifications in it.

This file is /etc/lighttpd/external.conf. Add this line to it, replacing 10.0.0.10 by the primary IP address you just set:

server.bind = "10.0.0.10"

If for whatever reason you are using an older version of Pi Hole, simply add that line to lighttpd.conf.

Let's restart Lighttpd:

$ sudo systemctl restart lighttpd

Now the Pi Hole admin console should only be available on your primary IP.

Step 3 - Bind your web server to the secondary IP

Finally, we need to make your web server bind only to the secondary IP. The procedure is analogous to what we did on step 2: edit the configuration of your server, binding it to your Pi's secondary IP.

The specifics on how to do this depend on which web server you pick and your configuration.

For example, if you are using Nginx, set the listen directive on your site configuration:

# /etc/nginx/sites-available/default
# (or whatever the path for your site configuration)

...
listen 10.0.0.11:80
...

Please refer to the documentation of your web server for details.

After making this change, start the server and everything should work as we wanted.

Step 4 - Install Pi Hole or reconfigure it

If you haven't installed Pi Hole yet, do it now, pointing it to the primary IP.

Alternatively, if Pi Hole is already installed, reconfigure it to make sure it points to that address. Run pihole -r and select "Reconfigure".

This step is necessary because it tells Pi Hole to resolve the blocked domains to that address. It expects Lighttpd to be there to serve the "Pi Hole blocked" page.

Also notice that this guide placed Pi Hole and Lighttpd in the primary IP and your webserver in the secondary, but the opposite is obviously also possible. The key is that Pi Hole and Lighttpd should be configured to the same address.

As a side note, the DNS server binds to both IPs and we'll not touch it. We are only concerned about port 80, so this fact doesn't bring any issues and is irrelevant for our goals.

Enjoy your webserver and Pi Hole together

Done. You should now be able to run Pi Hole and a webserver simultaneously and without issues on your Pi.

Smart morning radio with Raspberry Pi, cron and MPD

Mon, 13 Aug 2018 05:14:19 GMT

What if your Pi waked you up every morning with your favorite radio station? Wouldn't it be cool if it stopped playing when you leave home? And what about not bothering you on holidays?

I have a pair of speakers connected to my Pi, and I keep them on 24/7. This opens a lot of possibilities. One is to make my Pi stream some radio always at a fixed time.

After configuring a player such as MPD and obtaining the streaming URL, that becomes fairly easy to do. Just a matter of placing a couple of commands on your crontab.

I wanted, however, to make something more robust and take care of some details.

This post walks you through my fairly simple, but convenient setup. If you want to cut through the talk and just take a hint at it, you can check it here.

Requirements

I'll assume you have:

Some speakers connected to your Pi, and configured on MPD
MPC installed, to control MPD
Cron installed, to schedule our commands

Cron and scripting

As I said, to schedule our Pi to play radio at specific times, we could just drop something as mplayer url_of_the_stream on the crontab.

But what about the volume? And holidays?

As your command becomes more complex, it makes sense to extract it from the crontab and make it a script.

While you could write it in any language you like, Bash and Python are sensible choices. I pick Bash.

In the following sections, we'll build that script together. You can check mine here.

First of all, set the volume!

As much as you like a station, you probably don't want to listen to them on a random volume first thing in the morning. Neither your neighbours.

So let's set it to a good level.

On ALSA

If your Pi uses ALSA, doing it is as simple as this command, replacing 20 for the desired level:

$ mpc volume 20

On PulseAudio

For PulseAudio, things get a bit trickier. In this case, the volume command adjusts the volume of the MPD sink-input, which is closed whenever MPD stops the playback. This means that, if you issue the same command before anything is playing, you'll get an error.

A solution for that is setting always_on = true for the PulseAudio output in /etc/mpd.conf. However, doing this made me experience some delays and weird behaviours on MPD. So I did another thing.

My hacky workaround is to create a silent track and ask MPD to play it. In the meanwhile, I can set the volume. Like this:

set_volume() {
  mpc clear
  mpc add /path/to/silence.ogg
  mpc play
  sleep 10
  mpc volume $1
  mpc clear
}

Did you unmute?

This step may sound silly, but for someone as me who mutes the Pi to do some VNC work, it can actually be a lifesaver.

My script makes sure my Pi is not muted and it also assures the general volume to be at 100%.

For PulseAudio:

pactl set-sink-mute sink_name false
pactl set-sink-volume sink_name 100%

Where sink_name will be something like alsa_output.pci-0000_00_1f.3.analog-stereo. You can get it issuing:

$ pactl list sinks short

For ALSA, you should run something similar to this:

$ amixer -c 0 set Master unmute

Check alsamixer and replace 0 and Master with the values for your setup. We don't set anything to 100% here, because on ALSA you only have one volume per output (the one we set on the previous step).

Holidays!

On cron, we'll make sure that our radio alarm only plays on weekdays. But what about holidays? You probably don't want to be woken up at 6 am!

I solved that in a simple way. In a text file I placed all the holidays, one per line, in the mm-dd format. The ones that change each year, such as Easter, are written as yyyy-mm-dd. I made the script look for the current day on that file, and to abort if it is found.

So we got a function like this:

check_holiday() {
	if grep -q -e "^\s*$(date +%Y-%m-%d)\s*" -e "^\s*$(date +%m-%d)\s*" "$holidays_file"; then
		printf "Today is a holiday. Not doing anything.\n" >&2
		exit 0
	fi
}

Disable dates

At times, you may want the radio not to play at some workable dates. Maybe you'll be out of town, you'll not go to work for some reason, or you'll wake up much later.

While we could use here the same solution that we did for the holidays (placing the dates in a text file), this didn't cut it for me. Reasons:

You would have to SSH to the Pi and mess with a text file every time you wanted to disable a date.
Do you ever want other people in your household to use this?

For storing mostly stable values, as in the holidays case, a plain text file works well. But for something more dynamic and ad-hoc as this, I wanted other thing.

So I coded a simple web app to handle that. Under the hood, it still writes to a plain text file, very similar to the holidays one, with the script grepping it the same way. It does the management of that file and offers a friendly interface.

Let's play!

Now that we checked the day is not a holiday nor a undesired date and properly set the volume, it's time to play our radio!

For this, I'd also recommend to have a backup station, in case the streaming URL of your favorite radio gets broken. You could also add a song from your library, in case there are any network problems. This way, you make sure something will always play.

One possible way:

mpc clear
mpc add https://example.com/preferred_stream
mpc add https://example.com/backup_stream
mpc add "A song.ogg"
mpc random off
mpc play

You can get creative here. For example, you could add many radios, maybe using a playlist, and turn random on. So each day a different station would wake you up.

On my script, instead of passing some URLs through MPC, I call the PiFi Radio (a MPD web client to listen to radio that I wrote) API with the radio names. This is more convenient to me, since I can store all the streaming URLs in a single place.

What about stopping?

The same way I wanted my Pi to play radio automatically every morning, it would be nice that would stop playing it without human intervention.

While we could get fancy here and try to detect when we leave home, I decided to just schedule a reasonable time for the playback to stop.

At the given time, cron calls the necessary steps to do it, which are simply:

mpc stop
set_volume 50

Where set_volume is the function we've written before.

Let's schedule it

Now that our script is done, we need to make it run at the desired time. For that, we'll use cron. Alternatively, you could use systemd timers. I'll do it old school.

You can add the script to your personal crontab, running:

$ crontab -e

I dropped it under /etc/cron.d:

# /etc/cron.d/radioauto

# Play radio automagically in week days
00 06 * * 1-5 pi /opt/scripts/radioauto start
00 08 * * 1-5 pi /opt/scripts/radioauto stop

This will run the script from Monday to Friday at 6 and 8 am. First with the start argument, than with stop.

If you copy and paste those lines to a user crontab, the columns are a bit different. Be sure to remove the user column (the one which says pi).

The result

And we are done. Our Pi will wake us up every day with our favourite radio. It will stop playing at a given time automatically. And we won't be bothered on holidays and whenever we don't want it.

You can check my setup here.

Export all your Kindle highlights and notes

Thu, 19 Sep 2019 17:37:40 GMT

Previously, I discussed the current state of annotations in digital books and documents.

In this post, I want to introduce a tool I developed to help Kindle users handle their highlights, notes, bookmarks, etc.

Getting annotations from your Kindle

So you've been reading on your Kindle device. You highlighted some interesting parts. You wrote important notes. And you bookmarked relevant pages. Now how do you access it outside of the Kindle?

The Kindle has a mobile app and a web page where you can see your annotations and also export them. But whether your annotations for a particular book/document will be available there depends on how you acquired it.

I made a table to illustrate how it currently works (2019):

Got from...	Mobile app	Web
Bought on Amazon	✅	✅
Sent via e-mail	✅	❌
Stored via USB	❌	❌

So if you bought the book from Amazon, you have the best of worlds. You can access your annotations from Amazon's mobile app or the web.

If you sent the content to your Kindle e-mail, Amazon automatically tagged it as "personal document" (even if it is a book). Its annotations will only be available on the mobile app.

Lastly, if you added content to your Kindle via USB, bad luck. No way to access its annotations or the content out of the Kindle.

My Clippings to the rescue

So we get a somewhat fragmented experienced. Depending on how you acquired each content, its annotations are available on one place or another; and thus are easily exportable or not.

Luckily, the Kindle stores a plain text file on its documents folder called My Clippings. For each highlight, note, bookmark and clip you set while on your Kindle, it appends this file with the corresponding information.

My Clippings shortcomes

Now, this file is very handy, no doubt. But yet it is kind of a mess. As I said, it is appended whenever you do one of the above operations. This means:

It is not ordered by document, but by time. So, for instance, if you switch reading between two books, you'll get some annotations for one, then for the other, then for the first again, etc.
As the entries are ordered by time, if you annotate something in page 100, and later on page 50, the later will be after the former.
If you edit or delete a highlight, note, etc, the file doesn't reflect it. It adds the newly edition, but keeps the previous one. It doesn't delete any entry. The result is tons of similar, duplicated, or previously removed entries floating on there.
For every append, it adds info about the correspondent book, the time the append was done, etc. The actual content can be missed with all that noise, making the file difficult to read.

Solutions available

So while having tons of valuable data, this file is not really readable nor easily browseable. The obvious thing to do was to try to parse it. I looked for applications to do that and found a few: web and desktop. However, none satisfied me:

Most of them didn't work. While I didn't investigate the causes for each codebase, some failed because locale specific strings were hardcoded.
Web based solutions seemed to add complexity to the problem. Having to periodically upload My Clippings to a platform, manage my data there in a complex interface and then export my annotations again seemed overkill.

I didn't try all the applications available. I quickly realized that it would be much better to code my own solution from ground up, than testing many until one worked or reasonably satisfied me. Besides, I still would have to adapt them to my needs.

Meet Fyodor

So I created a tool to solve those problems. It's Fyodor, written in Ruby and libre and open-source.

Fyodor parses all the precious data from My Clippings and makes it readable. It generates well formatted markdown files: one per book or document that you read.

Some of the features:

Your highlights and notes are ordered by page (not time).
Cleans up empty and duplicated entries as possible.
Tries to be locale agnostic, and allows configuration for different Kindle languages.
The output is easily editable and read by virtually any computer (plain text).
And more...

The workflow, pros and cons

To extract your Kindle annotations:

Connect your Kindle via USB.
Copy My Clippings from documents folder to your computer.
Run Fyodor.
Now you have a bunch of markdown files, one for each document. Edit them as you will.

Advantages of this method:

You extract all the annotations from all your Kindle content with one command.
You don't need to remember how each document got to your Kindle just to export its annotations.
The content you loaded via USB can finally have their annotations set free from the device (remember the table?).
All your annotations are stored in one single folder, conveniently organized per book.
Clean and editable output.

Of course, we still have some limitations that the Kindle imposes us:

We can't guess all highlights and notes that were deleted.
We don't have chapter information.
We need to transfer My Clippings via USB.

But yet, this is a much better state of affairs, and I'm fairly satisfied. I hope this app makes your life better. Check it out here.

Send files to your phone from file manager

Wed, 16 Oct 2019 20:55:41 GMT

A very handy thing to have in your file manager is an option to send files directly to your phone.

If you happen to use KDE Connect and Dolphin, this is already there out of the box. Just right click a file and will see an option to send it to your devices. GNOME and Nautilus with the GSConnect extension provides the same.

But what if you use other file manager? You can replicate that functionality, and this post aims to help you on that.

The general idea is to:

Craft the right command to send the file.
Instruct the file manager to have it as a context menu item.

So let's do it.

Step 1 - Install and configure KDE Connect

First of all, you need to have KDE Connect installed (both on your computer and your phone) and do the pairing.

Step 2 - Craft the command

KDE Connect has a CLI, kdeconnect-cli. Running it with -l provides a list of paired devices:

$ kdeconnect-cli -l

To send them a file, you can run:

$ kdeconnect-cli -d DEVICE_ID --share FILE_PATH

$ kdeconnect-cli -n DEVICE_NAME --share FILE_PATH

Take a look at the output of the first command and replace DEVICE_ID or DEVICE_NAME accordingly, as well as FILE_PATH.

Step 3 - Setting the command on the file manager

Now you are able to send files to your phone by typing a command. The next step is to configure your file manager to offer to run that same command when you select a file.

The precise way to do that depends on which file manager you are using. I'll briefly explain it for Thunar and Nemo.

Thunar

On Thunar, add a custom action.

Click on Edit - Configure custom actions. After clicking the + icon, paste the command you got from Step 2, replacing the file path by %f. You'll have something like this:

kdeconnect-cli -d DEVICE_ID --share %f

In the tab "Appearance conditions" be sure to check all file types except "Directories", as kdeconnect-cli can't handle them.

Nemo

On Nemo, you can create a Nemo action. These are files very similar to desktop entries and are placed at ~/.local/share/nemo/actions/.

You can get mine here. Replace what is after Exec= with the command from Step 2, and change Selection=m to Selection=s.

Improving: Multiple files and notifications

If everything went well, you can now send a file to your phone just by right clicking it and selecting the option. Cool, uh?

However, there is room for improvement. As I pointed out, this setup doesn't allow you to send more than one file per time. That's a limitation from kdeconnect-cli. Also, you may want a notification if the sending was successful or not.

Both things can be achieved by writing a small wrapper script around kdeconnect-cli, and making your file manager call it instead of the former. Then, make the file manager allow multiple selection. For this, on Thunar replace %f with %F in your command; on Nemo, set Selection=m in your action.

If those improvements interest you, take a look at the next section.

My setup

I wrote a small wrapper script, which takes care of all the points above.

Some readers asked me for a step-by-step guide on setting it up, so I'll describe it below.

On Nemo

Download the script to your PATH and make it executable:

$ cd /usr/local/bin    # or anywhere in your PATH
$ sudo wget https://gist.githubusercontent.com/rc2dev/678adc40cd75f9ea472cd3f77b63d21c/raw/893032b9c60f510727fed20548a6be93e1048e81/send2phone -O send2phone
$ sudo chmod +x send2phone

Download the Nemo action and place it in the appropriate directory:

$ mkdir -p ~/.local/share/nemo/actions
$ cd ~/.local/share/nemo/actions
$ wget https://gist.githubusercontent.com/rc2dev/678adc40cd75f9ea472cd3f77b63d21c/raw/893032b9c60f510727fed20548a6be93e1048e81/send2phone.nemo_action -O send2phone.nemo_action

On Thunar

Download the script to your PATH and make it executable:

$ cd /usr/local/bin    # or anywhere in your PATH
$ sudo wget https://gist.githubusercontent.com/rc2dev/678adc40cd75f9ea472cd3f77b63d21c/raw/893032b9c60f510727fed20548a6be93e1048e81/send2phone -O send2phone
$ sudo chmod +x send2phone

Open Thunar and create a custom action with the following command:

send2phone %F

As always, on "Appearance conditions" check everything except directories.

On ranger

If you prefer a terminal-based file manager, things are analogous. On ranger, just download the script to your PATH and add a line to your rc.conf:

map bp shell -f send2phone %s

Now you can select some files, press bp (or whatever shortcut you prefer) and they are sent to your phone.

Troubleshooting "No such object path"

If kdeconnect-cli is throwing a message like error: No such object path, take a look here.

Mount Borg backups with ease

Mon, 07 Oct 2019 17:20:07 GMT

Borg is an excellent backup software. One of Borg's features is mounting the backups and accessing all files in them. This is done by running borg mount with the path to the repository and the name of the archive you want to mount.

My workflow for mounting a Borg archive is typically like this:

Make an empty directory for the mounting, taking care of the permissions.
Determine which repository contains the archive I want to mount and cd into it.
Export my Borg passphrase, so I'm not asked for it multiple times.
Run borg list . to list the archives on that repository and decide for one of those.
Mount the archive with borg .::${archive_name} ${mount_path}. This is the most tedious step since we need to type the full archive name and the mount path.

Note from 2023-06-07: This became easier as Borg added support for shell tab completion. Also, you can now mount the entire repository instead of choosing an archive in advance.
cd into the mount point or open my file manager and browse to it.
After I'm done, remember to type a command to umount the archive.
Delete the mount point that I created.

It's easy to see how repeatedly typing those commands can become tedious and frustrating, not to mention error prone.

So I wrote a simple Bash script to automate this task.

The solution

It works like this:

It first lists all your archives.
You select one by simply typing a number.
The archive is mounted and your file manager pops up with it (if you are using a graphical interface).
After you are done, you can just press enter and the archive will be umounted.

So from all that huge list of commands, we came to just type this:

$ borg-mount /repo/path
foobar # type the passphrase (if not exported)
8  # the archive number
↵  # umount when done

Cool, uh?

Downloading and running

You can find the script here. Near the top you'll find a configuration section with the values to pass to borg mount command. You'll probably want to change the file manager command and empty the other values before first running it.

A workaround for KDE Connect browsing bug

Sat, 16 Nov 2019 07:51:02 GMT

If you press "Browse device" on the KDE Connect tray icon and get the following error:

A folder named ~/.cache/kioexec/krun/<some_numbers>/ already exists.

In this post I will show you a simple workaround: open your file manager and browse to /run/user/<YOUR UID>/<YOUR DEVICE ID>/.

If you are unsure of your UID, try 1000, or issue id or echo $UID in the terminal.

YOUR DEVICE ID is a hexadecimal string and should be obvious when you get to the parent directory. In any case, you can find it out running kdeconnect-cli -l.

That's it! Now you should see your device files, despite of the previous error.

So what happened?

Apparently, when you click "Browse device" , KDE Connect succeeds to mount the filesystem, but fails to bring your file manager to show it. When you browse to the mount path, everything is there.

The bug is already fixed upstream, so in the future a update from your chosen distro should deal with it. The system in which I see this issue is Linux Mint 19.2 Cinnamon, with Nemo file manager and KDE Connect 1.3.3.

In the meantime, you can use this workaround. Also, some people reported that installing Dolphin fixes the issue, so you might try it if it sounds appealing.

Watching YouTube playlists on shuffle with MPV

Sat, 06 Jun 2020 21:32:25 GMT

Right now, I have a bunch of videos in my YouTube watch later playlist. After a certain number, browsing through them becomes a pain. So I thought of watching them randomly, and skip whatever didn't interested me at the moment.

YouTube does have a shuffle button, but it never worked well when I tried it. Also, I wanted to use MPV, which gives me better performance on Linux and a nice experience.

A first approach

Initially, I thought of a very nixy solution, combining some utilities to get the job done:

Use yt-dlp to get the list of URLs on my watch later playlist.
Shuffle it with shuf.
Make mpv run each video.

However...

MPV has a playlist feature. Instead of using shuf and calling mpv for each video, we could let it handle the whole playlist. This would give us more possibilities such as easily toggling shuffle on and off and going to previous videos.
MPV has a yt-dlp hook. If we pass a playlist URL, it will automatically retrieve the list of videos. This could simplify our code further.

Solution

So my solution came to this:

$ mpv --shuffle --ytdl-raw-options="cookies-from-browser=<browser>" "https://youtube.com/playlist?list=WL"

Let's take a look at the arguments:

The first one, --shuffle, is self-explanatory. We want the videos to play randomly.
The second argument passes your browser cookies to yt-dlp. This is necessary in the case of a private playlist, which your "watch later" probably is. Replace <browser> with your browser's name. For example, if you use the Chrome browser, use --ytdl-raw-options="cookies-from-browser=chrome". Check yt-dlp documentation for the supported browsers.

As an alternative, you can pass a cookies file to yt-dlp. You can easily obtain it using an extension for your browser. Then,use with --ytdl-raw-options="cookies=path/to/cookies.txt", replacing the path to cookies.txt.
The last argument is the playlist URL; in this case the watch later playlist.

If you already have your cookies configured on your yt-dlp configuration, or if the playlist is public, you won't need the second argument, and the command will be as simple as:

$ mpv --shuffle "https://youtube.com/playlist?list=WL"

Just be sure to have MPV and yt-dlp installed.

Usage

Running this, MPV will pop with a random video from your watch later playlist.

To go to the next (random) video, the default MPV keybinds are > and Enter. To go the previous, <. Close MPV with q. You also have the current and previous videos URLs printed in the terminal, so you can easily visit their pages if you need to.

Open the video page with a keybinding

While watching my playlists on MPV, I often want to open the current video in the browser.

MPV makes it easy by printing the URL of the current video in the terminal. However, I can't make use of that, because:

My window manager swallows the terminal.
If I invoke it via "Open with" or dmenu, I won't get the terminal output by default.

Besides, it would be nice to have a keybinding for that, instead of clicking the URL.

Implementing this is as simple as dropping a line at MPV's input.conf or using this plugin.

Invocation with dmenu

Besides "watch later", I sometimes watch other playlists. Copying and pasting their URLs every time would be tedious. Instead, I wrote a dmenu script.

Pressing a keybind on my computer, dmenu shows all the playlists from my logged account and let me pick one to watch. After that, MPV starts the playback on shuffle mode. This is very convenient and much better than browsing YouTube.

My playlists on dmenu.

If you don't use dmenu, you can adapt this idea. You just need some kind of menu from which to choose the playlist and call the correct MPV command.

Invocation from browser

Another convenient way to watch different playlists is to invoke MPV directly from the browser.

I do that with a browser extension called Open With. This extension allows you to send the URL of your current tab or a right-clicked link to a program of your choice. Btw, I wrote a whole article about how I use that extension.

Download the extension and add an entry for the command we crafted, replacing the playlist URL with %s:

$ mpv --shuffle --ytdl-raw-options="cookies-from=<browser>" %s

As I have a keybinding on MPV for shuffling and the cookies are taken care by my yt-dlp configuration, I simply use:

$ mpv %s

Now, when you visit a playlist and click the entry, MPV will pop with that playlist on shuffle.

Additionally, this entry will allow you to watch individual videos, if you select it on a video page.

Happy watching!

How I use the Open With extension

Sun, 27 Sep 2020 00:31:18 GMT

A very useful browser extension is Open With. Although it hasn't been updated for a while, I've yet to find something to replace it.

Open With describes itself in the Chrome web store as the following: "Quickly test out your web pages in Edge, Firefox, Safari, or Opera." However, it is much more powerful than that: it actually allows you to run any external program on your computer passing the URL of the current tab or the selected link.

After installing the extension, you should define a list of commands. The following are some from my list.

Other browsers

The most obvious use for this extension is to open a page in other browser. For that, you should add your browsers to the list. Thankfully, this is easy, as the extension tries to automatically find them all.

Incognito mode

Sometimes you want to open the page as incognito. So, for each browser (even the current one), I also add an entry for launching a page in their incognito mode / private window.

Browser temporary profile

Now and then you might stumble upon a broken webpage and wonder if is conflicting with some of your extensions or settings. In that case, opening it in a clean browser profile might be useful.

The exact command for running a temporary profile depends on your browser. For some, like Chromium, you just run chromium --temp-profile. For others, you are better off writing a small script for it.

Place the command at your Open With list, and now with just a click you open the page in a clean browser profile that will be removed from disk just after use.

MPV

Other of my entries is MPV. This allows me to play not only videos, but also entire YouTube playlists in that fantastic player. By the way, I wrote a whole article about it.

youtube-dl

With a click, the page will be sent to youtube-dl, which will try to download the video or playlist for you. I also have a separate entry for youtube-dl -x which just downloads the audio. Please, don't use it for anything illegal.

Wishlist

Some things I miss on this extension:

Support for sending all tabs at once.
Export/import option. The lack of it makes switching browsers or profiles a pain.
Better keyboard bindings.

Update

Since 2021, I've replaced Open With with a dmenu script I wrote and attached to a keybinding. This way, all the above points in the wishlist were accomplished. Also, it works with any browser and any profile without configuration.

Convert Kindle annotations from HTML to markdown

Fri, 08 Jan 2021 04:14:52 GMT

The Kindle app on your phone can export your annotations on a particular book to an HTML file.

However, I find that file quite noisy, and would rather have my annotations in a simpler format: markdown. Also, I would like to remove unnecessary information and make it less verbose.

For the first books, I did this conversion in a couple of minutes using macros in VIM. But as I needed to do it more and more often, the procedure quickly became tedious, and I wanted to automate it.

So I wrote a Python script to the job. The code is here.

By the way, if you are interested in exporting all your annotations from your Kindle directly to markdown, from your clippings file, take a look at my project Fyodor.

Reading random Pocket articles with a hotkey

Fri, 11 Dec 2020 17:21:55 GMT

I have tons of articles in my Pocket account. To make it easier to read them, I wanted a way to get a random one on demand.

As it turned out, this was very straightforward. Pocket has a URL that gives you exactly that: a random article from your list each time you visit it.

So far so good. However, when I get a random article, I may not like it. Like a roulette, I may want to spin it again and again until I find something I want to read at a given moment. This means that I usually visit that URL many times in a row.

This could be as easy as reloading the page, but that URL actually redirects you to the article's page, so doing this won't get you anywhere. My options were to click that page on my bookmarks bar repeatedly, or to write that address on the omnibar multiple times. None of this is exactly enjoyable.

For a much better experience, I wanted to bind a keyboard shortcut for that URL. This way, every time I pressed some key combination, my browser would show a different article from my Pocket list. Cool, right?

To achieve this, my browser doesn't support this feature natively, neither could I find a working extension for this. So I solved it by coding a small userscript and dropping it at ViolentMonkey.

Done. But there is one last problem. After you read an article, you probably want to do something with it on Pocket, maybe archive it or delete it, right? However, this "random" URL brings you directly to the actual page, not Pocket's article view. Thus, after each page you read, you'd have to open Pocket, search for the article you just read and only then do whatever you wanted to do. Not very nice either.

I made it much easier by adding another key combination. This one searches for the current page on the Pocket list. Now you are just a few clicks away from archiving the article.

Installation and usage

If you want to try my solution, install a extension such as ViolentMonkey and install my userscript from here. Don't forget to reload your current tab.

Now pressing Alt+Shift+R brings you a random Pocket article, and Alt+Shift+E searches for the current page on your Pocket list.

How to automatically reflect vim-plug changes on all hosts

Sat, 06 Mar 2021 02:24:49 GMT

I use the excellent vim-plug to manage my VIM plugins. In this setup, whenever you want to add or remove plugins, you have to do three things:

Edit (and source) vimrc.
Call a command to install the new plugins, :PlugInstall.
Optionally, call a command to clean the removed ones, :PlugClean.

If you use VIM on a single machine, this is straightforward enough. However, if you implement your dotfiles across multiple hosts, simply pulling the changes on vimrc doesn't make new plugins work. Every time you change your VIM plugins list, you need to remember to also do 2 and 3 on each host.

This was painful to me and I wanted to automate the process. My goal was that whenever I pulled my dotfiles on any device and my vimrc had changed, those commands would run automatically.

The solution: Git hooks

My dotfiles are under source control, so I immediately thought of Git hooks. They reside under your repo's .git/hooks directory and allow you to do exactly that: before or after a certain Git event, run a certain command.

I wrote a post-merge script (name is important), made it executable, and dropped it into this directory.

#!/bin/sh
# Author: Rafael Cavalcanti

exec </dev/tty >/dev/tty

readonly changed_files="$(git diff-tree -r --name-only --no-commit-id ORIG_HEAD HEAD)"

has_changed() {
  echo "$changed_files" | grep --quiet -E "$1"
}

# Update VIM plugins
if has_changed .vimrc; then
  echo "\n[Hook] vimrc changed: Installing/cleaning VIM plugins..."
  # PlugInstall doesn't proceed with GIT_DIR set (https://github.com/junegunn/vim-plug/issues/506).
  (unset GIT_DIR && vim +PlugInstall +PlugClean! +qa!)
fi

Whenever I git pull, this script will be automatically run by Git. As it is pretty clear, it checks if .vimrc has changed from the previous HEAD, and if so, calls PlugInstall and PlugClean!.

So far so good. However, the hooks directory is not tracked and, thus, not distributed to all installations. Let's tackle it.

Tracking the hook

One way to track your hook script is to create a directory in your repo, say git-hooks and move it there. Then, anytime you clone the repo, you should configure Git to look that directory for hooks: git config core.hooksPath THE_PATH_TO_HOOKS_DIR.

My dotfiles have a bootstrap script, so I placed this command there, to be run automatically on new clones. For the systems with my dotfiles already installed, I just run the command manually once.

Done! Now every time I pull my repo and there are changes to my vimrc, my list of plugins is conveniently checked for new installs and removals.

Using Timewarrior on multiple devices

Thu, 18 Mar 2021 16:06:01 GMT

For a few weeks, I've been tracking my time with Timewarrior on the desktop. At some point, I missed also having it available on other devices, namely my phone.

Unlike its sibling Taskwarrior, it lacks a synchronization server, or any official way of using it on multiple machines. So, at first, you are stuck at only using it on one device. However, there is an easy fix for that, and in this post I'll describe it.

TL;DR: Install timewarrior on a server and set an alias to run it through SSH.

My solution

Pick a Linux host that is always available from any of your devices.

It could be a Raspberry Pi at your home, a VPS, etc.
Install Timewarrior on that host.

This is where your data will be stored and controlled.
Make sure your devices have SSH access to that host.

I suggest you to use key-based authentication. Besides being more secure, you don't have to type your password each time, which will come in handy for this.
On your devices, add a shell alias for Timewarrior.

Something such as alias timew="ssh THE_HOST timew :color".

The :color option forces color on, since this ssh command won't allocate a tty.
Make the SSH connection to that host persistent.

I would get a delay each time I run the timew alias. I solved this by making the connection persist. This way, only the first invocation would get the delay.

There are some ways of doing that. I created a directory at ~/.ssh/sockets and wrote this to my ~/.ssh/config:
```
Host THE_HOST
ControlMaster auto
ControlPath  ~/.ssh/sockets/%r@%h-%p
ControlPersist 600
```

Done. Now just use Timewarrior normally. Every time you type timew on your devices, you'll get to your same, "synchronized" data.

Backup your YouTube playlists in JSON with git

Fri, 18 Jun 2021 01:13:49 GMT

Backups are important for a number of reasons. As of lately, much of our data has moved to the cloud, so this brings the need to also backup our data from those online services.

With this in mind, I've been building some solutions to periodically backup my most relevant data from the cloud to some system I have control.

One of the services that I use and consider meaningful to backup is YouTube. My main concern are the playlists. I have many of them, but I don't care much about the actual video files, so this isn't about downloading them all. The point is to have some peace of mind about having all the titles and URLs permanently stored somewhere.

Getting the JSON for each playlist

While yt-dlp is mostly famous for downloading videos, it has many more capacities. One of them is exactly what we want for our project. With the right options, you can easily get a JSON file with all the videos from a playlist, including their title, channel, URL, description and more. You can use something like this:

$ yt-dlp --flat-playlist --dump-json PLAYLIST_URL > output.json

Just remember that you may need to provide cookies for your YouTube account in case of your playlists being private.

Then, combine it with a command to get all the playlists, some Bash scripting and in a moment we'll have all our playlists stored as JSON.

Incremental backups

So now we have a initial script. But what about next executions?

At first, I thought of storing each backup in a separate directory. It did work well, but I quickly thought about a better way: version control.

These are simple plain text files, which are perfect for a git repository. Storing them as such will give us some nice stuff such as automatic deduplication and easier diff.

Run periodically

After all that, we're left to schedule the backup, so we can forget about it and let it run automatically. For that, I created a user systemd service that runs weekly.

The code

If you are interested in the code, feel free to take a look.

Why not just use Google Takeout?

Instead of writing this script, we could use Google Takeout for our YouTube data. Among other thing, this includes a CSV file containing the URL of each video from your playlists. However...

This solution only provides the URLs. I'd like to have more info about each video, such as the title. This makes easier to read and manipulate the data and this info could be invaluable if any of those videos are gone.
More importantly, Google Takeout is, at best, a semi-automatic process. It can send you an e-mail every 2 months with a link to a page for you to go and download the data. I'd like to completely automate the process of backup.
Lastly, I'd like to schedule the backup to be more frequently than bi-monthly.

Fixing kdeconnect-cli "no such object path" error

Wed, 23 Jun 2021 13:21:23 GMT

At some point, kdeconnect-cli started to throw me this error error: No such object path '/modules/kdeconnect/device/<DEVICE_ID>/share' when trying to send a file to my phone.

This seems to mean that the share plugin isn't enabled on that device. However, I checked it wasn't the case, by going to the plugin list on the KDE Connect app on the phone. I could fix it by toggling it twice (disabling and re-enabling).

So, if you are getting a similar error, it's worth to try this with the respective plugin.

These are the versions used:

kdeconnect-cli: 1.4.0
KDE Connect App (Android): 1.17.0
Distro: Linux Mint 20.1

Fix Chromium signing out from Google under Linux Mint 20

Mon, 12 Jul 2021 22:44:04 GMT

Recently, I started experiencing this issue on Chromium under Linux Mint 20.

Every time I opened Chromium and tried to use a Google service, I would not be logged on them. For example, opening Gmail would show me the login page. I, then, proceeded to login, and everything worked fine until I closed the browser. Opening Chromium again would bring me back to the same problem: I was signed out from Google and prompted to login.

This only happened to Google, other websites worked fine.

Clearing the cache, trying different password stores and even deleting every Chromium file on my home directory and starting clean didn't solve it.

What did the trick is the following:

On Chromium, go to settings.
Click on "Sync and Google services".
Uncheck "Allow Chromium sign-in".
Restart the browser.

This issue seems related to the recent announcements around the Google Sync API and "3^rd party browsers". Note that if you try to login to Google through the browser menu it fails silently.

Valid certificates for LAN-only websites using HTTP-01 challenge

Tue, 27 Jul 2021 14:18:34 GMT

Scenario: You serve some websites exclusively within your network and you own a domain name. You want to enable SSL and that their certificates are recognized out of the box, without manual instalation on each client.

This rules out a self-signed certificate. A solution may be using Let's Encrypt with the DNS-01 challenge.

However, if your DNS provider doesn't support DNS-01, you may need to use the HTTP-01 challenge. The problem is that, since your websites aren't publicly available, this challenge will fail.

In this post, I explain how to run the HTTP-01 challenge under these conditions.

The how-to

The problem we have here is that your server can't be contacted from the internet for the HTTP-01 challenge. A way to overcome this is to set up a dummy server to listen in the appropriate place.

My goal in the next paragraphs is to guide you on how to do it a general way. Then, if needed, you can research a particular step to get more in-depth details for your particular setup.

To start, I'll assume you want to setup 2 websites using domain example.com: subdomain1.example.com and subdomain2.example.com.

1. Set up a dummy server

First, we'll set up a web server to be contacted for the challenge. This should be a non-SSL server and listen externally on port 80. You can keep its root empty.

How exactly you'll implement it depends on your setup. For example, you could add a new virtual server to the same web server that hosts your LAN websites and set it to listen to a different port. Then, forward that port to external port 80.

2. Point your (sub)domains to that IP

Configure your domain's DNS to point subdomain1.example.com and subdomain2.example.com to the public IP of the dummy server. If you are configuring many subdomains, consider using CNAME.

3. Issue the certificate

Now with the appropriate Let's Encrypt tools, issue the certificate using the dummy server. Include all the subdomains you need.

For example, if you set the root of the dummy server to /var/www/dummy, using acme.sh you'd run:

$ acme.sh -d 'subdomain1.example.com' -d 'subdomain2.example.com' -w '/var/www/dummy'

Your dummy server should be contacted and the certificate generated with success. You can then install it normally. For example, on acme.sh you can use --installcert.

4. Configure the certificate on the actual websites

On your web server, configure the actual websites to use the installed certificate.

Set them to listen on the https port (443) and their server_name to subdomain1.example.com or subdomain2.example.com, accordingly.

5. Set split-horizon DNS

By now, your real websites are not reachable from the internet, as you wanted. However, they aren't available for your LAN either.

To fix this, we need to tell the devices on our network that (subdomain1|subdomain2).example.com aren't available on that IP we set on the public DNS, but on the appropriate internal IP.

Two ways of doing that are:

Edit the hosts file on the devices you want.
Set a DNS on your LAN that resolves those entries.

This can be done on a capable router or on a small device such as a Raspberry Pi.

6. Test

Enter (subdomain1|subdomain2).example.com while on your LAN and you should access your websites securely with SSL. Exit your LAN and they'll not be available.

All done

You now have multiple websites that are only available on your network and they have a valid certificate issued by a trusted CA. If you did everything properly, it should also be automatically renewed.

Fix Taskwarrior autocompletion on Termux

Sat, 24 Jul 2021 19:53:30 GMT

If you use Taskwarrior on Termux, autocompletion doesn't work out of the box, be it on Zsh or Bash.

I found out that the completions are available at $PREFIX/share/doc/task/scripts, but absent on the appropriate shell completion directories.

For zsh, I solved it by linking into zsh's site-functions directory (vendor-completions didn't do it):

$ cd $PREFIX/share/zsh/site-functions
$ ln -s $PREFIX/share/doc/task/scripts/zsh/_task

Now I can press tab and have my list of projects and all the good stuff I'm used to on my desktop. If use Bash, the solution should be analogous.

I opened an issue for it.

Relevant versions

Taskwarrior 2.5.3
Termux 0.114

Fix opening locked app from Termux on MIUI

Sun, 25 Jul 2021 15:47:45 GMT

Termux has the handy termux-open command, which is aliased as xdg-open. I use it to open markdown notes from Termux on Markor (a markdown editor application), by simply running xdg-open foobar.md.

This stopped working when I set Markor to use MIUI's "app lock" feature, which forces you to authenticate before opening selected apps. Termux would open Markor normally and the "app lock" screen would ask for my credentials. However, after logging in correctly, I would be brought back to Termux. Manually opening Markor wouldn't show the file I opened.

I did some tests and the issue didn't seem to be on Markor's end. So I went to check on MIUI's side.

MIUI has additional permissions, besides the ones you find on AOSP. In my experience, they often are the cause for that type of weird behaviour, when you ask an app for something and at some point they completely ignore the request. I'm thinking, for example, about some KeePassDX features, which require you to fix those MIUI permissions to work properly.

I checked that Termux had three MIUI permissions in red:

Show on lock screen
Display pop-up windows while running in the background
Display pop-up window

I authorized all three. Now I'm not sure which one exactly did the trick, but this solved the problem.

So if you use MIUI and happens to have the same situation, long press Termux icon, tap "app info", "permissions", and then toggle some or all of those red permissions.

Relevant versions

MIUI 12.0.3

Multi-line annotations on Taskwarrior

Wed, 04 Aug 2021 03:52:28 GMT

When I started using Taskwarrior, one of the first things that I missed was having plenty of space for writing my annotations.

Of course, I could add \n's as I wished to break lines, but I wanted a comfier place to write them.

I quickly stumbled upon a simple script that could solve that. It worked like this: you run it with the task number, and your preferred editor opens with a blank screen, ready for your annotation. Now when you save and close it, your task is annotated. Very useful.

I started to use that script, fixed some minor issues, added features, made it more robust... You can find the result here.

Some features I added:

It accepts a filter instead of task ID, which may be convenient and more similar to the Taskwarrior interface.
You can avoid opening the editor if you provide the annotation as an argument, as you would do with Taskwarrior.
It has some checks to avoid surprises and data loss. For example, if your filter doesn't return any task, the editor won't be started. If there is any error when adding your annotation, you won't lose your text.
It enables syntax highlighting for markdown in VIM or any editor that checks the file extension.
It distinguishes between multi-line and one-line annotations, adding a line break to the former.

My workflow is the following:

I have the script placed on PATH and I name it tan. This is an abbreviation for task annotate. I named this way to emulate my Taskwarrior aliases, which are tad for task add, te for task edit, etc. So tan for task annotate. This makes switching between my aliases and this script seamless.
Running tan <filter> This is an annotation will work as expected, as if you used Taskwarrior directly.
Running tan <filter> opens your editor (as defined in $EDITOR). You then are free to write your annotation with the size and break lines that you wish. When saving and exiting the editor, it will be appended to the task.

However, not everything is glory. This solves the issue of adding large annotations and they are displayed correctly in task info. However, task edit can be a confusing view and I find manipulating them somewhat cumbersome.

What is termux-dialog and how I use it

Fri, 06 Aug 2021 12:49:33 GMT

I have been using Termux for several years, since I came back from iOS to Android. However, only recently I have explored termux-dialog, and this can be really be a game changer.

What is termux-dialog and why it matters

Needless to say, with Termux on your phone you can run (almost) the same scripts from your Linux box, or write new scripts specifically for your mobile device. Termux allows you to interact with your phone in several ways, such as accessing the file system, opening files and URLs in other applications, etc. It's a very powerful application if you know what you are doing.

The termux-dialog command makes it even better by providing an easy way to grab user input, with a mobile UI. Run it and, as the name implies, a dialog will pop-up. There are several type of dialogs: text input, lists, time, date, etc.

I see it as a sort of dmenu for phones (or zenity, kdialog if you prefer floating WMs). It's a graphical interface for user input. You first provide some options or ask a question, and with the user's answer you determine what to do next.

The alternative to termux-dialog is to grab the input inside the Termux terminal. In this case, you could ease the typing by showing some kind of text or ncurses menu such as select in your Bash script. I used it in some occasions, and I'll continue to in those situations when it makes sense to be in the terminal.

However, if the script doesn't have any good reason to spawn a terminal on my phone screen, termux-dialog is the way. I couple it with termux-toast or termux-notification to give output to the user, and termux-widget for having a way of running it without the terminal. This results in a great mobile-like experience. Depending on your goals, you saved yourself from writing an APK or webpage from scratch.

How I use it: productivity system

I use some scripts for productivity and note-taking that I wrote tailored for my needs. With Termux, I can run them on my phone and still have a nice experience.

Using termux-widget, I have a list of actions ready to go. Tapping on it, termux-dialog will prompt me with whatever information it needs. For example, which command I want to execute, or what text I want to enter. Also, if a markdown file is opened next, I run VIM on my desktop, but on the phone I can run a markdown application, with the aid of termux-open.

A concrete example of this is my task logging. On my desktop I run tl Watered the plants. and this is added to my list of done tasks for the day. On my phone, I tap "task" on the widget. A popup asks me if I want to add or log a task. I tap log. A text input - with auto-correction - lets me write "Watered the plants." Done.

How I use it: wake up time

Another way I use it is to track my wake up time, which I do daily for more than a year.

I used to keep this data on a spreadsheet, and then generate charts and calculate a couple of statistics. The data was entered mostly from my phone (as I did it just after waking up), and I have done so in three different ways:

Manually appending the data at the end of the rows.
Through a heavily scripted spreadsheet I wrote. This is what I had been happily using for months.
I also tried Google Forms for a brief while.

My favourite approach was the second and it worked well. However, it still required to open the Google Sheets app, which is too much interface for so little I wanted to do. Yes, I had a shortcut for this specific workbook on my home, but the problem remains.

These days, following a bunch of changes on my productivity system, I decided to use Termux for logging this data. After putting together a Bash script, it works as the following:

Press the appropriate option in the Termux widget.
A time picker is shown, brought you by termux-dialog.

I really like that the time picked by default is the current time, so usually I don't have to do many changes besides pressing OK.
Done! Today's time was appended to a tsv file, together with the date. This file is automatically synced to my other devices with Syncthing.
As a bonus, my script also do two checks:
- If I'm logging for the second time on the same day.
- If I missed yesterday's logging. In this case, a notification is displayed and tapping it opens the tsv file so I can handle it.

What about the statistics? Well, this is as easy as importing the tsv file into my spreadsheet.

And this is a much better, non-intrusive experience.

Conclusion

I hope you can build some of your ideas using Termux, termux-dialog and its other tools, and unleash the power of your phone.

Sync WM wallpaper with LightDM on Linux Mint

Thu, 21 Oct 2021 14:03:53 GMT

Linux Mint uses LightDM GTK greeter for the login screen. It tries to show each user's wallpaper, and it works well if you stick to the default Cinnamon desktop environment.

However, I use a standalone window manager (dwm) and my wallpaper is set by Nitrogen. This breaks the feature, unless we take some steps.

Solution

At least on Mint (and probably other Debian-based distros), the GTK greeter gets the current user wallpaper from AccountsService. You can find the values set for your user under /var/lib/AccountsService/users/$USER, but, being a D-Bus service, it is better to interface with it through that mechanism.

To set the LightDM background to $bg_path, we can run:

$ dbus-send \
  --print-reply \
  --system \
  --dest=org.freedesktop.Accounts \
  /org/freedesktop/Accounts/User$(id -u) \
  org.freedesktop.DBus.Properties.Set \
  string:org.freedesktop.DisplayManager.AccountsService \
  string:BackgroundFile \
  variant:string:"$bg_path"

We want this to run whenever we change the wallpaper, so it gets automatically synced. So, I wrote a wrapper script that calls this command after I exit Nitrogen.

Done. Now my login screen always shows my current dwm wallpaper. Of course, make sure that LightDM has read access to your wallpaper file.

Relevant versions

Linux Mint 20.2
dbus 1.12.16-2
lightDM 1.30.0
lightdm-gtk-greeter 2.0.6

Fix choco-package-list-backup not saving to network

Fri, 18 Feb 2022 00:00:00 GMT

On my (barely used) Windows box, I wanted to set a backup of the installed Chocolatey packages. The choco-package-list-backup tool seems to be the way to go. So I installed it and set the backup path to a mapped network drive.

It didn't work. Picking different folders under C:\ went fine, but the backup never could be saved to the network location.

So what was going on?

It turns out that choco-package-list-backup schedules itself to run as administrator. Plus, as Chocolatey needs to be run on an elevated terminal, I also run this tool interactively with such privileges. However, on Windows, by default network drives are inaccessible to privileged applications.

So how to solve this? I did some quick tests and the backup tool run fine as a normal user. So you have two choices:

change the scheduled task to run without privileges, and always run choco-package-list-backup this way;
or allow privileged programs to access your mapped drives.

For the later, this short guide does the trick. It instructs you to create a DWORD key called EnableLinkedConnections under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System and set it to 1.

Relevant versions

choco-package-list-backup 2022.02.06
Chocolatey 0.12.1
Windows 11 21H2

Copying previous commands with fzf and zsh

Thu, 14 Jul 2022 00:00:00 GMT

Sometimes I want to copy a command I previously typed in my shell to the clipboard. It may be for documentation, note-taking, writing a script, setting up an Ansible playbook, sending to someone… You name it.

While I could always search the terminal window for it and select it, I have set up an alias that makes things much easier and less error-prone:

alias hy="
  fc -ln 0 |
  awk '!a[\$0]++' |
  fzf --tac --multi --header 'Copy history' |
  xsel --clipboard
"

This will perform the task silently. If you prefer a confirmation message after each copy, a clean approach is to convert the alias into a function like this:

hy() {
  local -r entry="$(fc -ln 0 | awk '!a[$0]++' | fzf --tac --multi --header 'Copy history')"
  [[ -n "$entry" ]] && xsel --clipboard <<< "$entry" >/dev/null && echo "Copied to clipboard." >&2
}

Until now, we assumed the system was running on X11. Now, let's make it work on Wayland too:

hy() {
  local copy_cmd
  case "$XDG_SESSION_TYPE" in
    x11)     copy_cmd="xsel --clipboard" ;;
    wayland) copy_cmd="wl-copy" ;;
    *) echo "Session type not detected."; return ;;
  esac

  local -r entry="$(fc -ln 0 | awk '!a[$0]++' | fzf --tac --multi --header 'Copy history')"
  [[ -n "$entry" ]] && eval $copy_cmd <<< "$entry" >/dev/null && echo "Copied to clipboard." >&2
}

In action

Your browser does not support the video tag.

The alias in action.

Typing hy (short for "history yank") brings fzf with a list of your most recent commands. You can browse them using the keyboard or perform a fuzzy search. Pressing Enter copies the selected command to the clipboard.

Even better, if you enable multi-selection on fzf, you can select multiple commands using Tab. They will be copied to the clipboard one per line.

The how

Explaining each part:

fc -ln 0: On zsh, this returns the entire shell history, one command per line. If you use Bash or another shell, just replace it with the equivalent command.
awk '!a[\$0]++': The history is piped to awk, which removes duplicate entries. Without this cleaning, fzf may display multiple repeated lines, which can be annoying.
fzf --tac --header 'Copy history': The result is piped to fzf. The --tac argument reverses the order (as we want the last commands to be at the top), while --multi allows multiple selection. We also add a prompt message using --header.
wl-copy (on Wayland) or xsel --clipboard (on X11): Finally, the commands selected are copied to the clipboard.

Needless to say, be sure to have the mentioned tools installed on your system for this to work.

Mounting SMB1 shares after kernel 5.15

Tue, 29 Nov 2022 00:00:00 GMT

Linux kernel 5.15 dropped support for NTLMv1, a weaker authentication algorithm.

As a consequence, if you have old hardware that only supports SMB1 (such as Apple’s Airport Time Capsule), you may have trouble mounting them on recent distributions like Ubuntu 22.04.

Some workarounds are:

Downgrading or patching the kernel.
Using an extra device between the SMB1 hardware and your client to do the mount.
Switching from SMB to another protocol, if the device supports it. For example, the Time Capsule is reachable via AFP.

An easy path, however, is to enable guest mode on that hardware, if available. Then, just mount it on your client with something like this:

$ sudo mount -t cifs -o guest,vers=1.0 //SERVER/PATH /mnt/path

Sure, you lose the password "protection", and you may be left with only one share. However, taking in account that the security for SMB1 and NTLMv1 is broken for a long time, that’s not much of a loss.

More information is available here.

Point a subdomain to an EC2 instance without elastic IP

Mon, 29 May 2023 00:00:00 GMT

The IP address of an AWS EC2 instance is dynamically assigned when it launches. Allocating an elastic IP to the instance prevents the address from changing, but you might be in a situation in which you can't or don't want to use this service. In this case, it might be handy to have a name that always points to the current IP of the instance.

What we are looking for is dynamic DNS, and you only need two things: a DNS provider that supports it and a client to periodically send it the current public IP of the system. One of such clients is ddclient, which is compatible with many dynamic DNS providers and is packaged in many Linux distributions. I've been using it with Google Domains for years, and it works well.

Install it and configure it on your EC2 instance. On Ubuntu and Debian, it is just a sudo apt install ddclient away, and you'll be prompted with an easy setup process. You'll need to configure a name on your DNS provider and get the necessary credentials to input in the wizard.

And, simple as that, you have a subdomain that always points to your instance. Obviously, after launching the EC2 instance you'll need to wait for DNS propagation. In my experience it takes a few minutes.

Oh, and of course, you can use ddclient not only on AWS EC2, but on any Linux system with a dynamic public IP address.

Debian package for afpfs-ng

Sat, 20 Sep 2025 00:00:00 GMT

afpfs-ng is a client for the Apple Filing Protocol. It is useful, for example, to mount AirPort Time Capsule shares (more on it in this post).

Unfortunatelly, Debian no longer packages it, so I set up a personal repository to easily build and install it. You can find it here: afpfs-ng-deb.

ThinkPad X220's touchpad and the 90W charger

Tue, 08 Aug 2023 00:00:00 GMT

In this post, I'll describe my experience replacing my stock 65W charger for a 90W charger on a Lenovo ThinkPad X220 and the unintended consequences for the touchpad behaviour. I'll report what I've tried and which solutions and workarounds I've found.

The replacement and the issue

When my ThinkPad X220's charger stopped working, I bought a new one. My former charger was 65W, but this was 90W.

I plugged the new charger and powered on the machine. Everything seemed fine, except the cursor when using the touchpad. If you put your finger on the touchpad, moving it or not, the cursor would start moving erratically around the original position.

Removing the system from AC power would make the issue go away, which meant that the charger was involved.

My system at that time was Fedora 38. Booting into Windows or other distros also showed the problem.

Updating the firmware

This issue is documented here and, as stated in the link, a firmware update was released to solve it. While the file attachment on that page doesn't work anymore, you can find it for download on this excellent page.

I'm a Linux user. I saw some reports of incompatibility between that new firmware and MacOS, but nothing very concrete about Linux. I couldn't be sure that it would solve the issue, but I decided to try.

The update software only works on Windows, so I installed a fresh copy of Windows and applied the update.

Windows: Results of the new firmware

As I said, I'm not a Windows user, so I won't review the results of the update on Windows comprehensively. However, from what I've seen on my spare interactions with that OS on the X220, after the firmware update:

The Windows 11 installation media still has the issue.
A fresh Windows 11 install still has the issue.
On a fresh Windows 11 system, after installing the Synaptics driver from Lenovo's support page, the issue seems gone. However, the cursor now moves much slower.

Linux: libinput flag

On Linux, having tested different distros, the problem persists after the firmware update.

The ArchWiki states that you can set a flag for libinput to address issues on firmware 8.1 (the version to which we updated).

I have applied that flag both on Fedora 38 as on Debian Bookworm. My experience is that, while it brings some improvement, the issue is still present.

Linux: Synaptics

From what I've heard, after applying firmware 8.1, the touchpad on X220 is similar to the one on X230.

So I tried a fix for the later available at ArchWiki. It consists in switching to the legacy Synaptics driver and doing some configuration on it.

The package for Synaptics will vary depending on your distro. On Debian, you can install it with sudo apt install xserver-xorg-input-synaptics.

Then, drop the configuration from ArchWiki at /etc/X11/xorg.conf.d/30-touchpad.conf. I'll paste it here for reference:

Section "InputClass"
    Identifier "touchpad"
    MatchProduct "SynPS/2 Synaptics TouchPad"
    Driver "synaptics"

    # Disable two fingers right mouse click
    Option "TapButton2" "0"

    # fix touchpad resolution
    Option "VertResolution" "100"
    Option "HorizResolution" "65"

    # disable synaptics driver pointer acceleration
    Option "MinSpeed" "1"
    Option "MaxSpeed" "1"

    # tweak the X-server pointer acceleration
    Option "AccelerationProfile" "2"
    Option "AdaptiveDeceleration" "16"
    Option "ConstantDeceleration" "16"
    Option "VelocityScale" "20"
    Option "AccelerationNumerator" "30"
    Option "AccelerationDenominator" "10"
    Option "AccelerationThreshold" "10"

    Option "HorizHysteresis" "100"
    Option "VertHysteresis" "100"

    # fix touchpad scroll speed
    Option "VertScrollDelta" "500"
    Option "HorizScrollDelta" "500"
EndSection

For my taste, the speed of the cursor is a bit slow. I solved it by bumping VelocityScale a bit. Also, if you want to enable tapping to click add:

Option "TapButton1" "1"

Now restart the Xorg server and voilà. On my Debian Bookworm system, the "shaky" behaviour is gone.

Automatically switch to dark theme with Redshift hooks

Fri, 24 Mar 2023 00:00:00 GMT

Sometimes, I switch between a dark and a light theme on my desktop. Long before the big DE's (or other operating systems) offered that feature via a simple button, I wrote a script to automate that task.

That script is now 6 years old and has evolved together with my desktop use. I've updated it with my different setups, and at some point it supported more than 5 DE's. I have it associated to a keybinding, so the toggle is easy and fast on my dwm desktop.

For a long time, I've been mostly using the dark theme. However, lately I've found myself repeatedly switching to the light theme during daytime.

Therefore, my goal is to automate that daylight/night toggling, while keeping the possibility of manual toggling at any time.

The how

To implement that automation, the first most obvious tools we can think of using are cron or systemd-timers.

There is also a couple of projects that specifically aim to solve that. They ask you to run their daemon, which tries to switch your theme at sunrise/sunset. However, they only do it successfully on some setups (not mine), and so I'm left to provide them a custom script to execute at that time.

For me, however, the better alternative is using Redshift hooks.

Redshift is already always running on my desktop and knows when it's night or day. It has support for hooks, which means you can drop a script in a directory, and it will be executed when some events happen, including sunset and sunrise.

It's an elegant solution and it doesn't require any more daemons running. This also works on Gammastep, which is a Redshift fork, just by changing the configuration directory accordingly.

If you need some inspiration, here's my setup:

Mounting AirPort Time Capsule on Linux in 2025

Sun, 21 Sep 2025 00:00:00 GMT

Apple AirPort Time Capsule provides two protocols to access its shares:

SMB1
Apple Filing Protocol

In this post I'll briefly review the status of both methods on Linux in 2025.

SMB1

SMB1 support has been partially dropped from the kernel since 5.15, yet you may still use it with some workarounds. More details in this post.

Apple Filing Protocol

AFP shares can be mounted using afpfs-ng. The project was archived in 2020, but still works for my use case.

On ArchLinux you can install it with: sudo pacman -S afpfs-ng.

If you run Debian, the package is no longer on the repositories. This post provides a solution.