Below is information on about the Unix shell. Although modified for users of
Ripco BBS, it is generally applicable to all Unix shell users
kelly
Archive-name: shell/part3
THE UNIX SHELLS
What is a Unix Shell?
A Unix shell is a command line interface program. All a shell does is
accept input line by line and run various programs and utilities. The
shell is similar to the DOS environment in many ways, but much more
powerful. In this chapter, we will discuss how a shell works, from
files and directories to advanced network commands.
Bourne Shell (sh)
The Bourne Shell is a good shell for programming.
Korn Shell (ksh)
The Korn Shell (ksh) is the default shell for Ripco. It is an
updated version of the Bourne Shell, and is usually used in its
place.
C Shell (csh)
The C Shell is a 'C'-language-like operating environment. It
has been made obsolete by the tcsh shell.
Modified C Shell (tcsh)
The tcsh shell is an improved version of the C shell (csh) and
has rendered it obsolete.
For more information on any of the shells, see the online help.
Structure of a Unix Shell
At first, using a Unix shell might seem a bit cryptic, even downright
confusing. However, it doesn't have to be. Using a Unix shell is
powerful and quite rewarding, provided the user takes time to get used
to it. Unix, like DOS, revolves around a few simple commands to
navigate and manipulate files and directories. The headaches come when
trying to cipher through the hundreds of utility programs. Later in
this chapter, we will touch upon many of the most important utilities.
In this section of the manual, we will take a look at the Unix file
system, the heart of the Unix shell. Similar in many ways to DOS, Unix
shells provide a way for users to examine files, navigate through
directories, and run programs. If you are already familiar with DOS
commands and file structures, then you are well on your way to
understanding the Unix shell system. If you have no prior experience
with DOS, don't fret: we will take you through the whole thing step by
step.
First, we must define a few terms, beginning with files and
directories. It is best to picture a file the same way you would
picture a file inside a file cabinet. There are many of them, and they
are usually named to give a clue as to what is in the file. The file
can contain a variety of information, such as text (documents), or
actual programs. A directory is the medium in which files are
contained, like a file cabinet drawer. For example, to find all the
files pertaining to 'A', you would look in the drawer (directory)
marked 'A'. Inside file drawer 'A,' you might find a list of
subcategories (subdirectories) that would then guide you closer to the
file you are looking for: i.e. in file drawer A, you would find the
subcategory 'ART' in which all files pertaining to art would be
stored. Similarly, on a Unix machine, you would look under directory
A, then under subdirectory ART for files pertaining to art.
On a Unix machine, you might find the directories msdos, Unix, and
Mac. Under msdos you would find a list of subdirectories pertaining to
DOS machines. One of these subdirectories might be 'graphics', under
which all DOS graphics files are kept. Get the picture?
The Unix File System
Like DOS, Unix contains a system to store files on disk to provide for
some type of order. This is done by a 'directory tree' system. In DOS,
the following example is the same:
Directory of C:\
WINDOWS <DIR> 09-11-94 10:51pm
USERFILE >DIR< 10-12-90 11:12am
COMMAND.COM 39041 11-12-94 10:01am
CONFIG.SYS 1022 12-11-86 09:15pm
C:\>
The above example shows the directory listing of the first (or root)
directory on an DOS machine. As you can see, there are two
subdirectories named WINDOWS and USERFILE. Subdirectories are
directories that are stored under the directory at which we are
looking, in this case, the root directory. These directories are
marked by the <DIR> flag in the column to the right. There are
also two files present in this directory, COMMAND.COM, and CONFIG.SYS.
We know that these two files are files because they have their size
listed in the column to the left instead of <DIR>. COMMAND.COM is
39,041 bytes in size, and CONFIG.SYS is 1,022 bytes in size. By
entering the command 'CD WINDOWS' and ENTER, we have just entered the
WINDOWS subdirectory under the root directory, hence the C:\WINDOWS
prompt. By entering the command DIR and ENTER we now get a directory
listing of the WINDOWS directory. Under the WINDOWS directory, there
may be still other subdirectories that we may enter. At any rate, we
can see where we are in the directory tree by looking at the prompt,
which tells us what directory we are in. In DOS, if we had the
following prompt:
C:\WINDOWS\SYSTEM\APPL>
This would mean that we are currently in a directory called APPL under
the SYSTEM directory which is under the WINDOWS directory, which
finally, is under the ROOT (C:\) directory.
Look at this example in a TREE structure:
C:\
--- WINDOWS
-----SYSTEM
----- APPL
At any rate, the Unix system uses this same style of directory tree
management. Now we will focus on Unix directory listings.
It is important to note here, first of all, that Unix commands are
case sensitive, while DOS commands are not. As a general rule, always
use lower case letters when on a Unix machine. The command 'ls
FILENAME.EXT' is different than 'ls filename.ext' on a Unix machine,
while on DOS it is not.
So, here we are after logging onto Ripco. The system displays the Unix
prompt and waits silently for you to do something:
(/home/foley/grnwood)
[golden] (grnwood):
NOTE: On a less user-friendly system, the Unix prompt is usually a
dollar sign ($) only. Ripco has changed the default prompt to display
the current directory, machine name, and account name.
First of all, let's explain what information is in the prompt. The
first line tells us what directory we are in on the system. Looking
closely, we see that we are in a directory called 'grnwood' (that's
mine,) which is under a directory called 'foley', which is under a
directory called 'home', which, ultimately, is under the 'root'
directory of the machine. We have our own little workspace, which is
our own directory (home directory). We also have the power to create
and remove subdirectories, which are under our own directory. The
'[golden]' tells us that we are on the 'golden' machine. At present,
there are four different machines at Ripco, named foley, golden, gail
and cook. We will need to know this information later for network
utilities. Finally, the (grnwood) tells me that I am using the
'grnwood' account. If I had another account on the machine, this would
clarify which account I was using.
Basic Unix Commands
Using ls, cd, mkdir, rmdir, and rm.
Using the 'ls' Command
The first and most necessary command for beginning Unix users to learn
is the command 'ls'. The ls command is the Unix equivalent of DOS's
DIR command. The ls command will display the contents of a directory,
or the current directory.
(/home/foley/grnwood)
[golden] (grnwood): ls
Mail News msdos.txt music ripco src text
(/home/foley/grnwood)
[golden] (grnwood):
This is a listing of the subdirectories and files in the 'grnwood'
directory. Not very informative, is it? It doesn't show whether or not
an item is a directory or a file. It doesn't show the file size
either. What gives? Well, in Unix, to get a comprehensive listing of
everything in a directory, you must run the 'ls' command with the
'-al' option.
The -a option tells ls to list all files, including hidden files.
Hidden files are files that start with a '.' Most hidden files are
files that you don't want in your way anyway.
(home/foley/grnwood)
[golden] (grnwood): ls -al
total 140
drwx--x--x 10 grnwood member 1024 Nov 18 14:12 .
drwxr-xr-x 440 root admin 7680 Nov 16 12:41 ..
drwxr-x--- 2 grnwood member 512 Oct 19 08:11 .bbs
-rwx------ 1 grnwood member 2131 Nov 5 23:16 .kshrc
-rw------- 1 grnwood member 3754 Nov 24 1993 .kshrc.prepaid
-rwx------ 1 grnwood member 756 Nov 5 23:16 .login
-rw------- 1 grnwood member 934 Nov 15 12:47 .newsrc
-rw-r--r-- 1 grnwood member 1 Nov 5 14:16 .plan
-rwx------ 1 grnwood member 1821 Nov 5 23:16 .profile
-rw-r--r-- 1 grnwood member 36 Nov 5 14:13 .signature
drwx------ 4 grnwood member 512 Nov 15 12:47 .tin
drwx------ 2 grnwood member 512 Nov 15 15:06 Mail
drwx------ 2 grnwood member 512 Nov 15 12:52 News
drwx------ 2 grnwood member 512 Nov 15 15:06 ripco
drwxr-x--- 2 grnwood member 512 Dec 18 1993 src
drwx------ 2 grnwood member 512 Nov 16 07:58 text
Ah! There it is! That even has more information than the DOS directory
listing! Let's take a look at what all of this stuff means :
-rw------- These are the 'flags' for a file, they tell us
whether a file is read only, hidden, system, or even
a directory.
drwx------ The 'd' in this flag set tells us that the item in
question is a directory.
grnwood Tells us who has ownership of the file. Since this
is my directory, I have ownership of all of the
files, and I can do what I wish with them.
member Specifies what type of account I have.
2230 The number column tells us the size of the file in
bytes.
Dec 18 07:48 Tells us the date and time that the file or directory
was created.
msdos.txt Finally, this is the actual name of the file or
directory.
NOTE: The 'ls' command has an exhaustive list of options that list the
directory in other formats, enter 'man ls' at the Unix system prompt
for a detailed list.
Using the 'cd' Command (Change Directory)
By looking at the set of file 'flags' in the left column, we can see
which items are directories, they contain the 'd' flag. It is the Unix
custom to name directories with the first letter being upper case,
i.e. Mail, News. Files should be all lowercase, this makes it even
easier to distinguish between files and directories. The Unix command
to change directories is the same as the command in DOS. 'cd' (change
directory) is used like this:
cd dirname
So, to change to my Mail directory, I would issue the command:
(/home/foley/grnwood)
[golden] (grnwood): cd Mail
(/home/foley/grnwood/Mail)
[golden] (grnwood):
Now, the prompt informs me that I am in the 'Mail' directory under the
'grnwood' directory. By issuing the command 'ls', I can now receive a
list of files in my Mail directory:
(/home/foley/grnwood/Mail)
[golden] (grnwood): ls
outline received saved-messages sent-mail users
(/home/foley/grnwood/Mail)
[golden] (grnwood):
Now I see which files are in my Mail directory. I'm done here. I want
to return to my home directory, which is one level up. How do I do it?
In every Unix directory, there are two 'virtual' directory names that
accomplish specific actions. The first one is the directory called
'..' By changing to this directory, you will actually go one level up.
So, to get out of the Mail directory, you would issue the command 'cd
..' to move one level up:
(/home/foley/grnwood/Mail)
[golden] (grnwood): cd ..
(/home/foley/grnwood)
[golden] (grnwood):
NOTE:
Entering 'cd' alone at the prompt, from any directory, will
also return us to our home directory.
Now we have returned to our home directory, one level up from the Mail
directory. If we were to issue the command 'cd ..' again, what would
happen? We would move up from the 'grnwood' directory and into the
'foley' directory. Follow along as I move from my directory, to my
friend Monte Gabor's directory (monte):
(/home/foley/grnwood)
[golden] (grnwood): cd ..
(/home/foley)
[golden] (grnwood): cd ..
(/home)
[golden] (grnwood): cd golden
(/home/golden)
[golden] (grnwood): cd monte
(/home/golden/monte)
[golden] (grnwood): ls
Cannot access directory.
So, as you can see, I can freely move to another users directory;
however, I do not have the proper access to view or manipulate his
files. There are directories that all users of Ripco can view,
examine, and manipulate, and there are directories that only the
system administrators can access. Feel free to move around wherever
you would like. The system will not let you tamper with any of its
important files. As a general rule of thumb, you should work out of
your own home directory. You may look around at other files, but do
not tamper with them.
You may also use full paths to manipulate directories. NOTE: The Unix
system uses the forward slash '/' as its root character, while DOS
uses a backslash '\'.
DOS Directory Unix Directory
\ /
\WINDOWS\TEMP /windows/temp
\TELIX\DOWNLOAD\GAMES /telix/download/games
You may give full path names to the ls and cd commands :
(/home/foley/grnwood)
[golden] (grnwood): cd /
(/)
[golden] (grnwood): cd /home/foley/grnwood
(/home/foley/grnwood)
[golden] (grnwood): cd /
(/)
[golden] (grnwood): ls /home/foley/grnwood
Mail News msdos.txt music ripco src text
(/)
[golden] (grnwood):
Using mkdir, rmdir and rm
mkdir
There will come a time in your Unix career when you will want to
structure your home directory better. You have already been given a
head start by the system with your 'Mail' and 'News' directories.
These directories will contain information pertaining to your email
and news articles, respectively. It is desirable to separate files
into various subdirectories or 'categories' to keep your directory
clean and efficient. For example, I have a directory under my home
directory titled 'Text.' I store any text files that I want to keep
under this directory. Now they are out of the way, and I know where to
find them when I need them. Programmers like to keep a directory
called 'src' (source) for source codes and programs. Other people like
to keep subdirectories for graphics, sound, and other various
projects. At any rate, lets now discuss how to create and remove
directories. The mkdir command (Make Directory) will create a
directory for you. Let's make a directory called 'Text' under my home
directory:
(/home/foley/grnwood)
[golden] (grnwood): mkdir Text
Now, I can change to my new text directory (remember cd?):
(/home/foley/grnwood)
[golden] (grnwood): cd Text
Okay, now what? I've created my directory; that's all there is to
it. There is really no limit to how many directories you can
have. Often it is better to split a subdirectory into
even MORE subdirectories. For example, let's say that I want to
store my personal texts in a different directory from my business
texts. I would still want them both to be under the larger topic
of 'Text,' but I would like to differentiate between the type of
texts. I would create two separate directories under my
text directory like this:
(/home/foley/grnwood/Text)
Now, by entering the command 'ls' from the text directory, I can
see my new directories:
(/home/foley/grnwood/Text)
[golden] (grnwood): ls
Personal Business
Change to the directory that you wish to access now, it's
that simple. Of course, if you changed to the Personal text
directory, you could then create directories for every month of
the year!
rmdir
Let's say that you no longer have any need for a
directory and you would like to remove it. First of all, you must
be out of the directory you wish to delete (i.e. able to see it
with the 'ls' command). Simply by issuing the command 'rmdir
' the directory will be deleted. In the following example, I
will delete my 'Business' directory because I just got fired:
(/home/foley/grnwood/Text)
[golden] (grnwood): rmdir Business
That's it. The Business directory is gone-- that is, provided that
the Business directory was empty. The command 'rmdir' will not delete a
directory unless the directory is completely empty, which brings
us to our next basic Unix command, rm.
rm
The 'rm' (Remove Files) command is Unix's equivalent of DOS's DEL command.
The rm command will delete files from a directory, or the current
directory. The general format for the command is as follows:
rm filename
You may also specify multiple files for rm, like this:
rm filename filename filename filename
Using the Unix Wildcard (*) Feature
At this point, it is imperative to discuss the Unix wildcard
option. Like DOS, Unix has a wildcard feature for accessing
files. The wildcard allows you to work with multiple files using a single
command. The wildcard option works with nearly all Unix
commands, not just rm. For example, let's say I want a listing of
all the files in my directory that begin with the letter 'a'. I
would issue the command:
(/home/foley/grnwood)
[golden] (grnwood): ls a*
a01442.text a02122.text a10235.text aero.document
The asterisk (*) tells 'ls' that I want all the files that match the
'a' criteria. You could also think of the wildcard as a 'filler'
of sorts. Changing the command a little bit, I can now get a
listing of all files that begin with 'a' and end in '.document':
(/home/foley/grnwood)
[golden] (grnwood): ls a*.document
aero.document
Now, 'ls' only gives me the file 'aero.doc' because I added
'.document' to the command. The other files may have matched the 'a'
criteria, however they did not match the '.document' criteria.
As you have seen before, using 'ls' with no options actually
simulates an 'ls *' command.
We can use the wildcard feature with most Unix commands. In
the example above, if I wanted to remove all files beginning with
the letter 'a' and ending in '.txt', I would issue this command:
(/home/foley/grnwood)
[golden] (grnwood): rm a*.txt
I have now told RM to remove all files beginning with the letter
'a' and ending with '.txt'. _WARNING: Be careful using RM with
wildcards!_ It is often wise to issue the same command using LS
first, to see a listing of files that RM will delete upon command
(i.e., 'ls *.txt' before actually 'rm *.txt'.)
To run 'rm' a little more safely, specify the '-i' option. This
will tell 'rm' to ask you before deleting a file
(i.e. 'rm -i .)
You could also waste your time deleting every file manually, but
this is impractical in most cases.
For more information on any of the commands previously discussed,
consult the
manual pages.
This is done by entering the command:
man command
at the prompt. To look up the LS command, type man ls and
enter. The system will give you the Unix manual page for the
desired command.
Unix Input/Output Redirection
Normally, when accessing Unix commands, the system accepts input
from the console or your keyboard, which is called stdin (standard input).
When a Unix command is running, it usually reports to your screen,
which is called stdout (standard output.) As we will see, the
standard out (and in) can be changed to suit our needs.
Output redirection is a term used to describe the process of changing
stdout. For example, let's say we want to get a directory listing,
using the LS command, and put the output into a file, how do we do
this? We can use output redirection with >to do this:
(/home/foley/grnwood)
[golden] (grnwood): ls >dir.txt
The command runs, and guess what? You don't see anything on the
screen. Unix ran the command ls, and it put everything that
normally would have appeared on the screen into a file called
dir.txt. This is a simple example of output redirection. Now,
issue the command 'ls' alone to view the files in your directory.
You will notice a new file called dir.txt.
The cat command allows us to view a text file on a Unix system.
Since the file dir.txt is a text file, we can view
it with the cat command:
(/home/foley/grnwood)
[golden] (grnwood): cat dir.txt
Mail News somefile.fil another.txt yetanother.txt
So, we see that we redirected the output of the ls command into
a file called dir.txt.
You may successfully redirect the output of _any Unix command_ at
any time. You may also redirect the output to entities other than
a file. You may redirect output directly into another program,
this is called 'piping,' and will be covered in the next section. For example,
let's look at the Unix program cat.
Running cat without any options allows you to enter keystrokes.
When you press Enter, your keystrokes are repeated on the monitor.
What possible good is this program? Unless your keystrokes have been
saved to disk, they are gone forever. Cat becomes much more
useful when a filename is added to the command line:
[golden] (grnwood): cat myfile.txt
Now, the cat program reads in the file myfile.txt and displays
it to the standard output, your monitor.
NOTE:
Using the cat myfile.txt has the same effect as using the cat
<myfile.txt input redirection method.
Now, let's say we want to save our keystrokes to a file. Using
cat and 'output redirection' we can use CAT as a bare bones
text editor:
[golden] (grnwood): cat >key.strokes
Hello.
This is a mini (very mini) word processor.
<CTRL-D>
Now, our keystrokes have been saved to a file called
'key.strokes'. <CTRL-D>is the standard way to end input on a
Unix machine.
We can also use cat to copy a file into another :
[golden] (grnwood): cat key.strokes >key.strokes.2
Now, we have copied the contents of key.strokes to key.strokes.2.
As you can see, using output redirection (and input
redirection,) we can make many uses of programs.
Here is a list of the Input/Output symbols:
>
command >filename
Output of command is sent to filename.
<
command <filename
Input from the file filename is used by command.
>gt
command >gt >filename
Output of command is appended to filename.
|
command1 | command2 Runs command1 and sends its output to the
input of command2.
Unix Pipes
Piping is another powerful feature of the Unix command line.
Piping is simply a way of sending the output of one command into
the input of another command. Think of it as connecting two
programs with a pipe, so that information can flow freely. This is
called a 'pipeline' and it looks like this:
[golden] (grnwood): ls *.txt | grep graphics
grep
is a program which searches a list of files for a certain
string, in this case 'graphics'. The above pipeline will get a
listing of all the .txt files in the directory and send them to
grep to search for the word 'graphics'. The lines that contain
the term 'graphics' that are in any of the .txt files will then be
displayed.
You may have as many pipe commands on a command line as you need.
One commonly used example of a pipe is like this:
[golden] (grnwood): cat myfiles.txt | more
This will display the text file 'myfiles.txt,' through the program
more,
which pauses the screen every page of text.
more, like
cat, can be used this way as well:
[golden] (grnwood): more myfiles.txt
Which basically means the same as more <myfiles.txt.
More Advanced Unix Commands and Utilities
In the previous section, we discussed some of the primary Unix
commands. Now you have explored some of the system, and you have a
good idea of how to get around. What else is there to do? Well, Unix
has well over three hundred commands to be used at your disposal. In
this section, we will discuss some of the 'more advanced' Unix
programs, utilities you might use, and background and foreground
shell jobs. Keep in mind that the intent of this manual is not to
discuss every Unix command, but rather,to discuss some of the more
common ones.
General Purpose Commands
In addition to the basic commands discussed above, there are several
general purpose utilities worth exploring. More information on these and
others can be found in the
online help.
cal
Displays the current month in calendar form. If a year is
specified, then a 12-month calendar is printed. If a month and
year are specified, that specific month is printed. NOTE:
Remember output redirection (cal >anyfile.txt)? This is the
same program that is called by the 'calendar' option from the
menus.
date
Displays the current system date in a variety of formats.
du
The disk used command 'du,' tells us how much disk space is
used by a directory and all of its subdirectories. Run this
utility from your 'home' directory to find out how much disk
space you are using. Ripco also has an add-on program that
calls 'du', then prints the output in a nicer format. Just
enter 'space' from the shell prompt.
echo
Echo's text or values to standard output.
echo 'Good Morning!' Echos Good Morning to the screen.
echo 'Add to a file' >gt filename Appends Add.. to filename.
ee filename
Runs the 'Easy Editor' and (depending on whether filename
exists): loads filename into memory or creates a new file named
filename.
man command
Returns the Unix 'manual' page for the supplied command. This
will give detailed help on any and every Unix command.
more
'More' will display a large text file page by page, prompting
you between pages. The usual syntax is more filename.
exit
Exits the current shell. If you exit the 'top level' shell,
then the system will log you off.
File Manipulation Commands
We have discussed several Unix commands that allow us to navigate
through the system, create and remove files, and redirect standard
input and output. How do we convert, copy, and transfer files?
Let's take a look.
Using Transfer Protocols
Right now, you might not have a need to transfer files from your
Unix directory to your computer at home. Once you start saving articles
from
Usenet News or using
anonymous FTP to get free programs, you will need
a way to get the files to your home computer.
Just like a BBS, Ripco offers most of the common file transfer
protocols. As a matter of fact, transfering files to and from Ripco
is much easier than using a BBS. For example, let's say that we
have a file in our directory titled, 'send.me,' and we want to
download it to our home computer. We have to determine which
protocol we would like to use. Ripco supports Zmodem, Ymodem,
Xmodem, and Kermit transfers. If your system supports Zmodem, then
it is best to use this one. So, to download 'send.me' we would
issue the command:
[golden] (grnwood): sz send.me
If your terminal supports automatic Zmodem initiation, then your
system will start receiving the file automatically. Otherwise,
initiate a Zmodem receive on your end. You may enter multiple file
names on the sz command line. You may also use the wildcard
feature as well. Examples:
sz *.txt Send every file ending in .txt
sz my.file.one my.file.two my.file.3 Send all three files
The following is a list of protocols and the associated programs.
Zmodem (batch)
sz *.zip
Ymodem (batch)
sbsb *.zip
Xmodem
sx myfile.zip
Kermit
kermit -s myfile.zip
Not only do all of these protocols send files, but they can be used to
receive files as well:
Zmodem
rz (no filename needed)
Ymodem
rb (no filename needed)
Xmodem
rx myfile.zip
Kermit
kermit -r
If you have problems using a protocol, try using another one. If
problems persist, send feedback.
Making and Extracting Zip Archives
Ripco supports a full arsenal of archiving utilities. This list
includes .ZIP, .Z (GZip), ZOO, LHARC (.LZH), and many others. Unix does
not use a version of PKZIP, as do DOS machines. Unix uses a ZIP/UNZIP
program that is fully compatible with PKZIP.
Instead of PKZIP, use just ZIP:
DOS Unix
pkzip mynew *.* zip mynew *
Instead of PKUNZIP, use just UNZIP:
DOS Unix
pkunzip myfile.zip \temp\stuff unzip myfile.zip /temp/stuff
Uuencode, uudecode, and mailing binary files
Uuencode and uudecode are programs that transform a binary file into
text format, and vice versa. Why would you want to do this?
Unix mail (and most Internet mail sites) is not an '8 bit clean' system.
What does this mean? This means that you cannot send
anything other than low order ASCII characters over the net. Low
order ASCII characters consist of the alphabet, both lower and upper
case, and the SHIFTED keys (punctuation). Binary programs
(executables and archives) consist of many high order characters
that can't be transmitted without using a protocol (FTP, UUCP,
etc.) Mailing a favorite program of yours to your friend becomes
difficult, because it will never make it there. But there is
a way around this. It comes in the form of the
uuencode and uudecode commands.
What uuencode really does is to take a binary file, such as an
archive (.ZIP) or other program, and make a text message out of it.
This text message can then be mailed to anywhere in the world. The
recipient of the mail, need only to run what he receives through
uudecode and boom! The program is transformed back into its
original form!
Let's walk through the process. I have a program called
music10.zip that I want to mail to someone across the net.
Actually, I will mail it to myself so that we can see both ends of
the process. Okay, first I want to uuencode the file
music10.zip.
The format for running the uuencode program is as follows:
uuencode inputfile progname
The input file, or course, would be music10.zip. Progname requires
a little explaining. Uuencode is going to code the file. When
someone executes a uudecode on the file, it will uncode the contents
to . So, in our case, we want to use the same file name
for progname. Keep in mind that uuencode prints output to standard
output (stdout), so we will have to redirect the standard output to
a file. A good name is music.uue. So, our command is:
[golden] (grnwood): uuencode music10.zip music10.zip >music.uue
NOTE: The '.UUE' extension usually indicates a UUencoded file.
After this command executes, we now have a 'UUencoded' representation
of music10.zip, contained in music.uue.
Now look at the file music.uue in a text editor.
Enter more music.uue at the command prompt.
Now you know what a UUencoded file looks like.
So, we've got the encoded file, it's time to mail it to the
recipient, myself. Execute your mail program and address the
message to whomever it is going. If you're using the Easy Editor you
would select file operations and read file.
Most other editors have similar commands. In EE, when asked to input the
filename, enter music.uue, then save the message and send it.
Now, ELM (or the equivalent) tells me that I have a new message. Of
course; I just mailed the message to myself. Place the selecter bar
over the new message. Press 's' to save the message to disk. ELM will
ask you what folder (file) to save to, enter musictest.uue.
Next, quit out of the mail reader. At the prompt, issue an ls
command and see if your new file musictest.uue is present. We
will want to remove the old version of music10.zip because UUdecode
will write a new one from musictest.uue.
To remove the old file, enter rm music10.zip, then use
ls to see that it's really gone.
The format for UUdecode is as follows:
uudecode encoded_file
The encoded file is any UUencoded file, in our case, musictest.uue, so enter:
[golden] (grnwood): uudecode musictest.uue
Now give another ls command; look what file is there again:
music10.zip.
There is another decoding utility beside uudecode called
uuconvert. This works the same way, but it will handle
files broken into several parts. This is handy when
decoding Usenet postings, which is
covered in the section on Usenet News.
Text Processing Commands
The difference between MS-DOS text and Unix text
Unix and DOS use different formats for storing text files.
DOS uses a CR/LF combination at the end of each line. Unix only
uses an NL (null) after each line. On an DOS machine, a
Unix text file would appear to have no breaks. There are three ways to solve th
is problem.
1. Use Unix2DOS before transferring the file. This utility reads in a
Unix text file and outputs it in DOS format.
[golden] (grnwood): unix2dos Unix.text.file >msdos.txt
2. To transfer a text file from an DOS machine to Unix: Upload the
msdos text file to your Unix directory. Then use the dos2unix
utility:
[golden] (grnwood): dos2unix msdos.txt >Unix.text.file
3. Download the Unix text file as is. Then, load it into the
shareware text editor QEDIT and re-save it. QEDIT will
automatically add the CR/LF combination.
4. Use the '-a' option on sz,sb,sx, protocol engines. To send a text
file from the Unix machine to the DOS machine:
sz -a Unix.text.file
This will automatically change Unix's NL to DOS's CR/LF. To
receive a DOS text file to Unix:
rz -a Unix.text.file
On your end, send your DOS text file, rz will convert DOS's CR/LF
combination into Unix's NL format.
Other file and text processing commands
cp
Copies files and entire directories. Used in the following ways:
* cp sourcefile destinationfile
* cp file1 directory
* cp directory1 directory2
For example:
cp joe.memo joe.memo.old
copies 'joe.memo' to 'joe.memo.old' and keeps the first file.
cp joe.memo /home/foley/grnwood/old_stuff
copies the file 'joe.memo' into the directory 'old_stuff'.
grep options pattern file(s)
Searches for text in a file or multiple files.
-
-c Returns only the number of matches (without text)
-i Ignores case
-l Returns only filenames, no text
-n Returns line number and text of match
-v Returns lines that do not match the text
Examples:
grep 'Money' * Search all files for 'Money'
grep -i 'memo' *.txt Search in all .txt files for
memo,MEMO,MeMorandum,mememmomo, etc.
'head option file(s)'
'tail option file(s)'
HEAD displays the first 10 lines of a file (default), and TAIL
displays the last 10 lines of a file (default).
-
-n Specifies the number of lines to display. The
default is 10 lines.
'mv options source target'
Moves files. Also may be used as a rename utility.
-
-f Moves file without checking for confirmation in case
of overwrite.
-i Prompts users if action would overwrite an existing
file
Examples:
mv 1993.joe /home/foley/grnwood
'wc '
Counts the number of words, characters, and lines in a text file
or files. The output presents the number of lines, followed
by the words and characters of the file(s).
-
-c Prints only the number of characters
-l Prints only the number of lines
-b Prints only the number of words
'banner '
Prints a large banner of .
There are many other
utilities available. Most are
documented in the online help.
Background and Foreground Shell Jobs
Not only does Unix allow you the flexibility and versitality of its
many commands, it also multitasks them. On the DOS level, the
closest example of this, although nowhere near as powerful, is
Microsoft Windows. Windows allows the user to open several windows
at the same time. In enhanced mode, one can execute these windows
simultaneously. This means that while one window is executing a
process, you may be interacting with another window. The concept of
multitasking is easily seen in the Windows environment. What is
really happening, is a division of microprocessing time. Each
program receives a 'slice' of time (pictured best as a piece of pie,
out of the whole) to be used accordingly. Unix governs and
maintains all of the various time slices by way of a 'Process ID.'
The Process ID (PID) is the name Unix gives to the piece of pie.
Each PID is unique and refers to one process and one process only.
Now then, what does this mean for us, the user? This means that
while we are transferring a file from anywhere in the world, we can
be working on an email message at the same time. The terms
'process,' 'job,' and 'task' all mean the same thing. Manipulating
shell jobs is very easy, and revolves around four basic commands,
ps,
fg,
bg,
kill.
At any time, in most any program, you may
press Control-Z to stop a job. You will find yourself back at the
Unix prompt, and Unix will have told you that the job was 'Stopped.'
This means that the job you just quit out of is 'frozen' and will
stay that way until you do something with it.
To list all of your current jobs, enter ps alone at the prompt.
After a couple seconds of processing, you will receive a chart
similar to this one:
PID TTY TIME COMD
25510 term/a07m 0:01 ksh
25539 term/a07m 0:00 ps
This tells us that we currently have two jobs running. Our first
job, job #25510 is ksh. Ksh is our shell. We will always have this
job running until we logoff. Our second job, job #25539, is the
program 'ps.' During the time that this chart was being printed, ps
was once of our jobs. As soon as the chart was finished, ps
was no longer one of our jobs. NOTE: 'ps' will always be displayed
as well, because looking at our jobs in itself is a job.
So, what can we do with these jobs? We can either 'kill' these
jobs, or we can run them in the background or foreground. Running a
command in the 'background' means that the job will continue to
execute even though we can't see it. When a job being run in the
background is finished, Unix will tell us. Running a job in the
'foreground' means that we are interacting with the job, i.e. output
to our screen, input from our keyboard. It is important to note that
we may only have one job at any time running in the foreground, but
we may have many jobs in the background. To run a job in the background
enter the command :
bg JOBID
This will run the particular job in the background. To bring a job
into the foreground, enter the command:
fg JOBID
To kill a job, whether running in the background, foreground, or not
running at all, enter the command :
kill PROCESS
_
NOTE: When a job reaches the end, Unix automatically KILLs it.
_
IMPORTANT:
Never kill your original shell job, doing so will log you off
of the system. Also, on programs such as ftp, where the program
outputs the progress of the transfer, shut off progress
indicators before running a job in the background, i.e. in ftp,
issue the command set progress 0 from the ncftp>/CODE> prompt.
To summarize, any job may be run in the background as well as the
foreground. To stop a job in process, press CTRL-Z. To list all
processes, enter ps. To run a job in either the background or
foreground, enter bg JOBID or fg JOBID, respectively.
And now, one final note on jobs. It is not very polite to other
users if you run six ftp jobs in the background while running a
seventh job in the foreground. This applies not only to ftp jobs,
but other jobs that rely heavily on the system resources. The more
jobs your account has running, the more pieces of the pie it holds.
If your account is hoarding all of the pie, then there will be none
left for the other users. There is no reason why you should be
running more than three jobs at any given time. The system
administrators know how much of the system resources you are using.
If this becomes a frequent problem, you will be notified.
Network Utilities
In addition to the hundreds of general, file, and text manipulation
commands, Unix offers a wide variety of network utilities for
accessing the internet. In this portion of the manual, we will cover
most of the major network utilities.
However, major programs, including
ftp,
IRC,
Gopher, and the World Wide Web (WWW) will be covered in their own sections.
Finger
Finger is a utility used to look up account information of other
users. It is also used to give a list of the users currently logged
on a particular machine. Entering 'finger' alone at the prompt
will generate a list of users currently logged on at your
home system. For an example of finger output, select list
users option ('l') from the menu system. FINGER is usually invoked in
this manner:
[golden] (grnwood): finger username@hostname
Username may be any valid account at hostname. To look up
account information for 'grnwood,' on the local machine (ripco), we
would enter:
NOTE : @hostname is not needed because we want to search the local
machine.
[golden] (grnwood): finger grnwood
Login name: grnwood In real life: Joe Greenwood
Directory: /home/foley/grnwood Shell: /usr/bin/ksh
On since Nov 19 13:11:33 on term/a14m
No unread mail
Plan:
Hi, this is an example '.plan' file.
As you can see, by adding the account name to the finger command line,
finger will look up information of the specified account. Finger
will report the login name and the account's real name. Finger also
tells us what shell the account is using (ksh). The 'On Since...'
line tells us that I have been logged on since 1:11pm on terminal
a14m. If I were not logged on, finger will still return all
information, however, this line would be omitted. The next line
tells us that the account has no unread mail. If I had mail in my
mailbox that I had not read yet, it would say that here. Now would
be a good time to discuss what the '.plan' file is.
Using a .plan and/or .project file
Every user has the option of keeping a '.plan' file in their home
directory. A .plan file is simply a text file that contains any
information you would like to make available about yourself. If
someone from any where in the world, or your home system, should
'finger' your account, this file would be displayed with your
account information. The '.project' file works the same way. In
this file you would state what projects you are currently working
on. The .project file can be a maximum of one line, however, the
.plan file may be as long as needed.
Now let's look at some other uses for the 'finger' command.
If you have ever selected the 'list users' option from the menus,
you have already seen another aspect of finger in action.
Previously, we stated that we may supply any valid email address to
finger, we may also supply any host name of a computer, for example:
[golden] (grnwood): finger @foley.ripco.com
Login Name TTY Idle When Where
bje Bruce Esquibel vt01 1 Sun 13:28
root System Administrator console 1:01 Sun 13:27
grnwood Joe Greenwood term/a02m Fri 14:12
robzr Rob Zwissler term/a03m Fri 14:03
mikebvc Mike Stillman term/a05m Fri 13:58
dstaples Daniel Staples term/a04m Fri 13:41
kerri Kerri Kadow term/a06m 1 Fri 13:58
Since 'foley,' is the name of a computer, entering 'finger
@foley.ripco.com' will display all users currently logged on this
machine. Ripco also has a machines called 'golden,'(golden.ripco.com), 'gail',
and 'cook'.
By using the
'list users'
command from the menu
or 'wh' from the shell prompt, users on all major Ripco machines will
be listed.
The Login portion of the display shows us the account name of the
account owner 'Name.' TTY tells us from what port the account is
connected. Idle tells us how long the account has been 'Idle' (not used.) When
tells us when the account logged on, and Where tells
us what the account is currently doing. Now that we have a list of
accounts logged onto the machine, we may get more specific in our
search. Let's say that we want to look up 'bje'. We will use
finger:
[golden] (grnwood): finger [log in to unmask]
On the local machine, we need not supply the host name (foley.ripco.com);
however, on queries beyond our machine, we must. To see who is
logged on at the University of Illinois, Urbana-Champaign we would
finger one of their host computers:
[golden] (grnwood): finger @cso.uiuc.edu
Once we have the list of accounts logged on, we may again get more
specific with our finger search:
[golden] (grnwood): finger @cso.uiuc.edu
So, to summarize, we may use finger to check who is logged on any
machine on the Internet. We may also use finger to look up any account
on any computer on the Internet.
It is important to note here that some universities have a finger
'lookup' utility available. Instead of using 'finger' to find account
names, which can sometimes be cryptic and hard to guess, you can
search for first and last names of students. Ripco supports this
option as well.
Finger has literally dozens of other options. Again, the
manual pages describe all of the options in detail (i.e. 'man
finger')
Using Talk and Write
Talk and Write are Unix programs that allow you to communicate with
other users on the network. Sometimes one user needs to correspond
with another user instantly. At these times, email, although very
fast, will just not do.
The Talk Command
Talk allows two or more users to conduct a 'live' private chat
back and forth in a split screen environment. Talk goes hand in
hand with the Finger command discussed earlier. Once you have
decided what user you would like to chat with, and you have made
sure that they are currently logged on (using finger) on a computer
somewhere on the net, you may request a chat with them. The Talk
command uses this format:
[golden] (grnwood): talk username@hostname
Talk, like finger, may be used to access an account on the local
machine, or any machine on the net. If requesting a 'talk' with the
local machine, the hostname need not be added. To talk to user
'joeshmo' at Harvard University, you would enter the command:
[golden] (grnwood): talk [log in to unmask]
Your terminal will then change into a 'split-screen' chat mode.
This means that text that you type appears on the top of the screen,
and the text that the remote user is typing appears on the bottom
of the screen. At the top of the screen, talk tells you that it is
'Ringing your party.' Joeshmo will
receive the following message on his terminal:
Message from Talk_Daemon@golden at 14:55 ...
talk: connection requested by [log in to unmask]
talk: respond with: talk [log in to unmask]
If joeshmo were to enter the reply 'talk [log in to unmask],'
his talk program would load, and both of you would be in a 'live'
chat. Text either of you type appears instantly on both
terminals.
If joeshmo were to request a 'talk' with you, you would receive the
following message on your terminal at Ripco:
Message from Talk_Daemon@golden at 14:55 ...
talk: connection requested by [log in to unmask]
talk: respond with: talk [log in to unmask]
If you were to enter the command that 'talk' tells you to, you would
then be placed in chat mode with joeshmo.
When finished talking, press CTRL-C to end session.
The Write Command
Write is used instead of talk to write a short message to a user on
the same machine when a chat is not necessary. Write uses a simple
command line similar to talk, but only works for users on the same
machine.
[golden] (grnwood): write nobody
Hi!
How are you?
<CTRL-D>
_NOTE: write will only work on the local machine. i.e. if you are on
'foley' you cannot write to someone on 'golden' and vice versa. Use
talk for this. _
Using 'mesg' to Control Messages From Others
What happens if you are busy and don't feel like being bothered by
TALK requests? What if someone keeps harassing you with the WRITE
command? You can disable messages from these programs with the 'mesg'
command. To turn off incoming messages from talk :
[golden] (grnwood): mesg -n
Now, you can no longer be reached with talk or write.
To turn messages back on:
[golden] (grnwood): mesg -y
Telnet and rlogin
Telnet and rlogin are programs that allow a user to login to remote
machines around the world. In most cases, to log onto another machine
somewhere, you would have to have an account on that machine. Some
machines have guest accounts and information accounts that you can
use. For example, let's say that I am at school now on the other side
of the country. I could log onto a machine at the university and
'telnet' right into Ripco whenever I wanted.
The Telnet Program
If I was at a school terminal and I wanted to check my mail on a
subscriber account at Ripco from the machine at the university, I
would use this command:
university prompt: telnet ripco.com
Trying 127.0.0.1...
So, telnet connects with Ripco. It tells me the 'escape
character is '^[''. This means that anytime while in the telnet
session, I can press CTRL-[ to escape to the telnet prompt (more
later). The next line tells me that the system I just connected to
is a Unix System V machine. Other machines might be VAX, SUN, etc.
As you can see, on this machine, Ripco only allows the 'info'
account to log in. If I wanted to connect to my account, I would
have to telnet to either the 'foley' node (foley.ripco.com) or the
'golden' node (golden.ripco.com). So, I quit out of telnet by
pressing CTRL-D, and run telnet again:
university prompt: telnet foley.ripco.com
Trying 127.0.0.1...
Connected to foley.ripco.com.
Escape character is '^]'.
Ripco Communications Inc.
Node:foley
Welcome to Ripco Communications Inc., for information login as 'info'.
login:
Does this look familiar? Now I can use the Ripco machine just as
if I had called in on a modem line.
The full command line for telnet is:
telnet system [port]
Some systems require that you 'telnet' to a specific port to use the
facilities.
One common example is the MUD server at Ripco. A MUD is a
Multi-User Dungeon server that is used for online interactive games.
To 'telnet' to the MUD at Ripco, enter:
telnet chicago.ripco.com 4201
This would connect you to the 'Virtual Chicago' MUD at Ripco.
Running telnet with no options on the command line, puts you into
the telnet>CODE> command prompt. At any time during a telnet session,
you may press CTRL-[ to escape to the command prompt as well. From
the telnet>CODE> command prompt, you may enter the following commands:
close
Ends remote session
display
Displays 'set' and 'toggle' values
mode mode
Changes mode to character or line, etc.
quit
Ends remote session and exits telnet
status
Displays status
There are other options accessible from the telnet command prompt as
well, see the
man page
for a detailed description.
Using rlogin
Rlogin is similar to telnet, it lets you logon to other machines on
the net. The command line for rlogin is :
rlogin options hostname
Rlogin options
-8
Use 8-bit data (default is 7)
-e char
Uses char as the escape character, default is '~' (the tilde)
-l username
Remotely logs on under the new username, instead of the name on
your local host, provided of course, you have permission from
that user.
You should almost always use telnet instead of rlogin. To end an
rlogin session, type 'exit' at the shell prompt. This should log you
off properly. You can also enter an escape combination to close the
rlogin session by pressing the escape character (usually the '~') then
enter.
More information on rlogin is available in the
man page.
Using Nslookup and InterNIC's Whois Server
We already discussed how to look up a user's account on a particular
machine, but how do we go about looking up the machines themselves?
It is possible that you might want to find out if some university or
other site has computers connected to the internet. To do this, we
can use two utilities and a little guesswork. I know, for
example, that Harvard University near Boston, MA simply MUST have
computers connected to the internet, how can I find out? Well,
since Harvard U is an educational establishment, chances are that
the last three characters of the domain name are '.edu'. This is not
enough to go on, however. 'Harvard.edu' seems like a legitimate
domain name. Let's check.
The Nslookup Program
Nslookup stands for Name Server Lookup, and its primary use is to
retrieve information about specific hosts on the internet. You can run
nslookup as an interactive program:
[golden] (grnwood): nslookup
Default Server: dns.ripco.com
Address: 209.100.227.1
>
The program first displays information about the name of the default
server (rci.ripco.com), its IP address (209.100.227.1), then displays
a >prompt.
At the prompt, we enter 'harvard.edu' and see if it is a valid
IP address.
>harvard.edu
Server: dns.ripco.com
Address: 209.100.227.1
Name: harvard.edu
Address: 128.103.200.101
>
Aha! 'harvard.edu' is a valid IP address, which means that
'harvard.edu' is a legitimate domain name. Enter 'exit' at the
nslookup prompt to exit out of the nslookup program, or enter 'help' to
find out more commands you can use. You might also want to read the
man page.
You can also run nslookup by way of a command line instead of
interacting with the program. For example:
[golden] (grnwood): nslookup harvard.edu
The Whois Program
Now that we know harvard.edu is a valid domain name, what next? How
can we find out information about that domain? InterNIC runs a
WHOIS server that contains information about registered Internet
domains. There are many different WHOIS servers that contain other
information. By executing the command :
[golden] (grnwood): whois domain
You can find out if there is any information about the domain name
in question. So, continuing our example, let's see what they've got
on harvard.edu:
[golden] (grnwood): whois harvard.edu
... A few seconds of processing ...
Harvard University (HARVARD-DOM)
Network Services
10 Ware Street
Cambridge, MA 02138
Domain Name: HARVARD.EDU
Administrative Contact:
Jackson, Lance F. (LFJ1) [log in to unmask]
(617) 495-7632 (617) 496-4736
Technical Contact, Zone Contact:
Newhall, Gerald S. [Mr.] (GSN2) [log in to unmask]
617-4996-4736
Record last updated on 22-Oct-92.
Domain servers in listed order:
NS1.HARVARD.EDU 128.103.200.101
HARVARD.HARVARD.EDU 128.103.1.1
CUnixD.CC.COLUMBIA.EDU 128.59.40.142
The InterNIC Registration Services Host contains ONLY Internet Information
(Networks, ASN's, Domains, and POC's).
Please use the whois server at nic.ddn.mil for MILNET Information.
We now know the names (and email addresses) of a few of the
technical support staff at Harvard. We also have a list of the
domain servers at Harvard University. Now you can direct nslookup
to query these domain servers, then get information to help you use
,talk,
GOPHER,
ftp, and other
programs which will be discussed in another chapter.
To summarize, a little guesswork has to be used when trying to
find domain names. Guessing valid domain names gets easier with
practice. For example, New York University uses the domain name
nyu.edu; Iowa State University uses the name, uiowa.edu; University
of Illinois at Chicago, uic.edu; University of Illinois at
Urbana-Champaign, uiuc.edu.
There are several top level domains,
which are documented in the chapter on E-Mail.
If all else fails, you can try to guess valid domain names and send them
through NSLOOKUP. Upon getting a valid domain name, you can then
query the InterNIC database.
For more information on host/domain addressing schemes, read the chapter on
E-Mail.
A DOS to Unix Cross reference is available.
__________________________________________________________________________
APPENDICES
Appendix:DOS to Unix Cross Reference
Since most of Ripco's users are accostomed to the MS-DOS platform, we
have included a DOS/Unix cross reference guide. Of course, Unix
and DOS are completely different operating systems: DOS is more geared
to disk utilities and the single user, while Unix is more geared towards
network utlities and the multi-user. DOS found
its roots a long long time ago, in the Unix operating system. Many DOS command
s have been
shaped from their Unix equilvalents. Of course, Unix has commands
that DOS cannot match, and DOS has commands that Unix cannot match.
This list is current through DOS 6.0:
ATTRIB chmod
BACKUP cpio,tar
CD cd
CHDIR cd
CHMOD chmod
CLS clear
COMMAND sh,ksh,csh,tcsh
COMP bdiff,cmp,diff
COPY cp
CTTY stty
DATE date
DEL rm
DELTREE rm -r
DIR ls
DOSKEY history (sh,ksh)
ECHO echo
EDIT ee,vi
EXPAND uncompress,unpack
FASTHELP apropos,man,whatis
FC bdiff,cmp,diff,diff3
FIND find
FOR for (shell)
HELP man,whatis
IF if (shell)
MKDIR mkdir
MODE stty,tty
MORE more
MOVE mv
MSBACKUP cpio,tar
PATH setpath, setenv PATH
PRINT pr
PROMPT ps1="what"
REM #
RENAME mv
RESTORE cpio,tar
RMDIR rmdir
SET env,set,setenv
SORT sort
TIME date
TYPE more,page,cat
VER uname
XCOPY cp
NOTE: All Unix commands have electronic 'manual' pages. This is a
built in on-line
help system.
Enter 'man command' for detailed information on any command.
VICUG-L is the Visually Impaired Computer User Group List.
To join or leave the list, send a message to
[log in to unmask] In the body of the message, simply type
"subscribe vicug-l" or "unsubscribe vicug-l" without the quotations.
VICUG-L is archived on the World Wide Web at
http://maelstrom.stjohns.edu/archives/vicug-l.html
|
