File and Directory Commands

These exercises will familiarize you with the basic UNIX commands for working with files and filesystems. Note that the non standard and generic file and directory names are provided as examples and please replace them with file and directory names in your area to work with and practice the commands.

Setup

Open a new window or use an existing open window. To open a new window, press and hold the middle mouse button. A "pop up" menu will appear. Still holding the middle mouse button, drag the pointer to the desired selection. When it is selected (the item will appear highlighted or raised), release the button. A new window will appear in a second or two.
Begin the Filesystem exercises with the ls exercise below.

ls

Read/scan the man page for ls with the command:
```
     man ls 
     
```
Use ls without any arguments to display your current directory contents. How many files do you see?
Now use ls with the -a option. How many files do you see this time? Notice that the "new" files all begin with a "dot", which indicates they are "hidden" files.
```
     ls -a
     
```
This command is useful for distinguishing between directories, ordinary files, and executable files. Notice how its output differs from ls without arguments.
```
     ls -F
     
```

Use the command ls -l to obtain a "long" listing of your files. Sample output from this command and an explanation of the information it provides appears below.


-rwxr-xr-x   1 jsmith   staff         43 Mar 23 18:14 prog1
-rw-r--r--   1 jsmith   staff      10030 Mar 22 20:41 sample.f
drwxr-sr-x   2 jsmith   staff        512 Mar 23 18:07 subdir1
drwxr-sr-x   2 jsmith   staff        512 Mar 23 18:06 subdir2
drwxr-sr-x   2 jsmith   staff        512 Mar 23 18:06 subdir3
    1        2   3        4           5       6          7

1 = access modes/permissions
2 = number of links
3 = owner
4 = group
5 = size (in bytes)
6 = date/time of last modification
7 = name of file

Recursive listings can be very useful. Try both of the commands below. What does the output tell you?
```
     ls -R
     ls -Rl
     
```
Try three options together:
```
     ls -lFa
     
```

Read/scan the man page for more with the command:
```
     man more 
     
```
Use the more command to read a file:
```
     more   filename 
     
```
As you are reading, notice the "More" prompt at the bottom of the page.
Try pressing the return key - what happens?
Try pressing the space bar once - what happens?
Type the letter b - what happens?
Use the search forward feature to find a word say, "MARCH" by entering the command:
```
     /MARCH 
     
```
Now use the search backward feature to find a string of words say, "black hole" by entering the command:
```
 
     ?black hole 
     
```
more will continue until the end of the file is reached or until you type q for quit. Try typing q to quit.

head and tail

Read/scan the man page for head with the command:
```
     man head 
     
```
Display the top of a file with the command below. How many lines do you count?
```
     head  filename 
     
```
Now try this command and note how many lines are displayed this time?
```
     head -5  filename  
     
```
Read/scan the man page for tail with the command:
```
     man tail 
     
```
Display the same file with the tail command. How is it different and how many lines do you count?
```
     tail  filename  
     
```
Now try this command and note how many lines are displayed this time?
```
     tail -5  filename 
     
```

cat

Read/scan the man page for cat with the command:
```
     man cat 
     
```
Use this command to display the contents of a file. What happens?
```
     cat  filename 
     
```
Now try this command notice the difference. How many lines are in the file?
```
     cat -n  filename 
     
```

The cat command is more often used for purposes other than just displaying a file. Try these commands to "concatenate" two files into a new, third file:


     cat file1                  - first, show file1 
     cat file2                  - then, show file2 
     cat file1 file2 > newfile  - now do the actual concatenate 
     cat newfile                - finally, show the result

cp

Read/scan the man page for cp with the command:
```
     man cp 
     
```
Copy an existing file in your current directory to another file in the current directory and then list your directory to prove that it was done:
```
     cp  file1  file2 
     ls
     
```
Copy a file from a different directory to your current directory and then list your directory to prove that it was done:
```
     cp /etc/ifconfig my.config 
     ls
     
```
Use the copy command with the "inquire" option. What happens when you try to copy one file to an already existing file?
```
     cp -i file1  file2  
     
```
Use the recursive option to copy an entire subdirectory to a new subdirectory and then list both directories to prove that it worked:
```
     cp -R subdir1 subdir4 
     ls subdir1 subdir4
     
```
The copy command accepts "wildcard" characters. Try the command below. What did it do? List the subdir1 subdirectory to find out.
```
     cp samp* subdir1 
     ls subdir1
     
```
If you are copying a file from another location to the current directory and want its name to remain the same, you can use the shorthand "." to indicate the current directory. Try this for example and note what happens:
```
     cp /etc/ifconfig  . 
     ls
     
```

mv

Read/scan the man page for mv with the command:
```
     man mv 
     
```
The mv command can be used for renaming files. Try this command and then list your files to prove that the command worked:
```
     mv my.config  new.config
     ls
     
```
mv can be used to rename directories also. Try this command and then list your files to prove that the command worked:
```
     mv subdir4  dir4  
     ls
     
```
The mv command is also used for moving files. Use the command below to move new.sample into a new location, then list your files to prove that the command worked:
```
     mv new.sample  dir4  
     ls
     ls dir4
     
```
Like many other UNIX commands, mv recognizes wildcard characters. Try the command below and then list your files to prove that the command worked:
```
     mv *env* dir4  
     ls
     ls dir4
     
```

rm

Read/scan the man page for rm with the command:
```
     man rm
     
```
Use the rm command to delete a file. List your directory after the command completes.
```
     rm new.config
     ls
     
```
cd to another subdirectory say, subdir2. List the directory to view its contents. Then use the "*" wildcard to remove all of the files. NOTE: using rm in this manner can be dangerous! If you are in the wrong directory, you'll remove files you didn't mean to remove. You may want to use the -i option to protect yourself from accidents.
```
     cd subdir2
     ls
     rm -i *
     ls
     
```
Get out of the subdir2 subdirectory by using the command cd .. Now try to use rm to remove a directory. What happens?
```
     cd ..
     rm subdir3
     
```
This time, include the -r option when you try to remove a directory. For example, try removing some subdirectory subdir3. What happens?
```
     rm -r subdir3
     ls
     
```

file

Read/scan the man page for file with the command:
```
     man file
     
```
Use the file command to determine a file's type:
```
     file file1
     
```
Now try it with a directory say, dir4:
```
     file dir4
     
```
Finally, try it with a wildcard character;
```
     file *
     
```

find

Read/scan the man page for find with the command:
```
     man find
     
```

Use the find command to find the file new.config.


     find . -name new.config -print

Now use the find command to find all files with "file" as part of their name. Don't forget to put the wildcard specification in quotes - it won't work otherwise:
```
     find . -name 'file*' -print
     
```
Try to find only directories with "file" as part of their name. Are there any?
```
     find . -name 'file*' -type d -print
     
```

diff and sdiff

Read/scan the man page for diff with the command:
```
     man diff
     
```
Use the diff command to determine the differences between two files:
```
     diff names1 names2
     
```
Use the diff command to determine the differences between two directories.
```
     diff subdir1 dir4
     
```
Try using sdiff to display the differences between names1 and names2:
```
     sdiff names1 names2
     
```
Now try sdiff specifying that the screen width is 80 characters...not the default 130:
```
     sdiff -w 80 names1 names2
     
```

sort

Read/scan the man page for sort with the command:
```
     man sort
     
```
Use the cat command to look at an unsorted list of names. Notice that there are multiple columns of information and that the list is not alphabetically sorted.
```
     cat name.list
     
```
Use the sort command to perform a basic sort of the list:
```
     sort name.list
     
```
Do the same sort, but send the output to a file. Then use the cat utility to view the file:
```
     sort name.list > sorted.list ; cat sorted.list
     
```
Sort the list by first names. This requires skipping over the first field, which is the last name:
```
     sort +1 name.list 
     
```
Sort the list by department. This requires skipping over the first four fields and using the -b option to ignore blank characters:
```
     sort -b +4 name.list 
     
```

pwd

Read/scan the man page for pwd with the command:
```
     man pwd
     
```
Issue the pwd command to display the name of your current working directory:
```
     pwd
     
```

Change to several other directories and issue the pwd command between each change. Notice the different outputs:


     cd dir4
     pwd
     cd /usr/bin
     pwd
     cd /var/spool
     pwd
     cd ~/Filesystem
     pwd

mkdir

Read/scan the man page for mkdir with the command:
```
     man mkdir
     
```
First make sure that you are in your home directory. Then, create a new directory with the mkdir command. List your directory after the command completes to prove that it worked:
```
     cd ~
     mkdir newdir
     ls
     
```
Now create some additional subdirectories within your newdir. List newdir after the command completes to prove that it worked:
```
     mkdir newdir/sub1  newdir/sub2  newdir/sub3
     ls newdir
     
```
Try to create a directory in a location where you don't have permission. What happens?
```
     mkdir /etc/mydir
     
```

cd

Read/scan the man page for cd with the command:
```
     man cd
     
```
Change to your default, home directory:
```
     cd
     
```
Change to a subdirectory within you home directory and list its contents:
```
     cd dir4/subdir1
     ls 
     
```
Go up one level to the current directory's parent directory and list the contents:
```
     cd ..
     ls 
     
```
Change to the root (top-most) directory and list the contents:
```
     cd /
     ls 
     
```
Change to another student's directory and list the contents:
```
     cd ~studnt01
     ls 
     
```
Change to another one of your subdirectories and list the contents:
```
     cd ~/newdir
     ls 
     
```

rmdir

Read/scan the man page for rmdir with the command:
```
     man rmdir
     
```
First make sure you are in your home directory. Then try to remove the newdir directory. What happens?
```
     cd ~
     rmdir newdir
     
```
Recursively list the contents of newdir. Notice that its subdirectories are all empty. Remove all of the empty subdirectories within newdir and then list newdir again to confirm that they were removed:
```
     ls -R newdir
     rmdir newdir/*
     ls -R newdir
     
```
Finally, remove the empty newdir directory:
```
     rmdir newdir
     
```

Access Permissions Exercises

These exercises will familiarize you with the basic UNIX commands for working with file access permissions. Click here for more information on access permissions.

Make sure that you are in your Filesystem exercise directory, and then do a long listing of your files:
```
     cd ~/Filesystem
     ls -al
     
```
Notice the access permissions assigned to each file. Can you tell:
- which files are directories?
- if a file is executable?
- who has write access to each file?
- who has read access to each file?
- who owns the file?
- which group the owner belongs to?
- which permissions the group has?
- which permissions others have?

Use the chmod command to change the permissions for some files. List the file before and after each change and determine how the command changes the file permissions.


     ls -l names1
     chmod o-r names1
     ls -l names1

     ls -l names2
     chmod g+w names2
     ls -l names2

     ls -l file*
     chmod go-r file*
     ls -l file*

Try a chmod command with numerical access specifications:


     ls -l prog1
     chmod 754 prog1
     ls -l prog1

Look in your ~/.cshrc file and find where your umask setting is specified. What is it and what does it do? How would you change it so that nobody except you could see your files?
```
     cd
     more .cshrc
     
```

Standard UNIX File System Exercises

These exercises will familiarize you with the overall organization of your UNIX filesystem.

Change directory to the root level and then list the contents.
```
     cd  /
     ls 
     
```
Change to the /usr directory and list it.
```
     cd  /usr
     ls 
     
```
Spend some time navigating about the upper levels of the filesystem.... see how lost you can get!!
Don't forget that you can always use the pwd command to tell you where you are, and the cd command to return to your home directory.