I’d like to standardize the color palette of vobsub subtitles of all video files in my collection. Further, I’d like to have consistent colors between mplayer and vlc.

Solution

First, mplayer cannot play colored vobsub subtitles. This immediately narrows down our color palette to white text with a black outline/shadow.

A typical vobsub file pair would consist of an index file (subtitle.idx) and the vobsub file (subtitle.sub). The index file is a plain text file with a preamble section and a list of time stamps and matching subtitles indicating when the subtitles should be shown. It’s the preamble section we are interested in.

A typical preamble section might look like this:

# VobSub index file, v7 (do not modify this line!)
size: 720x480
# The original palette of the DVD
palette: 000000, 828282, 828282, 828282, 828282, 828282, 828282, ffffff, 828282, bababa, 828282, 828282, 828282, 828282, 828282, 828282
# Custom colors (transp idxs and the four colors)
custom colors: OFF, tridx: 1000, colors: 000000, bababa, 828282, 000000

The original DVD color palette is of no use to us. We can throw those lines out. The way to control the color of the subtitles on-screen is through the custom colors. Now, our preamble looks like this:

# VobSub index file, v7 (do not modify this line!)
size: 720x480
custom colors: OFF, tridx: 1000, colors: 000000, bababa, 828282, 000000

First, set the custom colors to ON to activate this line. There are four colors that you can prescribe for a vobsub subtitle stream. The first is the background color of the subtitle. The second is the color of the subtitle text. The third and fourth represent the inner, thick outline/shadow and outer, thin outline/shadow around the subtitle font respectively.

The tridx parameter allows one to set one of more of these fields to be transparent. Typically, the background to the subtitle font is set to be fully transparent(1). The rest are opaque(0). This is then followed by a set of four rgb colors for each of the aspects of the subtitle mentioned earlier. I’ve chosen to go with this:

custom colors: ON, tridx: 1000, colors: 000000, ffffff, 000000, 000000

In the above example, the background and outlines are set to be black (000000). The font color is set to be white (ffffff). The background is set to be fully transparent, but the font and its outlines are set to be opaque (tridx: 1000). This produces clear, legible subtitles that follow the same color scheme regardless of whether the file is played in mplayer or vlc.

Now, merge this back into the matroska file or select this file as the subtitle while playing your video file. Enjoy your nice looking subtitles!

Matroska files are a great format to build a video collection in. One of the most interesting aspects of the format is the ease of adding, removing, extracting or replacing streams (video, audio, subtitle) in the file. An example would be if you found a better subtitle file for one of the movies and would like it to replace the current one in the file. So, it’d be useful to be able to split a file into its individual tracks and reconstitute it back.

Solution

Use mkvinfo, mkvextract and mkvmerge. All are part of the mkvtoolnix package.

Identification

For this example, I have a matroska file called test.mkv. It consists of a video stream encoded using x264 at 29.97 fps. It contains one Japanese audio track and one english subtitle track in the vobsub format. I have recently come across a new subtitle track in the srt format that I’d like to use instead of the original subtitles.

Although I already know the make up of my mkv file, I’ll pretend I don’t. I’ll start by identifying the tracks in the matroska file.

MKVFILE=test.mkv
mkvinfo $MKVFILE | grep Track

Your output will look similar to this:

| + Track number: 1
| + Track UID: 631176983
| + Track type: video
| + Track number: 2
| + Track UID: 1164692611
| + Track type: audio
| + Track number: 3
| + Track UID: 1596684428
| + Track type: subtitles

This shows the makeup of the matroska file. It contains three tracks. The first is the video track, the second is the audio track and the third is the subtitle track.

Extraction

The tracks can be extracted one at a time or all at once. While extracting the video track, be sure to note down the the fps (frames per second) and the display dimension (which can be different from the actual dimensions of the video stream). To get the fps, use mkvinfo:

mkvinfo $MKVFILE | grep duration

This might produce an output similar to this:

| + Default duration: 33.367ms (29.970 fps for a video track)
| + Default duration: 32.000ms (31.250 fps for a video track)

Since the video track is the first track, the fps value to note is 29.970. Similarly, to get the display dimensions,

mkvinfo $MKVFILE | grep Display

And this might yield something like this:

| + Display width: 835
| + Display height: 480

Now, extract the tracks. I’ll extract all three tracks at once and dump them in appropriately named files:

mkvextract tracks $MKVFILE 1:video.264 2:audio.ac3 3:subtitle

This will create a raw video stream (video.264), a raw audio stream (audio.ac3) and a subtitle set with an index file (subtitle.idx) and a vobsub file (subtitle.sub). The subtitle files are useless to me.

Reconstruction

Now, I’ll reconstruct the video and audio streams along with my new subtitle file called newsubs.srt. To reconstitute this set back together, use the mkvmerge command like this:

TITLE="My Title"
AUDIOLANGUAGE=jpn
SUBLANGUAGE=eng
OUTFILE=output.mkv
mkvmerge --title "$TITLE" -o $OUTFILE --default-duration 0:29.970fps --display-dimensions 0:835x480 video.264 --language 0:$AUDIOLANGUAGE audio.ac3 --language 0:$SUBLANGUAGE newsubs.srt

The fps value can also be given in terms of fractions (29.970 = 30000/1001). Note that you need to specify a three-letter code to designate the language of the audio and subtitle stream. These language codes can be easily got from the mkvmerge command like this:

mkvmerge --list-languages

You can pipe this to a grep command to search for the language code for the specific language you’re using. For instance,

mkvmerge --list-languages | grep "Japanese"

GUI alternative

As an alternative to all this CLI work, you could just launch the mkvinfo and mkvmerge GUI programs and drag and drop the streams to create the new file. You’d then fill in the fps and display dimensions in the appropriate text fields and pick the languages from the drop-down menus. I feel that GUIs tend to slow you down, so I prefer the CLI route.

This article refers to deprecated methods/software. It’s presented here for archival purposes only.

While much of this article is deprecated now, I’m starting to believe that this is in fact, quite impossible. I can’t seem to automatically switch wireless networks without restarting the net-auto-wireless daemon. The only time this works as it should is when the computer is freshly booted up. Being a linux user, reboots are rather rare for me. That makes net-auto-wireless perfectly useless to me.

Problem Background

I need to seamlessly connect to the wireless networks at two (or more) locations. I have the essid and passkey along with authentication type. As an additional constraint, I need it to connect without me needing to log in. This is a requirement because I often just need to transfer some files from one computer to another. All my machines have an ssh server running and I’d like to be able to just turn it on and connect to it.

Solution

This is expected behavior from your wireless setup and is actually fairly simple to do. It didn’t come straightforward to me. The solution requires you to install the following packages:

• wireless_tools (tools like iwlist, iwconfig etc. Handy while troubleshooting)
• drivers for your wireless card
• netcfg (to manage your wireless networks)
• wpa_supplicant (for WPA secured networks)
• wpa_actiond (for enabling roaming)

For each of the networks that you need to connect to, go to /etc/network.d/ and copy over the example file wireless-wpa-configsection and rename it as you see fit. Use one file per network and enter your network information in these files. Since these files now contain password information, it will be a good idea to restrict access privileges to these files. Use chmod to accomplish this:

# chmod 600 <files>

Now, enter these file names in /etc/rc.conf in the NETWORKS array, separating each name with a space. I called my files Home and School:

...
NETWORKS=(Home School)
...

Now, scroll up and state your wireless interface. Mine’s eth1.

...
WIRELESS_INTERFACE="eth1"
...

Finally, just add net-auto-wireless to the list of daemons to start.

DAEMONS=(... net-auto-wireless ...)

That’s all. Now, when you reboot, the net-auto-wireless daemon will automatically take care of your wireless networks. You can stay connected as long as any of the networks is within reach.

Bonus

If you have a ethernet port and would like to have that activate if you plug in an ethernet connector (again, standard expected behavior), you’ll need to install the ifplugd package. Then, declare your WIRED_INTERFACE and add the net-auto-wired daemon to the list of daemons in /etc/rc.conf:

...
WIRED_INTERFACE="eth0"
...

...
DAEMONS=(... net-auto-wired ...)
...

This should take care of your wired connection as well.

I have all my files stored in my music directory in this structure:
Artist/Album/Song.mp3

I need them to be normalized by embedding replay gain values into their ID3 tags. The replay gain values tell the music player to increase or decrease the loudness of a song. The net effect is that all the songs in the collection sound about the same volume. So, I don’t need to fiddle with my system volume setting when a loud song comes up next.

Solution

I can locate all the mp3 files using the find command. To apply normalization, I’ll use the mp3gain package.

find

First, I switch to the Music directory to limit my searches to my music collection only. I’ll use find to give me a list of the album directories. I’ll use this list in a script later.

cd Music/
find . -mindepth 2 -type d -execdir /path/to/applyreplaygain.sh {} \;

• -mindepth 2 looks two levels deep into the directory structure.
• -type d finds directories.
• -execdir executes the following command from the directory containing the album directory (instead of from the top level directory).
• {} is a stand in for the name of the album directory.

At first, I tried using the following command:

find . -mindepth 2 -type d -execdir mp3gain -p -a -k -s i -o {}/*.mp3 \;

But, it didn’t work because it wouldn’t let me use the * wild card to match all mp3 files in that directory. Further, it would cause havoc every time it encountered a directory name with spaces in it. So, I decided to wrap the mp3gain command in a script.

mp3gain

Using mp3gain is relatively simple. The command, with the options I want is as follows:

mp3gain -p -a -k -s i -o *.mp3

• -p preserves the original time stamp of the file.
• -a applies album gain so that all songs in an album sound relatively the same with respect to each other. The album on average sounds the same as the rest of the collection.
• -k prevents clipping by lowering the gain value.
• -s i writes the tags to the file in the form of ID3v2 tags.
• -o shows the output in a tab delimited list

Wrapping this in a simple script, called applyreplaygain.sh, I get

#!/bin/bash
mp3gain -p -a -k -s i -o "$1"/*.mp3

The quotes around the first argument ($1) protect spaces in the name of the directory.

Results

Now, to put it all together,

cd Music/
find . -mindepth 2 -type d -execdir /path/to/applyreplaygain.sh {} \;

This will trawl through each album directory and normalize all the mp3 files found within. Each album is treated as a separate unit and the replay gain values will keep the relative loudness of the album intact. The procedure will take several hours to complete (depending on the size of your collection).

Almost all music players respect replay gain and therefore, this will be instantaneously noticeable once the tags are written — I’ve noticed the loudness change in mid-play if the song is being played on any of the phonon-based music players in KDE (Dragon Player, Amarok, etc).

Since no changes have been made to the music file itself, it’s technically possible to undo all this. mp3gain provides the -s d option to delete the embedded normalization tags. I’ve not seen it work too well, though. So, I would suggesting using kid3 to manually delete the volume normalization tags from the mp3 files. It’s not an automated solution and will take time to delete the tags manually from every file in your collection. However, I don’t see why you would want to undo this in the first place!

It’s easy to delete all files in a directory:

$ rm *

However, making exceptions to this command is a little tricky. Suppose I have a LaTeX file (report.tex) in a directory and have a accompanying shell script (createreport.sh) that processes this file to produce a pdf (report.pdf) and/or dvi (report.dvi) file. The LaTeX compilers often produce lots of extra files (log, aux, etc.) that I want to delete. A typical example for createreport.sh would probably look like this:

#!/bin/bash
latex report || exit 1
pdflatex report
rm -f *.{aux,log,out}

The last line of the above script would delete all the auxiliary files created by LaTeX. However, this requires that I know before hand what I want to delete. it would be great if I could tell rm to delete all files, except the files I want to retain.

Solution

Use rm like so:

shopt -s extglob
rm -f !(*.+(tex|sh|pdf|dvi))

This is an example of nesting two extended globs. The explanation is found about a thousand lines into the bash manpage:

If the extglob shell option is enabled using the shopt builtin, several extended pattern matching operators are recognized.
In the following description, a pattern-list is a list of one or more patterns separated by a |. Composite patterns may be formed using one or more of the following sub-patterns:

?(pattern-list)
Matches zero or one occurrence of the given patterns

*(pattern-list)
Matches zero or more occurrences of the given patterns

+(pattern-list)
Matches one or more occurrences of the given patterns

@(pattern-list)
Matches one of the given patterns

!(pattern-list)
Matches anything except one of the given patterns

In my example, the first line enables the use of extended globs. Then, I used the +() glob to present a list of valid extensions and used a !() glob around that to exempt such files from deletion. So, rm will delete all files except .tex, .sh, .pdf or .dvi.

Tips

Since rm is a dangerous command to use, you can test out the test with ls or echo like this:

$ shopt -s extglob
$ ls !(*.+(tex|sh))
$ echo !(*.+(pdf|dvi))

This should print out the names of all files that are not .tex, .sh for the first example and not .pdf or .dvi files for the second example.

You can concoct similar negating tests for your needs:

Match files that don’t have a .xyz extension
!(*.xyz)

Match files that don’t begin with abc
!(abc*)

Match all files that don’t start with a, b, c, d or e
!([a-e]*)

Match all files that don’t start with a or b and don’t end with c or d
!(+(a|b)*+(c|d))

Here’s a good explanation of extended globs for further reading.

• Merge two or more PDF files together
• Extract a portion of a PDF file
• Modify metadata in a PDF file

These three basic operations enable a user to manipulate a PDF file at the page level. A command line approach is preferable as it allows scripting.

The solution is to use ghostscript and other basic utilities.

Merging PDF files

INPUT=part*.pdf
OUTPUT=final.pdf
gs -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile=$OUTPUT $INPUT

The option -dBATCH tells ghostscript to exit after the last file has been processed. -dNOPAUSE prevents it from pausing after each page.

Other options of interest include -q to suppress output messages and -dPDFSETTINGS=/prepress to include higher quality (300 dpi, rather than the default 72 dpi) images.

Extracting a section from a PDF file

INPUT=bigfile.pdf
OUTPUT=partofbigfile.pdf
FIRSTPAGE=1
LASTPAGE=5
gs -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile=$OUTPUT -dFirstPage=$FIRSTPAGE -dLastPage=$LASTPAGE $INPUT

Modify metadata in a PDF file

There are two categories of metadata included in a PDF file. The first includes fields such as Title, Author, Subject and Keywords. The second is the file outline, consisting of a table of contents pointing to various pages in the file

All of this can be specified in a plain text file and passed as part of the input to ghostscript. A simple example of adding such metadata is shown below.

% This is an simple pdfmark file adding metadata and Chapter outlines to a PDF file
% Comments are preceded with a % sign.

% Metadata

[ /Title (The Title of the PDF file) /Author (Karthik Periagaram) /Subject (PDF metadata) /Keywords (PDF, metadata) /DOCINFO pdfmark

% Outline

% A simple bookmark

[ /Page 1 /Title (Title Page) /OUT pdfmark

% A set of nested bookmarks

[ /Count 2 /Title (Nested List) /OUT pdfmark
[ /Page 2 /Title (Part 1) /OUT pdfmark
[ /Page 3 /Title (Part 2) /OUT pdfmark

% This final line makes the PDF open with the Outline view shown

[ /PageMode /UseOutlines /DOCVIEW pdfmark

It is customary to save this in a file called pdfmarks. Pass it along with the input files to gs like this:

gs -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile=final.pdf input.pdf pdfmarks

Tips

While scripting, you may come across the need to find the number of pages in a PDF file. The best option for that is to use pdfinfo. This requires the xpdf package. The output consists of various properties pertaining to the PDF file, including its number of pages.

$ pdfinfo file.pdf | grep Pages
Pages: 3

You can use awk or cut as part of your script to do the rest.

Most people will not encounter any issues with the login screen. However, if you do set out to customize it and run into trouble, you can use the following procedure to reset kdm to “factory default” condition.

At some point, I downgraded from an unstable beta release to the older, stable release of KDE. Rather unsurprisingly, the downgrade didn’t go smooth. One of the things that broke was the login screen. I understand this happened because the kdmrc file was referencing the new greeter screen, which no longer existed after the downgrade.

Ideally, the way to fix this would be to fire up System Settings and head to the login theme control module and set things right. For whatever reason, it didn’t work for me. So, I had to manually edit the kdmrcfile, found at /usr/share/config/kdm/kdmrc. It is a very convoluted file and I don’t recommend trying to edit it by hand. I tried deleting it, but turned out it doesn’t get automatically regenerated — I was shown a very basic fallback login screen instead.

The command that saved the day is genkdmconf. This command regenerates the contents of the /usr/share/config/kdm directory. Navigate to the location of your kdm configuration files (locate kdmrc should do it) and issue the following command as root in that folder:

# genkdmconf --no-old

The –no-old option tells genkdmconf to not bother reading the old config files and start fresh. Now, you should have a brand new set of configuration dialogs. The old versions of the configuration files will be saved with a .bak extension. It’s entirely safe to delete them when you’re done.

# rm *.bak

Now, you can restart X and enjoy your fresh new login screen.

Before we begin, I need to mention that much of this applies to X-based GUI’s. I have not yet found an easy or simple way (or need) to type in special characters in the console, that is, when X is not running. A partial solution is offered to vim users – you can press Ctrl+V, type u, followed by the hexadecimal code of the unicode character (say, 00e0) and voilà! Similar solutions exist for emacs users, too, I’m sure. As you’ll see, it’s more elegant in X.

I also want to point out that this is not a good replacement for keyboard layouts. If you find yourself typing in another languages for longer than a few characters at a time, you really should look into using multiple keyboard layouts.

Problem Background

I often found the need to use accented characters, such as é, Å or Greek characters such α, Φ etc., but lacked the means to type it easily and quickly. I found several kludgy, but somewhat usable ways to get around this:

• Use a character-picker, an app that will let you choose special characters from a table.
• Use an office app and copy the special character from there.
• Use krunner. Typing a # followed by the hexadecimal character code will let you select and paste a special character. #00e0, for instance will let you pick à.
• Use a keyboard layout that supports the accented characters and switch back to your default one after typing the character in.

Such solutions are not elegant and lack customizability. So, I looked to AltGr and Compose keys for a better solution. These are two techniques to enter special characters in X. Since neither AltGr, not Compose are found ubiquitously on keyboards anymore, it’s up to the user to designate keys you don’t use to assume their behavior. AltGr works a bit like the shift key, entering special characters when pressed along with other keys. However, the AltGr key combinations do not exist for Greek characters. Further, the AltGr behavior is really just a subset of what the Compose key is capable of.

Pressing the Compose key tells the computer that the next few keys are part of a sequence. The computer will search through a pre-defined list of sequences and when it finds a match, it will display the corresponding special character. Till then, no characters will be displayed on the screen. If no sequences match, it’ll drop out of compose mode at the next character.

Designating and Enabling the Compose Key

In what follows, we’ll set up a Compose key and customize compose key sequences to suit our needs. To know which keys can be designated as the compose key, pull up the following file: /usr/share/X11/xkb/rules/xorg.lst. Scroll down to the Compose key section and pick an option that works for you. I picked compose:caps, but I understand that compose:rwin and compose:menu are popular choices as well.

Now, we need to set this as an option for our X server. What I describe will work for xorg-server 1.8 and up (or any set up that doesn’t use hal for input hot-plugging — if you use hal, you probably need to enter this in an fdi file). You also need to have root privileges to edit system files. In the keyboard section of /etc/X11/xorg.conf, or in the appropriate .conf file in /etc/X11/xorg.conf.d/, add the XkbOptions line. If you use multiple options, separate them using commas.

Section "InputClass"
  Identifier "Keyboard"
  MatchIsKeyboard "yes"
  ...
  Option "XkbOptions" "...,compose:caps,..."
  ...
EndSection

Now, restart X to have your designated Compose key active.

If you don’t have root privileges, you could still designate a Compose key using the keyboard settings control module in your DE. And you shouldn’t even require to restart X to enable it! However, this is still less preferable as it will only work in your login and is tied to your choice of DE.

If you are curious to explore available compose key sequences, check out the so-called Compose file: /usr/share/X11/locale/en_US.UTF-8/Compose.

My locale in en_US.UTF-8, but replace it by your locale if it’s different (use locale | grep “LANG” to find your locale). This is a huge, 5000+ line text file listing enough key combinations to type in multiple languages. If you balk at reading such a huge file, trial-and-error is often a good way to find key sequences as most of them are quite logical (e.g., multi-key + t + m = ™).

Editing the Compose file

I felt that the default Compose file could use a cleanup for two reasons. First, as I’ve stated earlier, I don’t see the Compose file as a replacement for switching keyboard layouts. The default compose file spends far too much time setting up various European and Asian language characters. Second, while most shortcuts are well thought out, it’s a bit overwhelming and badly organized. Similar keyboard shortcuts are not found together (much like the Unicode character blocks, unfortunately).

Hence, I decided to cut down the number of key sequences to just the characters that I can see myself using and bring some organization to the list. As you can see, the syntax is quite easy to understand:

<Multi_key> [KEY SEQUENCE] : "[SYMBOL]" [UNICODE HEX OR OPTIONAL NAME OF SYMBOL] # [OPTIONAL COMMENT, USUALLY THE UNICODE DESCRIPTION]

For instance, to use ‘ + a to type á, the line will look like this:

<Multi_key> <apostrophe> <a> : "á" U00E1 # LATIN SMALL LETTER A WITH ACUTE

Compose key sequences are case-sensitive. So you can define another sequence to use ‘ + A to get Á. Further, apart from alphabets and numbers, all other keys are referred to by their description: asciitilde (~), grave (`), apostrophe (‘), asciicircum (^), exclaim (!), asterisk (*), leftparens (() etc. Read the original Compose file for more such names.

While defining your own sequences, be careful not to overload sequences or define two sequences in a way that you can’t get to the second one. The computer will enter the first matching sequence, so if you define two sequences like this;

<Multi_key> <minus> <minus> : "–" U2013 # EN DASH
<Multi_key> <minus> <minus> <minus> : "—" U2014 # EM DASH

you will never be able to enter the EM DASH as by the time you hit the second minus, you’ll drop out of Compose mode with an EN DASH. Incidentally, the default Compose file solves the above problem by using the following sequences:

<Multi_key> <minus> <minus> <period> : "–" U2013 # EN DASH
<Multi_key> <minus> <minus> <minus> : "—" U2014 # EM DASH

I set out to organize my Compose file into two broad sections with subsections as follows:

• Part A: Punctuation
1. Accented Capital Latin Characters
2. Accented Small Latin Characters
3. Punctuation Marks
4. Currency
5. Emoticons, Miscellaneous
• Part B: Mathematics
1. Capital Greek Characters
2. Small Greek Characters
3. Operators
4. Fractions
5. Superscripts
6. Subscripts

Most of the compose key sequences in my file are the same as the original, but I invented some for new characters not in the original file. For instance, compose sequences for Greek letters start with a g, while some mathematical symbols sequences start with an m:

<Multi_key> <g> <a> : "α" U03B1 # GREEK SMALL LETTER ALPHA
<Multi_key> <g> <b> : "β" U03B2 # GREEK SMALL LETTER BETA
<Multi_key> <g> <g> : "γ" U03B3 # GREEK SMALL LETTER GAMMA
...
<Multi_key> <m> <d> : "∂" U2202 # PARTIAL DIFFERENTIAL
<Multi_key> <m> <I> : "∫" U222B # INTEGRAL
<Multi_key> <m> <i> : "∞" U221E # INFINITY

In other places, I changed the default sequences to type characters that were more important to my usage. For instance, in the original Compose file, < + < produces the left guillemet («). I find that the much less-than character (≪) is much more useful. So, I defined it like so:

<Multi_key> <less> <less> : "≪" U226A # MUCH LESS-THAN

Finally, in the emoticons and miscellaneous section, I added some whimsical characters that struck my fancy: ☢ (r + a), ☣ (b + h), ☯ (y + y), ಠ (l + o + d)… while retaining some equally interesting characters from the original Compose file: ☭ (C + C + C + P), ♥ (< + 3), ☺ (: + )) …

The new Compose file took a day to put together and came in at 250 lines and packed a lot more useful characters for me.

I could save my Compose file as ~/.XCompose and have it active just for myself after I log in, or I could replace the original file so that it is active for all users and available as soon as X starts — although I don’t recommend using Unicode characters in usernames or passwords… it can make console-based recovery options virtually impossible.

My compose file is now hosted on a git repository and from time to time, I make edits to it. You can find it here.

Feel free to edit and hence or otherwise, customize the compose key sequences I put together!

I want to connect to my work computer from home, to the primary X session and continue working remotely. My work computer is the vnc server. My home computer (the client) is to use a vnc viewer such as krdc (KDE Remote Desktop Client) to allow me to control the remote machine. An added layer of complexity arises from the firewall that I need to tunnel through to reach my machine at work.

Solution

Server side, I’ll use x11vnc to accomplish this. This is because x11vnc allows me to connect to the primary X session — I need this since I might already have applications running at work and would like to continue where I left off. If this is not a concern, you can use tightvnc or other vnc servers, but you will need to start a separate X session to connect to.

As an aside, for working with GUI programs, vnc works out better than ssh with X11 forwarding. This is because if the connection gets dropped, an application forwarded through ssh will terminate, sometimes uncleanly, leading to potential data loss or corruption. vnc, on the other hand, leaves the application running on the server and you have the possibility of resuming after you reconnect. Further, if the application was already running on the server to start with, ssh forwarding doesn’t really help.

Tunneling all vnc communication through an ssh tunnel, though optional, is highly recommended.

1. Install the x11vnc package on the server.

# pacman -S x11vnc

2. Set up a vnc password for authentication.

This step is optional, but recommended as without a password, anyone can connect to the vnc server. The following command will store a vnc password in ~/.vnc/passwd.

$ x11vnc -storepasswd

3. Open the first of two tunnels.

The first tunnel is for ssh. The following command will open a tunnel from local port 2222 (or any other port of your choice) to remote port 22.

$ ssh -fNL 2222:REMOTE:22 USERNAME@GATEWAY

4. Connect to the remote server and start the x11vnc server.

$ ssh -p 2222 localhost
REMOTE $ x11vnc -create -usepw -noxdamage

The -create flag for x11vnc will scan for X sessions you’re logged into and connect to it if it finds one. If you’re not logged in, or if someone else is logged in at the remote machine, it will create a new session for you. This new session cannot be viewed by someone at the remote server console.

The -usepw flag tells the server to use an authentication password. The first place this looks for a stored password is in ~/.vnc/passwd.

The -noxdamage flag is a performance option that worked well for me.

When starting the x11vnc server, make a note of the port number the x11vnc server is listening on. Usually, this will be port 5900.

5. Open the second tunnel to the port vnc is listening on

$ ssh -fNL 5959:REMOTE:5900 USERNAME@GATEWAY

Replace 5900 with the appropriate port number, if necessary.

6. Start a vncviewer locally and connect to the remote x11vnc server.

When you’re done, terminate the x11vnc server on the remote machine. If you logout, the server automatically terminates.

Problems

• If you connect to a locked X session, it remains visible remotely. Other than leaving your monitor turned off, I haven’t come up with a better solution for this. If the remote machine is either at the login screen or if someone else is already logged in, the new session is invisible to the remote user.
• Performance is wickedly slow, especially when compared to protocols like rdp (remote desktop from Windows). This seems to be the best vnc is capable of. I’ve heard good things about freeNX and will play with it when I get the time. If you have any suggestions about improving the performance of vnc, do let me know!

I have two computers at home side by side and would like to share a keyboard and a mouse between them. It would be a great help to share the clipboard as well as it would let me move bits of text really quickly between the two computers (select on one and paste in the other).

As an example, let’s say the ‘server’ computer has a physical keyboard and mouse. It is located to the right of the ‘client’ computer. The server’s keyboard and mouse needs to be used on the client.

Solution

The package I’ll use is called synergy. Since synergy sends unencrypted information back and forth, I’ll need to route it through an ssh tunnel so that no one can snoop on my key strokes and clipboard contents. Here’s how to implement this.

1. Install synergy on both computers.

Arch linux has synergy in its ‘extra’ repository.

# pacman -S synergy

The # prompt indicates that the command requires root privileges. Similarly, a $ prompt indicates that a command does not require root privileges.

2. Edit the /etc/synergy.conf file on both machines.

This file specifies the physical layout of the screens to synergy. This way, The mouse will smoothly transition from one computer to another when it encounters the correct screen edge.

The contents of synergy.conf should look like this on both machines: (Replace SERVER and CLIENT by the correct IP addresses/hostnames)

section: screens
  SERVER:
  CLIENT:
end

section: links
  SERVER:
    left=CLIENT
  CLIENT:
    right=SERVER
end

section: aliases
end

These files can also be saved in one’s home directory as ~/.synergy.conf

3. On the server, start the synergy server.

$ synergys

4. On the client, open an ssh tunnel to the server.

Note that this is an optional, but strongly recommended step.

$ ssh -fNL 24800:SERVER:24800 USERNAME@SERVER

5. On the client again, start the synergy client.

$ synergyc localhost

If there’s no ssh tunnel running, replace ‘localhost’ in the above command by SERVER.

Now, I have a working setup with two computers sharing the same mouse and keyboard! The keyboard strokes are sent to the computer whose screen the mouse cursor is on.

Problems

• If a corner or edge of the screen is shared between the two computers, kwin effects cannot be designated to those corners or edges.
• I’ve sometimes seen the mouse jump to the center of the client screen when transitioning past the edge of the server screen.