Archive for July, 2012

Another pi pun

Monday, July 30th, 2012

Continued from here

First page here.

6.  Creating a user

Now you are starting to get to know your Pi, you’ll want to start making it feel more like home.  Unless your name is “Pi” you will want to add yourself as a user.  Type this:

adduser naich

Do I really need to explain that you should replace “naich” with your name?  If you’ve already guessed that and typed it in with your name, you will probably be slightly worried at this point because it will have replied “adduser: Only root may add a user or group to the system.”

“Root” is the name of the account that has full access to the Linux system.  There are many things that only Root can do, and it’s just as well really; one of the things that only root can do is permanently delete the entire filesystem with one command that doesn’t even bring up an “Are you sure?” type question.  As an ordinary user, you can only screw up your own stuff that you put on there, but as root you are a god that can break everything for everyone forever.  This is why we try to avoid being root as much as possible.  Luckily the root password does not actually exist, so you can never log on as root!  Problem solved, except that sometimes we do want to be able to do rooty stuff, like add users.  There is a way to temporarily become root and that way is sudo.  You might remember typing it in earlier.  Sudo executes a command with root privileges and you simply add “sudo” in front of the command you want to run like this: sudo adduser naich:

naich@raspberrypi ~ $ sudo adduser naich
Adding user `naich' ...
Adding new group `naich' (1000) ...
Adding new user `naich' (1000) with group `naich' ...
Creating home directory `/home/naich' ...
Copying files from `/etc/skel' ...
Enter new UNIX password:

Choose a good password for your username but one you will remember.  Write it down if you have to.  Fill in the rest of the details or leave them blank if you want.  You also need to add your new user to the list of people who can use sudo, so type sudo visudo and you should see this:

# This file MUST be edited with the 'visudo' command as root.
# Please consider adding local content in /etc/sudoers.d/ instead of
# directly modifying this file.
# See the man page for details on how to write a sudoers file.
Defaults        env_reset
Defaults        mail_badpass
Defaults        secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:$
... and so on ...

“visudo” is the command that allows you to modify the list, “sudo” means you are temporarily granted root’s super powers in order to do so.  What visudo actually does is load a text file into an editor called “nano”.  Once nano has loaded the sudoers list, move the cursor down to where it says


and change “pi” to your new username.  This means “pi” will no longer be able to sudo, but that doesn’t matter because we are going to delete him soon anyway.  To save the changes and exit nano, press CTRL-X.  If you want to exit without saving your changes press N at the prompt, otherwise press Y and then hit return to save it with the suggested name.  You’ll be using nano a bit, as most configuration is done with plain text files.

Once you have got back to the “pi@raspberrypi:~$” prompt, type exit to log out and log back in again as you.

6.1 A Windows diversion

Windows users: this is the part where we sort out the static IP stuff.  Linux users can skip this bit and go to section 6.2.

You now need to edit two files – the /etc/network/interfaces file that you couldn’t edit earlier, and the /boot/cmdline.txt file to take out the stuff you put in earlier.  Type sudo nano /etc/network/interfaces and use the text editor (in the same manner as you did to edit the sudoers file) to edit the file as described in section 3 (click to open in a new window/tab).  Save it with CTRL-X, [Y]es, Enter and then type sudo nano /boot/cmdline.txt and remove all the text after “rootwait” that you put in earlier.  Make sure the text is still all on one line and that there is still a newline at the end of the line.  Save the file.  Your Pi is now properly configured with a static IP.

6.2 Back to our scheduled programming

Now let’s kill off “pi”.  If you add users with the command “adduser”, you might think you delete them with “deluser”, right?  Nope, it’s userdel.  No idea why.  As a general rule, if you don’t know what command to use, a good place to start is Google – “linux delete user”, returns 205 million pages telling you how to do it.  Anyway, have a go at deleting pi.  I’m not going to tell you how to do it.  See if you can guess.

Done it?  It was sudo userdel pi, by the way.  Do you like the way it didn’t ask if you really wanted to do that?  Linux assumes you know what you are doing and doesn’t treat you like an idiot by asking you if you really want to do something.  Successful operations for simple things (like copying, moving and deleting files, for example), generally won’t produce any output unless you tell them to.

If you don’t know how to navigate the Linux filesystem, now is the time to check out Appendix B and learn all about it.  Got it?  Go to the home directory – cd /home  and have a look – ls :

naich@raspberrypi ~ $ cd /home
naich@raspberrypi /home $ ls
naich  pi
naich@raspberrypi /home $

As well as your new user’s directory, there is also one called “pi”.  Although you deleted the user pi you didn’t delete his stuff.  You don’t need or want it, so get rid of it.  Type sudo rm -r pi (“rm is short for “remove”),… and it’s gone.  As before, there are no prompts, no “are you sure?”s; it’s gone forever.  If this doesn’t make you a little uneasy, then you might not have grasped how devastating a mistake could be and will probably discover this the hard way at some point!

Before you go any further, please consider expanding your knowledge about commands  a bit by reading appendix C.  You don’t have to but it might help you understand what’s going on a bit more.  See if you can find out what the “-r” does when you types sudo rm -r pi earlier.

Continued here…


Tuesday, July 17th, 2012

These are appendixes from the set of posts about setting up and using a Raspberry Pi.

Appendix A: Selecting an IP Address

As part of the boot process, your Pi used DHCP to get an IP address from the router. The problem with this is that it is an automated process which is invisible to you unless you log onto your router’s admin page to discover it.  If only the Pi and your router know what its IP address is, you don’t know where to log on to your Pi.  The easiest thing to do is change the IP settings on the Pi’s card to a static address, assigned by you.  That way you know what it is and you know it won’t change.  You don’t need to let the router know which address you have chosen, as the magic IPixies in the Pi sprinkle the router with their Ipixie Dust to let it know automatically.  Well, they do for all I know; I’ve no idea how the router finds out, but it does.

You need to pick an address for your Pi – something like, but you want to pick one that is not in the range of addresses your router assigns for DHCP requests.  If the address you choose is within the router’s DHCP address range there is a possibility that you will end up with two devices using the same address.

I’m going to leave it to you to find out what range of addresses your router assigns for DHCP and which ones are suitable for static IP addresses.  The settings will be available somewhere in your router’s admin pages.  If fiddling around with your router is out of the question, as a quick bodge you could try finding the IP address of your PC in order to guess a safe non-DHCP range address for your Pi.  Copy the first 3 sets of numbers of your PC’s address and change the last number to a low one if it’s not low or a high one (maximum 254) if it is low.  e.g.

  • Your PC’s IP is so you pick for your Pi
  • Your PC’s IP is so you pick for your Pi

You also need to know the gateway (the router’s IP address on the LAN) and subnet mask (which will probably be – it usually is for home networks).

Go back

Appendix B: The Linux Filesystem

Here’s a quick and dirty note about the way the Linux filesystem is arranged.  For a better description try this or this.

You might be used to Windows, with its lame C: drives, D: drives, random assignation of drive letters for plug-in devices, and its pathetic attempts to hide this lameness with My Documents, libraries and other rubbish.  Linux has one hierarchical tree of files, with everything hanging off the root “/” directory.  There are no drive letters or special places; everything – programs, user data, log files, temporary files and even devices, is placed on the same directory tree.  There is a convention as to where different types of file are stored, but let’s have a little wander around and see for ourselves.

Take a look at the command prompt – “naich@raspberrypi ~ $”  It contains 4 pieces of information; your name and the name of the computer you are on (with an “@” between them), the working directory (~) and the effective user ID ($).  The “$” changes to a “#” if you are currently root – that’s all that does, but it is important to know if your powers are currently elevated to those of the godly root.  The working directory is where you currently are in the directory tree, i.e. it is the directory that a command will take action in if you don’t actually specify which directory you want the command to do its stuff in.  Get it?  No?  An example will demonstrate better than that convoluted jumble of words; type ls:

naich@raspberrypi: ~ $ ls
naich@raspberrypi: ~ $

See anything?  Nope.  ls means list all the files in a directory.  As you did not specify a directory it lists the files in the working directory, which is “~”, and is currently empty.  If you tell it to list files in a different directory it will use that one instead of the working one; type ls /:

naich@raspberrypi ~ $ ls /
bin   dev  home  lost+found  mnt  proc  run   selinux  sys  usr
boot  etc  lib   media       opt  root  sbin  srv      tmp  var
naich@raspberrypi ~ $

These are all the files and directories in the root directory “/”.  Try ls /bin – see what is happening there?  You are listing all the files in the “/bin” directory.  This rule also goes for file names.  If you want to access a file but only write a file name, the command or program will look for that file in the working directory.  If you include the directory that the file is in, it will look there instead. This goes for any type of file – data, programs or devices.  Think of your terminal window as psychically sitting on a branch of the directory tree, with everything you type in acting on that branch unless you explicitly specify otherwise.  The location of that branch is the working directory.

Handy hint – Stuff shooting off the top your screen before you can read it?  Add “ | more” to the end of your command, (e.g. ls /bin | more) to show one page of output at a time.  Scroll to the next page with the space bar or press “Q” to quit.  This works with all commands.  Don’t try to understand how it works for the moment, just consider it magic.

You can move your terminal around the directory tree with the cd (change directory) command.  Type cd / to move your working directory to the root directory and type ls again.  Now your working directory is “/”, it lists the files there when you don’t explicitly say otherwise.  Try moving to “/bin” and looking at the files there.  Try moving to other places and have a good old poke around.  Even with a basic install there are tens of thousands of files on your Pi, so there’s plenty to look at.  When you are done, move back to your home directory by simply typing cd ~.

As well as looking at the the prompt, another way to find out the working directory is to type pwd:

naich@raspberrypi ~ $ pwd
naich@raspberrypi ~ $

Eh?  I thought we were in “~”?  Well, we are.  “~” means “my home directory”, which is “/home/your_username”.  Your home directory is where you put all your stuff and is probably the only directory you can write to.  If you are going to start drawing Windows analogies, it is a bit like “My Documents”.  The “~” provides a reference to where all your stuff is, so using “~/README.txt” refers to README.txt which resides in your home directory, rather than any other README.txt which might be in whatever working directory you happen to be in.

It’s all relative though.  When you specify a directory to move to, look in, or to find a file in, the location you give is relative to where you currently are – i.e. your working directory.  If you start the directory location off with a “/” or “~/” it doesn’t matter where you are, as the location you are specifying starts at the root or home directory.  These are fixed absolute points on the tree, but miss off the “/” or “~/” from the start of the directory or file and it becomes relative to your working directory.  Type cd /usr to move your working directory to the “/usr” directory.  Do a ls to see the contents.  See that directory called “bin”?  It’s not the one you looked at earlier; that was a directory for general system bin(ary) programs, this one is for user-orientated bin(ary) programs.  Type ls bin.  The files listed are not the ones you saw earlier in “/bin” but are the ones in “/usr/bin”.  Because the “/” is missing from the front of “bin”, the “bin” it is showing you is the one relative to your working directory, which is currently “/usr”.  You can still see the contents of “/bin” (with the slash) by typing ls /bin (with the slash).

If you understand the concept that everything is relative to the working directory unless you say so, you are ready to know about dots – “..”, “.” and dots at the start of files.

A double dot is shorthand for “the parent directory”, i.e. the next directory down on the way to the root.  If your working directory is “/home/naich” then typing cd .. will change your working directory to “/home”.  Typing ls .. will list the contents of “/home” and so on.  You can string double dots together as if they were real directories. cd ../.. will move you two directories towards root – from “/home/naich” to “/”.  You can do daft things like cd /home/naich/../../home/naich to end up in “/home/naich”, the first “/home/naich” having been rendered pointless by the two sets of double dots moving you back down to “/” again.

A single dot means “this directory”, i.e. the current working directory.  That might not sounds useful, seeing as how, by it’s very nature, you are already working in the working directory but it does have its uses.  I’m not going to go in to them here, but you should know about it in case you see it later on.

Finally, there are hidden files.  These are hidden for convenience not security and are simply files that you don’t care about in the normal scheme of things.  Files like configuration files or log files.  You can hide a file or directory by starting its name with a dot, e.g. “.config_file”.  You have some in your home directory but didn’t see them earlier.  Go home (cd ~) and have a closer look – type ls -a.

naich@raspberrypi ~ $ ls -a
.  ..  .bash_history  .bash_logout  .bashrc  .profile
naich@raspberrypi ~ $

The “-a” bit is an “option” that tells the “ls” command to show hidden files.  Those hidden files are configuration files that are automatically generated when you create a user and control parameters about the way your terminal works.  Most of the time you don’t need to see them, so they are hidden.  You can also see the “.” and “..”, which show up as directories in their own right.

Go back

Appendix C: Commands

The basic format for doing things from the command line has 3 sections separated by spaces:

command [-options] [the_thing_you_are_doing_it_to]

An “option” is a way to modify what the command does.  For example, the default thing for the ls command to do is show the files as a horizontal list, so to list all the files in the root “/” directory:

naich@raspberrypi ~ $ ls /
bin   dev  home  lost+found  mnt  proc  run   selinux  sys  usr
boot  etc  lib   media       opt  root  sbin  srv      tmp  var
naich@raspberrypi / $

but if you add the option “-l” (minus lower case L) to the “ls” command it does this:

naich@raspberrypi ~ $ ls -l /
total 84
drwxr-xr-x  2 root root  4096 Aug  6 12:35 bin
drwxr-xr-x  2 root root 16384 Jan  1  1970 boot
... skip a few ...
drwxr-xr-x 10 root root  4096 Jul 15 19:57 usr
drwxr-xr-x 11 root root  4096 Jul 15 20:42 var
naich@raspberrypi / $

The “-l” means print it in “long” format, i.e. with more information about what sort of file or directory it is (the “d” in “drwxr-xr-x” means directory, don’t worry about the rest for now), who owns it (“root”), the group they are in (root), the size of the file, date it was last modified and its name.  You can have more than one option.  Try ls -lh /.  The “h” means put the file sizes in human readable units.

naich@raspberrypi ~ $ ls -lh /
total 84K
drwxr-xr-x  2 root root 4.0K Aug  6 12:35 bin
drwxr-xr-x  2 root root  16K Jan  1  1970 boot
... and so on

You could make it show you hidden files (“-a”), in date order (“-t”), but reversed so the latest is at the bottom (“-r”) by using ls -lhatr /

naich@raspberrypi ~ $ ls -lahtr /
total 92K
drwxr-xr-x  2 root root  16K Jan  1  1970 boot
dr-xr-xr-x 68 root root    0 Jan  1  1970 proc
drwxr-xr-x 12 root root    0 Jan  1  1970 sys
drwxr-xr-x  2 root root 4.0K Jun  2 10:25 mnt
... etc. ...

Note that the “Jan 1 1970” comes from boot time, when the Pi doesn’t know what time it is (no real time clock), so it defaults to the earliest time a Unix timestamp can have.

It would be pretty unreasonable to expect everyone to remember what all the options are, so most commands have help built in, accessible by using either “-h” or “–help” (that’s two dashes there, compared to the one for single letter options).  With ls, “-h” is used for specifying human-readable units, so –help (with the two dashes) is the option to use for help.

naich@raspberrypi ~ $ ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.

Mandatory arguments to long options are mandatory for short options too.
  -a, --all                  do not ignore entries starting with .
... blah blah etc. ...

Options with two dashes and a word are called “long options”, one dash, one letter ones are “short” options.  Obviously you can’t lump long options together behind the same dashes, so you have to use them seperately, i.e. ls --all --human-readable /.  You can also mix them if you want, i.e. ls -la --human-readable /.

A huge amount of help is also available from the manual pages residing on your Pi, which contain more verbose instructions.  You use these by typing “man command”, e.g. man ls or man adduser or even man man.  While they are very detailed and available for pretty much every command you’ll use, a) you need to already know what command you want, and b) they aren’t always written in the clearest manner for a beginner.  Don’t be afraid to google for information too – for example, putting “how do i add a user in linux” into google’s search box gives you exactly what you need to know.  You aren’t born with knowledge of how Linux works so you need to find it somewhere.  Start off with the manual pages but if you only understand a few of the words on them, have a google for it.

Go back