Posts on manueljimenezs

Building my first Flatpak

Sun, 20 Jul 2025 00:00:00 +0000

A SteamDeck running the SDR software SDR++ via Flatpak

First things first, I’ve had a SteamDeck for some time now. Even though you can use it for its primary purpose, playing games 😆, there’s so much you can do with it.

At my family’s home there is a radio antenna on the roof, that can be used with the typical ham radio handhelds and transceivers. In my case, I have it setup with a Raspberry Pi, a RTL-SDR v4 dongle connected to it and to the antenna. That way I can listen to HF, UHF and VHF bands from anywhere I want.

That concludes the server part. There are a few clients that can be used to connect to the Pi via RTL-TCP, some of them are GQRX, SDRSharp, CubicSDR, and SDR++. The former is what I have been using lately.

I was looking for a more portable way to access the SDR, so the SteamDeck was a perfect fit for this. There’s is only one problem, everything in SteamOS is usually installed via Flatpak because by default SteamOS sits behind an immutable file system, so having SDR++ via Flatpak would be great, but looking on the official repos there is no Flatpak package.

The beginning

This is a short definition about what a Flatpak is

Flatpak is a technology for distributing and running sandboxed desktop applications on Linux. It allows developers to package their applications with all necessary dependencies, making it easier to distribute software across different Linux distributions.

There are some basic things that are necessary for building a Flatpak:

The YAML manifest: where modules, metadata and build steps are defined
The icon and desktop file

This is an example of the manifest file:

id: org.sdrpp.App
runtime: org.kde.Platform
runtime-version: '5.15-23.08'
sdk: org.kde.Sdk
command: sdrpp
finish-args:
 - --share=network
 - --socket=pulseaudio
 - --filesystem=home
 - --device=usb
 - --socket=x11
 - --device=dri
modules:
 - name: rtl-sdr
 buildsystem: cmake
 config-opts:
 - -DINSTALL_UDEV_RULES=OFF
 - -DDETACH_KERNEL_DRIVER=ON
 sources:
 - type: git
 url: https://github.com/rtlsdrblog/rtl-sdr-blog.git
 branch: v1.3.6
...

The runtime defines a set of libraries where the program is going to run on. In this case, SDR++ is a QT app so the KDE Runtime would guarantee the least hassle to make this run.

Each module defines a dependency, needed to build the software from source, you can also set where does it fetch the sources from with the sources: tag, doesn’t matter if sources are local or not. After reading the SDR++ repo for quite a while i managed to gather all the module dependencies and their options. I only built this with the RTL-SDR driver and ‘didnt bother with compatibility for other drivers as that would have made the build process even more complex.

In finish-args you define the permissions the final app will need.

Handicaps

I had a few problems trying to run the app due to an error linking stdc++fs whilte trying to build the source. After battling a little bit with ChatGPT it led me to the right path: modify the upstream code so it doesn’t try to link stdc++fs. (modern GCC versions (≥9) integrate std::filesystem directly into libstdc++, so explicitly linking -lstdc++fs results in an error because it doesn’t exist!)

Trial and error

I was building and trying to run the app with these commands:

flatpak-builder --force-clean build-dir org.sdrpp.App.yaml --install build-dir --user
flatpak run org.sdrpp.App.yaml

You can also open a shell inside the Flatpak environment like this for debugging:

flatpak run --command=sh --devel org.sdrpp.App

Now that was running it is time to add the icons and the .desktop file shortcut to make it pretty. You can check the repo here

Scraping one of the main Spanish TV broadcasters with cookies, Python and yt-dlp

Sun, 19 Feb 2023 00:00:00 +0000

As a little project I wondered: Would it be possible to scrape the contents of a Spanish channel website so I could get their content offline and without any loss? That way you would be able to watch it everywhere, with no ads and no resolution limits. (This broadcaster is also known for their bad practices in ad breaks, on-screen elements and an unbrowsable website if not using adblock).

I was thinking about publishing the code in the first place, but I think it will be more safe and productive to write about the process of doing it so you could extend it to any websites you like:

If you give a man a fish, you feed him for a day. If you teach a man to fish, you feed him for a lifetime.

This is generic information, the URLs provided in this article are not real. This is only for educational purposes about working with python, requests and cookies.

Analyzing the problem

To be able to see any content on that channel platform, you will need to create a user account. That means, we will need to create an account to be able to make and send our requests to their internal API

For this I used any modern browser and I toggled the Developer tools in the Networking tab. That way you will be able to see the login sequence.

In this case, the login is a POST request to an API endpoint sending your username and password as an input. Then it generates a session token inside a cookie and allows you to interact with the internal API.

You could replicate that in python like this:

session = requests.Session() # create a new session object to store session data for future requests
credentials = { "username:" "myuser", "password:" "mypassword"}
session.post("http://api.web.com/login", credentials)

You can use the python-dotenv package to store credentials inside an external file

Choose an example content

The best way to scrape something is to use actual data, but be careful: some websites have request limits and may block you with a HTTP 429 Too Many Requests error. One way of avoiding this is dumping your jsons and content locally and scraping over that local copy.

After logging in, we will send a GET request with the URL of the content we want to scrape (e.g: http://web.com/episode/example) Use a browser in developer mode first to see what you need to look for. For me, the useful data was stored inside two <script> tags.

For this, you may find the re and BeautifulSoup4 packages useful for filtering the info you need. In this case, a simple call to re was all I needed:

html = session.get("http://web.com/episode/example").text
matches = re.findall("<script>(.*?)</script>", html)

Inside those tags theres another url that will lead you to the specific content API endpoint, the response is a JSON where you could scrape the metadata and the streaming url

You can use the json get('') functions or the jmespath package to fetch the data you want from a json into variables

Interfacing your code with yt-dlp

yt-dlp is a fork of youtube-dl, a python utility to download video from lots of sources you can install it with:

pip3 install yt-dlp

Suppose we already extracted a filename string and the m3u8 playlist with the content we want to download. We can pass them to yt-dlp like this:

import yt_dlp

# * the options we will pass to yt-dlp *
# in this case only the outtmpl property to specify the
# output filename we extracted in a previous request

ydl_opts = {'outtmpl': title+'.mp4'}

for item in items:
 if "mpegurl" in item.get("type"):
 with yt_dlp.YoutubeDL(ydl_opts) as ydl:
 error_code = ydl.download(item.get("url"))
 exit()

That will have your file downloaded, yt-dlp will take care of downloading the separate audio and video streams and merging them into a file.

I hope you find this information useful and try to get your hands dirty with something that comes to your mind. Scraping can be very powerful for automation, IoT, Telegram notifications…

Patching the kernel as a custom package in Archlinux

Sun, 06 Nov 2022 00:00:00 +0000

Following the adventure of patching the linux kernel, I tried to automate it a bit. Part of the process is well documented as always in the wiki

The idea is to fetch the official Archlinux sources for the linux kernel so we can modify them and add our patches.

Could I buy a graphics card with a normal HDMI port for a hundred bucks and skip all of this mess? Yes, but where is the fun in that?

Start by creating a new src folder in your homedir.

We will need the asp package that will take care of fetching the sources for us by issuing these commands:

asp update
asp export linux

I will also add my custom kernel patches in a patches/*.diff dir, you can see why I need to patch the kernel here

There is also another issue here: the config for the kernel issued by asp is different than the upstream package, meaning that we will need to modify it, otherwise my system, which is a BTRFS filesystem, will not boot:

cd linux
mv config config.old
sed -r "s/^(|#)CONFIG_BTRFS_FS=.*/CONFIG_BTRFS_FS=y/g" config.old > config

I also built a PKGBUILD patch with e.g diff -Naru PKGBUILD PKGBUILD.old > custom_PKGBUILD.patch to apply it on each kernel release, this gets rid of building the docs and their dependencies, also does a shallow clone and introduces my 0001-amdgpu-clock.patch patchfile. That way the build will take less time:

--- PKGBUILD 2022-10-29 12:28:27.038231602 +0200
+++ PKGBUILD 2022-10-29 12:28:27.038231602 +0200
@@ -1,6 +1,6 @@
 # Maintainer: Jan Alexander Steffens (heftig) <heftig@archlinux.org>

-pkgbase=linux
+pkgbase=linux-amdclock
 pkgver=6.0.5.arch1
 pkgrel=1
 pkgdesc='Linux'
@@ -10,14 +10,13 @@
 license=(GPL2)
 makedepends=(
 bc libelf pahole cpio perl tar xz
- xmlto python-sphinx python-sphinx_rtd_theme graphviz imagemagick texlive-latexextra
 git
 )
 options=('!strip')
 _srcname=archlinux-linux
 source=(
- "$_srcname::git+https://github.com/archlinux/linux?signed#tag=$_srctag"
 config # the main kernel config file
+ 0001-amdgpu-clock.patch
 )
 validpgpkeys=(
 'ABAF11C65A2970B130ABE3C479BE3E4300411886' # Linus Torvalds
@@ -26,13 +25,14 @@
 'C7E7849466FE2358343588377258734B41C31549' # David Runge <dvzrv@archlinux.org>
 )
 sha256sums=('SKIP'
- '05168cbbeb6378eec6c84fe3300cede4fa5cf6130c39fb8af95040529bd390a6')
+ 'SKIP')

 export KBUILD_BUILD_HOST=archlinux
 export KBUILD_BUILD_USER=$pkgbase
 export KBUILD_BUILD_TIMESTAMP="$(date -Ru${SOURCE_DATE_EPOCH:+d @$SOURCE_DATE_EPOCH})"

 prepare() {
+ git clone --depth=1 --branch=$_srctag "https://github.com/archlinux/linux" $_srcname
 cd $_srcname

 echo "Setting version..."
@@ -60,7 +60,7 @@

 build() {
 cd $_srcname
- make htmldocs all
+ make all
 }

 _package() {

That patch is then applied like this: patch -p0 < ../custom_PKGBUILD.patch

Now the only thing left is to build and install it:

makepkg -s
sudo pacman -U linux-amdclock-*.zst

You can bundle all of it in a shell script to save time in further upgrades:

#!/bin/bash
rm -rf linux
asp update
asp export linux
cp patches/* linux
cd linux
mv config config.old
# enable support for / as BTRFS filesystem
sed -r "s/^(|#)CONFIG_BTRFS_FS=.*/CONFIG_BTRFS_FS=y/g" config.old > config
patch -p0 < ../custom_PKGBUILD.patch

Enriching your articles with Hugo

Sat, 09 Apr 2022 00:00:00 +0000

Hugo has some tricks to enrich the contents of the posts and is highly customizable. With some imagination, one can implement features that are in no way inferior to some popular CMS out there.

When writing a long post, a table of contents can be quite useful to quickly access parts of the article. Hugo comes with a TableOfContents module by default. We’re going to use something called shortcodes. Shortcodes allow you to write small snippets of code that are triggered with a macro. This way we can optionally add a table of contents.

We’re gonna create a file layouts/shortcodes/toc.html with the following content:

<hr>
<h1>Table Of Contents</h1>
<div class="toc">
 {{ .Page.TableOfContents }}
</div>
<hr>

Next time we add {{ toc }} inside a Markdown file, it will insert a new table of contents in that place.

Add captions to images

Another useful feature is having descriptions of the images inserted. In this case we are going to take advantage of the title property of the img tag.

We are also going to take advantage of the Markdown syntax for inserting images: While the usual way to inserting images is like this ![Alt text](location), you can also add a title that will not be displayed like this ![Alt text](location "my description").

Create this file: layouts/_default/_markup/render-image.html

{{ if .Title }}
<figure>
<img src="{{ .Destination | safeURL }}" alt="{{ .Text }}">
<figcaption>{{ .Title }}</figcaption>
</figure>
{{ else }}
<img src="{{ .Destination | safeURL }}" alt="{{ .Text }}">
{{ end }}

Now you can add images with captions whenever you want, jump to the next section to see an example of an image with such feature.

Invert (some) diagrams and images on dark mode

This is a greeeat feature 👌, especially for the actual users of dark mode, so they don’t get blinded with white squares!. Again we are going to use shortcodes. This shortcode is pretty simple, when used, the content inside will be surrounded by an .invert class, just add this snippet of code to layouts/shortcodes/invert.html

<div class="invert" >{{ .Inner | markdownify }}</div>

You will also need to do something with that class. In my case I went to my theme’s css, located in themes/mytheme/assets/css/main.css. Inside the dark mode condition, we will insert this code, which will invert the images located inside that class:

@media (prefers-color-scheme: dark) {
 .invert img {
 -webkit-filter: invert(85%); /* safari 6.0 - 9.0 */
 filter: invert(85%);
 }
}

Finally, in any Markdown document you could insert the following tag, and automatically that image will be inverted, useful for diagrams, not that much for photos. That’s why we don’t want to always apply the inversion:

{{< invert >}}
![Alt Txt](/img/test.svg)
{{< /invert >}}

Here’s an example: (try toggling your system to dark/light mode!)

This diagram will adapt to the theme of the page

Update: alert boxes

Alert boxes are the definitive tool to catch the attention of the reader. Particularly when everything has gone out of hand and we may break things 😂.

Add this snippet of code to layouts/shortcodes/notice.html:

<div class="notice {{ .Get 0 }}">
 {{ if (or (eq (.Get 0) "alert" ) (eq (.Get 0) "warning")) }}
 <span class="icon alert">
 <object data="/icons/alert.svg" width="24" height="24"></object>
 </span>
 {{ else if (eq (.Get 0) "info")}}
 <span class="icon info">
 <object data="/icons/info.svg" width="24" height="24"></object>
 </span>
 {{ else }}
 <span class="icon info">
 <object data="/icons/info.svg" width="24" height="24"></object>
 </span>
 {{ end }}
 <p>{{ .Inner | markdownify }}</p>
</div>

With css you can customize it a little bit:

.notice {
 position: relative;
 border-radius: 6px;
 margin-bottom: 5px;
}

.notice.alert, .notice.warning {
 background-color: var(--warning-bg-color);
 border: solid 1px rgb(164, 27, 27);
}

.notice.info {
 background-color: var(--info-bg-color);
 border: solid 1px rgb(21, 81, 170);
}

.notice p {
 padding: 0 0.8em 0 2em;
}

.icon.alert, .icon.info {
 position: absolute;
 top: 0.6rem;
 left: 0.5rem;
}

You can use it in a post like this:

{{<notice warning>}}
This is a warning
{{</notice>}}

Aaand, this is the final result 🎉:

This is a warning

This is an info block. (You can use markdown code)

This is a note block. (You can use markdown code)

Sources

ruddra | sebastiandedeyne

This blog now runs under Hugo

Sun, 03 Apr 2022 00:00:00 +0000

So I wanted to give another chance to Hugo, I was using Jekyll for a while but I didn’t quite like the hassle of managing ruby dependencies and versions.

At the same time, I also took the opportunity to entirely redo the layout of the page, using the Anubis theme as a base. I liked that the old design was quite minimal and i wanted to preserve that. I also tried to avoid using JavaScript so if you block it, it will look exactly the same, on any device 😁.

Also migrating the posts from one platform to another worked flawlessly with almost no modification to the source files 👍.

Now I use two repositories for managing this page, one repo for serving the static build, and other repo for making the edits.

Using a workflow is very convenient with this setup becase you can write posts from everywhere without having a local enviroment to deploy.

Setting up the environment

If you want to make a similar setup, here’s the steps to reproduce it:

Create the user.github.io repo, here is where you will deploy the final statified webpage.
Create another repo myblog-hugo, here is where you will edit the page.
Create a new personal access token and copy the code generated!: https://github.com/settings/tokens/new

Note that maybe you have to check the repo checkbox while generating the token, so push access from one repo to another is allowed.
Go to both repositories > section Secrets and add a new Secret pasting the code generated. Name it as you like (e.g hugosecret).
In your myblog-hugo repo, create the following file at .github/workflows/main.yml with this content, changing the <user> variable to your liking.

name: hugo build

on:
 push:
 branches:
 - master

jobs:
 build-deploy:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v3

 - name: Setup Hugo
 uses: peaceiris/actions-hugo@v2
 with:
 hugo-version: '0.96.0'

 - name: Build
 run: hugo --minify

 - name: Deploy
 uses: peaceiris/actions-gh-pages@v2
 env:
 PERSONAL_TOKEN: ${{ secrets.HUGOSECRET }}
 EXTERNAL_REPOSITORY: <user>/<user>.github.io
 PUBLISH_BRANCH: master
 PUBLISH_DIR: ./public/

How I ended up compiling my own Linux kernel

Mon, 20 Sep 2021 00:00:00 +0000

I didn’t expect this day would arrive. It’s all fun and games until you buy a cheap graphic card with only a DVI port in it. It works great for FullHD resolutions. The problem is when you have resolutions and framerates bigger than that.

In the Linux kernel, the maximum pixel clock (the speed at which pixels are transmitted over a port) is limited to 165 MHz leading to messing with the images when displaying bigger resolutions than fullHD.

There are two solutions to this problem:

Using lower resolutions/framerates, this means not taking advantage of e.g ultrawide monitors. (Spoiler: nobody wants this 😛)
Tweaking your kernel, increasing the clock ratio and happily use your shiny screen as it was intended.

Getting your hands dirty

After a long journey searching on the interwebs, I found that increasing the pixel clock to 250 MHz is enough for WFHD resolutions. There is even a calculator for that.

Note that you may be running your graphics card out of spec, and you can irreversibly damage your hardware so be very cautious with this.

Here is the line in the Linux kernel that we’re going to change. This change is provide as a patch file, which concisely represents how and where a change in a file is made. Something like diff --git oldfile.txt newfile.txt will suffice.

--- a/drivers/gpu/drm/amd/display/include/signal_types.h 2020-12-17 20:11:00.261706513 +0100
+++ b/drivers/gpu/drm/amd/display/include/signal_types.h 2020-12-17 20:09:14.391997315 +0100
@@ -29,7 +29,7 @@
 /* Minimum pixel clock, in KHz. For TMDS signal is 25.00 MHz */
 #define TMDS_MIN_PIXEL_CLOCK 25000
 /* Maximum pixel clock, in KHz. For TMDS signal is 165.00 MHz */
-#define TMDS_MAX_PIXEL_CLOCK 165000
+#define TMDS_MAX_PIXEL_CLOCK 250000

I also created a script that downloads the linux source code, automatically applies all the patches and compiles it with a basic config. Here is the full set of files.

#!/bin/bash
KERNELVER=linux-5.14.2

get_and_prepare() {
 wget https://cdn.kernel.org/pub/linux/kernel/v5.x/$KERNELVER.tar.xz
 tar -xf $KERNELVER.tar.xz
 cp -r config $KERNELVER/.config
}


patch_kernel() {
 for i in $(ls patches); do
 patch -Np1 -d $KERNELVER < patches/0001-amdgpu-clock.patch
 done
}

build() {
 export KBUILD_BUILD_HOST=archlinux
 export KBUILD_BUILD_USER=linux-amdclock
 cd $KERNELVER
 make -j10
 make modules -j10
 sudo cp -v arch/x86/boot/bzImage /boot/vmlinuz-linux-amdclock
 sudo make modules_install
}

if ! command -v wget &> /dev/null; then
 echo "Please install wget"
 exit 1
fi

case "$1" in
 -b|--build-only)
 build
 exit 0
 ;;
 -p|--patch-only)
 patch_kernel
 exit 0
 ;;
esac

get_and_prepare
patch_kernel
build

On each update you would have to increase the kernel version and recompile the new kernel to copy it to your bootdir.

Also, you would have to blacklist the linux package on your distribution’s package manager so it doesn’t automatically update and you don’t lose the changes made.

In the case of Archlinux, as aaalwayss ;)) the wiki clearly explains it: link

Full-disk encryption on Archlinux with LVM+LUKS+BTRFS

Thu, 28 May 2020 19:19:54 +0100

This article will guide you through a basic Archlinux installation with full-disk encryption and the usage of the BTRFS filesystem for managing subvolumes and snapshots.

The steps shown here are all available in the Arch Wiki, but I wanted to make an installation example from scratch until OS startup.

This installation will presume you are booting from an EFI System and that you will be using a SWAP partition. Again, this is a concrete real-world example but feel free to make it match to your likings.

Planning the disk layout

In this case we’re going to make two main partitions in a GPT partition table:

/dev/sda1, the ESP (UEFI Boot Partition) that will hold our kernel and the bootloader. Formatted as FAT32 with a size of 512MB with mkfs.fat -F 32 /dev/sda1
/dev/sda2, is a partition that will contain an encrypted container which at the same time will contain an LVM physical volume which at the same time will contain logical volumes for both the root and swap filesystems. Yeah, this seems a little bit crazy but it is a very flexible configuration :)

Setting up the disk layout and volumes

Supposing you’ve already created the two partitions mentioned about and formatted /dev/sda1 as FAT32, the next step is to create the encrpyted container:

# cryptsetup luksFormat /dev/sda2
# cryptsetup open /dev/sda2 cryptlvm

Consecutively, a physical volume called cryptlvm is going to be created. We will also add that physical volume to a volume group called secure

# pvcreate /dev/mapper/cryptlvm
# vgcreate secure /dev/mapper/cryptlvm

Then we’re going to focus on creating the swap and root filesystems:

The swap partition will be 4GB and the rest will be used for the BTRFS system partition

lvcreate -L 4G secure -n swap
lvcreate -l 100%FREE secure -n root

Initialize the swap partition:

mkswap /dev/mapper/secure-swap
swapon /dev/mapper/secure-swap

Create the BTRFS filesystem and their subsequent subvolumes: ‘@’ for root, ‘@home’ for the home folder and ‘@snapshots’ for making filesystem backups. This makes it to discriminate directories when making backups.

mkfs.btrfs /dev/mapper/secure-system
mount /dev/mapper/secure-system /mnt
btrfs subvolume create /mnt/@
btrfs subvolume create /mnt/@home
btrfs subvolume create /mnt/@snapshots
umount /mnt

Now we’re going to mount all the volumes and we’re going to enable zstd compression.

mount -o subvol=@,compression=zstd /dev/mapper/secure-system /mnt
mkdir -p /mnt/{home,boot}
mount -o subvol=@home,compression=zstd /dev/mapper/secure-system /mnt/home
mount /dev/sda1 /mnt/boot

Continue with the usual Arch install

Follow the normal install of the base system and basic config. in the Installation guide

Finishing the installation

When arriving at the mkinitcpio part some extra steps will be required:

Install intel-ucode (or the AMD counterpart) and install systemd-boot on the ESP:

bootctl –path=/boot install

Head over to the ESP (/boot) and create arch.conf inside the entries directory with the following content:

title Arch Linux
linux /vmlinuz-linux
initrd /intel-ucode.img # ONLY FOR INTEL CPUs!!
initrd /initramfs-linux.img
options luks.uuid=<LUKS_UUID> root=/dev/mapper/secure-system rootflags=subvol=@ rd.luks.options=discard

Replace <LUKS_UUID> with the UUID shown in blkid in the filesystem flagged as LUKS.

Add default arch inside the loader.conf file.

Edit the HOOKS line in /etc/mkinitcpio.conf with the following modules:

HOOKS=(base systemd autodetect modconf keyboard sd-vconsole block sd-encrypt sd-lvm2 filesystems fsck)

Lastly run mkinitcpio -p linux and reboot. If you’re lucky enough you will enter to your newly installed operating system.

Running vanilla GNOME on Ubuntu

Mon, 16 Mar 2020 20:19:54 +0100

Install gnome-session and some components:

sudo apt install gnome-session gnome-tweaks chrome-gnome-shell
Restore the default login screen style:

sudo update-alternatives --config gdm3.css

Select /usr/share/gnome-shell/theme/gnome-shell.css

Log out from your PC and switch the session to GNOME by clicking the gear icon

Go to extensions.gnome.org and install the User Themes extension

Go to Tweaks and set themes, icons, etc in Adwaita

Removing snapd

Snaps are a self-contained package technology that allows software to be installed without worrying about incompatible libraries. The downside is that apps are bigger in size and the startup may be slower.

sudo rm -rf /var/cache/snapd/

sudo apt autoremove --purge snapd gnome-software-plugin-snap

rm -rf ~/snap

You may have to run apt install gnome-calculator gnome-system-monitor to get back some default applications that were initially shipped as snaps.

rEFInd: An elegant bootloader

Tue, 29 Oct 2019 20:39:54 +0100

Introduction

From the year 2013, Microsoft switched its operating system’s booting mode to a technology called EFI, already being used in Macs for a long time.

In UEFI (The PC implementation) multiple applications can coexist, this means you can combine multiple bootloaders such as Windows Boot, GRUB, systemd-boot without taking over each other.

EFI Requirements

Your motherboard has to be supported (>2013)
Your disk has to be formatted in GPT instead of MBR
You need an ESP (EFI system partition) that stores all the bootable executables

The ESP

The ESP (EFI system partition) is a small FAT32 partition (~512MB) that stores all the bootloaders:

.
├── Boot
│   ├── BOOT.CSV
│   ├── bootx64.efi
│   └── ref.bak
├── Microsoft
│   ├── Boot
│   └── Recovery
├── refind
│   ├── BOOT.CSV
│   ├── drivers_x64
│   ├── icons
│   ├── keys
│   ├── refind.conf
│   ├── refind.conf.bak
│   ├── refind_x64.efi
│   └── themes
├── tools
└── ubuntu
├── fw
└── fwupx64.efi

The default bootloader is stored in the firmware level in something we call EFI Variables that we’ll configure in just a moment. In some motherboards the default bootloader can be chosen in the motherboard config screen.

The Boot directory is a fallback option just in case those variables are not set, you could copy any .efi file in other folder to bootx64.efi to make it your fallback option.

rEFInd

rEFInd is a graphic bootloader that is smart enough to find the bootable entries without much configuration, it is also able to remember the last booted option to be selected on the next boot. It is also able to boot USB sticks and be bootable from any install media.

Manual install

Supposing you have an ESP partition in a GPT disk (If you are using Windows 10, you probably are) you just have to copy the refind folder into the /EFI folder of the ESP (There are also OS-specific installers that do this)

Once copied you have to tell your motherboard to boot from it by default.

In Linux there is an utility that list the boot order called efibootmgr

BootCurrent: 0002
Timeout: 1 seconds
BootOrder: 0002,0000,0006,0001,0003,0004
Boot0000* Windows Boot Manager
Boot0001* UEFI:CD/DVD Drive
Boot0002* rEFInd Boot Manager
Boot0003* UEFI:Removable Device
Boot0004* UEFI:Network Device
Boot0006* proxmox

To add rEFInd:

efibootmgr -c -l \\EFI\\refind\\refind_x64.efi -L rEFInd

To change the boot order:

efibootmgr -o 0,1,2

To remove an entry:

efibootmgr -Bb 0000

Refind has a refind.conf and lots of themes to customize it.

Adding Linux

Windows is automatically detected by refind and some Linux distros too, but if you want to be sure add a refind_linux.conf file into your Linux Partition in the /boot/ directory:

"Boot using default options" "root=PARTUUID=a9fbd673-2ba9-4dcd-be6b-97423dd74c89 rw initrd=/boot/amd-ucode.img initrd=/boot/initramfs-%v.img"

the root points to the ID of the partition in which the distro is installed, it can be retrieved with blkid.

Extra: Ubuntu: Copying kernels to ESP

manu@x240:~$ cat /etc/kernel/postinst.d/zz-kernel-esp
#!/bin/bash
#
# This is a simple custom kernel hook to populate the systemd-boot entries
# whenever kernels are added or removed during an update.
#
vmlinuz=$(find /boot -maxdepth 1 -name "vmlinuz-*-generic")
version=$(echo $vmlinuz | grep -o -P "\d+\.\d+\.\d+\-\d+" | sort -V | head -n -1)
latest=$(echo $vmlinuz | grep -o -P "\d+\.\d+\.\d+\-\d+" | sort -V | tail -n 1)
echo ">> COPYING ${latest}-generic. LATEST VERSION."
for file in initrd.img vmlinuz; do
cp "/boot/${file}-${latest}-generic" "/boot/efi/EFI/ubuntu/${file}-generic"
done

Building a router with a Raspberry Pi and OpenWRT

Sat, 06 Jul 2019 00:00:00 +0000

OpenWRT is a well known distribution among routers. It provides a wide variety of possibilities with the inclusion of a package manager opkg. Here I’m going to be installing OpenWRT on a Raspberry Pi 3 B+ and creating a wireless access point with its own subnet that doesn’t have access to the rest of the network. This could be useful for isolating IoT devices or creating a ‘‘guest’’ network.

The OpenWRT Wiki gives a bit of light on the installation of OpenWRT on the Pi. First of all I’m going to use the snapshot build instead of the release located at https://downloads.openwrt.org/snapshots/targets/brcm2708/bcm2710/. If you use the release build the onboard wi-fi will not be detected.

There are a few considerations before flashing the image that should be worth taking a look:

The default IP for thr RPi will be 192.168.1.1, this will collide with your main router address so you have to temporarily change your router IP to something like 192.168.1.3 and after having access to the raspberry pi changing it back.
If using a Pi 3B+, your country has to be set with raspi-config in a Raspbian environment for the onboard wireless to work.

Ok so we will be plugging the pi into an ethernet device like any other normal computer to give it access to the internet.

Unzip and flash the rpi-3-ext4-factory.img.gz image located in the previous link and turn on the pi.

Run ssh root@192.168.1.1 and you will be presented with a shell prompt.

Configure the internet access

Do an ip addr and look for the ethernet interface, in this case it will be eth0.

In OpenWRT the interfaces are configured in /etc/config/network add or modify the lan entry in that file:

config interface 'lan'
option type 'bridge'
option proto 'static'
option ipaddr '192.168.1.2'
option gateway '192.168.1.1'
option netmask '255.255.255.0'
option ip6assign '60'
option ifname 'eth0'

For updating the packages we will also need to configure the DNS servers so edit the /etc/config/dhcp and add list server 1.1.1.1 or something similar to the config dnsmasq entry.

With that set you could do an /etc/init.d/network restart to apply the changes.

Installing the software and the web interface

Run opkg update and then run opkg install luci. If you want to install packages from the interface also install luci-app-opkg

reboot the device and access your Pi from a browser:

Configuring the zones and creating an isolated AP for guests

In the Web GUI, I configured a new interface called wifi and I linked it into the existing lan connection. Then you can specify different rules for restricting the access in that new network. My main router works in the 192.168.1.0/24 range so the access point will have its own isolated network in the 192.168.2.0/24 range. Here’s an /etc/config/network example:

...
config interface 'lan'
option type 'bridge'
option proto 'static'
option ipaddr '192.168.1.2'
option gateway '192.168.1.1'
option netmask '255.255.255.0'
option ip6assign '60'
option ifname 'eth0'
config interface 'wifi'
option proto 'static'
option ipaddr '192.168.2.1'
option netmask '255.255.255.0'

The zones are configured in /etc/config/firewall

...
config zone
option name 'wifi'
option input 'ACCEPT'
option output 'ACCEPT'
option forward 'ACCEPT'
option masq '1'
option network 'lan wifi'
config forwarding
option dest 'wan'
optioconfig interface 'lan'
option type 'bridge'
option proto 'static'
option ipaddr '192.168.1.2'
option gateway '192.168.1.1'
option netmask '255.255.255.0'
option ip6assign '60'
option ifname 'eth0'
config interface 'wifi'
option proto 'static'
option ipaddr '192.168.2.1'
option netmask '255.255.255.0'
n src 'wifi'
config forwarding
option dest 'wifi'
option src 'wan'
config rule
option enabled '1'
option src 'wifi'
option name 'isolatewifi'
option proto 'all'
option src_ip '192.168.2.0/24'
option dest_ip '192.168.1.0/24'
option target 'DROP'
option dest '*'

All of this can also be done in the web interface, but I put here the config files for clarity’s sake.

FFmpeg, the video Swiss Army Knife

Thu, 24 Jan 2019 10:55:30 +0100

You may have found yourself in a situation where you have to modify a video or extract its audio. Firing up a complete editor for such simple tasks could be a waste of energy and time.

Here are some basic tips for FFmpeg that can sometimes make your workflow more efficient:

Change the aspect ratio of a video without re-encoding

This can be useful when the only thing we want to do is changing the proportions of a video without losing quality.

For example for converting a 4:3 video to an stretched 16:9:

ffmpeg -i in.mp4 -aspect 16:9 -c copy out.mp4

The -c copy option allows setting up the codec to a copy mode where ffmpeg doesn’t reencode the video and the results are done immediately.

Extracting audio from a file

ffmpeg -i in.mp4 out.mp3

Note: the extensions shown here are completely arbitrary, ffmpeg supports a wide variety of codecs and formats which can be seen with the commands ffmpeg -codecs and ffmpeg -formats

Cutting a video file without reencoding

ffmpeg -i in.mp4 -ss 00:00:25.0 -codec copy -t 30 out.mp4

In this case the cut starts on second 25 and the video lasts 30 seconds

Converting a video to other format

ffmpeg -i in.ogv -c:v libx264 out.mp4

-c:v libx264 sets the video codec
-c:a vorbis sets the audio codec
-r 25 sets the framerate to 25fps
-s <1280x720|hd720> sets the video resolution to 720p
-b:v 1M sets the video bitrate to 1MB/s

Vertically split double PDF pages

Wed, 16 Jan 2019 20:39:54 +0100

Some people like to distribute their slides in a printing format, making reading and skipping pages really difficult.

mupdf, among other options, has a CLI utility to overcome this and have as a result one slide per page.

mutool poster -y 2 in.pdf out.pdf

Posts on manueljimenezs

Building my first Flatpak

The beginning

Handicaps

Trial and error

Scraping one of the main Spanish TV broadcasters with cookies, Python and yt-dlp

Analyzing the problem

Choose an example content

Interfacing your code with yt-dlp

Patching the kernel as a custom package in Archlinux

Enriching your articles with Hugo

Table Of Contents

Table of contents

Add captions to images

Invert (some) diagrams and images on dark mode

Update: alert boxes

This blog now runs under Hugo

Setting up the environment

How I ended up compiling my own Linux kernel

Getting your hands dirty

Full-disk encryption on Archlinux with LVM+LUKS+BTRFS

Table Of Contents

Planning the disk layout

Setting up the disk layout and volumes

Continue with the usual Arch install

Finishing the installation

Running vanilla GNOME on Ubuntu

Removing snapd

rEFInd: An elegant bootloader

Table Of Contents

Introduction

EFI Requirements

The ESP

rEFInd

Manual install

Adding Linux

Extra: Ubuntu: Copying kernels to ESP

Building a router with a Raspberry Pi and OpenWRT

Configure the internet access

Installing the software and the web interface

Configuring the zones and creating an isolated AP for guests

FFmpeg, the video Swiss Army Knife

Table Of Contents

Change the aspect ratio of a video without re-encoding

Extracting audio from a file

Cutting a video file without reencoding

Converting a video to other format

Vertically split double PDF pages