UNIX 103: more progress on document
[kspaans/UnixTutorial] / holy-fuck-a-shell.pod
1 =head1 Welcome to Unix
2
3 Welcome to the unix environment. Here you have the familiar point
4 and click gui, but thats not why you're reading this, you're here for
5 the shell. So what is this mysterious shell you've been told about by
6 upper year students? It is a command line interface to your computer.
7 Where the gui is like pointing and grunting the shell is using language.
8 A beginner might not do much better than pointing and grunting, but with
9 practice one can control a computer with the skill of a poet.
10
11 =head2 A few useful keys before we begin
12
13 As you've probably guessed the shell is a command line interface that
14 you type into. It's essentially an interactive programming language,
15 like the interactions window in DrScheme, but designed to operate on
16 the system and work in a rather diverse environment. Its also designed
17 for convinence, and as you'll discover, quite powerful. Before we get
18 started there are a few keystrokes you'll need to be aware of.
19
20 First, the commands that you type in can be editted, similar to a line of
21 text in a text editor.  You can move the cursor left and right, erase text
22 (both delete and backspace work as you're familiar with from your word
23 processor, and ctrl+k will delete everything to the right of the cursor),
24 and scroll through your I<command history> (using the up arrow and down
25 arrow for back and forwards respctively).
26
27 If you want to view your command history use the command C<history>. To run
28 an old command type C<!number> where number is the number next to the 
29 command in history.
30
31 Most shells also provide tab completion of commands and file names, to
32 use this just press tab after typing part of a file path or command, as long
33 as it's unique. If it's not the shell will show you all the possibilities
34 (this may be a rather long list).
35
36 =head2 Getting to the Shell
37
38 There are several ways to access the shell remotely and locally. Remote
39 shells can be obtained by connecting to a server with a program called
40 Secure Shell or ssh. If you're local to a linux or unix system just start
41 any of the many terminal programs. (On OS-X, look for Terminal in
42 Applications>Utilities.  On Ubuntu look in the Applications menu under
43 Accessories.)
44
45 =head3 From Windows
46
47 Unlike the other operating systems discussed here, Windows does not have
48 a built in Unix-like shell.  There are several applications that provide
49 Unix-like shell features on Windows, but the
50
51 There are several utilities that can provide access to ssh from Windows, 
52 the main one used by people at Waterloo is PuTTY 
53 L<http://www.chiark.greenend.org.uk/~sgtatham/putty/>. There is also a
54 program called Cygwin L<http://cygwin.org>. It provides a Linux-like
55 environment in Windows. You use it inside of a command-prompt window. So it's
56 just like using PuTTY, except you don't have to be online to use it. Make sure
57 the ssh package is installed, and then just type ssh.
58
59 =head3 From Mac OS-X
60
61 Mac OS X comes with X11 (more on X11 later) installed, and with X11 comes
62 a unix shell with most of the features discussed here, including an 
63 ssh client. There is also a Terminal.app that you
64 can find in /Applications/Utilities. It doesn't require that you start X11, but
65 then you don't get the advantage of X11 forwarding. But that's an advanced
66 topic that will be discussed later. You can also use many of the non student
67 environment commands on your mac. Like most Unix-like operating systems, OS-X 
68 comes with a built in ssh client. All you need to do to connect using SSH is to 
69 open up Terminal and type in ssh user@host.  (Go on, give it a try.)
70
71 =head3 From Linux
72
73 To connect to the student environment from linux just start a terminal program
74 and use ssh like on OS-X, ssh will be documented in its own section. Also
75 most of the things in this guide are useable on your local terminal as well.
76
77 =head3 ssh(1) 
78
79 The ssh utility is invoked from your local command line like this
80
81  $ssh username@hostname
82
83 At this point you will be prompted for your password. For the student.cs
84 environment hostname is student.cs.uwaterloo.ca or just student.cs from
85 inside the network. Your user name is your quest id.
86
87 =head4 ssh keys (optional)
88
89 ssh can be configured to log in automatically without prompting you for your
90 password using cryptographic keys to authenticate. To set this up do the 
91 following:
92
93  $ssh-keygen -t dsa
94  Generating public/private dsa key pair.
95  Enter file in which to save the key (~/.ssh/id_dsa): 
96  Enter passphrase (empty for no passphrase): 
97  Enter same passphrase again: 
98  Your identification has been saved in ~/.ssh/id_dsa.
99  Your public key has been saved in ~/.ssh/id_dsa.pub.
100  The key fingerprint is:
101  <some numbers> user@host
102  $ssh-keygen -t rsa
103  Generating public/private rsa key pair.
104  Enter file in which to save the key (~/.ssh/id_rsa): 
105  Enter passphrase (empty for no passphrase): 
106  Enter same passphrase again: 
107  Your identification has been saved in ~/.ssh/id_rsa.
108  Your public key has been saved in ~/.ssh/id_rsa.pub.
109  The key fingerprint is:
110  <some numbers> user@host
111  $ssh-copy-id user@host
112  user@host's password: 
113
114 This is optional and more detail can be found in the man page. More
115 on those in the next section...
116
117 Also, please keep in mind that while the passphrase can be, and too often is,
118 left blank, this poses an enormous security risk and should only be done if
119 you are 100% certain you are the only person who will be using the computer
120 in question, and your hard drive is encrypted.
121
122 =head2 Getting Help
123
124 Now that you can log in easily (or at least login if you skipped the section on 
125 keys) you're probably wondering what you can do, we'll get to that, but first 
126 a way to get help beyond this guide. For most commands (which are just 
127 programs) the authors often include manual or man pages (the good ones anyway) 
128 documenting how to use the program. To access this information use the C<man> 
129 command like this:
130
131  $man <command name>
132
133 There are also manual entries on various system calls and program libraries, 
134 configuration files, and system daemons. These are in different numbered 
135 sections, type C<man man> for more information.
136
137 =head2 Thats all well and good, what can I do?
138
139 Like we said earlier, the shell can be used to command a computer. So anything 
140 you could do in graphical programs you can do on the shell and more. Many shell 
141 tools don't translate well to pointing and clicking, just like its hard to read 
142 a poem to a caveman. Commands don't function in a vaccum though, they take 
143 input a variety of ways. The first is standard input, normally attached to your 
144 keyboard (but it can be moved around), the second is command line arguments and 
145 flags. Arguments are just placed after the command, and the man page can 
146 explain which flags are avaiable and how to use them. Two common ones are 
147 C<--help> and C<--verbose> which have obvious functions. The third input method 
148 is reading from various files, some specified on the command line some searched 
149 for by default.
150
151 We'll start with some basic file tools and command and control abilities.
152
153 =head2 The file system and what to do about it
154
155 Programs are just files on disk and manipulate data which is also on the disk, 
156 so it obviously follows that the most important programs are the ones for 
157 working with files on the disk. This section will go over the file system and 
158 these important programs.
159
160 =head3 The file system is organized into directories
161
162 The file system in the unix environment starts with C</> or the root, different 
163 drives are all attached as directories under the root. For now don't worry 
164 about drives and lets chat about directories. In unix everything has a running 
165 or "working" directory, including your shell prompt. To see what your current 
166 directory is use the B<p>rint B<w>orking B<d>irectory command C<pwd> at the 
167 prompt. This will give you the I<absolute path> to your working directory. Any 
168 I<relative paths> you specify will be relative to this location. To go 
169 somewhere else use the B<c>hange B<d>irectory command C<cd> followed by the 
170 path you wish to change to. With no arguments it takes you to your home 
171 directory. The path specified can be relative or absolute.
172
173 =over
174
175 =item I<absolute paths>
176
177 Absolute paths are specified starting from the system root and look like 
178 C</this/path/is/absolute>. Absolute paths are important when working with 
179 other people or when going somewhere completely different on the filesystem, 
180 really anywhere precision is needed.
181
182 =item I<relative path>
183
184 Relative paths are specified relative to your (or a program's) current working 
185 directory and are just like they sound. They start without a C</> (remember 
186 that C</> specifies the system root) and otherwise work exactly the same. There 
187 are a few special directories that can be used in relative paths, the first is 
188 C<.> which stands for the current directory. The second is C<..> which is the 
189 directory above the current directory. Here are some examples:
190
191  $pwd
192  /home/user
193  $cd /etc/games
194  $pwd
195  /etc/games
196  $cd ../config
197  $pwd
198  /etc/config
199  $cd network/
200  $pwd
201  /etc/config/network
202  $cd ..
203  $pwd
204  /etc/config
205  $cd ./network
206  $pwd
207  /etc/config/network
208
209 =back
210
211 Which directories exist isn't set in stone, you B<r>eB<m>ove B<dir>ectories 
212 with the C<rmdir> command, and B<m>aB<k>e them with C<mkdir>. C<rmdir> takes an 
213 existing path and removes the directory (you can't remove one with anything in 
214 it). C<mkdir> takes a valid path and makes a directory.
215
216 Paths may seem confusing, but they are a rather straightforeward way of 
217 specifying both directory locations and filenames. How do you specify a filename 
218 you ask? Just like a directory. If you're in C</path/to> and want a file called 
219 C<afile> all you need to do is write C<afile>. If you're somewhere else you can 
220 get to it absolutely C</path/to/afile> or use any of the other things mentioned 
221 in path specification to name it.
222
223 =head3 Files, they're people too
224
225 Speaking of files, you probably want to see them. The first step to seeing 
226 files is seeing where they are, the command for this is the B<l>iB<s>t command 
227 C<ls>, which shows the files in your current directory, as well as directories. 
228 C<ls> might be set up for colour coded output, it might not be, the man page 
229 can explain how to set that up. C<ls> also has a B<l>ong format, viewed using 
230 C<ls -l>, which provides a lot of useful information about the files listed. 
231 Again the man pages can give you more information.
232
233 Now that you know the names of your files you might want to actually get at 
234 their contents. The simplest way is C<cat> which takes a file name and spits 
235 out the contents to the screen. This is nice for short files, but you can't
236 scroll back. Two commands that give you a little more control are C<head> 
237 and C<tail> which display the start and end of files. C<tail> is particularly 
238 useful in watching log files using the B<f>ollow flag C<-f>, which watches the 
239 file for updates and displays the new entries as they appear. A third way to 
240 view files, which is perahps the most convinient, is something known as a 
241 I<pager> program. There are many pagers, this author's favorite is C<less>, 
242 which takes a filename argument and lets you scroll up and down as well as 
243 search. To search in less type C</> followed by what you're looking for. To 
244 find more matches press C<n> to go foreward and C<N> to go back. In less 
245 C</> actually takes a pattern, to learn about those check the man pages or 
246 the text manipulation and editing tutorial.
247
248 You might be asking how to create files now. Lots of programs create files 
249 as output, there are logs, data files, random crap, so what you probably 
250 want is a way to edit text. Thats easy, use C<pico> or C<nano> for simple 
251 command like editors. However these editors are rather simple and lack power, 
252 for a full introduction to the vast text editing capabilities refer to the 
253 text manipulation and editing tutorial.
254
255 Files can also be B<m>oB<v>ed around, B<c>oB<p>ied and B<r>eB<m>oved. The 
256 commands C<mv> and C<cp> do moving and copying, taking the original filename 
257 as the first argument and the destination as the second. If the second is a 
258 directory then the filename is kept the same and the file is placed in that 
259 directory, if a name is specified then the file will be moved or copied to 
260 the new name. C<rm> removes files given to it as arguments, as many as you 
261 like.
262
263 =head3 Your home folder (theres no place like it)
264
265 When specifying paths there is another special character C<~>, which is short 
266 for your home directory. Your home directory is exactly what it sounds like, 
267 your place on the file system to keep your crap. If you use C<cd> without an 
268 argument it will take you to your home dir. Whats in your home dir? Well, any 
269 files you want to keep. Is that it? No, also kept in your homedir are so-called 
270 "dot files" since their filenames start with a C<.> so they don't normally show 
271 up in C<ls>, to view them use the B<a>ll option for C<ls>, C<-a>. These dot 
272 files store configuration information for various programs, as well as B<r>un 
273 B<c>ommands files with commands to be run on startup of various applications. 
274 You can edit these to customise your various preferences for applications, but 
275 consult the man pages first to make sure you enter sane values.
276
277 Also in your home folder is your web folder, usually called C<www> or 
278 C<public_html>, depending on the configuration of the system. To set up a 
279 personal web page all you have to do is place your html (or text or whatever) 
280 files in there and make sure they are world readable. Word Readable? What? 
281 Its a permission, subject of the next section.
282
283 =head3 File permissions, or how to keep people out of your crap.
284
285 In unix every file has an owner, these owners are the users, and an owning
286 group, which is some group that the owner is a member of. You can control who 
287 can read, write, and execute your files based on these categories: user, group, 
288 everyone. Collectively these permissions are known as the file's 
289 (or directory's) I<mode>. To view a file's mode use a long listing with 
290 C<ls -l> and look at the I<mode string>. Mode strings are 10 characters, the 
291 first character specifies if the file is a file with a C<-> or something 
292 special, like a directory C<d> or a character device like a terminal with C<c>. 
293 Following the file type are nine characters, they represent the 3 permissions 
294 for the 3 groups, the first three characters stand for B<r>ead, B<w>rite, and 
295 eB<x>ecute for the user, and repeat for the group and everyone. For example 
296 C<-rw-r-r> provides the owner read-write access and everyone else.
297
298 To B<ch>ange B<mod>es, B<own>er, or B<gr>ouB<p> of a file use the commands 
299 C<chmod>,C<chown>, and C<chgrp> (actually C<chown> can also change groups). 
300 We won't go into C<chown> since only the superuser (a user with more permissions 
301 than normal, for administrative purposes) can use it. To use C<chmod> to change 
302 modes first pass in a mode alteration followed by files you own. A mode 
303 alteration has the form C<w[+,-]p> where C<w> stands for who the mode change is 
304 for, B<u>ser owning the file, B<g>roup, B<o>thers, or B<a>ll groups, followed a 
305 C<+> to grant the permission or a C<-> to revoke it, and C<p> stands for the 
306 ability to change, B<r>ead, B<w>rite, or eB<x>ecute.
307
308 You may be wondering about the execute permission. This grants people the 
309 ability to run your files, if you have binaries or executable scripts to 
310 permission. Depending on the programs you might want to be careful with this. 
311 On directories, where executing makes little sense it is the permission to 
312 traverse or change into the directory.
313
314 =head3 Talking about more than one file at a time
315
316 Often its useful to talk about a group of files (like to tell C<rm> about them, 
317 or backup your website with C<cp>). The shell has a way to do this. Using a 
318 wildcard C<*> you can name all files that match a patern, for example C<*.mp3> 
319 would be all mp3s in a folder. Multiple wildcards can be used in a single name, 
320 but note they don't match C</>, that is they don't traverse directories. There is
321 also the C<?> wildcard which matches any one character.
322
323 Specific characters can also be matched using C<[..]> with the characters or a
324 range of characters (say C<[a-z]> to match all lowercase) to match. Note that
325 this only matches once, so for repeats you must repeat your bracket expression.
326
327 For more information on this matching/expansion, which is called 
328 I<file globbing> consult C<man 7 glob> (there will probably also be an entry
329 in section 3 of the system manual for glob. This is for a C library function
330 that actually works out the list of files from the glob expression).
331
332 If you want to specify a C<*>, C<?> or C<[> you must escape it with a C<\>,
333 and to get a literal C<\> you must escape that as well, using C<\\> in its
334 place. There are a few other characters that must be escaped: a space,
335 C<">, C<'>, and C<;> for reasons that may or may not be obvious now, but 
336 will be after the next section.
337
338 =head3 Power searching: finding files with find
339
340 The C<find> command is a flexable tool used to locate files and folders in a 
341 given folder (or set of folders). The basic structure of the command is 
342
343         find [Folder(s)] [Search Expression]
344
345 Note that the Search Expression is not simply a string that you wish to match - 
346 it is more powerful and more complicated than that. As an example, this command:
347
348         (1) find ~/ -name "cs*" 
349
350 will locate all files in your home folder that begin with "cs". Find searches 
351 recursively, meaning that it will even find matching files when they are located 
352 inside subfolders in the home directory. To adjust the number of levels down 
353 that 'find' will search, you can use the -maxlevels and -minlevels flags.
354
355 You can also use find to B<exec>ute a command on each file returned using the C<-exec>
356 flag. Everything after the C<-exec> flag will be considered part of the command you 
357 wish to run on all files until the sequence C<\;> (an escaped semi-colon) is 
358 encountered. You can use the sequence C<{}> to represent the name of the current 
359 file. As an example, this command will search all files in your home direcotry 
360 for the phrase I<"Hello World"> and print the name of the files that have matches.
361
362         (2) find ~/ -exec grep -q Hello\ World {} \; -print
363
364 The search expresison in C<find> is evaluated left-to-right as a boolean 
365 expression based on the success or failure of each parameter. The C<-exec> and 
366 C<-print> expressions are implicitly joined by an AND operator.
367
368 Example 2 can have this implicit AND written explicitly as:
369
370         (3) find ~/ -exec grep -q Hello\ World {} \; -and -print
371
372 Whereas:
373
374         (4) find ~/ -exec grep -q Hello\ World {} \; -or -print
375
376 would show only files that *didn't* have matchs.
377
378 Find will stop processing the expression once the final result is known. 
379 In (3), C<-exec> returning false means that the whole expression is false, since 
380 false AND anything is false. In (4), if C<-exec> returns true, C<-print> will not be 
381 processed, since the exit state is already guaranteed to be true.
382
383 =head2 What the shell really gives you.. power.
384
385 Up until now we've only really covered features that you can find in your
386 familiar point and click environment. Going back to the language analogy
387 think of that as boring vocabulary work and whats about to be covered
388 grammar, rhyme, and meter work. This section discusses the features of the
389 shell that separate it from the gui, the programmable loops, variables that
390 affect program execution, and io redirection. This section describes the
391 machinary the shell provides to put words together to form ideas.
392
393 =head3 Every command you run is a process: how to run more than one.
394
395 Every command you start from the shell (well there are a few exceptions we'll
396 go in to in a bit) runs as a I<process>. In Unix processes represent separate
397 discrete running programs, for example you can have several processes which 
398 are all cp with different arguments (or the same arguments, but that is likely
399 to break and not advised). In playing around with what you've learned in the
400 last chapter you may have been frustrated by only being able to do one thing
401 at a time. The shell does not limit you to running one thing at a time, and
402 on the contrary gives you powerful tools for managing processes, both those 
403 started by you and those already running on the system.
404
405 For the purposes of I<job control>, processes can be viewed in two groups:
406 those under the control of your shell (your I<jobs>), and those not. We'll
407 first discuss the ways of starting your own jobs and interacting with them.
408
409 =head4 Your jobs and what to do about them
410
411 The first thing you're probably wondering is how to start more than one job.
412 To do this you first need to know the difference between a I<foreground>
413 process and a I<background> process. A foreground process is running attached
414 to your terminal, your command prompt goes away and is replaced by its output 
415 and any input goes to the program. With a program running in the background 
416 it doesn't recieve input (unless you have an io redirect, more on that later)
417 and output goes to your terminal, but you can still enter other commands.
418
419 Before we can get to fancier features you probably want to know how to stop
420 something in the foreground. To I<interrupt> or B<c>ancell the job in the
421 foreground press C<CTRL+C> (hereafter C<control> will be abreviated with C<^>
422 followed by a character. So C<CTRL+C> is C<^C> and so on and so forth). If you
423 want to pause the job instead of terminating it press C<^Z>. This stores the
424 process in a stopped state and gives you your command prompt back. You'll also
425 see a message that looks like
426
427  [1]+   Stopped         some command with args
428
429 The number in square brackets is the job number, C<+> means the state has
430 changed. This is followed by the new state and what job is being run. If you
431 want to bring your job back to the foreground type C<fg %1> and your job will
432 come back just as you left it. Not very interesting, but the next part is. If
433 you want to let your job finish running in the I<background> while you do
434 something else type C<bg %1> and your job will resume running, but you still
435 have a prompt to use. If you know you want a command to run in the background
436 and don't want to futz with C<^Z>ing it and then typing bg you can just put an
437 C<&> at the end of your command like so:
438
439  $cp ~/giant_file.tar.gz /mnt/usbdrive &
440
441 Note that the number 1 in C<%1> isn't special, its just the usual job number of
442 your first job. It will be different if you have more jobs running. To get a
443 list of your jobs type C<jobs>. This will have job numbers, states and what
444 command is running.
445
446 To terminate a job early or put one of your background in a "Stopped" state
447 (and often to communicate with it in other ways) unix provides I<signals>. A
448 signal is a numbered code sent to a process with a meaning defined by the
449 system. Commonly used signals are terminate, C<TERM>; kill, C<KILL>; and stop, 
450 C<STOP>. C<TERM> instructs a process to stop what its doing and quit, C<KILL>
451 ends it, and C<STOP> is equivalent to C<^Z>. Yes, C<^C> has a corresponding
452 signal: interrupt, C<INT>. To send signals to jobs use the C<kill> command.
453 By defaul C<kill> sends the C<TERM> signal, to specify other ones use C<-s>
454 followed by the signal name. You also need to tell C<kill> which job to send
455 the signal to.
456
457 =head4 Other processes
458
459 You may be wondering about the mention of processes not started by your shell.
460 These all have associated numbers, called a I<process id>. Your jobs also have
461 pids, and kill will take a pid instead of a job id. To see a listing of current
462 processes use the command C<ps>. This will give all sorts of information:
463 the pid, who started it, the attached terminal, whats running, the ram usage.
464 C<ps> gets more useful when you're using more than one terminal or performing
465 system administration.
466
467 =head3 Input, output, and the story of a plumber
468
469 As stated earlier processes running take input from standard input (your
470 keyboard) and send it to standard output (your terminal) or errors to standard
471 error (also your terminal). Sometimes this can be really inconvinent or down 
472 right aggravating. Fortunatly the shell has an answer, its called 
473 I<IO redirection>. This is the process of sending output somewhere other than
474 your terminal and getting it from somewhere other than your keyboard.
475
476 =head4 Simple redirection
477
478 Simple redirection sends program output to a file or brings input in from a
479 file. To connect input to a file use the C< < > character followed by a
480 file name like this:
481
482  $mysql < lots_of_sql_queries.sql
483
484 Output goes the other way, so naturally you use C<< > >> to send output to a file.
485 By default one C<< > >> overwrites a file, for output to append you must add a
486 second C<< > >>. Before going further, a word on I<file descriptors>. In unix when
487 a file is opened by the system the open file handle isn't attached directly to
488 the file on disk, but to a file descriptor, which is a number that the process
489 can use internaly. File descriptors are also used by interpreted scripts, which
490 when executed start an interpreter. Instead of passing the interpreter the
491 filename (which could have been changed to do nasty things if someone is up
492 to no good) the system passes the interpreter the file descriptor of an open
493 handle to that file, as these are process specific and much harder to muck
494 with. Normally you don't have to worry about file descriptors, but when
495 redirecting input and output its nice to be aware of 3 of them. These are fds
496 0,1, and 2, which correspond to standard in, standard out, and standard error
497 respectively.  The left sides of C<< < >>, C<< > >>, C<<< >> >>> all take an
498 implicit fd argument, 0 for the input operator and 1 for the output operators.
499 To redirect standard error add a 2 in front of your operators. You can also
500 redirect from one file descriptor to another using C<< i>&j >> to send output
501 on fd i to fd j.
502
503 File descriptors will be revisited when we discuss scripts, as you might have
504 a need for more than the 3 default file descriptors there.
505
506 You might be wondering if you can read from or write to other programs. Thats
507 the topic of the next section, just remember with simple redirection you can't
508 read from or send to programs.
509
510 =head4 You mentioned plumbing? I don't see any pipes
511
512 Actually, there are pipes in the shell, they are one of the most useful shell
513 features. A pipe or pipeline is a way to connect standard out of one program
514 to standard in of another. This is represented with the C<|> I<pipe> character.
515 To demonstrate its power say you have a command that generates a lot of output,
516 you don't really want to save it but you need to look at it, and it doesn't fit
517 on one screen. Using what you know above you do this:
518
519  $massive-output > output.txt
520  $less output.txt
521  $rm output.txt
522
523 Seems like a lot of work, since less by default reads from standard in. With
524 pipes this mess gets shortened to:
525
526  $massive-output | less
527
528 You can also chain pipelines using inbetween commands as filters, you can even
529 use many of the commands that normally take files in pipelines using the
530 special C<-> filename, consult the man pages for what you're using to get the
531 specifics, a lot of commands take input from standard input by default. If you
532 want to start the pipeline out with some text you enter you can put it in a
533 file or you can use C<cat -> to send standard in to standard out. When you are
534 done typing press C<^D> to send the End of File (EOF) character (Note not all
535 control characters send signals).
536
537 Chaining pipes was mentioned, this allows you to insert filters into the stream
538 we'll go over a few useful ones now, though for more in depth coverage check
539 the text editing tutorial.
540
541 =over 8
542
543 =item C<tee>
544
545 C<tee> creates a split in a pipe, saving the output to a file (or multiple
546 files) as well as passing it on standard out so the pipeline can continue.
547 Useful for saving state or putting a T in your pipeline and starting the
548 other branch with C<cat your_tee_savefile | rest_of_pipeline>.
549
550  $ command_pipeline | tee save_file | more_pipeline
551
552 =item C<grep>
553
554 C<grep>'s odd name comes from an antiquated unix editor and a common sequence
555 of commands used to search. These commands are B<g>lobally, B<r>egular 
556 B<e>xpression, B<p>rint, used to go through an entire file and print lines
557 matching a pattern. For details on C<grep>'s pattern format check the text
558 processing tutorial or the man page. C<grep> can be used on files but its 
559 mentioned here as a filter. When used in a pipe it will filter whats coming
560 in on the pipeline, outputting only what matches the pattern, for example:
561
562  $ps | grep mysql
563
564 will print information about every process with mysql somewhere in its
565 information (usually things run by the mysql user or mysql client processes).
566
567 =item C<sed>
568
569 C<sed> stands for B<s>tream B<ed>itor, and provides powerful facilities for
570 editing data as it comes in through a pipeline. C<sed> can also automate various
571 other editing tasks. More information on C<sed> can be found in the editing
572 tutorial.
573
574 =item C<sort>
575
576 C<sort> does exactly what you think it does, takes input, outputs a sorted
577 version. The various options in the man page control different ways of sorting,
578 but its not worth mentioning them here, as I'm sure you'll look it up when you
579 actually need it instead of reading it now and forgetting it.
580
581 =item C<uniq>
582
583 C<uniq> takes input and outputs only the B<uniq>ue lines. A useful option is
584 C<-c> which gives you a count of repitions.
585
586 =item C<wc>
587
588 C<wc> is a B<w>ord B<c>ounting program. It takes input and outputs the number
589 of lines, words, and characters in the input. It will also take a file or many
590 files and give you by file output as well as totals. You might write a version
591 someday...
592
593 =back
594
595 =head3 Variables and the Environment (no you don't have to go green)
596
597 At this point you may have guessed that the shell is infact an interactive
598 programming language designed specifically for gluing other programs together
599 and administering systems. If you did, you're right. If not, well it is, and
600 like most programming languages it has support for variables. Variables in the
601 shell come in two forms: locally scoped variables and I<environment> variables.
602 Locally scoped variables are visible only to one command (commands may start
603 multiple programs, see other parts of this chapter for how) while environment
604 variables are visible to everything that runs as a child of your shell (unless
605 otherwise specified, but we'll get to that).
606
607 To set local variables just use C<=> in a statement, like:
608
609  $var="stuff";
610
611 and to get values append a C<$> to the name and the shell will substitute it:
612
613  $echo $var
614
615 (echo just prints out what you pass to it).
616
617 Environment variables are global to your shell and allow you to customize
618 various shell options and inform programs you start of your preferences for
619 things like your pager and your prefered text editor. To get a full rundown
620 of the available vars check out the manpage for C<environ(7)> (if you haven't
621 read at least a bit of C<man man> yet the number is a manual section, and to
622 specify it place it before the name of the page: C<man 7 environ>). To set new
623 ones or modify your current ones use C<export> followed by your assignment
624 statement, or just the variable name if you have it set already. If you're
625 curious about what variables are already set just run C<export> without
626 arguments.
627
628 If you want environment variables to remain set in new sessions edit your
629 F<.bash_profile> or F<.profile> file and add new lines with your export
630 commands. For more on these files see the customizing your shell section.
631
632 =head3 Scripting the shell
633
634 Since the shell is really just an interactive programming language an obvious
635 question is "does it have a non-interactive mode?". The answer is yes. This is
636 called I<shell scripting> and is a useful way to automate repetitive tasks and
637 add desired functionality. Since the interactive shell and the scripted shell
638 are the same thing, features discussed here can be used at the prompt, though
639 they may not be useful.
640
641 Shell scripts consist of a series of shell commands on separate lines or
642 separated by semicolons. To create one open an editor on a new file (call it
643 whatever you like, by convention they have the C<.sh> extension) and enter
644 the sequence of commands you wish to be able to run over and over again. Save
645 the file and make sure you have permission to execute it. Then at the prompt
646 type C<./your_file_name> to run it. 
647
648 Scripts can also take arguments, these appear in variables C<$1> to C<$9>,
649 (if you need more than nine place the numbers in braces). There are also some 
650 useful special variables: C<$?> is the exit status of the last command run,
651 an indicator of error conditions; C<$$> is the process id of the script, and
652 C<$0> is the name of the script, which provide relevant information for error
653 messages as well as the change of behavior based on script name or process id
654 (the first one is sometimes used for startup/shutdown scripts, the second one
655 is insane).
656
657
658 =head3 Its a programming language? Wheres while and friends?
659
660 Yes, the shell is an interactive programming language, and yes there are loops
661 and conditional expressions. If you've ever used an imperitive programming
662 language (like Java or VB or Perl) these first few should be familiar. These
663 are going to be quick commentaries, for more info you can read the shell man
664 page.
665
666 =over
667
668 =item C<if>
669
670 If works just like you'd expect, except there are also a myriad of useful file
671 test options to query the properties of files and file descriptors.
672
673  if [ -e "filename" ]; then 
674      echo "filename exists";
675  fi
676
677  if [ "$3" = "start" ]; then
678      echo "starting";
679  elif [ "$3" = "stop" ]; then
680      echo "stopping";
681  else
682      echo "option 3 invalid";
683  fi
684
685 =item C<while>,C<until>
686
687 While loops while a condition is true, until loops until a condition is true. 
688 These are the same conditions used in if.
689
690  while [ -e "lockfile" ]; do
691      echo "waiting for lock to be released";
692      sleep 5;
693  done;
694
695  X=0
696  until [ $X = 20 ]; do
697      echo "zomgwtf";
698      X=$((X+1)) # arithmatic expression, read the man page. You probably
699                 # want to use a real programming language for heavy iteration
700  done;
701
702 =item C<for x in>
703
704 While bash has a c style for loop, don't use it. You probably want a real
705 programming language at that point. The useful for loop iterates through a
706 list for you, setting x (or whatever other variable name you use) to the values
707 one at a time. You can use a plain list, a file glob, or any command in
708 backticks (which evaluates the command and substitutes the value).
709
710  # Backup git repositories in /backup/repos
711  for d in `ls -d /backup/repos`; do
712      cd $d;
713      git pull;
714  done;
715
716 =back
717
718 =head3 Customizing your shell
719
720 Through this document we've been talking about "the shell". The fact is there
721 are many, many, shells all with the standard features discussed here (and some
722 without) as well as a variety of extensions and unique features.
723
724 The shell used as a reference when writing this guide and a common default is
725 C<bash>, B<B>ourne B<A>gain B<Sh>ell, also popular are C<ksh> (B<K>orn 
726 B<Sh>ell), C<csh> (B<C> B<Sh>ell), C<tcsh> (an enhancement of C<csh>), and
727 C<zsh> (the B<Z> B<Sh>ell, an addition of new features to a C<ksh> and C<bash>
728 featrues). Feel free to experiment, you can start a new shell by invoking it as
729 a command or using C<chsh> and logging out and in again.
730
731 To set shell options and environment variables you can edit the various F<rc>
732 and F<profile> files associated with your shell, check the man page for details
733 on which files to edit.
734
735 In these files you can also start background jobs if you'd like, though it is
736 often more useful to have automated tasks. Many systems have a C<cron> program
737 installed which can be used to run programs even when you aren't around, to
738 add these edit a file called a F<crontab> using the progrogram with the same
739 name to do so. Check the associated man page for syntax in the file and what
740 you can and cannot run in it.
741
742 =head2 About the Authors (when they wrote this)
743
744 This document is maintained and copyright The University of Waterloo Computer
745 Science Club 2008 and is released under the terms of the Artistic Liscence
746 version 2.0 available at L<http://www.perlfoundation.org/artistic_license_2_0>.
747
748 =head3 Edgar Bering (ebering@csclub.uwaterloo.ca)
749
750 A student heading into his second year Edgar served as club secretary W08 and
751 plans on running for executive most of the rest of the time he's around.