Since I’m using this to test the speed of my home network, I need two machines up and running Linux on my LAN. I’ll call the first machine Desktop and the second machine Laptop.

Start Netcat to Listen

I’m going to use a utility called netcat, or nc to listen on a particular network port on the Desktop machine. Enter the following command into a terminal on Desktop:

[term]nc -lk 2112 >/dev/null[/term]

This tells the Desktop machine to listen for network traffic on port 2112 and to keep listening. Any output is sent to /dev/null.

Linux network speed test: dd and netcat

Now that the first machine, Desktop, is set up to listen, I’ll use the second machine, Laptop, to send and receive data to test the network. The command below assumes that the IP address for Desktop is 192.168.2.2. Adjust the address accordingly for your network. From a terminal on Laptop, enter the following:

[term]dd if=/dev/zero bs=16000 count=625 | nc -v 192.168.2.2 2112[/term]

The first part of the command tells the machine to copy 10 megabytes of data from /dev/zero in 16 kilobyte blocks. The part after the pipe tells it to send that to the Desktop machine over port 2112.

You should see output similar to the screen shot below. In my case it showed that my wireless network is performing at 8.9 megabytes per second, or 71.2 megabits per second.

Once you’re done testing, go to the terminal on Desktop and use [Ctrl]+C to stop netcat.

So there you have it. A simple way to perform a Linux network speed test from the command line. You can adjust the count parameter to send smaller or larger amounts of data if you like.

Look for my review of the TRENDnet TPL-406E power line adapter in a future post.

This content originally appeared on Tux Tweaks at https://tuxtweaks.com/2014/11/linux-network-speed-test/. Copyright 2014

Netflix on Linux

Well, thankfully those steps are no longer required. The required version of Chrome has made it to the stable channel. Ubuntu has updated the nss libraries on currently supported versions. And finally, Netflix has updated their user agent filter to allow Linux users with the correct version of Chrome to use their instant streaming.

I’ve verified this to work on updated systems with Ubuntu 12.04, Ubuntu 14.04, and Linux Mint 17. I’ve also read that it is working on updated versions of Fedora and Arch Linux.

If you know of any other versions or distros that work, please leave a comment.

If you want to know your current user-agent string, click the button below to return the user-agent header sent by the browser to the server.

View User-Agent

Edit: 16-Sep-2014

It turns out that the Mark All Upgrades button was disappearing from the toolbar after a reboot, even though it remained on the Edit menu. We’ll have to use a portion of the old tutorial to prevent that.

Open a terminal window and enter the following:

[term]echo /usr/share/synaptic/gtkbuilder/window_main.ui | sudo tee -a /etc/linuxmint/adjustments/05-synaptic.preserve[/term]

This will create a file that prevents Linux Mint from over-writing the Synaptic menu.

End Edit

Downgrade Synaptic

Open the Synaptic Package Manager and search by name to find the synaptic package. At the time of this writing, it’s currently at version 0.81.2-4. Highlight synaptic and go to the menu to select Package -> Force Version… In the dialog pop-up, select the version from trusty-updates and then click Force Version.

This will tell Synaptic to downgrade the package. Click the Apply button to downgrade Synaptic. Immediately after applying the downgrade you may notice that the synaptic package is showing that there is an available upgrade. You don’t want this upgrade to happen, so make sure the synaptic package is highlighted, then go to the menu and click Package -> Lock Version.

Close the Synaptic Package Manager now and reopen it. You should now see that the Mark All Upgrades button has been restored.

Fixing apt-get and mintUpdate

If you only update your system using Synaptic, the instructions above will have you covered. But if you happen to use  apt-get, then it will override the settings in Synaptic and update the synaptic package to the one from the Mint repository as you can see in the following screen shots.

mintUpdate will also show the package, but it won’t actually upgrade it. It will be annoying though because the update indicator in the system tray will always show updates available.

You can fix this by setting a hold on the package with apt. Open a terminal window and enter the following command:

[term]sudo apt-mark hold synaptic[/term]

You can use any of the following 3 commands to verify the hold status.

[term]sudo apt-mark showhold

dpkg –get-selections synaptic

dpkg -l synaptic[/term]

Now you can upgrade with apt-get or mintUpdate without upgrading Synaptic.

So there you have it. You now have Mark All Upgrades in Synaptic and can now do full system updates of Linux Mint 17 Qiana using the Synaptic Package Manager.

Copyright 2014, TuxTweaks.com. Content originally appeared at https://tuxtweaks.com/2014/09/restore-mark-all-upgrades-in-synaptic-linux-mint-17

There have been many tutorials posted on how to get Netflix working on Linux. Personally I’ve had limited success using the Pipelight plugins. There’s good news for Linux users though. Recent development versions of the Chrome browser from Google include the required DRM code to allow HTML5 video streaming from Netflix. The goal of this tutorial is to provide easy instructions to get Netflix streaming working on Linux Mint 17, Ubuntu 14.04, and Ubuntu 12.04.

Install Chrome Beta

Update: The stable version of Chrome will now work for Netflix. You can download the install file from from here. You can then continue below with the User Agent String.

The first step of this process is to install either the beta version or the development version of Google Chrome. In my case, I’m using the beta version. Go to the Chrome Beta download page and click Download Chrome Beta. Select the correct package for  your architecture (32 bit or 64 bit). Click Accept and Install to accept the license agreement and download the installation file.

Click OK to open the file with GDebi.

Click Install Package and enter your password if prompted. After a few moments, the package will be installed.

Close the package installer. You should now be able to find a listing for Google Chrome (beta) on your menu.

Add the User Agent Switcher

Launch Chrome Beta, go to the web store and install the User-Agent Switcher extension. Click the +Free button to install the extension to Chrome.

You now need to set a custom user agent string for accessing Netflix. Right click the User-Agent Switcher icon in Chrome and select Options.

You’re going to create a new user agent string.

New User-agent name: Netflix
New User-Agent String: Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2114.2 Safari/537.36
Group: Chrome
Append?: Replace
Indicator flag: NFX

Install Required Packages

Update: The required packages have made it into the repositories for Ubuntu 12.04 and 14.04. There is no need to add the PPA show below. If you’ve already added the below PPA, you can remove it with:

[term]sudo add-apt-repository -r ppa:leonbo/nss
sudo apt-get update[/term]

Simply update your system packages and you should get the package updates you need.

You also need some upgraded packages from Ubuntu 14.10 in order to play protected content. The easiest way to install these is to add a PPA to your sources. Open a terminal and enter the following:

[term]sudo add-apt-repository ppa:leonbo/nss
sudo apt-get update
sudo apt-get install libnss3 libnss3-1d libnss3-nssdb[/term]

This should upgrade 3 packages: libnss3, libnss3-1d, and libnss3-nssdb.

You now have everything you should need to stream Netflix on Linux Mint 17, Ubuntu 14.04, or Ubuntu 12.04.

Streaming Netflix

If you haven’t already, shut down Chrome Beta and re-open it. Click the User-Agent Switcher icon and select Chrome -> Netflix as your user agent. Now go to Netflix and log in to your account. If everything went right, you can now use the instant streaming on Netflix. You may need to restart your system in order to get smooth streaming.

Setting the Default User Agent for Netflix

You may also want to add a setting in User-Agent Switcher so that your custom user agent is always used when you go to Netflix. Right click on the User-Agent Switcher icon and select Options. On the left side of the screen, select Permanent Spoof list. Under Domain enter netflix.com and select Netflix under User-Agent String, then click on Add. Your custom user agent will now be used any time you go to Netflix.

Your success with streaming may vary based on the power of your computer, the speed of your Internet connection, and your chosen quality settings for your Netflix account. I have nice, smooth streaming on my desktop computer with an Intel Core i5 processor. Streaming is a little more sketchy on my netbook with an Intel Atom processor. Streaming definitely works better using the lowest quality setting from Netflix, but obviously the picture isn’t the greatest. It’s still not up to par with streaming on Windows using Microsoft’s Silverlight, but it’s a major step in the right direction for streaming on Linux.

How does this technique work for you? Let me know in the comments.

This tutorial originally appeared on Tux Tweaks at https://tuxtweaks.com/2014/08/netflix-linux-mint-17-ubuntu-14-04/. Copyright 2014.

bash getopts

I started out just trying to figure out how to process command line switches in my scripts. Eventually, I added some other useful functionality that makes this a good starting template for any interactive script. I’ve also included a help function with text formatting to make it a little easier to read.

Rather than go into a lengthy explanation of how getopts works in bash, I think it’s simpler to just show some working code in a script.

[term]

#!/bin/bash

######################################################################
#This is an example of using getopts in Bash. It also contains some
#other bits of code I find useful.
#Author: Linerd
#Website: https://tuxtweaks.com/
#Copyright 2014
#License: Creative Commons Attribution-ShareAlike 4.0
#http://creativecommons.org/licenses/by-sa/4.0/legalcode
######################################################################

#Set Script Name variable
SCRIPT=`basename ${BASH_SOURCE[0]}`

#Initialize variables to default values.
OPT_A=A
OPT_B=B
OPT_C=C
OPT_D=D

#Set fonts for Help.
NORM=`tput sgr0`
BOLD=`tput bold`
REV=`tput smso`

#Help function
function HELP {
  echo -e \\n"Help documentation for ${BOLD}${SCRIPT}.${NORM}"\\n
  echo -e "${REV}Basic usage:${NORM} ${BOLD}$SCRIPT file.ext${NORM}"\\n
  echo "Command line switches are optional. The following switches are recognized."
  echo "${REV}-a${NORM}  --Sets the value for option ${BOLD}a${NORM}. Default is ${BOLD}A${NORM}."
  echo "${REV}-b${NORM}  --Sets the value for option ${BOLD}b${NORM}. Default is ${BOLD}B${NORM}."
  echo "${REV}-c${NORM}  --Sets the value for option ${BOLD}c${NORM}. Default is ${BOLD}C${NORM}."
  echo "${REV}-d${NORM}  --Sets the value for option ${BOLD}d${NORM}. Default is ${BOLD}D${NORM}."
  echo -e "${REV}-h${NORM}  --Displays this help message. No further functions are performed."\\n
  echo -e "Example: ${BOLD}$SCRIPT -a foo -b man -c chu -d bar file.ext${NORM}"\\n
  exit 1
}

#Check the number of arguments. If none are passed, print help and exit.
NUMARGS=$#
echo -e \\n"Number of arguments: $NUMARGS"
if [ $NUMARGS -eq 0 ]; then
  HELP
fi

### Start getopts code ###

#Parse command line flags
#If an option should be followed by an argument, it should be followed by a ":".
#Notice there is no ":" after "h". The leading ":" suppresses error messages from
#getopts. This is required to get my unrecognized option code to work.

while getopts :a:b:c:d:h FLAG; do
  case $FLAG in
    a)  #set option "a"
      OPT_A=$OPTARG
      echo "-a used: $OPTARG"
      echo "OPT_A = $OPT_A"
      ;;
    b)  #set option "b"
      OPT_B=$OPTARG
      echo "-b used: $OPTARG"
      echo "OPT_B = $OPT_B"
      ;;
    c)  #set option "c"
      OPT_C=$OPTARG
      echo "-c used: $OPTARG"
      echo "OPT_C = $OPT_C"
      ;;
    d)  #set option "d"
      OPT_D=$OPTARG
      echo "-d used: $OPTARG"
      echo "OPT_D = $OPT_D"
      ;;
    h)  #show help
      HELP
      ;;
    \?) #unrecognized option - show help
      echo -e \\n"Option -${BOLD}$OPTARG${NORM} not allowed."
      HELP
      #If you just want to display a simple error message instead of the full
      #help, remove the 2 lines above and uncomment the 2 lines below.
      #echo -e "Use ${BOLD}$SCRIPT -h${NORM} to see the help documentation."\\n
      #exit 2
      ;;
  esac
done

shift $((OPTIND-1))  #This tells getopts to move on to the next argument.

### End getopts code ###


### Main loop to process files ###

#This is where your main file processing will take place. This example is just
#printing the files and extensions to the terminal. You should place any other
#file processing tasks within the while-do loop.

while [ $# -ne 0 ]; do
  FILE=$1
  TEMPFILE=`basename $FILE`
  #TEMPFILE="${FILE##*/}"  #This is another way to get the base file name.
  FILE_BASE=`echo "${TEMPFILE%.*}"`  #file without extension
  FILE_EXT="${TEMPFILE##*.}"  #file extension


  echo -e \\n"Input file is: $FILE"
  echo "File withouth extension is: $FILE_BASE"
  echo -e "File extension is: $FILE_EXT"\\n
  shift  #Move on to next input file.
done

### End main loop ###

exit 0

[/term]

Paste the above text into a text editor and then save it somewhere in your executable path. I chose to call the script options and I saved it under /home/linerd/bin. Once you save it, make sure to make it executable.

[term]chmod +x ~/bin/options[/term]

Now you can run the script. Try running it with the -h switch to show the help information.

[term]options -h[/term]

Now try running it with an unsupported option.

[term]options -z[/term]

Finally, getopts can handle your command line options in any order. The only rule is that the file or files you are processing have to come after all of the option switches.

[term]options -d bar -c chu -b man -a foo example1.txt example2.txt[/term]

So you can see from these examples how you can set variables in your scripts with command line options. There’s more  going on than just getopts in this script, but I think these are valuable additions that make this a good starting template for new scripts. If you’d like to learn more about bash getopts, you can find the documentation buried deep within the bash man page in the “Builtins” section. You can also find info in the Bash Reference Manual.

What Next?

So what will you use getopts for? Let me know in the comments.

Copyright TuxTweaks.com. This content originally appeared at https://tuxtweaks.com/2014/05/bash-getopts/

What you’ll need

You’ll need a few things before you get started. I’ll be using an installation of Linux Mint 13 to create the Live USB in this tutorial, so it will be easiest to follow along if you’re running Linux Mint, Ubuntu, or something similar. While it should be possible to do this from Windows since both UNetbootin and GParted have Windows versions available, I’ll only be covering how to do this from Linux. You could use a standard Linux Mint Live CD or USB as your build system if you want.

Second, you’ll need the ISO image of Linux Mint. UNetbootin should be able to download it for you, but I prefer to just download it separately ahead of time. I’ll be using the 32 bit version of Linux Mint 16, MATE Edition for mine, but other versions should work just as well.

Download Linux Mint 16 ISO – torrent links:

• Linux Mint 16 Cinnamon 32 Bit
• Linux Mint 16 Cinnamon 64 Bit
• Linux Mint 16 MATE 32 Bit
• Linux Mint 16 MATE 64 Bit
• Linux Mint 16 KDE 32 Bit
• Linux Mint 16 KDE 64 Bit
• Linux Mint 16 Xfce 32 Bit
• Linux Mint 16 Xfce 64 Bit

Third, you’ll need to have UNetbootin installed on your Linux system. You should be able to find it in your distro’s repositories. If you’re running Linux Mint or Ubuntu, you should be able to install it with:

[term]sudo apt-get install unetbootin[/term]

Or, just click: install UNetbootin

And finally, you’ll need a USB flash drive or SD card that’s at least 2 GB in size. The larger your USB stick is, the more room you’ll have for persistent storage.

Preparing the flash drive

Now that we have everything we need, it’s time to get started.

The first task is to create a couple of partitions on the flash drive.

WARNING: This process will erase all the data on your flash drive. Make sure any files you need are backed up.

To avoid confusion, you may want to unplug any other USB drives from your system. Now plug in the flash drive you want to use for your persistent USB stick and open up GParted. If GParted is not already installed on your system, open up a terminal window and install it with:
[term]sudo apt-get install gparted[/term]

Select your USB drive from the device drop-down in the upper right corner.

If there are any existing partitions on your drive, right click on them and select Unmount, then right click again and select Delete Partition. Your drive should now be shown with only unallocated space.

Next, right click on the unpartitioned space and select New. Set the size of the new partition to 1500 MiB, set the File system to fat32 and click Add.

The next step is to create the persistent partition. Right click on the remaining unallocated space and select New. This time choose ext2 as the file system type and set the Label to casper-rw, then click Add.

Now you need to apply the changes to the flash drive. Go to Edit->Apply All Operations.

As long as you’re sure you picked the correct drive, click Apply at the warning pop-up.

The final task in GParted is to set the boot flag on your boot partition. Right click on the first partition and select Manage Flags. Mark the box next to boot and then click Close.

GParted Complete

Write the ISO with UNetbootin

Open UNetbootin and select the radio button for Diskimage. Click the “…” button and navigate to Linux Mint ISO that you downloaded previously. Make sure that USB Drive is selected and that first partition of your USB drive is listed as the drive. If you’re unsure of your drive letter assignments, use the lsblk command in a terminal to check them.

Next, enter 100 in the field labelled “Space used to preserve files across reboots (Ubuntu only):“.

When you have the UNetbootin window looking like the image below, click OK to start writing the image to your USB drive.

When UNetbootin is done writing the image, DO NOT click the Reboot Now button. Hit Exit instead because we have one more change to make to the USB drive.

Open the boot partition of your Linux Mint Persistent Live USB drive in your file manager. Select the casper-rw file and delete it.

Delete casper-rw

Congratulations! You now have a Linux Mint Persistent Live USB drive. You can now reboot your computer to boot into your USB drive and give it a try.

Here’s a picture of my Linux Mint Persistent Live USB running on my netbook.

Linux Mint Persistent Live USB

You can now use your bootable USB to install Linux Mint on another system, edit documents, browse the internet, or whatever you want.

Credit: This post by usbtux on the Linux Mint forums provided the basics of this tutorial.

This content was authored by Linerd and originally appeared on Tux Tweaks at https://tuxtweaks.com/2014/03/create-linux-mint-persistent-live-usb/

When Handbrake Doesn’t Work

Not only did Handbrake have trouble, but DragonPlayer couldn’t play the DVD and VLC crashed every time I tried to use it. I finally had my first glimmer of success with the Xine media player. With Xine I was able to open the DVD menu and launch the main feature. Using the navigation controls I clicked on the angle button and Xine momentarily showed the title number on the status line. In this case it showed that the main title was number 31 on the DVD.

Checking the DVD in Handbrake again showed that title 31 was not among the available selections. So at this point I needed a way to first rip the desired title from the disk.

Mplayer to the rescue

Once I knew that title 31 was the main movie on the DVD, I was able to play it in Mplayer with:
[term]mplayer dvd://31[/term]

Rip the DVD With Mplayer

Now to rip the DVD. Mplayer is able to do this task for you if it can play the DVD. The following command will rip title 31 to an uncompressed MPEG file.
[term]mplayer -dumpstream dvd://31 -nocache -noidx -dumpfile Movie.mpg[/term]

In this case I used the -noidx switch because I got a broken index on my MPEG rip without it. This completely removes the index from the file. Handbrake won’t know how much time is left in the encoding process, but it will create a good MP4 when it’s all said and done. You may not need this switch in your case.

 Re-encode with Handbrake

Now that you have an MPEG rip of the movie, you can re-encode it to a nice MP4 file with Handbrake.

In this particular case, the uncompressed MPEG was 5.9 GB in size. After re-encoding with Handbrake it was 1.3 GB.

So there you have it. When Handbrake doesn’t work on its own you can use Mplayer to rip the video first and then re-encode that file to MP4 with Handbrake or the tool of your preference.

screenFetch is a bash script. It will automatically detect your Linux distribution and will display the logo as ASCII art in a terminal window. Optionally, it can also take a screenshot of your Linux desktop with the aforementioned terminal window displayed.

screeenFetch on Ubuntu

Install screenFetch Dependencies

In order to detect your Linux Distribution and some of your other system information, the lsb-release package needs to be installed on your system. Most likely, you already have this installed, but it doesn’t hurt to request the install again. You also need a program called scrot installed to support the screenshot function. You should be able to find these packages in you distribution’s repositories. On Ubuntu, Linux Mint, and other Debian/Ubuntu based distros, you can install them with the following command.

[term]sudo apt-get install lsb-release scrot[/term]

Install screenFetch in Linux

Now that we have the dependencies installed, we can install screenFetch. Unfortunately, it’s not in the distro repositories for Ubuntu, Mint, or Debian, so we’ll have to download it from the project’s Git repository. First I’ll create a temporary directory for the download.

[term]mkdir ~/screenfetch
cd ~/screenfetch[/term]

Now we can download the latest package. As of this writing, the latest version is v3.2.2.

[term]wget -O screenfetch ‘https://raw.github.com/KittyKatt/screenFetch/master/screenfetch-dev'[/term]

Now, make the file executable with:

[term]chmod +x screenfetch[/term]

You can execute it from here if you want with:

[term]./screenfetch[/term]

However, I think it’s better to have it installed somewhere where it will be available system wide. I think /usr/local/bin is a good location. So let’s copy it over to there.

[term]sudo cp screenfetch /usr/local/bin[/term]

Now, assuming /usr/local/bin is in your $PATH, you should be able to run screenfetch from anywhere.

Taking a Screenshot with screenFetch

It wouldn’t make any sense to call the program screenFetch if you couldn’t use it to take a screenshot of your system. You can call the program with the -s switch to do just that.

[term]screenfetch -s[/term]

Here’s a screenshot I made on my netbook with Linux Mint 13.

screenFetch on Linux Mint 13

screenFetch Options

So there you have it. You now know how to install screenFetch and use it on Linux. If you want to see the other options, run screenFetch with the -h switch.

[term]screenfetch -h[/term]

Here’s the output on my system.
[term]

Usage:
  screenFetch [OPTIONAL FLAGS]

screenFetch - a CLI Bash script to show system/theme info in screenshots.

Supported Distributions:      Arch Linux (Old and Current Logos), Linux Mint,
                  LMDE, Ubuntu, Crunchbang, Debian, Raspian, Gentoo, Fedora, SolusOS,
                  Mandrake/Mandriva, Slackware, Frugalware, openSUSE, Mageia,
                  Peppermint, ParabolaGNU, Viperr, LinuxDeepin, Chakra, and FreeBSD, OpenBSD
Supported Desktop Managers:   KDE, GNOME, XFCE, and LXDE, and Not Present
Supported Window Managers:    PekWM, OpenBox, FluxBox, BlackBox, Xfwm4,
                  Metacity, StumpWM, KWin, IceWM, FVWM,
                  DWM, Awesome, XMonad, Musca, i3, WindowMaker,
                  Ratpoison, wmii, WMFS, ScrotWM, SpectrWM,
                  subtle, Emerald, E17 and Beryl.

Options:
   -v                 Verbose output.
   -o 'OPTIONS'       Allows for setting script variables on the
              command line. Must be in the following format...
              'OPTION1="OPTIONARG1";OPTION2="OPTIONARG2"'
   -n                 Do not display ASCII distribution logo.
   -N                 Strip all color from output.
   -t                 Truncate output based on terminal width (Experimental!).
   -s(m)              Using this flag tells the script that you want it
              to take a screenshot. Use the -m flag if you would like
              to move it to a new location afterwards.
   -c string          You may change the outputted colors with -c. The format is
                      as follows: [0-9][0-9],[0-9][0-9]. The first argument controls the
                      ASCII logo colors and the label colors. The second argument
                      controls the colors of the information found. One argument may be
                      used without the other.
   -S 'COMMAND'       Here you can specify a custom screenshot command for
              the script to execute. Surrounding quotes are required.
   -D 'DISTRO'        Here you can specify your distribution for the script
              to use. Surrounding quotes are required.
   -A 'DISTRO'        Here you can specify the distribution art that you want
              displayed. This is for when you want your distro
                      detected but want to display a different logo.
   -E                 Suppress output of errors.
   -V                 Display current script version.
   -h                 Display this help.

[/term]

So there you have it. Go ahead and upload your screenshot to a file or photo sharing site and post a link to it in the comments.

The Linux watch Command

The watch command in Linux provides a way to handle repetitive tasks. By default watch will repeat the command that follows it every two seconds. As you can imagine, watch is a great tool to keep an eye on log files. Here’s an example.

[term]watch tail /var/log/syslog[/term]

In order to stop the command execution, just use the standard kill sequence, [Ctrl]+C.

Using the Linux watch command to monitor the syslog

You can change the time interval by issuing the -n switch and specifying the interval in seconds. To check the log file every 10 seconds, try this.

[term]watch -n 10 tail /var/log/syslog[/term]

The Linux watch Command with a Pipe

The watch command isn’t limited to viewing log files. It can be used to repeat any command you give it. If you have your system set up to monitor the CPU temperature, you can use watch to view that with the sensors command.

[term]watch -n 1 sensors[/term]

The output on my netbook looks like this:

[term]

acpitz-virtual-0
Adapter: Virtual device
temp1:        +45.0°C  (crit = +100.0°C)

[/term]

I’d like to filter this output to only show the temperature output without all of the rest.

I can use this command to view it one time.

[term]sensors | grep temp | awk ‘{ print $2 }'[/term]

Keep in mind that the watch command will repeat the first command that is sees. Care must be taken when pipelining one command to the next. This can be managed by placing your command pipeline inside quotes.

[term]watch -n1 “sensors | grep temp | awk ‘{ print /$2 }'”[/term]

Using the Linux watch command with a pipe

Use watch as a clock

As you’ve probably noticed by now, the watch command shows the time that the command was executed in the upper right corner of the terminal window. We can use watch as a simple clock by passing an empty command line argument. We can just enclose a space in quotes to act as the empty command.

[term]watch -n 1 ” “[/term]

So you can see, this gives another meaning for the command name, watch. You can use it just like your wrist watch.

So now you know how to use the Linux watch command. What repetitive tasks will you use it to handle?

Install encfs

If you are using Ubuntu or one of its derivatives like Linux Mint, you should be able to find encfs in your software repositories. In this case you can install it with

[term]sudo apt-get install encfs[/term]

Create an Encrypted Folder with encfs

Once encfs is installed on your system, you can create an encrypted folder in your home directory. In this example, I’m going to create an encrypted folder called tuxtweaks. This will be done from a terminal window. You will need to provide full path names when creating a new folder. You can use standard shortcuts though, as I will show.

[term]encfs ~/.tuxtweaks ~/tuxtweaks[/term]

This will create two folders. The first one, .tuxtweaks, will contain the encrypted information. The second one, tuxtweaks, is where the decrypted version will be mounted when you want to access your information. If neither of these folders exist already, you will be prompted asking if you want to create them. Enter ‘y‘ at the prompts to allow the folders to be created. You should then see something like the following:

[term]

Creating new encrypted volume.
Please choose from one of the following options:
 enter "x" for expert configuration mode,
 enter "p" for pre-configured paranoia mode,
 anything else, or an empty line will select standard mode.

[/term]

If you want the strongest encryption, enter ‘p‘ at the prompt. Otherwise, just hit [Enter] and your new encrypted folder will be created with the standard options.

After that you’ll see several messages listing the parameters of your new encrypted volume along with some warnings, and then a prompt to create a password for encryption. Make sure to use a password you will remember because there is no password recovery mechanism. After entering and verifying your password, the new folder will be created and mounted, ready to use.

Using Your Encrypted Folder

With your new encrypted folder mounted, you can use it just like any other folder on your system with the exception that hard links will not work if you set it up in paranoia mode. I expect this won’t be an issue for most users. Let’s go ahead and create a simple text file in the new folder to test it out.

[term]echo “GNU/Linux is my favorite computer operating system.” >~/tuxtweaks/test.txt[/term]

Using the terminal or the file manager, you can see that you now have a new file called test.txt in the tuxtweaks folder. Upon opening this file you can see that it is a perfectly readable text file. Now navigate to your ~/.tuxtweaks folder. This is the encrypted version of your folder. You can see that the file names don’t match and if you try to view the contents of the files you’ll find that they are scrambled.

Unmounting an encfs Encrypted Folder

Once you are done accessing or creating data in your encrypted folder, it’s best to unmount it so that your information is safely hidden away. encfs doesn’t have its own command to do this. Since it created a user file system it takes advantage of the FUSE packages to handle unmounting. We’ll use the fusermount command to unmount our encrypted folder.

[term]fusermount -u ~/tuxtweaks[/term]

Navigating your home directory you can see that the tuxtweaks directory is still there. If you enter that folder though you’ll find that it is empty.

Mount an Encrypted Folder with encfs

The next time you want to access your encrypted data, you’ll need to mount it again to decrypt it. You can just use the same command you used to create the folder in the first place.

[term]encfs ~/.tuxtweaks ~/tuxtweaks[/term]

Uses

I find that using encfs encrypted folders is a handy way to securely store financial information such as tax returns as well as for storing lists of log-in credentials. This way I only need to remember the password for my encrypted folder, then I can access my list of other log-in ID’s and passwords.

What will you use encfs for? Let me know in the comments.