Chapter  23

Introducing Darwin and the Mac OS X Command Line

Running behind the slick Mac OS X Aqua GUI is Darwin, the POSIX-compliant, UNIX-based environment that forms the foundation of Mac OS X. While the majority of Mac OS X users never find it necessary to use the command line, for those that are willing to learn there is whole new world of powerful computing awaiting.

In this chapter you will learn

• The basics of Darwin and the command line
• Common and useful command-line commands
• The power and pitfalls of working as root
• Editing files with Vim, Emacs, and Nano
• What file attributes are and how to change them
• Customizing your command-line environment

Darwin Basics

Included in Darwin is a collection of many powerful tools that are not only used by many functions of Mac OS X, but are also available for you to use. The most direct way to interact with Darwin and take full advantage of all these wonderfully powerful UNIX tools is through the use of the Terminal application (/Applications/Utilities/Terminal). When Terminal is launched, it opens up a terminal window running a shell program, as shown in Figure 23-1.

Figure 23-1. The Terminal application running in Mac OS X

Before we jump to far ahead of ourselves, though, there are a few things worth learning up front that will be helpful on your journey into the command line. The first thing you need to know when working with Darwin is some of the common language and terms used when talking about a command-line environment, in order to avoid confusion. Next, you need to know how files are organized; and finally, you need to know how to move around the file system.

Darwin Semantics

To avoid confusion as the chapter proceeds, we should quickly go over some of the important terms used in Darwin and how they compare with terms used in the Finder. Table 23-1 defines a handful of terms used commonly in Darwin (and other UNIX systems), gives the Finder equivalent or alternate term, and adds any relevant notes. While there are many other terms you'll come across, these basics will be used repeatedly, so they are good to know.

The File System

The Darwin file system shares the same folder structure found while navigating through the Finder. However, while navigating through Darwin, you will notice a few differences. First, there are quite a few more visible items in the Darwin view. Second, you will find that your additional volumes (added hard drives, CD/DVD drives, flash drives, etc.) are found a little differently.

The Darwin file system starts from root, which is symbolized by /. This is the highest level of the file system and is essentially the same as viewing your primary hard drive in the Finder. A quick look in our root directory reveals the following items (the trailing / and @ symbols that follow have special meaning and are only visible when you use them with the F flag: / indicates that the item is a directory [or folder], and @ indicates that the item is a link [or alias]):

As you can see, all the basic Finder folders—Applications, Library, System, Users, and Developer (provided you've installed the Xcode tools)—are there, along with a slew of other items. Some of these are merely system files that are of little interest to most people. Table 23-2 shows some common directory paths and describes what sorts of files are located in them.

Introducing the Shell

The Terminal application (go ahead, fire it up) is essentially an empty window that can display and accept text input. In order for you to actually do anything, Terminal must run a shell program. Just as the Finder allows you to move around and interact with items in Mac OS X's GUI, the shell allows you to move around and interact with items on the command line. Bourne, Tcsh, and Zsh (the C shell is also listed as a shell—however, it is actually a link to Tcsh). Of the five, the shell Mac OS X uses by default is Bash.

The first time you launch Terminal, you'll be greeted by some text similar to this:

The first line tells you when you last logged into Darwin (even if you've never logged into Darwin before intentionally, you'll still get a message saying you did); the second line is the default prompt for Bash. The default prompt (which, like most everything else in Darwin, can be changed) gives you some important information. First, it gives you the name of your computer, which is either assigned by your network or taken from the Computer Name field in the system's Sharing preference pane. Next, following the :, the prompt gives you the name of your current directory in the file system (the ~ is a shortcut representing your home directory). Then the prompt gives you the username you are logged in as, followed by the $ prompt (which will change to a # if the user is logged in as the root user, otherwise known as the super user). Finally, you get the cursor patiently a waiting your command.

As you will soon see, shells possess some hidden powers that can make your interactions with Darwin more pleasant and add a new level of power and flexibility to the command line. Before you look at the shell in more depth, though, you should first learn a bit about the Darwin file system, as well as a few basic Darwin commands.

Moving Around Darwin

One of the first things you need to learn about the shell is how to move around and view the file system. To do this, there are three basic commands to start with: ls, cd, and pwd.

ls

ls is the “list” command, and by default, lists all the visible files in a directory. If you're familiar with the Windows command line, it would be the replacement for dir. By default, the ls command looks something like this:

The first thing you may notice is that by default all directories (folders), files, and executables (applications) look the same when using the ls command (of course, in this example, they all are directories). That's because, as we mentioned previously, Darwin treats everything as a file. To differentiate between the different types of files, there are two primary options:

• ls –F: Appends special files with a symbol to determine their type. It adds a / to directories, an * to executables, an @ to symbolic links (aliases), and a few other symbols for other special file types.
• ls –G: Colorizes the output using different colors for different file types as well as other file options. For example, by default most directories will appear blue; however, world-writable directories will appear black with a yellow background. Likewise, most executables will appear red, and most symbolic links will appear purple—however, if certain attributes are set, this will not always be the case.

Like most command-line commands, the options can be combined. For example, you can use -F and -G together:

Other important ls options include the following:

• ls –l: Displays a long list that provides additional information about each file. We'll cover what everything here means later in the “File Permissions and Attributes” section of this chapter, but for now the results appear to be something like this:
  Simba:~ scott$ ls -l
total 0
drwx------+  5 scott  staff   170 May 15 09:28 Desktop
drwx------+  8 scott  staff   272 May  6 15:13 Documents
drwx------+ 14 scott  staff   476 May 25 16:18 Downloads
drwx------@ 42 scott  staff  1428 May 15 18:29 Library
drwx------+  3 scott  staff   102 Apr 28 18:42 Movies
drwx------+  4 scott  staff   136 May  7 13:54 Music
drwx------+  5 scott  staff   170 Apr 30 13:53 Pictures
drwxr-xr-x+  5 scott  staff   170 Apr 28 18:42 Public
• ls -a and ls –A: Prints out a file listing that includes hidden dot files. There are two main types of files hidden on your computer: some that are hidden by default from the Finder but show up normally in Darwin, and others (the dot files) that are generally hidden in Darwin. These dot files (called that because they always begin with a .) are often preference or configuration files. They are usually hidden to reduce clutter, not for some nefarious purpose (although you may find that some Aqua applications utilize these hidden files to hide something they really don't want you to find). The main difference between ls -a and ls -A is that using ls -a will show two special files found in almost every directory—the . and the ..—which represent the current directory and the directory immediately above, respectively (these act the same as the . and ..files shown when issuing a dir command at the Microsoft Windows command prompt). A common ls -a on a home directory will produce quite a few more files than just a vanilla ls (three times as many or more is not uncommon):
  Simba:~ scott$ ls -a
.                                .cups                Movies
..                               Desktop              Music
.CFUserTextEncoding              Documents            Pictures
.DS_Store                        Downloads            Public
.Trash                           Library

While there are significantly more options available for the ls command, those are the most common and should get you started on the right path. You may learn a few other options as you go along, and later you'll learn about the man command, which will allow you to learn more about the ls command (and most others) than you care to know.

Listing a Directory Other Than Your Current Directory

Besides ls's many options, ls will also accept a directory or file name as an argument. This allows you to view the contents of any directory without actually moving into that directory, or explore a single file's attributes (using the -l option). For example, if you're in your home directory but want to view the files in your Documents folder, your can do this by adding Documents as an argument—for example:

Furthermore, if you want to find out more about a specific file, you can enter a command like this:

Now that you know how to list other directories, the next thing you may want to learn is how to move into them (virtually anyway).

cd

The cd command allows you to move from one directory to another (or as the command implies, it allows you to change directories). The cd command doesn't have any options, and it only accepts a path name as its single argument.

To issue the cd command, simply type cd followed by your destination, like so:

If no argument is given, then cd will take you back to your home directory:

Finally, if cd doesn't recognize the argument as a file or directory, it will tell you so:

This is an error statement, and most well-written functions and executables will provide some sort of error message if the information you provide doesn't make sense to them.

pwd

The final command in this section is the pwd command. The pwd command returns your current working directory, as this information is available by default in your prompt (after the :). You may not need to use this command too often—however, it is useful in illustrating the file structure of the system and can come in handy when you need to pass your current path into a script. Also, it's possible that you may find yourself stuck in a foreign shell on a foreign machine, where you may actually need this. The basic pwd command looks like this:

In this case, pwd returns the absolute path of your home directory rather than the abbreviated ~ in the command prompt.

Being a rather simple command, pwd only offers two extra options:

• pwd -L: Prints the logical path to your working directory
• pwd -P: Prints out the physical path to your working directory, resolving any symboliclinks

  NOTE: Logical paths and physical paths have to do with resolving symbolic links and aliases. For example, if you entered cd /etc and then entered pwd –L, the output would be /etc because that is where you are (logically); however, since /etc is a symbolic link, entering pwd –P would provide you with the actual physical location /private/etc.

Wildcards

Before moving on to more Darwin commands, we should have a quick lesson on wildcards and pattern matching. Wildcards are special symbols that, when used with other commands, can help limit or expand the results. Table 23-3 shows the three major wildcards and what they represent or match.

To put this to use using what you learned previously, if you cd to /usr/bin and list out the contents using ls, you are struck with a rather large list of files (in this case, mostly executable commands). Wildcards allow you to selectively list out the directory contents in more manageable chunks. For example, if you just wanted to list the files that begin with v, you could use ls v*, like so:

If, for whatever reason, you wanted to expand the search to include b and v, you could use ls [bv]*:

Note that like most things in Darwin, the characters used within the square brackets are case sensitive, so [bv] would not match any Bs or Vs.

Finally, if you wanted to list all files with two-letter names that begin with any letter in the alphabet from b to v, you could use ls[b-v]? and get the following:

Working with Files and Directories

While most people are perfectly happy and comfortable working with files and directories in the Finder, there are some times when it's either necessary or advantageous to work with files on the command line. Of course, like all things, before you are able to unleash the power of the command line, you need to learn a few basic commands for working with files and directories. These basic commands are shown and described in Table 23-4.

To illustrate how all of these work, we've created a test file named soliloquy4 in a directory named Shakespeare.

First, you can use the cat command to view the file:

Now, if you weren't sure what this file was (or how long it was), you could use head to view just the first three lines:

Likewise, you could use tail to view the last three lines:

To make a copy of the file, you would use the cp command:

You could then create a new subdirectory:

and then move one of the files into the new directory:

You can also use the mv command to rename a file:

Next, you could try to remove the Macbeth directory:

Oops, first you need to remove any files in there:

Finally, you can create a new empty file with touch:

More Essential Commands

There are literally hundreds of commands available at the command line, and it would take far more space than we have in this book to cover them all; however, as you progress through the rest of the book, you will learn a number of new commands when they are applicable to the topic at hand. In the meantime, there are a number of essential, or at least very useful, commands that you may want to know about that don't fit nicely in a future discussion in this book. They are covered here.

man

The man command is the command that explains all others. If you want to learn more about the ls command, enter man ls, and your terminal will open into a special mode (called a pager) for reading man pages, which will look something like this:

Now this is just the first page of the man page—you can scroll through the rest using either the arrow keys (to move up and down one line at a time) or the spacebar (to move through one page at a time). When you are done, you can exit the man page by pressing Q on the keyboard.

grep

The grep command searches through files or results for a specified string and then prints out the lines that contain a match. For example, using the preceding text file, you could print out all lines that contain “to” using the command grepto tomorrow. This is shown here:

ln

ln is the command-line utility for creating links. While there are different ways of linking files, what we are most concerned with are symbolic (aka soft) links (more commonly referred to as aliases, or shortcuts in Windows). To create a symbolic link, you use ln with the sswitch, followed by the name of the source file and then optionally the name of the linked file.

Let's look at ln in action:

who

The who command tells you who else is logged into the computer. Normally, this would just be you, since most personal computers would only allow one person to be logged in at a time (and this is how we still tend to use them). However, if you've turned on the Remote Login option on the Sharing control pane, it's possible for multiple users to actually be using one Mac OS system at a time. who also has a related command, whoami, which also tells you your username if you ever forget. (By the way, your Darwin username is the “short” username you picked when you created your account.)

Seeing these in action on your system isn't always that exciting:

ps

ps allows you to view what processes are running at any given time on your system. By default, it shows limited information about all the services running from the terminal you are using (i.e., only the current Darwin process that you've started from your current terminal session). Until you really start digging into the power of Darwin, ps will likely just return your shell as your only process:

The important pieces of information here are the PID (process ID) and the CMD (command). However, with a few options, ps can give you lots of information about every command running on your system. The most common options are -a, -j, and -x (so common, in fact, that you can issue them without the -). The ps command will most likely give you a long scrolling list of processes (the following list has had a significant chunk of the output removed for brevity):

This gives you much more information besides the PID and CMD (which is the full path, and as shown, is often truncated by the width of the terminal), including what user is responsible for the process. By default, the information is sorted by the process ID. If you want to filter this to show only what tasks a specific user is running, you can use the -u option. For example, if you just wanted to see how many processes you are personally responsible for, you could use the following:

kill

kill is used to stop a specific process. This can be necessary if you have a task that is running amok and you can't figure out how else to stop it (perhaps you are attempting to write your own application or script, and it gets caught in a nasty loop).

To see this in action, you can intentionally create some nasty background tasks using the yes command, which you will then kill.

To do this, first start running yes in the background twice, and then find out what the process ID of each yes process is and kill it:

There are a few things we should explain. The yes command you entered, yes > /dev/null &, takes the output of yes and redirects it to /dev/null, which is a special device in most UNIX systems that is a black hole of sorts. Everything sent to /dev/null just goes away. The > is the redirect command, and the & tells the terminal to run this in the background. We will cover background tasks and redirections later.

Finally, you may notice the ps command shows that one yes process is using 99.3 percent of the processor, and the other is using 97.8 percent, and these numbers don't seem to add up. The reason for this is that the %CPU shows the percentage for a single processor. Most Apple computers these days include at least two processing cores (including ours shown here), so in this case, one yes command is using 99.3 percent of one, while the other is using 97.8 percent of the other (your mileage may vary).

Occasionally, a simple kill still won't stop a process; in that event, you'll need to use kill -9 to stop the process. The -9 signal runs kill in Kill mode, which means that the process will force stop immediately.

less (more)

less is a pager, which allows you to scroll through large amounts of text that may normally scroll right by you in the terminal. You learned how pagers worked with the man command, which automatically runs in a pager (which by default in Mac OS X is actually less); however, sometimes it's useful to use a pager with other commands as well. For example, when you use the ps aux command, you are presented with lots of information scrolling right by; however, if you pipe the ps aux command into less, then you can scroll around the output just as you scrolled around the man pages. An example of this is the following:

Using the arrow keys, you can now scroll through your output, and when you are done, you can quit the pager and return to the prompt by pressing Q.

find and where is

find and whereis are two commands that work very differently, yet are both used to the same ends: finding something in the Darwin file system.

find, by default, takes a path variable and presents a list of matches. Additionally, if a match is a directory, find will traverse that directory as well (find / will return every visible file on your hard drive!). Using regular expressions and wildcards can effectively narrow (or broaden) your search as needed. A simple find example may be something like this:

Listing directories is nothing new, but find becomes very useful with its ability to search for matches of specific file properties, the most popular being the name of the file. To use find this way, you give find the directory you wish to traverse, and then enter the -name option, followed by your search string. For example, if you were looking for the soliloquy in your Documents folder, you could use the following:

Other properties that you can use as search parameters for find include the file's owner and its group.

Unlike find, whereis is tailored specifically for finding executable files. It does this by specifically searching the common places where programs live (primarily the various bin and sbin directories for a specific program name you enter). For example, if you wanted to see where the whereis command is located, you could do this:

While this may seem trivial on a certain level, there are a couple of good reasons to use this. First, if you occasionally compile or install your own Darwin software (which we'll talk about in the next chapter), at some point you may end up with two copies of the same program, and whereis will help you find them so you can deal with it. Second, scripts written in languages like Perl, Python, or Ruby often want to know where the language executable is, and whereis provides a quick way to determine that.

Pipes, Redirection, and Background Tasks

A few more things we should cover before we move on are the ability to pipe one command into another, the ability to redirect output (or input) to and from a command, and the ability to run tasks in the background. We've actually done each of these things in some of the preceding examples, yet as they are quite powerful, we'll give a bit more depth here.

Pipes

Piping one command into another is a great way to make even the simplest Darwin tools do powerful things. You saw this previously when you piped the ps command into the less command. The pipe symbol is the | (which is the tall line that lives above the on a normal US Mac keyboard). In practice, this takes the first command and sends the output into the second. For example, the ability to take commands that produce large amounts of output and pipe that content into a filter (like the grep command) can save lots of time and headaches.

Redirects

A redirect allows you to redirect the output of a command into a file, or alternatively direct the content of a file into a command. The symbols for redirection are < and >. A very simple use of a redirect is to create a text file using echo, like this:

The echo command normally would just print whatever you feed into it back to your terminal, but here we have redirected the output to name.txt (which may or may not have existed).

If you want to redirect additional data into an existing file (rather than replace the content, which the > always does), you can use >> to append the new data to the old:

Background Tasks

Any Darwin command can be issued to run in the background with the & symbol tacked onto the end of the command. This is particularly useful when you want to start a command that may take a long time to finish, or when running a task that you want to keep running indefinitely. For example, if you want to use the find command to find something with the name profile somewhere on your system, knowing that this may take some time, you may want to run it in the background. Here's an annotated example of this:

Here you start the find command in the background. You are redirecting the output to a file named found. The 2> found_err part of the command will redirect any error messages to a file named found_err. Without the 2> found_err, even though the command is running in the background, error messages would still spam the terminal (2> is a special redirect in Bash that only redirects error messages).

The jobs command gives you a list of all of the background tasks and tells you their state (in this case, your only task is running).

The fg command (fg for foreground) brings forward the first running task (which for now is your only task). Since the command is running in the foreground, you can no longer use the terminal unless you pause the process. You can do this using the Control-Z key combo.

When you use Control-Z, you are giving the message that your task has stopped. You can now resume this task in the background using bg:

While this task runs, let's start another background task:

Now you have two jobs running in the background, your find command is still chugging along, and you have the new command (which will wait, or sleep, 30 seconds, and then run the echo "done" command). Notice that each job has been given a number. The find command is [1], and the sleep command is [2]. To pull the sleep command into the foreground, you must specify that you want job 2.

Eventually, the sleep command will complete and echo “done” to the terminal. At this point, you can continue to use your terminal, and eventually you will get a message that your find command has completed.

Working As Root

In Darwin, the root user is synonymous with the administrator, superuser, or all-knowing, all-doing, grand poobah. Working as root is sort of like splitting the atom: great potential for good, great potential for total destruction. In the case of root, that which gets destroyed can vary from an important file to all of your data and the OS itself. Root has few boundaries and restrictions, and it can override all the security safeguards on the system. As such, you should never use it. Of course, sometime you may need to, or at least want to really, really badly.

So, when should you run a command as root? When there is no other way to run it. For example, when we ran our find command on the whole hard drive, we received a number of Permission Denied warnings (take a look at our found_err file). If we in fact wanted to search those protected files and directories, we would have to do so as root (or as the owner of the specific protected files or directories). Additionally, while you may be allowed to see and use many of the files and directories in Darwin, you won't be allowed to alter them or add new files to the directories. If you need to alter a configuration file, or install a new Darwin application in a specific location, or do one of many other related tasks, you will often have to do so as root.

When the time comes to run a command as root, one generally doesn't log out and log back in as root (which Apple goes to great lengths to make very difficult to do anyway). Instead, the recommended way is to utilize the sudo command.

sudo

The sudo command (which means substitute user do) allows selected users (only users with administrator privileges, by default) to run any other command as the root (or any other) user, as specified in the sudoers file (located at /etc/sudoers).

To run a command as root (which is sudo's default nature), merely precede the command with sudo—for example, if you wanted to manually run the weekly maintenance script, you would do so like this:

As you can see, the first time you use sudo, you are given a stern warning about the dangers of using sudo, followed by a prompt for your password. Upon entering your password, the command will execute. The preceding warning will only appear the first time you use sudo—however, each time you use sudo, you will be prompted for a password, with one caveat: by default, sudo will save your password for a period of time (5 minutes is the default), so you won't have to reenter it for any subsequent sudo commands within that time period.

By default, sudo allows root and any user in the admin group to utilize it. If a nonadmin user attempts to use sudo, instead of his or her chosen command being executed, that person will be presented with the following warning:

To run a command as a user other than root, sudo offers the -u option, which you would use as follows:

On the slight chance that you really must execute a series of commands as another user and you'd like to maintain the user state for an extended period of time, sudo offers the -s option, which in effect starts the shell as the specified user. Since this command starts a shell as the specified user or root, no additional command is necessary. By default, this is the equivalent of using the older su command. If you must use this (and it's recommended that you don't), it's important to remember to quit (i.e., type exit) as soon as you are done—otherwise, you will remain in root state and are more likely to do something regrettable (or forget you are logged in as root and walk away from your computer for a cup of coffee or something and allow someone else to do something perhaps even more regrettable)!

The sudoers File

The sudo defaults are sensible and appropriate for most computer uses. However, for servers or other computers with many users, sudo can be coaxed into providing very specific, fine-grained privileges to individual users or groups. To do this requires editing the /etc/sudoers file. The catch is that to edit this file, you must have root privileges and you must use a special editor named visudo. visudo is really a special mode of the Vi editor—or more specifically, Vim, which stands for Vi improved, and is installed on Mac OS X in place of Vi. The easiest way to accomplish all this is to merely use the following:

This immediately opens up the sudoers file to be edited (assuming you understand how Vi works, which if you don't right now, we will explain in the next section).

Sadly, a discussion of the many specific tweaks that can be made to this file would extend far beyond the confines of this book. However, typing man sudoers brings you to the man page for this particular file and explains in detail things like the extended Backus-Naur form, what exactly it means, and how to put it touse.

Editing Files

Editing files in Darwin is just one of those things that you'll eventually have to do to get the most out of it. For the most part, using a normal Mac OS X text editor like TextMate (€39, about $54), BBEdit ($49.99), Text Wrangler (free), or one of the many other text editors, may be your best bet—however, at times it may be handy or necessary to edit a file on the command line. Mac OS X ships with four command line–based text editors: Ed, Vim, Emacs, and Nano. Ed is the original text editor for UNIX, but many newer text editors have surpassed it in both usability and features. Despite this, it is still included in most UNIX distributions, since it has found a small niche within certain shell scripts. Each of the remaining three has its advantages, and what it comes down to for most people is a matter of taste and habit (i.e., once you start using one, it becomes a bit frustrating to use another, since they vary quite a bit).

Vim

Vim is, as the name suggests, an improved clone of Vi (Visual Editor), which in turn is based on Ex, which is based on the aforementioned Ed (which was based on an even older text editor called QED). Vim can be baffling to people new to command-line editors because, like its predecessors, it is a dual-mode text editor. To get things done, you must switch between an insert or edit mode and a command mode. While this way of working with a text editor takes some getting used to, it's fairly easy once you get the knack of it. Also, Vim, Vi, or one of its clones is installed by default on almost every version of UNIX or Linux, so once you learn it, you can count on something like it to be installed on any UNIX (or UNIX-like) system you encounter.

When you launch Vim, you can either open an existing file, create a new file, or just jump into the editor without creating a file. The syntax is fairly straightforward:

where filename is either an existing file or one you wish to create.

Vim begins in command mode when opening a new or existing file; so, if you open the soliloquy file you've been working with in this chapter, you will be presented with the following:

Some things to note here are the following:

• The cursor begins on the first letter of the first line.
• Lines on the screen beginning with ~ indicate that the line is empty (not just blank, but empty—in other words, it's not there).
• The line at the very bottom of the screen is the informational display. Initially, it displays the name of the file, how many lines the file contains, and how many characters the file contains.

In command mode, the keys and key sequences have special meanings. For example, you can move your cursor around the text using the arrow keys, or the H, J, K, and L keys (old UNIX keyboards didn't all have arrow keys). If you are searching for a particular word (e.g., candle), you could use the search function, which is / followed by your search term. /candle followed by the Return key moves the cursor to the first letter of the first instance of candle that it finds. If you want to continue to search for the next occurrence of your search term, you can use an empty / and then press Return. In this particular case, since there is only one occurrence of candle, the informational line at the bottom tells you the search hit BOTTOM, continuing at TOP. If there were more occurrences of your search term, / would continue to search forward in your text for them. To search backward, replace the / with ?.

To actually enter text, you need to enter insert mode. You can do this by typing i, which starts inserting at the point where your cursor is. Alternatively, typing I begins inserting text at the beginning of the line you are on, and o starts you at the beginning of a new line immediately below the line your cursor is on. In insert mode, you can type as you would normally. To exit insert mode and return to command mode, press the Esc key.

When you are done editing your file, you can save it (while in command mode) using :w followed by Return if you wish to save it with the name that you initially opened the file with. Alternatively, you can use :w filename to save the file with a specific name.

When your file is saved and you are ready to quit, you can quit using :q. Alternatively, you can save and quit in one shot using either :x, :wq, or (our favorite) ZZ.

Once you get used to working with two modes in Vim, the next thing you'll want to do is explore the features of the command mode. To help, Table 23-5 lists common commandmode keystrokes and what they accomplish (this is by no means a complete list).

Emacs

Emacs (or GNU Emacs, as the faithful like to refer to it) is another popular text editor (perhaps it may be best described as a powerful runtime system with text-editing capabilities). Emacs can do wonderful things provided you take the time to learn a rather large number of mystical key combinations (and learning a little Lisp helps too). In fact, people who love and use Emacs (who really should have a name to describe them—like Trekkies or something, since they tend to share the same sort of devotion) won't settle for anything less.

Unlike Vim, Emacs is a single-mode text editor; so, in that way, it's probably similar to most GUI text editors you may have used. However, since it lacks a GUI, you can't use your mouse to access the fancy features. That's where the crazy keystrokes come into play. In general, these keystrokes use either the Control key or the Meta key plus some other key (in Emacs, the shorthand for this would be something like C-k for Control-K, or M-k for Meta-K). Usually, you would hold these keys at the same time. The gotcha here is that the Mac keyboard doesn't have a Meta key. You can fix this by selecting the “Use option as meta key” option in Terminal's Settings preferences (on the Keyboard tab, as shown in Figure 23-2).

Figure 23-2. The “Use option as meta key” option is found in Terminal's Settings preferences.

As with Vi (described previously), you can either open an existing file, create a new file, or just start with a scratch buffer when you launch Emacs using the emacs [filename] command. Opening the soliloquy file produces the following output:

Once the file is open, it's immediately ready to edit. To move around in the file, you can use either the arrow keys or some C-n keystrokes (C-f, C-b, C-p, and C-n). The Delete key works as you would expect, and you can enter text at the cursor just by typing.

To save the file, you can either use C-x C-s to save the file with its existing name, or C-x C-w to save the file with a new file name. C-x C-c quits Emacs (it prompts you to save any changed files first). If you need to edit an additional file, you can use C-x C-f to open or create another file without quitting Emacs. Table 23-6 provides a handy list of a few common keystrokes and their effects.

Nano

Nano is another handy command-line text editor in Mac OS X. What makes Nano special is that, compared to the others, it is relatively easy to figure out and use. The trade-off is that it lacks some of the more advanced (esoteric) features of Vim and Emacs, and while it's installed by default with Mac OS X (since Tiger), it's not as pervasive as Vim or Emacs.

One advantage of Nano is that the most common commands, along with the keystrokes to invoke them, are listed at the bottom of the screen (and the ones that aren't listed are easily looked up with the short yet concise built-in help). While the keystrokes may seem similar to Emacs in practice, the actual keys are different. Also, the common shorthand is different—while in Emacs, Control-X is represented as C-x, in Nano, it's represented as ^x (the ^ [caret] symbol means Control).

Opening files in Nano is the same as opening them in Vi or Emacs. Just type nano filename at the cursor, and it will open up. Once again, opening the soliloquy file, you would see the following:

As you can see, at the top of the window Nano identifies the open file, and at the bottom it provides a list of common actions. The action list at the bottom will change based on circumstance—for example, when you go to save a file (using ^o), you will be prompted for the file name you wish to save your file as. The action list will also provide some other saving options (creating a backup, appending this file to another, etc.). With the short help file included with Nano, plus the adaptive action list shown, we're going to forgo the table of commands since it would largely beredundant.

File Permissions and Attributes

File permissions are a central concept found in UNIX systems. They allow one user to share files with everyone else on the system while still maintaining control of those files. The easiest way to view these permissions and attributes is with the ls -l command. For example, one line from an ls -l command may look like this:

The first string of 11 characters represents the permissions. Also of interest here are the file's owner (scott) and the file's group (also scott). The first ten characters are broken down as shown in Figure 23-3.

Figure 23-3. Insert Figure Caption

The permissions are r, w, and x, signifying the ability to read, write, and execute, respectively (these are often referred to as bits). In the case of a directory, the execute bit signifies the ability to list files in the directory. The owner of any file can set these permissions as he or she sees fit using the chmod command. Additionally, the owner can reset the group to which the files belong to any other group the owner belongs to using the chgrp command.

The chmod command can be used one of two ways to set the permissions (also referred to as setting the mode): either literally or symbolically. The literal way is to specify the permissions as a string of numbers such as the following:

where nnnn is the combined value of permissions based on Table 23-7.

For example:

would result in the filename having permissions -rwxr-xr-x.

The other, symbolic, way of setting permissions is to use chmod in the following way:

where u stands for owner, g stands for group, and o stands for other (everyone); followed by + (for adding) or - (for denying) permissions (r, w, and x).

For example, if you had a file with the permissions -rwxr-xr-x, but you wanted to allow anyone in its group to also write to the file, you could just use the following:

This would effectively just add write permissions to the group for filename.

Suppose you create a file and then wish to give special permissions to a group of people. By default, any file you create will have both the owner and group listed as you. You can change the group file to any other group that you belong to using the chgrp command with the following syntax:

To find out what groups you belong to you (and thus what's available to you), you can use the id command, like so:

So in this case, if you want to allow anyone in the admin group to be able to write to your soliloquy4 file, you could do the following:

ACLs and Extended File Attributes

ACLs (access control lists) and extended attributes were introduced to OS X in Tiger (OS X 10.4), but while they used to simply be an option available to those who wished to use them, they are now used by default.

ACLs allow fine-grained control of a file's access far beyond UNIX's historical owner/group/everyone permissions. With ACLs you can control specific permissions for specific users or groups, and you can treat each user and group differently.

Specifically, each file on your system has one ACL, and each ACL may contain an ordered list of entries. Each entry sets specific permissions for a single user or group.

Files with entries in their ACL will include a + in the 11th character in the permission listing when you use ls -l. If there are no ACL entries, but there are other file attributes for the given file, then the 11th character will contain an @. If there are no ACL entries or attributes, then the 11th character will be left off.

To view the ACL associated with a file, use the -e option with the ls command—for example, here's what one of our home directories looks like:

When you look at the ACLs attached to the default folders in your home directory, you'll see that they are set to deny everyone from deleting them. Don't be afraid to try it; if you try a rmdir, you'll get a Permission Denied warning, and if you try to drag the folders into the trash, you'll get a warning telling you that that directory can't be modified or deleted.

To view a file's attributes, use the -@ option with ls.

To add entries to or delete entries from an ACL, you use the chmod command with +a (to add an entry) or -a (to remove an entry). When you are adding an entry, the new entry will be added to the ACL. To remove an entry, you need to specify the entry number using #n directives. Here are some examples of working with ACL entries:

The types of actions you can control in ACLs depend on the type of file. The following actions are settable for any file:

• delete
• readattr
• writeattr
• readextattr
• writeextattr
• readsecurity
• writesecurity
• chown

The following actions are settable for folders/directories:

• list
• search
• add_subdirectory
• delete_child

Finally, the following are available for non-folder/directory items:

• read
• write
• append
• execute

More details about ACLs and controlling them are available in the chmod man page.

Customizing Terminal and the Shell

Once you start getting into using the command line, you may want to make a few tweaks to both the Terminal application and your shell environment to streamline how you work.

Terminal Setup

The Terminal application that Apple ships with Mac OS X is a nice, feature-rich application. It includes tabbed windows, which are handy for those who work with multiple shells or must access many remote terminals at the same time. It includes the ability to save different window settings that control the appearance and behavior of your terminal. The latest version that ships with Lion can be switched to full screen for a very retro-looking interface.

One of the first things you may want to do when working with Terminal is adjust how it looks and make a few other tweaks (such as remapping the Meta key if you are a big Emacs user). The options to control your terminal settings are listed under the Settings tab of Terminal's preferences (Figure 23-4).

Figure 23-4.The Settings tab of Terminal's preferences

The Terminal Settings preferences provide a number of different possible terminal styles listed in the column on the left. In the preferences, you can set options for each setting individually using the five tabs: Text, Window, Shell, Keyboard, and Advanced.

The text settings control the font size, face, and colors. They also allow you to set the options for the terminal's cursor.

The Window tab allows you to set options for controlling the background color, title bar information, initial window size (set in character width and line height), and scrollback buffer.

The Shell tab allows you to set special shell startup commands, as well as options about what happens when you exit the shell or try to close the window while a shell is still running.

The Keyboard tab allows you to set up key bindings, and it lets you toggle the option to use the Option key as the Meta key.

The Advanced tab allows you to set a few other miscellaneous options pertaining to terminal emulation, bell actions, and text-encoding options for foreign languages.

The other main Terminal preference tabs include the Startup tab, which allows you to select the default settings to use when Terminal launches, as well as what type of shell Terminal should use upon launching; the Window Groups tab, which allows you to save the behavior of multiple Terminal windows together as a group; and the Encodings tab, which allows you to select which text encoding should be made available to Terminal's settings.

Setting Up Your Shell Environment

Every shell has what is referred to as an environment, which is basically made up of customized variables and commands that make the shell work the way you want it to. The Bash shell stores this info in a number of places. The variables that apply to everyone are stored in /etc/profile and /etc/bashrc. Additionally, you can make your own personal configurations to ~/.bashrc and ~/.bash_profile. As a general rule, things that affect your environment should go in the .bash_profile file, and things that affect the shell specifically should go in the .bashrc file.

One common environmental variable that you may want to set is the $PATH variable. The $PATH variable describes where your shell will look for executables when you attempt to launch one from the command line. By default, your $PATH is set to include /bin, /sbin, /usr/bin, /usr/sbin, /usr/local/bin, and /usr/X11/bin (in the /etc/profile file). However, if you begin to install new executables, or even write your own, you may find that you need to add additional directories to your $PATH. The syntax to add a directory to the $PATH is as follows:

You can add as many directories as you need, separated by a colon. The $PATH at the beginning represents your existing path; without it, any of the default $PATH directories will be removed from your $PATH. To have your path updated each time you launch a shell, it's best just to put this info in your .bash_profile file. For example, the common .bash_profilefile may look like this:

Any line beginning with # is a comment. Here, some of the built-in scripting functionality is used to check if common executable directories exist—if they do, then they are automatically added to the $PATH.

The last part checks to see if the .bashrc file is present; if it is, then it is included as well.

The .bashrc files generally contain variables and commands that are specific to the shell. For example, the default /etc/bashrcfile sets the prompt variable. Other things that are generally included in the .bashrc files are common aliases and shell functions.

For example, a .bashrc file may contain the following:

Again, the lines that begin with # are comments.

Creating Commands with Aliases and Functions

The preceding sample .bashrc file shows a few aliases and a function. Essentially, these are both ways to create simple command-line commands that carry out more complex commands. In general, an alias provides a way of creating a shortened version of a single command, while a function creates a command out of an actual shell script that may consist of many commands and simple logic.

Aliases are incredibly handy when you find you are using the same commands over and over and want to simplify them; you can even use them to essentially overwrite the default behavior of a command. Take the first alias listed previously:

This command creates the ls alias from the ls -FG command, effectively overwriting ls so that it will, by default, provide colored output and the benefits of the -Fflag as well. The other two aliases in the previous .bashrcfile example also create aliases to other common ls options.

Functions, on the other hand, are more complex, as they are essentially simple shell scripts. Here's an example from the preceding.bashrc file:

The first line defines pman as a function accessible from the command line, and everything between the curly braces defines what happens when we use the pman command. So, if you were to enter pman ls at the command line, the function would take the first argument, ls, and run man -t ls | open -f -a /Applications/Preview, app/, thus allowing you to open the man page of any command in the Preview application in one simplecommand.

Summary

Whew, there was lots of info in this chapter. While the aim wasn't to teach you everything about working with the command line (which would take an entire book in itself, and still leave out details), hopefully you now know enough to get around the command linecomfortably, and more importantly, have a good base to build upon where you see fit. We will be using the info in this chapter to build upon in various upcoming parts of this book, beginning with the next chapter, where we will take a quick look at adding to the abilities of Darwin by creating our own simple scripts and adding new programs from other sources.