How to setup a VPN server in a FreeNAS jail

This post is not about configuring FreeNAS to connect to a VPN, but about running a VPN server inside FreeNAS, so you will be able to access all your jails and every host on your local (home) network from the outside, using the secure VPN tunnel.

Using a VPN connection is like sending a mail envelope inside another one: the external envelope is addressed to your VPN endpoint (the server), and only the server can extract the internal envelope and process it (i.e., forward it to the specified address) as if it originated locally (thus you can access private addresses on your local network). Replies will be sent back on the tunnel by securely re-encapsulating them in an external envelope.

So, after you are connected to your VPN, you can for example

ssh root@

(or whatever addresses you are using) through the Internet.

Continue reading “How to setup a VPN server in a FreeNAS jail”

Building a new fanless and silent server and NAS

I wanted a low-power micro server to have a permanent personal point of presence online to support my own operations. Main usages range from hosting some Git repositories to sync my data on OwnCloud and run HTTP servers.

Using a single board PC (raspberry-pi style) was a bit limiting as I wanted to have ZFS running with at least a mirrored zpool (so I needed SATA connectors and at least 8 GB of RAM).

Another requirement was low power consumption: I don’t want to notice the effect of this thing on my power bill.

Last important requirement was silence: I will have to sleep in the same room as my server. So, I decided for a completely fanless design, which also (necessarily) conciliates the low power consumption.

Shopping list

With a budget in mind of < 400 Euro, this is what I bought:

Continue reading “Building a new fanless and silent server and NAS”

Adding a new split functionality to konsole (multi-terminals)

The existing “Split-View” functionality in Konsole certainly has its rationale (, but it is not the one I expect to use.

I am trying to implement a different split, which works similarly to the one found in Terminator.

A picture can explain it better than words:

Multi-Terminals in Konsole
Multi-Terminals in Konsole

The work-in-progress is at this “personal” konsole repository on gitHub, which I will keep aligned with the master, hoping that, once finished, it will be possible to integrate this implementation into the KDE repos.

Sogno il giorno in cui…

Sogno il giorno in cui la smettiamo di dire che l’Italia fa schifo.

Il giorno in cui la smettiamo di dire ai nostri amici tedeschi, inglesi e svedesi che viviamo in un paese che non funziona, che ci vergogniamo, che ci dissociamo. Come se non ci fosse più niente da fare, come se loro non avessero i loro problemi.

Vedo gente insultarsi: “Bravo! Bella figura! Siamo proprio un popolo di me**a”. Come se provvedendo subito a condannare il gesto del connazionale si potesse creare un distinguo: “Io lo so come funzionano le cose, non sono come lui (o loro)”. Come se fosse normale sentirsi sempre senza dignità.

Possiamo ricominciare dall’orgoglio?

DHCP failure on Android WiFi (stuck on obtaining IP address) – How I solved it

This evening my phone wouldn’t connect to my WiFi network anymore after a SIM change + reboot (maybe unrelated?).

Anyway, it seems that many people are affected by this issue, but it took me a while to find a workaround, because I found a lot of incomplete and fragmented information. I’ll try to put everything in this post so people with the same problem can hopefully spend less time to solve it.

My configuration: Sony Ericsson Live with Cyanogen mod 9 (Android 4.0.4).

Problem description

Wireless card will not connect to WiFi network when using DHCP (in my case the AP is a CISCO router flashed with DD-WRT and secured with WPA2). In the Android WiFi settings, you will see the connection status looping between the same states over and over (the most noticeable is “obtaining an IP address” as that string remains on the screen longer).

To investigate a bit on the cause of the issue, I had a look at the ERROR logs, that revealed the failure of DHCP:

E/DhcpStateMachine( 218): DHCP failed on wlan0: DHCP result was failed
E/WifiStateMachine( 218): IP configuration failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/DhcpStateMachine( 218): DHCP failed on wlan0: DHCP result was failed
E/WifiStateMachine( 218): IP configuration failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/DhcpStateMachine( 218): DHCP failed on wlan0: DHCP result was failed
E/WifiStateMachine( 218): IP configuration failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/DhcpStateMachine( 218): DHCP failed on wlan0: DHCP result was failed
E/WifiStateMachine( 218): IP configuration failed
E/LanLinkProvider( 471): Sending udp identity package failed
E/LanLinkProvider( 471): Sending udp identity package failed


What worked for me (and hopefully for someone else too), was to delete every files in


In my case, I had the following two files:

So, if you can access the adb shell, you can try the following (please, see which files you have there with “ls”, so you will correctly remove what you need):

$ adb shell
# cd /data/misc/dhcp
# rm

Or, if you cannot use the adb shell, try to remove those files with a file explorer directly from the device.

After this, I had to reboot before I could get my WiFi connection work properly with DHCP.

Credits go to this page:

Remember The Lens – Revamped

I want to start this post by thanking Pavel Shabardin as he created some new tickets on the GitHub page of Remember The Lens that caused new nice features to be brought to the project.

What’s new

  • Icons. I was willing to replace those ugly icons I made a while ago since a long time. I found some really nice ones on that gave the lens a new fresh look.
  • Preview. It is now possible to right-click on a task to get extra information.
  • Complete/Uncomplete tasks. On the preview screen, a button will appear to complete/uncomplete a task (depending on its current status). Very handy.
  • Show completed tasks. Because of that button above, it’s also good to show already completed tasks, so a “Complete” can be easily undone. A new “Show/Hide” section on the lens filters has a button for this.
  • Internationalization. The lens is now open to translations. I lost the Russian translation because I introduced new messages and changed existing ones. The Italian translation is of course there :).

Under the lens

Screenshots are more immediate than a video showing the lens at work (also, last time I wasn’t able to speak loud enough). Here are some.

Search and replace from command line

I usually do my find and replaces from within VIM or Eclipse (refactoring).

It may be useful to do it from the command line in case you don’t want to (or cannot) open your editor or if you need to work on a larger set of files (e.g.: scripts, meta-languages that Eclipse won’t refactor, etc).

The following command will recursively find all the *.cpp, *.h and *.c files starting from the current directory and change every occurrence of the pattern (in this case just a string) “createAndSet” with “init” (IMPORTANT: read the WARNING notice below before using the command):

find . -name *.c -o -name *.cpp -o -name *.h | xargs sed -i.bak 's/createAndSet/init/g'

The -i option tells sed to edit files in place and the optional parameter “.bak” tells sed to create backup files with a “.bak” suffix. By removing the “-i” option, sed will just output the result to stdout.


Use the command above judiciously, it may be disruptive and change your code in ways you do not expect.

Sed will replace every occurrence of a regular expression. If you want to change every occurrence of the string “int” to “long int” and you try to use the substitution “s/int/long int/g“, then every occurrence of a “printf” call will become “prlong intf”.

Test the regular expressions and observe their effect by calling sed in “dry run” mode, without the “-i” option (no in-place editing).

I cannot be responsible for any damage caused by the usage of the above command or a similar one :)!

Setting up a personal git repository: end-to-end tutorial

Recently I was in France with a colleague at an event organized by ETSI. In that occasion we needed to work on some code, but for some reasons we couldn’t use the company remote repositories.

Manually merging changes to a local copy we had was a time consuming and inefficient task, so I quickly set up a git repository on my machine that my colleague could access through the local network. Having a reference to do that operation in a short time may be very useful in situations similar to that one, but version tracking may be essential as well when working on personal projects or sketching code for new ideas. Setting up a git server is also a good idea to recycle some old hardware (I used to have an old notebook which worked as a printing server and git repository on my home network).

The following tutorial summarizes the steps required to setup a SSH server, use RSA keys, authorize users, and create a new git repository. This reference is first of all useful for me, but I hope that someone else will take advantage of this yet-another-git-setup-tutorial :).


There are many different ways of setting up a git repository. This tutorial shows a possible way for doing this quickly. Do not use this tutorial to set up a git repository in a production environment, where every configuration parameter (e.g.: for the SSH server) must be finely tuned and well understood.

Intended audience and assumptions

If you need to setup a git repository for personal use or for some reasons you don’t want to use a cloud service such as github, then this guide may help you. The steps here described will allow for the quick setup and use of a git repository on top of a fresh installation of an Ubuntu GNU/Linux distribution (I am using Ubuntu 12.10).

I assume that a git repository is created on the local machine inside the home folder of a new “git” user. In a more general configuration, where the git client and server are remote machines, you will just need to replace the loopback address with the one of the server.

Some basic knowledge of the Unix command line interface is required.

SSH Server configuration

The machine that will host the git repository needs to be accessed by clients. A possible way to access a machine remotely is through SSH.
SSH supports both password and public/private keys authentication. In this tutorial I will use RSA keys.

Install and configure an SSH server on the machine that will host the git repository:

sudo apt-get install openssh-server

Edit the /etc/ssh/sshd_config file to tweak the SSH server settings at your preference. I generally disable Password Authentication (you may need to uncomment the line) and Challenge Response Authentication:

# Change to yes to enable challenge-response passwords (beware issues with
# some PAM modules and threads)
ChallengeResponseAuthentication no
# Change to no to disable tunnelled clear text passwords
PasswordAuthentication no

Start or restart the ssh daemon to accept the new configuration:

sudo /etc/init.d/ssh restart

Authorized Keys configuration

The public keys of the authorized entities who can login through ssh must be collected in the authorized_keys file under the ~/.ssh folder.

Create a git user on the machine that will host the repository (handle this as you prefer, it is not required to create a new user, but much cleaner):

sudo adduser git

Login as the git user, if you are on the same machine, just use

su git

to change to git user, then cd to the home directory


Create a .ssh folder and set its permissions (see the ssh man (1) page for explanations on permissions of the .ssh folder and its content):

mkdir .ssh
chmod 700 .ssh

Create an authorized_keys file under the ~/.ssh folder and append to it the public keys of the authorized git users:

touch .ssh/authorized_keys

A possible way to populate the authorized_keys file, from a user on the same machine as the “git” user would be (appends the public key of the current user at the end of the authorized_keys file of the “git” user, command issued from the home directory):

sudo bash -c "cat .ssh/ >> ../git/.ssh/authorized_keys"

Set the proper permissions for the authorized_keys file:

chmod 600 .ssh/authorized_keys

Create a new git repository

Install git (if needed):

sudo apt-get install git

Initialize an empty git repository (I assume repositories are created in the home folder of the git user):

mkdir test_repo.git
cd test_repo.git
git init --bare

The server configuration is done.

Setup RSA keys on the client

The remaining part of the tutorial refers to operations to be done on the client who wants to access the git repository that we have prepared. In order to use the Secure SHell connection, the client needs a pair of public/private keys.

If you already have RSA keys, put them in ~/.ssh, otherwise you can create a new pair with:

ssh-keygen -t rsa -C "Comment Here (usually your email)"

Move the pair of generated keys (id_rsa and into ~/.ssh
See the FILES section of the SSH man (1) page to set the proper permission to the ~/.ssh folder and its content. In a typical configuration, you may want to use:

chmod 700 .ssh/
chmod 400 .ssh/id_rsa
chmod 400 .ssh/

Clone the git repository

Set the git user global configuration:

git config --global "Your Name"
git config --global

Create a new folder where you want to clone the repository, cd into that folder and initialize git:

mkdir foo
cd foo
git init

Configure the git client to access the test_repo.git repository (add the pointer to a remote called origin):

git remote add origin ssh://git@

Clone the repository (if someone has already committed some changes):

git clone ssh://git@

Create a new file and upload to the repository:

echo "Hello" > readme.txt
git add readme.txt
git commit -m "First commit"

Push the committed changes to the master branch:

git push origin master


Ubuntu 12.10 and Hybrid Graphics on Sony VAIO S

Today I made a fresh install of Ubuntu 12.10.

After having read this thread on phoronix forums about the latest release of the proprietary AMD drivers, I decided (once more) to use the vgaswitcheroo solution.

The vgaswitcheroo module can be used to power off the discrete graphic card and use only the integrated one from Intel. Personally, I don’t have any advantage in using the discrete graphic as the integrated one is enough to play HD video, the most GPU consuming task I ever need.

So I confirm that the solution described in this post still works on 12.10.

I edited the two files, rebooted the notebook… and then there was silence!