Greg Wooledge has an excellent list of Bash Pitfalls, with good explanations as to why they are wrong, and what the correct syntax should be.
Understanding init scripts
July 25, 2007UNIX and Linux systems use “init scripts” – scripts typically placed in /etc/init.d/
which are run when the system starts up and shuts down (or changes runlevels, but we won’t go into that level of detail here, being more of a sysadmin topic than a shell scripting topic). In a typical setup, /etc/init.d/myservice
is linked to /etc/rc2.d/S70myservice
. That is to say, /etc/init.d/myservice
is the real file, but the rc2.d
file is a symbolic link to it, called "S70myservice"
. The “S” means “Start”, and “70” says when it should be run – lower-numbered scripts are run first. The range is usually 1-99, but there are no rules. /etc/rc0.d/K30myservice
(for shutdown), or /etc/rc6.d/K30myservice
(for reboot; possibly a different scenario for some services), will be the corresponding “Kill” scripts. Again, you can control the order in which your services are shut down; K01* first, to K99* last.
All of these rc scripts are just symbolic links to /etc/init.d/myservice
, so there is just one actual shell script, which takes care of starting or stopping the service. The Samba init script from Solaris is a nice and simple script to use as an example:
case "$1" in start) [ -f /etc/sfw/smb.conf ] || exit 0 /usr/sfw/sbin/smbd -D /usr/sfw/sbin/nmbd -D ;; stop) pkill smbd pkill nmdb ;; *) echo "Usage: $0 { start | stop }" exit 1 ;; esac exit 0
The init
daemon, which controls init scripts, calls a startup script as "/etc/rc2.d/S70myservice start"
, and a shutdown script as "/etc/rc0.d/K30myservice stop"
. So we have to check the variable $1
to see what action we need to take. (See http://steve-parker.org/sh/variables2.shtml to read about what $1
means – in this case, it’s either “start” or “stop”).
So we use case (follow link for more detail) to see what we are required to do.
In this example, if it’s “start”, then it will run the three commands:
[ -f /etc/sfw/smb.conf ] || exit 0 /usr/sfw/sbin/smbd -D /usr/sfw/sbin/nmbd -D
Where line 1 checks that smb.conf exists; there is no point continuing if it doesn’t exist, just “exit 0” (success) so the system continues booting as normal. Lines 2 and 3 start the two daemons required for Samba.
If it’s “stop”, then it will run these two commands:
pkill smbd pkill nmdb
pkill
means “Process Kill”, and it simply kills off the two processes started by the “start” option.
The "*)"
construct catches any other uses, and simply replies that the correct syntax is to call it with either “start” or “stop” – nothing else will do. Some services allow for status reports, restarting, and so on. The one thing we do need to provide is “start”. Most services also have a “stop” function. All others are optional.
The simplest possible init script would be this, to control an Apache webserver:
#!/bin/sh /usr/sbin/apachectl $1
Apache comes with a program called “apachectl” (or “apache2ctl”), which will take “stop” and “start” as arguments, and act accordingly. It will also take “restart”, “status”, “configtest”, and a few more options, but that one-line script would be enough to act as /etc/init.d/apache, with /etc/rc2.d/S90apache and /etc/rc0.d/K10apache linking to it. To be frank, even that is not necessary; you could just link /usr/sbin/apachectl
into /etc/init.d/apache
. In reality, it’s normally good to provide a few sanity-checks in addition to the basic stop/start functionality.
The vast majority of init scripts use the case command; around that, you can wrap all sorts of other things – most GNU/Linux distributions include a generic reporting script (typically /lib/lsb/init-functions
– to report “OK” or “FAILED”), read in a config file (like the Samba example above), define functions for the more involved aspects of starting, stopping, or reporting on the status of the service, and so on.
Some (eg, SuSE) have an “INIT INFO” block, which may allow the init
daemon a bit more control over the order in which services are started. Ubuntu’s Upstart is another; Solaris 10 uses pmf (Process Monitor Facility), which starts and stops processes, but also monitors them to check that they are running as expected.
After a good decade of stability, in 2007 the world of init scripts appears to be changing, potentially quite significantly. However, I’m not here to speculate on future developments, this post is just to document the stable interface which is init scripts. Even if other things change, the basic “start|stop” syntax is going to be with us for a long time to come. It is easy, but often important, to understand what is going on.
In closing, I will list the run-levels, and what each run-level provides:
0: Shut down the OS (without powering off the machine) 1, s, S: Single-User mode. Networking is not enabled. 2: Networking enabled (not NFS, Printers) 3: Normal operating mode (including NFS, Printers) 4: Not normally used 5: Shut down the OS and power off the machine 6: Reboot the OS.
Some GNU/Linux distributions change these definitions – in particular, Debian provides all network services at runlevel 2, not 3. Run-level 5 is also sometimes used to start the graphical (X) interface.
Shell Pipes by Example
July 22, 2007Pipes, piping, pipelines… whatever you call them, are very powerful – in fact, they are one of the core tenets of the philosophy behind UNIX (and therefore Linux). They are also, really, very simple, once you understand them. The way to understand them, is by playing with them, but if you don’t know what they do, you don’t know where to start… Catch-22!
So, here are some simple examples of how the pipe works.
Let’s see the code
$ grep steve /etc/passwd | cut -d: -f 6
/home/steve
$
What did this do? There are two UNIX commands there: grep
and cut
. The command “grep steve /etc/passwd
” finds all lines in the file /etc/passwd
which contain the text “steve” anywhere in the line. In my case, this has one result:
steve:x:1000:1000:Steve Parker,,,:/home/steve:/bin/bash
The second command, “cut -d: -f6
” cuts the line by the delimiter (-d) of a colon (“:
“), and gets field (-f) number 6. This is, in the /etc/passwd
file, the home directory of the user.
So what? Show me some more
This is the main point of this article; once you’ve seen a few examples, it normally all becomes clear.
EG2
$ find . -type f -ls | cut -c14- | sort -n -k 5 rw-r--r-- 1 steve steve 28 Jul 22 01:41 ./hello.txt rwxr-xr-x 1 steve steve 6500 Jul 22 01:41 ./a/filefrag rwxr-xr-x 1 steve steve 8828 Jul 22 01:42 ./c/hostname rwxr-xr-x 1 steve steve 30848 Jul 22 01:42 ./c/ping rwxr-xr-x 1 steve steve 77652 Jul 22 01:42 ./b/find rwxr-xr-x 1 steve steve 77844 Jul 22 01:41 ./large rwxr-xr-x 1 steve steve 93944 Jul 22 01:41 ./a/cpio rwxr-xr-x 1 steve steve 96228 Jul 22 01:42 ./b/grep $
What I did here, was three commands: “find . -type f -ls
” finds regular files, and lists them in an “ls”-style format: permissions, owner, size, etc.
“cut -c14-
” cuts out the first 14 characters, which mess up the formatting on this website (!), and aren’t very interesting.
“sort -n -k 5
” does a numeric (-n) sort, on field 5 (-k5), which is the size of the file.
So this gives me a list of the files in this directory (and subdirectories), ordered by file size. That’s much more useful than “ls -lS
“, which restricts itself to the current directory, but not subdirectories.
(As an aside, I have to admit that I only concocted this by trying to think of an example; it actually seems really useful, and worth making into an alias… I must do a post about “alias
” some time!)
So how does it work?
This seems pretty straightforward: get lines containing “steve” from the input file (“grep steve /etc/passwd
“), and get the sixth field (where fields are marked by colons) (“cut -d: -f6
“). You can read the full command from left to right, and see what happens, in that order.
How does it really work?
EG1 Explained
There are some gotchas when you start to look at the plumbing. Because we’re using the analogy of a pipe (think of water flowing through a pipe), the OS actually sets up the commands in the reverse order. It calls cut
first, then it calls grep
. If you have (for example) a syntax error in your cut
command, then grep
will never be called.
What actually happens is this:
- A “pipe” is set up – a special entity which can take input, which it passes, line by line, to its output.
cut
is called, and its input is set to be the “pipe”.grep
is called, and its output is set to be the “pipe”.- As
grep
generates output, it is passed through the pipe, to the waitingcut
command, which does its own simple task, of splitting the fields by colons, and selecting the 6th field as output.
EG2 Explained
For EG2, “sort
” is called first, which ties to the second (rightmost) pipe for its input. Then “cut
” is called, which ties to the second pipe for its output, and the first (leftmost) pipe for its input. Then, “find
” is called, which ties to the first pipe for its output.
So, the output of “find
” is piped into “cut
“, which strips off the first 14 characters of the “find
” output. This is then passed to “sort
“, which sorts on field 5 (of what it receives as input), so the output of the entire pipeline, is a numerically sorted list of files, ordered by size.
Shell Cheatsheet
July 14, 2007There doesn’t seem to be any decent shell CheatSheet out there, so I have undertaken to write one.
This is my first attempt; once I actually printed it out, I realised that the the font was actually rather large, so I had room to include much more than I had originally sketched out.
Cheatsheet You may notice that there are a lot of blanks; Shell Cheatsheet has the same content, with some ideas for new content. Please tell me what you want to see in there – There is still lots of room, it’s only about 60% full.
What would you fill the other 40% with?
Does this seem to be a useful cribsheet? What would you like to see in it?
Also, what format would you prefer? PDF? PNG? GIF? DOC?!
Termcap
July 13, 2007I could talk for hours about TERMCAP, but I won’t; instead, here’s a link to one usage of termcap:
The post is interesting, the comments are probably at least as useful as the post.
Positional arguments
July 11, 2007A tutorial reader, Maarten Zeinstra, emailed me the other day about Variables – Part II, where I "kinda implicitly state that there are only 9 available params to be given in any program $1..$9 so if you wanted do have more then those you might want to do something like your example. But ${n} also works to get above 9 params."
It turns out that this is entirely true – for bash, dash, csh, ksh, and probably other shells too. The ${9} limitation seems only to apply to the traditional Bourne shell – that is, #!/bin/sh on commercial Unices.
If you can be sure that your script will be interpreted by bash, or similar, you can quite happily refer to your tenth argument as ${10}.