Yelling home

Well, sometimes one gets bored…

I’m not much of a graphic designer, but I’ve had this image in my head for a few weeks now, and was hoping creating it would get rid of it. It didn’t.

Geplaatst in Nerd stuff | Reacties uitgeschakeld voor Yelling home

Version control for configuration files

Yesterday I wrote a post about setting up a Subversion server.
Subversion is a great tool for controlling versions of collections of files that are contained in a single root directory (an entire website, development of a software application, etc.). But it’s not the perfect tool for controlling the versions of single files.
So, after yesterday’s post, I now feel somewhat obliged to also document the system I use for controlling the versions of my configuration files.

Yes, I have all my configuration files under version control. I do this for 2 reasons:

  • I can easily go back to a previous version if changed settings break stuff
  • I can look up when and why I made certain changes

To ease this process, I wrote a wrapper around my text editor. Which in my case is vim, but could be any command line text editor; and maybe even graphical editors, I haven’t tested that.
You will find this Bash script below, but before you download and start using it, read these next few lines about it’s workings.

Make sure the RCS package is installed. If you can’t find it in your system’s package system, download it from the GNU website. With the last update in January 2015 it’s an old package; let’s hope it doesn’t die, because I haven’t been able to find an alternative.
Copy the script below, and save it as /usr/local/bin/vircs. It should be executable by everybody, but writable only by root:

# chmod 755 /usr/local/bin/vircs

From now on, the command you execute to edit configuration files is vircs, instead of vim, emacs, nano, or whatever you’ve been using; e.g.:

# vircs /etc/hosts

(Make sure the EDITOR environment variable is set to your favorite editor; vircs will default to vim if EDITOR is not set.)

This will create a file with the same name and suffix ‘,v‘ (‘comma-vee‘), which contains the version information; e.g. ‘/etc/hosts,v‘.

In some cases, this may be a problem. The configuration file for sudo/etc/sudoers — for example, contains the line

#includedir /etc/sudoers.d

which makes sudo include every file in the specified directory, including any files with a ‘,v’ suffix. But since sudo doesn’t recognize the RCS file format, it will then complain. Even though this is clearly a bug in Sudo, it is a reality we have to deal with.
In cases like this, create a sub-directory named ‘RCS‘ (yes, all capitals) before editing the file, and rcs will automatically store the version file in that directory.
If you’ve already created the version file, and then discover that it creates a problem (because a service won’t restart, for example), create the sub-directory and move the version file into it. The service should now restart without complaining, and rcs will automatically find the version file when you re-edit the configuration file.
(BTW: cronie will even complain about this new subdirectory, which is even worse. But since it runs without any problems after having complained, we’ll just let it sob.)

The file you are editing is supposed to exist before you start editing, so if you want to check in a file that doesn’t exist yet, create it first:

$ touch ~/groceries.txt
$ vircs ~/groceries.txt

Obviously, vircs is not limited to configuration files, but can be used for all text-based files (text, HTML, JSON, etc.).

When you bring a file under version control (you edit the file for the first time using Vircs), the script will ask you for a short description of the file. This description will be displayed in the output of rlog. The size of this description is limited to 1 line; hitting [Enter] will mark the end of the description.

Each time you save a file, you are asked to add a short log message. This message is also displayed in the output of rlog, and it’s size is also limited to 1 line.

And that concludes what I wanted to say beforehand. Here’s the script.
Have fun!

(If the script is too wide for your screen, just click on it and then use your arrow keys to scroll right and left.)

#!/usr/bin/env bash

# This is vircs.
# Vircs is a simple wrapper around `rcs ci', `rcs co' and a text editor; this is
# probably the millionth of its kind.

# For more info, see


# Copyright (c) 2018 Rob La Lau <>

# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:

# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.



# Dependencies.
RCS=`which rcs`     || exit 1
CI="${RCS} ci"
CO="${RCS} co"
DIFF="${RCS} diff"
CLEAN="${RCS} clean"
CHGRP=`which chgrp` || exit 1
CHMOD=`which chmod` || exit 1
CHOWN=`which chown` || exit 1
FILE=`which file`   || exit 1
RM=`which rm`       || exit 1
STAT=`which stat`   || exit 1
[ -z "${EDITOR}" ] && {
    # Real men use vim. ;)
    echo "Environment variable EDITOR not set; we'll use vim."
    EDITOR=`which vim` || exit 1

# File to edit.
[ -z "${file}" ] && {
    echo "Usage: $0 file"
    exit 1

# File exists?
[ ! -e "${file}" ] && {
    echo "File ${file} does not exist. Please create it before continuing."
    echo "If an RCS file exists, you can (re)create the original by executing"
    echo " ${CO} -u ${file},v"
    echo "Remember to set the correct permissions using 'chown', 'chgrp' and 'chmod'."
    exit 1

# Bail out if file ends in ',v'.
[ "${file##*,}" = "v" ] && {
    echo "You specified the RCS file. Please specify the working file."
    echo "If you do not have a working file, you can (re)create it by executing"
    echo " ${CO} -u ${file}"
    echo "Remember to set the correct permissions using 'chown', 'chgrp' and 'chmod'."
    exit 1

# Acceptable mime type?
mimetype=`"${FILE}" --brief --dereference --mime-type "${file}"`
[ "${mimetype%%/*}" != "text" -a "${mimetype}" != "inode/x-empty" ] && {
    echo "File ${file} is of type ${mimetype} and cannot be edited by $0."
    exit 1

# RCS ignores file owner, group and permissions.
# We don't, as this could break services or applications.
user=`"${STAT}" -c %u "${file}"`
group=`"${STAT}" -c %g "${file}"`
rights=`"${STAT}" -c %a "${file}"`

# Name of author, for log messages.
if [ -n "${SUDO_USER}" ]; then
    # Using `sudo'.
elif [ "${USER}" = "root" -a -n "${MAIL}" ]; then
    # When using `su', some of the user's environment is retained (but not when using `su -' !).
    # Obviously, we're making a dangerous assumption here (but for me it works).

# Is file under version control?
# If so, are there any differences?
diff=`${DIFF} "${file}" 2> /dev/null`
# rcsdiff may have 1 of 3 return values:
# 0 : no differences found
# 1 : differences found
# 2 : rcs file or working file not found
if [ ${retval} -eq 2 ]; then
    # Initial checkin.
    echo "File ${file} is not yet under version control."
    echo "Let's check it in right away."
    echo "Please give a short (1 line) description of the file."
    echo "E.g.:"
    echo " Apache config for virtual host"
    echo "or"
    echo " Postfix mail aliases for host `hostname`"
    echo "(This is not the log message!)"
    read -p "Description: " descr
    ${CI} -i -u ${author} -t-"${descr}" -m"Initial checkin" ${file}
    "${CHOWN}" "${user}" "${file}"
    "${CHGRP}" "${group}" "${file}"
    "${CHMOD}" "${rights}" "${file}"
elif [ ${retval} -eq 1 ]; then
    echo "There is a difference between ${file} and the last version in it's RCS file."
    echo "Please verify and correct this before continuing."
    echo "The approximate steps for correction would be (adjust to system and taste):"
    echo " mv '${file}' '${file}.changed'"
    echo " ${CO} -l '${file}'"
    echo " diff '${file}' '${file}.changed'"
    echo " # incorporate changes to be kept into '${file}'"
    echo " ${CI} -u ${author} -m'Checking in old changes.' '${file}'"
    echo " rm '${file}.changed'"
    echo "(Do not simply copy the above, but make sure you understand what it does.)"
    echo "After correction, make sure the file attributes for the working file are as follows:"
    echo "User: ${user}"
    echo "Group: ${group}"
    echo "Rights: ${rights}"
    exit 1

# We can now safely delete the original (to keep co from complaining).
"${RM}" -f "${file}" || exit 1

# Checkout and lock.
${CO} -l "${file}"

# Edit.
"${EDITOR}" "${file}"

# Compare.
diff=`${DIFF} -q "${file}"`

if [ -n "${diff}" ]; then
    # Working file has changed.
    # Checkin (and checkout again, unlocked).
    echo "Please give a short (1 line) log message for this change."
    read -p "Log message: " msg
    ${CI} -u ${author} -m"${msg}" "${file}"
    echo "New version of ${file} saved."
    # Working file has not changed.
    # Remove unchanged locked working file, and checkout unlocked.
    ${CLEAN} -u "${file}"
    ${CO} -u "${file}"
    echo "Changes to ${file} cancelled."

# Correct file attributes.
"${CHOWN}" "${user}" "${file}"
"${CHGRP}" "${group}" "${file}"
"${CHMOD}" "${rights}" "${file}"

# Done

To make full use of the potential of RCS, have a look at it’s documentation.

Geplaatst in Nerd stuff | Reacties uitgeschakeld voor Version control for configuration files

Subversion server

Despite the fact that I have set up quite some Subversion servers in the past 15-20 years, I still need to turn to the documentation for the details each time I do it. So, to save myself some time searching and filtering next time, I decided to document it here this time.

Open door: if you don’t know what a Subversion server is, you don’t need this post.

And why Subversion and not Git? Because I prefer having a central repository, so I always know where to find the most recent versions of my files. And you’ll find some more reasons here.

Naturally, to get a good understanding of what you’re doing, and to make decisions that fit your requirements, I’d advise you to read the SVN book instead of this post.
But then again, I’m writing this post mainly for me, so do as you please.

Okay, with that out of the way, let’s set up this server.

I’ll create a single repository, and each user will have access to all of the data it contains; if you need more access restrictions, you can create multiple repositories or have a look at the documentation for Subversion.
The server is Gentoo, but this setup should be the same or very similar for other Unices.
If you’ve read my post about setting up a mail server, you’ll remember that our server is called
Make sure the Subversion package is installed.

First, create a group. For now, this group will have only 1 member, but if you decide some day that you need a second repository, the account you create for that repository will be a member of this same group.

root# groupadd svngroup

Second, create a user. This account will be used by everyone who accesses the repository, but don’t worry: users will not share this account’s password. Actually, this account won’t even have a password; users will be accessing the account using SSH keys, so we won’t set a password, thereby eliminating one important risk of security breach. (Actually, I have disabed password authentication altogether.)

root# useradd -c "Account for SVN access" -G svngroup -m -s "/bin/bash" -U svnuser

Now, collect SSH public keys from everybody who needs access to the repository.
To generate such key, a Linux or BSD user would execute

user$ ssh-keygen -f ~/.ssh/svn_rsa

and then send you the file ~/.ssh/

Windows/PuTTY users check out this page on the PuTTY website for more info.

Obviously, no matter how the key was generated, you call the users on the phone or speak to them in person to verify the fingerprint of their public key, before you accept said key.

While your users are generating their keys and trying to figure out where the f**k they may find those fingerprints, you continue setting up your repository.

Start by creating a directory /srv, if it doesn’t exist yet. Not every distribution includes this directory, but it is defined in the Filesystem Hierarchy Standard, and I actually think that it is a good idea to collect all world-facing services in a single directory (eases security, backup, etc.). Ideally this directory resides on a separate partition or disk.

root# mkdir -m 755 /srv

Create a directory where the repository will resign.

root# mkdir -m 710 /srv/subversion
root# chgrp svngroup /srv/subversion

Now, create the repository in that directory.

root# svnadmin create /srv/subversion/repository
root# chown -R svnuser:svnuser /srv/subversion/repository
root# chmod o-rwx /srv/subversion/repository

Attention: the above is not a typo. The ‘-U‘ switch to the ‘useradd‘ command created a group with the same name as the user, and it’s this group the repository belongs to. The group ‘svngroup‘ was created to limit access to the parent directory.

If you ever need to create a second repository, you can create it in this same directory.

By now you should have received and verified at least some of the SSH public keys, so let’s reward these users with acces to our newly created repo.

An SSH public key looks roughly like this

ssh-rsa AAAAB3NzaC1...hkXm7 user@host

But then way longer. (That’s what the 3 dots mean: ‘and then some‘.)

To give a user normal SSH access, you would copy this key in it’s entirety to /home/svnuser/.ssh/authorized_keys. But since we want to limit the access to Subversion-only, we prepend a command.
This would be the line we add to /home/svnuser/.ssh/authorized_keys for our friend George:

command="/usr/bin/svnserve -t --tunnel-user=george -r /srv/subversion/repository",no-port-forwarding,no-agent-forwarding,no-X11-forwarding,no-pty ssh-rsa AAAAB3NzaC1...hkXm7 george@foobar

Once we have this in place, George can connect to the Subversion repository using the address ‘svn+ssh://‘ with username ‘svnuser‘. He will not need a server password because he has an SSH key (for which hopefully he does have a password). This SSH key will also tell the server that it’s actually George who is connecting, and George’s name will be added to the Subversion logs for the commits he makes. The name george does not need to exist as a user account at the server.

If George connects from a Linux/BSD/Mac, he could type

user$ svn help

on the command line to get going.
For brevity, he would add these lines to ~/.ssh/config:

Host svnserv
    User svnuser
    IdentityFile /home/george/.ssh/svn_rsa

With that, his Subversion commands would look like

user$ svn ls svn+ssh://svnserv/

If he prefers Windows, he could have a look at TortoiseSVN.

You now have a running and usable Subversion server, but what I’ve told here is not even 1% of what Subversion is capable of, so go read the book.


  • 2019-04-28
    Changed directory /service back to /srv to comply with the Filesystem Hierarchy Standard.
  • 2019-04-13
    Added ~/.ssh/config.
  • 2019-04-13
    Changed shell for user svnuser to /bin/bash; access to the repo is refused with /sbin/nologin.
  • 2019-04-13
    Changed directory /srv to /service for conformity with other blog posts.
  • 2019-03-31
    Initial publication.
Geplaatst in Nerd stuff | Reacties uitgeschakeld voor Subversion server

Pasta met kip-pesto saus – Vegetarisch

Een golden oldie: bij dit recept zie ik al vele jaren mensen hun lippen af likken en hun vingers opeten. Maar dan nu de vegetarische variant, omdat ik vandaag voor vegetariërs moest koken. Ik denk trouwens dat je ‘m heel makkelijk veganistisch kunt maken door een beetje op te letten welke pesto je koopt — in de potjes pesto die ik vandaag kocht zat schapenmelk — of je pesto zelf te maken.

Pak het originele recept erbij: Pasta met kip-pesto saus.
Vervang de volgende zaken:

  • kipfilet → vegetarische kipfiletreepjes
  • spek → vegetarische spekreepjes
  • kipbouillonblokjes → tuinkruiden-bouillonblokjes

Verder heb ik kookroom gebruikt op basis van soja in plaats van melk.
En ik heb een handje ongezouten, ongeroosterde cashewnoten toegevoegd, in de bouillon, voordat ik de room toevoegde.
De penne was trouwens biologisch en volkoren.

Zelf vind ik zaken als vegetarische kip en vegetarisch spek altijd een beetje flauw, en de vegetariërs aan tafel bleken het zelfs nog nooit geprobeerd te hebben, maar ze hebben me verzekerd dat ze lekker gegeten hebben. En dus verdient ook deze variant een plekje op mijn blog.

Geplaatst in Aan de kook | Getagged , , , | Één reactie

Mail server

After having depended on my friends for a few years, for web and email hosting, I recently acquired a private server again. In this HOWTO I will try and document the entire mail setup.
At the end of this article, I will have a mail server that does:

  • Postfix MTA (Mail Transfer Agent)
  • Dovecot IMAP (Internet Message Access Protocol)
  • Let’s Encrypt (SSL certificates)
  • Dovecot SASL (Simple Authentication and Security Layer)
  • mail accounts (partly) separated from system accounts
  • Dovecot LDA (Local Delivery Agent)
  • Sieve / ManageSieve
  • Greylisting
  • RBLs (Real-time Blackhole Lists)
  • Bogofilter (spam filter)
  • ClamAV (virus scanner)
  • SPF (Sender Policy Framework)
  • DKIM (DomainKeys Identified Mail)

Just so you know that there’s more to mail than just typing a text and hitting the Send button…

Currently my server only serves 1 user with 3 domains. But with the setup I describe here, it is extremely simple to upgrade that to many users running many domains.

This tutorial is not for the complete layman, but should be comprehensible for those who have played around with Linux and its services and command line a bit. I have tried to make it interesting and useful for both the beginning and the experienced sysadmin.

Corrections, clarifications, supplements and typos are welcomed at
Spam is not, as you will understand after reading this article.

Lees verder

Geplaatst in Nerd stuff | Reacties uitgeschakeld voor Mail server

Waarom natuurkunde cool is

Ik ben technicien. Dat is Frans voor ‘klusjesman’, of ‘huismeester’. Want ik ben het in Frankrijk. In een hotel. Maar dat doet er voor dit verhaal niet toe.

Ik had vanmiddag een lekkage. Een plas water van 5 meter lang, 2 en een halve meter breed, en een centimeter of 8 diep; dan heb je het toch over een liter of duizend. En geen afvoer. Ja, een verdieping lager, een steil trapje af.
Mijn chef dacht dat ik dat wel even met emmers zou wegwerken. Nou ben ik op zich helemaal niet vies van werken, maar wel net even te bijdehand om 1000 liter water emmertje voor emmertje een steil trapje af te gaan dragen. Neem bovendien van me aan dat er echt geen 10 liter water in een emmer gaat, als je het moet weg scheppen uit een laagje van 8 centimeter.

En dus deed ik het als volgt.
Ik nam een lange waterslang, waarvan ik het ene uiteinde in het water legde; ik legde er een tegel op, om te zorgen dat-ie goed onder water bleef. Het andere uiteinde hield ik op de kraan, en ik liet de kraan lopen; tot er geen belletjes meer uit het onderwater-uiteinde kwamen, en ik dus zeker wist dat er geen lucht meer in de slang zat, maar alleen water. Met mijn duim de slang dicht houdend ging ik vervolgens het steile trapje af, en ik hing de slang in de afvoer. En verder deed de natuur het werk voor me: dankzij de zwaartekracht van de aarde en het vacuüm in de slang, kon ik achteroverleunen terwijl natuurkrachten bijna 1000 liter water voor me weg pompten.
Er bleef een laagje van een paar millimeter over, want als er eenmaal lucht in de slang komt, is het vacuüm verbroken en werkt het niet meer. Maar ik heb er alle vertrouwen in dat dat morgen verdampt is.

Het leven is zó cool, als je een beetje snapt hoe de dingen werken.

Geplaatst in Nerd stuff | Reacties uitgeschakeld voor Waarom natuurkunde cool is

Rata à l’hobo

Ratatouille. Maar dan in de rubriek Hobo food, dus het moet goedkoop, snel, en met weinig gereedschap en gedoe. In het kort betekent dat dat we:

  • de aubergine achterwege laten, want die is te duur
  • het bouquet garni vervangen door Provençaalse kruiden, want dat is minder gedoe
  • gas uitsparen door het spul niet 3 kwartier te laten pruttelen om de tomaten tot saus te koken

Daar gaan we.

Nodig, voor 1 persoon:

  • een kleine courgette
  • een halve rode paprika
  • een halve groene paprika
  • een kleine ui (of een halve grote, natuurlijk)
  • een blikje tomatenpuree (zo’n kleintje)
  • Provençaalse kruiden
  • knoflook
  • zout
  • peper
  • olijfolie

Uiteraard kun je, in plaats van 2 kleuren paprika te nemen, ook gewoon voor 1 kleur kiezen. Maar ik wilde zo dicht mogelijk bij het oorspronkelijke recept blijven, en morgen verzin ik wel iets voor de andere 2 helften.

Je hebt voor dit gerecht een wok, koekenpan of sauspan met deksel nodig.

Was de courgette en de paprika, en snijd ze in blokjes. Snipper de ui.

Verwarm wat olie in de pan (niet te zuinig!), en bak hierin de groenten even aan op hoog vuur, onder constant omscheppen. Als de courgette en de ui een beetje glazig van kleur worden, schep je er naar smaak Provençaalse kruiden door (niet te zuinig!), doe je de deksel op de pan, en zet je het vuur laag. Schep af en toe om.

Als de groenten bijna gaar zijn — minuut of 10; beetje afhankelijk van de hoeveelheid en de grootte van de blokjes — schep je er de tomatenpuree doorheen, en voeg je knoflook (niet te zuinig!), peper en zout naar smaak toe. Als de prut in de pan erg droog is, kun je eventueel een klein beetje water (zuinig!) toevoegen.
Deksel terug op de pan, en samen nog even een paar minuten doorwarmen.

In de Provence, waar dit gerecht vandaan komt, eten ze ratatouille graag met gegrild vlees (barbecue!). Maar het gaat ook prima, zoals voor mij vanavond, met zilvervliesrijst; omdat vlees nou eenmaal niet iedere dag in het budget past.


Geplaatst in Hobo food | Getagged , , , | Reacties uitgeschakeld voor Rata à l’hobo

iPhone synchroniseren met Linux

Die titel is niet helemaal eerlijk: wat ik hieronder beschrijf, zou onder Windows net zo goed moeten werken. Maar omdat Windows-gebruikers ook via iTunes kunnen synchroniseren, en het dus vooral de Linux-gebruikers zullen zijn die deze info nodig hebben, staat ‘Linux’ in de titel, voor de zoekmachines.

Wat ik hieronder beschrijf, heb ik overigens niet zelf uitgevonden (behalve het synchroniseren van Herinneringen); ik heb alleen de informatie van verschillende websites samengevoegd en gestructureerd.

En uiteraard accepteer ik, zoals gewoonlijk, geen enkele verantwoordelijkheid voor wat jij doet met de informatie die je hier leest. Als jij met onderstaande aan de slag gaat zonder eerst een backup te maken, en je raakt zaken kwijt, dan is dat niet mijn probleem.

Goed, nu dat uit de weg is…

Ik heb een iPhone aangeschaft. En ik zou het wel handig vinden als ik wat gegevens zou kunnen synchroniseren tussen mijn telefoon en mijn laptop.
Het gaat daarbij dan vooral om de agenda(‘s), de contacten, en de herinneringen. Voor mijn mail gebruik ik IMAP, dus daar kan ik overal vandaan bij zonder te hoeven synchroniseren; mijn foto’s doe ik liever via de USB-kabel; en verder heb ik niets dat heen-en-weer zou moeten tussen tussen telefoon en pc.
Alles dat ik wil synchroniseren, kan ik op de laptop kwijt in Thunderbird, dus die keuze is snel gemaakt, want TB heb ik sowieso altijd open staan voor mijn mail.


iCloud is de backup-dienst van Apple; je hebt bij de aanschaf van je toestel ook een iCloud-abonnement gekregen. De instellingen voor dit abonnement vind je via InstellingenAccounts en wachtwoordeniCloud. Geef daar toestemming voor het synchroniseren van je contacten, agenda’s en herinneringen:

Log vervolgens in op de web-versie van iCloud om te verifiëren dat je daar nu inderdaad die gegevens terugvindt.

(Let op: als je bij iCloud over de 5GB gaat, moet je betalen; voor contacten en agenda is dat geen probleem, maar met je foto’s erbij, zit je daar snel aan.)

Als je een mobiel abonnement hebt met onbeperkt datagebruik, of je agenda, contacten en herinneringen zijn heel belangrijk voor je, zet dan ook mobiele data aan voor deze diensten, via InstellingenMobiel netwerk.


Apple staat niet toe dat je met je standaard iCloud wachtwoord je gegevens synchroniseert met Thunderbird; je moet hiervoor een apart wachtwoord aanmaken.

Log in op de Apple ID website; houd je telefoon bij de hand, want Apple gaat je een inlogcode sturen voor de 2Factor Authenticatie.
Onder het hoofdstuk Beveiliging vind je het kopje APP-SPECIFIEKE WACHTWOORDEN. Klik hier op Maak wachtwoord aan… en volg de aanwijzingen. Kopieer het gegenereerde wachtwoord naar een tekstbestandje dat je open laat staan.


Ga in het menu van Thunderbird naar ExtraAdd-ons, en vervolgens naar het tabblad Extensies. Rechts-bovenin, bij Alle add-ons doorzoeken, vul je in ‘CardBook‘ (en druk je op ‘Enter’). Installeer de CardBook add-on, en herstart Thunderbird.

Na de herstart selecteer je ExtraCardBook. Maak een nieuw adresboek aan; kies bij de lokatie ‘Op internet‘, en bij het type ‘Apple‘; bij Gebruikerscode vul je je Apple ID in, en bij Wachtwoord het wachtwoord dat je daarnet hebt gegenereerd en gekopieerd naar dat tekstbestandje dat nog open staat. Als je dan op Volgende klikt, worden je contacten vanuit iCloud gesynchroniseerd naar Thunderbird.

De overige instellingen van CardBook mag je zelf uitvogelen. (En het handmatig samenvoegen van de contacten in je iPhone/iCloud-adresboek, en die in Thunderbird, waar ongetwijfeld overlap tussen is, is trouwens ook een erg leuke klus…)


De stap die nu volgt is wat lastig. De agenda’s in iCloud zijn namelijk beschikbaar via het CalDAV-protocol, maar Apple publiceert de adressen niet; die moeten we dus zelf uitvogelen.
De basis van het adres is<gebruiker>/calendars/<agenda>. Zoals je ongetwijfeld al begrijpt, moeten we zelf de variabelen <gebruiker> en <agenda> zien te achterhalen.

Log in Firefox met je Apple ID in op; ga vervolgens naar de agenda. Druk op Ctrl-Shift-E om de netwerk-console te openen.
Selecteer nu één van de agenda’s aan de linkerkant van de pagina, en maak een test-evenement aan. In de netwerk-console komt dan allerlei verkeer voorbij. En bij dat verkeer ga je dan, in de Parameters-tab, op zoek naar de variabelen dsid en en guid. De eerste is numeriek en kom je vrij vaak tegen; dit is de gebruikers-id. Voor de tweede zul je wat meer moeten graven; de waarde kan een woord zijn (‘home‘, ‘work‘), of een lange string (‘1A2B3C4D-A1B2-C3D4-E5F6-6F5E4D3C2B1A‘); dit is de ID van de agenda.
Dit doe je voor alle agenda’s (de agenda-id verschilt per agenda, maar de gebruikers-id zou steeds hetzelfde moeten zijn). Noteer al deze IDs in het tekstbestandje dat nog open staat.

Ikzelf heb 3 agenda’s, en dus ook 3 URLs:


De kalender-extensie voor Thunderbird heet Lightning; installeer die (spiek hierboven als je vergeten bent hoe je add-ons installeert).

Als je Thunderbird herstart hebt, en de agenda geopend, zie je aan de linkerkant van het scherm dat er 1 agenda is, met de naam ‘Home‘. Rechtsklik daaronder, en selecteer Nieuwe agenda….
Geef in het eerste scherm aan dat de agenda op het netwerk staat. In het tweede scherm geef je aan dat het een CalDAV agenda betreft, en bij Locatie vul je één van de URLs in die je net gevonden hebt; als je Offlineondersteuning aanvinkt, kun je de agenda ook gebruiken als je niet verbonden bent met het internet.

Herhaal dit voor alle agenda’s.


Tja, en toen had ik al mijn agenda’s gesynchroniseerd, en toen dacht ik ‘Zou het niet mooi zijn als mijn Herinneringen (Reminders, die in andere agenda’s altijd Taken of Tasks heten) gewoon beschikbaar zouden zijn onder de URL /tasks?‘. En dat bleek ook het geval.

Maak dus tot slot nog een laatste agenda aan met de URL<gebruiker>/calendars/tasks. De Herinneringen uit je iPhone zullen dan in Lightning zichtbaar zijn als Taken, en vice versa.

Hoe dit werkt als je meerdere lijsten met Herinneringen hebt, weet ik niet, want ik heb alleen de ene standaardlijst.

Let op: taken/herinneringen zonder datum worden wel getoond in de Herinneringen-app op de iPhone, maar niet in de Herinneringen-widget! (Wat overigens niets te maken heeft met Thunderbird, maar alles met de widget, die alleen de herinneringen voor vandaag toont.)

Have fun!

Geplaatst in Nerd stuff | Één reactie

Dit weblog werd me een beetje teveel een verzamelbak voor links naar berichten op mijn andere blog. En aangezien ik niet denk dat er nog iemand is die dit blog leest, maar niet mijn andere blog weet te vinden, heb ik de categorie verwijderd.

Voor de zekerheid nog 1 keer een link:

Geplaatst in Algemeen | Reacties uitgeschakeld voor


Ooit, op 19 november 2011 om precies te zijn, schreef ik een paar zinnen op Wikipedia; aan de pagina Golden Delicious voegde ik toe:

Vroeger werd deze appel banaanappel genoemd, vanwege de vettige gele schil en de zoete smaak. Sommige fruitverkopers gebruiken deze naam nog steeds.

Om de een of andere reden, ik weet eigenlijk niet precies waarom, tikte ik vandaag banaanappel in in een zoekmachine. En wat ik dus wel grappig vind, is dat er verschillende websites zijn die mijn tekst letterlijk of vrijwel letterlijk hebben overgenomen.
Goed, ’t is nog niet die eigen Wikipedia-pagina waar ik zo van droom, maar het is een stapje in de goeie richting.

Overigens, voor wie dit leest, en die zinnen op zijn/haar website heeft gebruikt: het is wel echt waar. Mijn groente-/fruitboer in Escamp destijds had een bak appels met daarbij een bordje ‘Banaanappels‘, waarop ik zei ‘Voor mij zien ze er gewoon uit als Golden Delicious.‘. En hij heeft me toen uitgelegd hoe het zat. En omdat hij niet op mij overkwam als iemand die heel veel om Wikipedia gaf, heb ik het toen maar op Wikipedia gezet.

Dus eigenlijk zijn het niet eens mijn eigen woorden…


Ik ga verder zoeken naar mijn eigen 15 minuten roem…

Geplaatst in Aan de kook, Nerd stuff | Getagged , , | Reacties uitgeschakeld voor Banaanappel