Anything appearing in italic, like this is either an executable command or emphasized text. Tools (executable commands) are in italics to prevent confusion. Some tools have names which are real english words, such as the “locate” tool.

Are represented by using a '-' (dash sign) in-between the key(s), which must be used in combination. All combinations are also printed in italics to improve clarity. For example CTRL-Z means hold down the Control key and press the z key.

Admonitions are little pictures used to emphasize something of importance to the reader.

The five types used are:

	This is a note
	Notes often give important information about a tool.

	This is a tip
	This will offer a useful switch or useful way to use a tool.

	This is something important
	This is something that is considered very important. Consider it like a note with extra importance, they are usually there to save the reader time.

	This is a caution
	This will inform you of something that you be careful about (because it could be harmful to your system).

	This is a warning
	This will inform you of something that you shouldn't do (because it probably will break something within your system).

Code examples are shown for most commands.

Below is an example of what code looks like:

Hello World, I'm a code example. :)

(or a similar phrase) simply shows how you would normally use the command. Often real examples are used instead of explaining the command syntax.

The phrase “ Command syntax” is always followed by the way you would type a command in a shell.

The standard syntax for any tool is usually:

command -options file

	Note
	Note that some tools do not accept options.

Also note that most commands, even when not explicitly stated, will work with standard wildcards (or globbing patterns) such as *, [A-Z] and various other standard wildcards. Refer to Section 20.4.1 for further information.

Access keys enable navigation through the document, without relying on a mouse. The following keys have been given special meaning in this document:

If you also happen to be reading the document from its original location, then the following access keys can also be used:

Chris allowed the use of his lyxtox scripts to convert the LyX file of the document to working DocBook SGML output (to learn how to use the lyxtox scripts yourself, see Document processing with LyX and SGML).

• Chris provided useful suggestions and advice, and added an index listing for many of the commands.

• Chris is also responsible for the great looking HTML file for this document (the CSS file and HTML customisations are completely his work).

• Chris has also helped fix up problems in the document (many times), especially with docbook/sgml, and LyX related issues.

• Chris has also improved the structure of the document by adding labels and fixing minor errors.

William provided a thorough review of the document as required by the Linux Documentation Project. He is responsible for a variety of improvements to the quality of this document.

His contributions include:

• Improvements to the readability of this document.

• Improvements to the structure and consistency of this document.

• Various grammar improvements throughout the document.

• Repair of some minor technical errors.

Tabatha, as the Linux Documentation Project Review Coordinator (at the time) also gave a brief review of this document. Her general advice was used to improve the structure, language and grammar of the document.

Rahul provided a brief review of this document for the Linux Documentation Project. Advice from his brief review was integrated into this document to improve readability and structure, several references were added as recommended by Rahul.

David's criticism of the document (via the TLDP discuss list) were listened to, and attempts to improve the document were made. A number of his criticisms were addressed and improved.

George provided a second language review. His detailed review of the material allowed me to improve the general grammar of the document and some minor errors.

Machtelt provided tips in regard to referencing the correct LDP documents from this guide. As well as general advice on improvements to the guide.

Michael pointed out a number of technical errors in the document after his brief review on behalf of the TLDP during posts to the discussion list.

Use the TAB key and bash will attempt to complete the command for you automatically. You can use it to complete command (tool) names. You can also use it when working with the file-system, when changing directories, copying files et cetera.

There are also other lesser known ways to use automatic command completion (for example completing user names):[1]

Special-characters:

Use the following special characters combined with either ESC-Y or CTRL-X-Y , where Y is some special characters. For example ESC-$ or CTRL-X-$ to complete an environment variable name.

• ~ (tilde) complete a user name

• @ (at sign) complete a machine name

• $ (dollars sign) complete an environment variable name

• ! (exclamation mark) a magic character for completing a command name or a file name. The ! special character has the same function as the TAB key. It works in some other situations; for example when completing man page names.

The alias command will list your current aliases. You can use unalias to remove the alias (to disable it just for one command add a “\” (back-slash) before the command)...

An alias allows one command to be substituted for another. This is used to make a command do something else or to automatically add certain options. This can be either be done during one session using the alias command (see below) or the information can be added to the .bashrc file (found in the users home directory).

Below is an example of what an alias section (within your .bashrc file) might look like:

# my personal aliases
alias cp='cp -vi' #to prompt when copying if you want to overwrite and will tell you where information is going 
alias rm='rm -i' #Prompts you if you really want to remove it.
alias mv='mv -i' #Prompts you if you are going to overwrite something

On any Mandriva GNU/Linux system the global aliases (for all users) are all in /etc/profile.d/alias.sh. The above listed commands already have aliases, as well as several other commonly used commands.

set is one of bash's inbuilt commands, try looking in the bash manual for its many usage options.

Using set with the -x option will make bash print out each command it is going to run before it runs it.

This can be useful to find out what is happening with certain commands such as things being quoted that contain wildcards or special symbols that could cause problems, or complex aliases. Use set +x to turn this back off.

Examples

After using set -x you can run the command:

ls

The output printed before the command runs (for example):

+ ls -F --color=auto 

Which means that the command is really an alias to run ls with the -F and --color=auto options. Use a “\” (backslash) before the command to run it without the alias.

The backslash escape character can be used before a shell command to override any aliases.

For example if rm was made into an alias for rm -i then typing “rm” would actually run rm -i.

However, typing \rm lets the shell ignore the alias and just run rm (its runs exactly what you type), this way it won't confirm if you want to delete things.

	Using rm
	Please note that the alias for the remove command is there for a reason. Using it incorrectly could remove files which you don't want removed. Only use \rm if you know exactly what you are doing (recovering files is not easy, rm does not send things to a recycle bin).

The “\” character can be used before special characters (such as a space or a wildcard), to stop bash from trying to expand them. You can make a directory name with a space in it using a backslash before the space. For example you could type cd My\ Directory\ With\ Spaces which normally wouldn't work.

The “\” character can also be used to stop bash from expanding certain symbols (as an alternative you could use single quotation marks, although you may need to use both).

	The TAB Key
	Please note that using the TAB key (automatic-command-completion) will automatically use escapes for spaces (so you don't have to type them manually).

The “script” command creates a typescript, or "capture log" of a shell session - it writes a copy of your session to a file, including commands you type and their output.

The tilde character is used as an alias to a users home directory.

For example, if your user-name was “fred”, instead of typing cd /home/fred you could simply type cd ~. Or to get to fred's tmp directory (under his home directory) you could type cd ~/tmp.

	Home directory shortcut
	~ (tilde) can also be used as a shortcut to other users home directories, simply type: ~user_name and it will take you to the users home directory. Note that you need to spell the username exactly correct, no wildcards.

This particular set command will turn off the system bell from the command-line (use xset -b for X windows). If you want the bell to stay off pernamently (no audible bell) then you can add this command to your “.bashrc” or “.bash_profile” (just add it to the same one you have your alises in...).

The reset command re-initializes your current terminal. This can be useful when the text from your terminal becomes garbled, simply type “reset” and this will fix your terminal.

Closes your current terminal (with x-terminals) or logs-out. Also try CTRL-D .

Logs out of a terminal, also try CTRL-D .

A little command that repeats anything you type.

Example:

echo “hello world”

Simply displays “ hello world”.

Example:

echo rm -R *

This will output what will be passed to the rm command (and therefore what would be deleted), putting echo before a command renders it harmless (it just expands wildcards so you know what it will do).

Also try using the -e option with echo. This will allow you to use the escape character sequences to format the output of a line. Such as '\t' for tab, '\n' for newline etc.

	Using echo to prevent accidents
	Typing: echo command(s) could save you the trouble of accidentally doing something you didn't expect. Using echo allows you to expand the wildcards to understand what will happen before you actually run the command.

Use the up and down key's to scroll through previously typed commands. Press [Enter] to execute them or use the left and right arrow keys to edit the command first. Also see history (below).

The history command can be used to list Bash's log of the commands you have typed:

This log is called the “history”. To access it type:

history n

This will only list the last n commands. Type “history” (without options) to see the the entire history list.

You can also type !n to execute command number n. Use !! to execute the last command you typed.

!-n will execute the command n times before (in other words !-1 is equivalent to !!).

!string will execute the last command starting with that “string” and !?string? will execute the last command containing the word “string”. For example:

!cd

Will re-run the command that you last typed starting with “cd”.

“ commandName !*” will execute the “commandName” with any arguments you used on your last command. This maybe useful if you make a spelling mistake, for example. If you typed:

emasc /home/fred/mywork.java /tmp/testme.java

In an attempt to execute emacs on the above two files this will obviously fail. So what you can do is type:

emacs !*

This will execute emacs with the arguments that you last typed on the command-line. In other words this is equivalent to typing:

emacs /home/fred/mywork.java /tmp/testme.java

Use the CTRL-R key to perform a “reverse-i-search”. For example, if you wanted to use the command you used the last time you used snort, you would type:

CTRL-R then type “snort”.

What you will see in the console window is:

(reverse-i-search)`':

After you have typed what you are looking for, use the CTRL-R key combination to scroll backward through the history.

Use CTRL-R repeatedly to find every reference to the string you've entered. Once you've found the command you're looking for, use [Enter] to execute it.

Alternatively, using the right or left arrow keys will place the command on an actual command-line so you can edit it.

the “end-of-file” (EOF) key combination can be used to quickly log out of any terminal. CTRL-D is also used in programs such as “at” to signal that you have finished typing your commands (the EOF command).

key combination is used to stop a process. It can be used to put something in the background temporarily.

For example, if you were editing a file with vim or emacs just press CTRL-Z to regain control of the terminal do what you want and then type fg to bring it back.

For further information please see Section 9.3.

	If fg doesn't work
	If fg doesn't work you may need to type jobs and then fg job_name or fg job_number

These key combinations are used for going to the start and end of the line on the command line. Use CTRL-A to jump to the start of the line, and CTRL-E to jump to the end of the line.

This key combination can be used to cut or delete what is currently in front of the cursor.

This key combination can be used to paste the last thing you deleted (using CTRL-K or CTRL-W ).

This key combination can be used to cut or delete the entire line that has being typed.

is a great program that allows you to switch between multiple virtual terminals on the one physical terminal that you are using. Its a command-line based window manager, clearly this isn't that useful if you do have virtual terminals, but its amazingly useful when you log into machines remotely, using ssh and similar, see Section 13.3. It works on key-combinations, you type

screen

On the command-line to begin. Now you start with one virtual terminal by default, but using the key combination CTRL-A and then hitting "C" you can create another virtual terminal to use.

Use CTRL-N to go to the next virtual terminal and CTRL-P to go to the previous virtual terminal. Also try hitting CTRL-A to go backwards and forwards between two particular terminals.

screen also has various other abilities that you can test out. The documentation and guides are well written so please feel free to read the manual page or try searching the internet.

Standard output is the output from the program printed to the screen, not including error output (see below).

Standard input is the input from the user. Normally the keyboard is used as the standard input device in a UNIX system.

Standard error is error output from programs. This output is also sent to the screen and will normally be seen mixed in with standard output. The difference between standard output and standard error is that standard error is unbuffered (it appears immediately on the screen) and standard error is only printed when something goes wrong (it will give you details of what went wrong).

The greater than symbol is used to send information somewhere (for example a text file)

Example:

cat file1 file2 > file1_and_2.txt

This will concatenate the files together into one big file named “file1_and_2.txt”. Note that this will overwrite any existing file.

The less than symbol will insert information from somewhere (a text file) as if you typed it yourself. Often used with commands that are designed to get information from standard input only.

For example (using tr):

tr '[A-Z]' '[a-z]' < fileName.txt > fileNameNew.txt

The example above would insert the contents of “fileName.txt” into the input of tr and output the results to “fileNameNew.txt”.

The >> symbol appends (adds) information to the end of a file or creates one if the file doesn't exist.

The << symbol is sometimes used with commands that use standard input to take information. You simply type << word (where word can be any string) at the end of the command. However its main use is in shell scripting.

The command takes your input until you type “word”, which causes the command to terminate and process the input.

Using << is similar to using CTRL-D (EOF key), except it uses a string to perform the end-of-file function. This design allows it to be used in shell scripts.

For example type "cat" (with no options...) and it will work on standard input.

To stop entering standard input you would normally hit CTRL-D .

As an alternative you can type "cat << FINISHED", then type what you want.

When you are finished, instead of hitting CTRL-D you could type "FINISHED" and it will end (the word FINISHED will not be recorded).

Redirects error output. For example, to redirect the error output to /dev/null, so you do not see it, simply append this to the end of another command...

For example:

make some_file 2> /dev/null

This will run make on a file and send all error output to /dev/null

The “pipe” command allows the output of one command to be sent to the input of another.

For example:

cat file1.txt file2.txt | less

Concatenates the files together, then runs less on them. If you are only going to look at a single file, you would simply use less on the file...

Sends output of a program to a file and to standard output. Think of it as a T intersection...it goes two ways.

For example:

ls /home/user | tee my_directories.txt

Lists the files (displays the output on the screen) and sends the output to a file: “my_directories.txt”.

Redirects standard output and error output to a specific location.

For example:

make &> /dev/null

Sends both error output and standard output to /dev/null so you won't see anything...

Simply type:

command_1 `command_2 -options`

This will execute “command_2” and it's output will become the input to “command_1”.

	Backquote key
	The back-quote key is usually located at the same place as the tilde, above the [Tab] key.

Simply type:

command_1 $(command_2)

This will execute “command_2” and it's output will become the input to “command_1”.

You can of course use pipes to do the same thing, if you don't know what a pipe is, please see Section 6.2. For example instead of doing:

less $cat file1.txt file2.txt

You could do:

cat file1.txt file2.txt | less

And end up with exactly the same result, it's up to you which way you find easier.

To do this you would type:

command1 && command2

command2 will be executed if command1 successfully completes (if command1 fails command2 won't be run). This is called a logical AND.

To do this you would type:

command1 || command2

command2 will be executed if command1 does not successfully complete (if command1 is successful command2 won't be run). This is called a logical OR.

To execute commands sequentially regardless of the success/failure of the previous you simply type:

command1; command2

command2 will execute once command1 has completed.

	More than two commands
	You can continue to use ';' (semicolon) characters to do more and more commands on the one line.

Change directory. Use “ cd ..” to go up one directory.

One dot '.' represents the current directory while two dots '..' represent the parent directory.

“ cd -” will return you to the previous directory (a bit like an “undo”).

You can also use cd absolute path or cd relative path (see below):

For example to get to /boot/grub you would type:

cd /boot/grub

This is an absolute path because you start at the top of the hierarchy and go downwards from there (it doesn't matter where in the filesystem you were when you typed the command).

Please note that there is no / using the above cd command. Using a / would cause this to be an absolute path, working from the top of the hierarchy downward.

List files and directories. Typing “ls” will list files and directories, but will not list hidden files or directories that start with a leading full stop “.”.

Example options:

• ls -l --- long style, this lists permissions, file size, modification date, ownership.

• ls -a --- this means "show all", this shows hidden files, by default any file or directory starting with a '.' will not be shown.

• ls -d --- list directory entires rather than contents (see example below)

• ls -F --- append symbols to particular files, such as * (asterisk) for executable files.

• ls -S --- sort the output of the command in decending order sorted by size.

• ls -R --- (recursive) to list everything in the directories below as well as the current directory.

Command syntax, either:

ls -options

This simply lists everything in the current directory, the options are not required (options such as -l, -a et cetera).

ls -options string

This lists files using a certain string. The string can contain standard wildcards to list multiple files, to learn more about standard wildcards please read Section 20.4.1

You can use ls -d to show directories that match an exact string, or use standard wildcards. Type “ ls -d */” to list all subdirectories of the current directory. Depending on the setup of your aliases (see Chapter 4) you may simply be able to type lsd as the equivalent to ls -d */.

Examples for ls -d:

ls -d */

Lists all subdirectories of current directory.

ls -d string*

Lists directories that start with "string".

ls -d /usr/*/*/doc

Lists all directories that are two levels below the /usr/ directory and have a directory called “doc”, this trick can come in quite handy sometimes.

	You can also use
	Depending on how your aliases (see Chapter 4) are setup you can also use l, la (list all) and ll (list long) to perform the above commands

Print working directory. Print the absolute (complete) path to the directory the user is currently in.

Command syntax:

pwd

This will tell you the full path to the directory you are in, for example it may output “/usr/local/bin” if you are currently in that directory.

Outputs an ASCII text tree/graph starting at a given directory (by default the current directory). This command recursively lists all files and all directories.

In other words, it will list files within the directories below the current one, as well as all files in the current directory.

tree has a large number of options, refer to the manual page for details.

Command syntax:

tree

or

tree -option(s) /optional/directory/to/list

Make a directory. Use mkdir -p to create subdirectories automatically.

	Directories are Folders
	Directories are sometimes called folders in other operating systems (such as Microsoft Windows)

Examples:

mkdir -p /home/matt/work/maths

This would create the directories “work” and “maths” under matt's home directory (if matt's home directory didn't exist it would create that too).

mkdir foo

This would create a directory in the current path named “foo”.

Remove/delete a file(s) or directories(s). You can use standard wildcards with this command Section 20.4.1.

Command syntax:

rm -options file_or_folder

You can of course use standard wildcards to delete multiple files or multiple directories and files.

Use the -R or -r option to remove recursively, this removes everything within subdirectories. Also try the -f option to force removal (useful when you don't want to be prompted).

	Disabling Aliases (per execution)
	On some systems such as Mandrake an alias will send rm to rm -i (prompting you for every file you wish to delete). To override this use: \rm -R directory (using the \ disables the alias for this run only)

Remove an empty directory. If you want to remove a directory with files in it type “ rm -R directory”, read above for information on rm -R

Command syntax:

rmdir directory

This will only remove directory if it's empty otherwise it will exit with an error message.

Move a file or a directory to a new location or rename a file/directory.

Rename example:

mv filename1 filename2

Renames filename1 to filename2.

To move a file or directory, simply type:

mv original_file_or_folder new_location

Note that this command can use standard wildcards Section 20.4.1 to move files (not for renaming).

	Move and rename
	Note that you can also move and rename a file in a single command. The difference is with the destination (right hand side) you change the filename to the new name of the file. For example typing: mv /etc/configuration.txt /home/joe/backupconfig This would move the file "configuration.txt" to /home/joe/ and rename it "backupconfig"

Copy a file. Has a number of useful options, such as -R (or -r) which recursively copies directories and subdirectories.

Command syntax:

cp -options file_or_files new_location

Examples:

cp file1 file2

Simply copy file1 to file2 (in the same directory).

cp /tmp/file1 ~/file2 /mnt/win_c

Where the last option is the directory to be copied to. The above example copies two files from different areas of the file system to /mnt/win_c

cp -R directory_and_or_files new_location

This command will copy directories (and all subdirectories) and/or files to new_location

Note that this command can use standard wildcards Section 20.4.1 to copy multiple files.

You may also like to try the “-u” when moving large directories around, this copies only if the source file is newer than the destination to where you are copying to, or if the destination file does not exist at all.

Create a link to a file. There are two types of links:

Securely remove a file by overwriting it first. Prevents the data from being recovered by software (and even by most hardware), please be very careful when using shred as you may never be able to retrieve the data you have run the application on.

For example:

shred -n 2 -z -v /dev/hda1

“What this tells shred, is to overwrite the partition 2 times with random data (- n 2) then finish it up by writing over it with zeroes (-z) and show you its progress (-v). Of course, change /dev/hda1 to the correct partition . Each pass can take some time, which is why I set it to only do 2 random passes instead of the default 25. You can adjust this number, of course, to your particular level of paranoia and the amount of time you have.

Since shred writes on such a low-level, it doesn't actually matter what kind of filesystem is on the partition--everything will be unrecoverable. Once shred is finished, you can shutdown the machine and sell or throw away the drive with peace of mind.

...However, even shre dding devices is not always completely reliable. For example, most disks map out bad sectors invisibly to the application; if the bad sectors contain sensitive data, `shred' won't be able to destroy it. [ shred info page ].”[2]

	Shredding files doesn't work with all filesystems
	Please note that as mentioned in the shred manual page (please see the manual and preferably info pages for more information). shred does not work correctly on log-structured or journaled filesystems, such as JFS, ReiserFS, XFS, Ext3 and many other modern filesystems

Alternatives to using shred

shred has its disadvantages when run on a filesystem. First of all since it has to be installed you cannot run shred on your operating systems filesystem, you also cannot use shred on a windows machine easily since you cannot install shred on this machine. You may like to try alternatives such as the DBAN project that create self-booting floppy disks that can completely erase a machines hard disk.

You may also like to see how chattr can assist you in shredding files once they are removed (it has similar problems to shred, only ext2 and ext3 style filesystems...), please see Section 14.2.

Displays information about file size. Use du filename to display the size of a particular file. If you use it on directories it will display the information on the size of the files in the directory and each subdirectory.

Options for du (use du -option(s)):

• -c -- this will make du print a grand total after all arguments have being processed.

• -s -- summarises for each argument (prints the total).

• -h -- prints things in “ human readable” mode; for example printing 1M (megabyte) rather than 1,024,000 (bytes).

Using the -hs options on a directory will display the total size of the directory and all subdirectories.

Command syntax:

du -options file_directory_or_files

Example:

du -hs *

This command will list the size of all files in the current directory and it will list the size of subdirectories, it will list things in human-readable sizes using 1024 Kb is a Megabyte, M for megabyte, K for kilobyte etc.

Attempts to find out what type of file it is, for example it may say it's: binary, an image file (well it will say jpeg, bmp et cetera), ASCII text, C header file and many other kinds of files, it's a very useful utility.

Command syntax:

file file_name

Tells you detailed information about a file, including inode number creation/access date. Also has many advanced options and uses.

For simple use type:

stat file

Copies data on a very low level and can be used to create copies of disks Section 20.3 and many other things (for example CD image files).

dd can also perform conversions on files and vary the block size used when writing the file.

Command syntax, note the block size and count are optional and you can use files instead of devices...

	Please note
	dd is an advanced and difficult to use command. Its also very powerful, so be careful what you do with it

Command syntax:

dd if=/dev/xxx of=/dev/xxx bs=xxxx count=x 

	Warning
	The command dd is used to work on a very low level. It can be used to overwrite important information such as your master-boot record or various important sections of your hard-disk. Please be careful when using it (especially when working with devices instead of files).

This command is used to create empty files, simply do touch file_name. It is also used to update the timestamps on files.

touch can be used to change the time and/or date of a file:

touch -t 05070915 my_report.txt[3]

This command would change the timestamp on my_report.txt so that it would look like you created it at 9:15. The first four digits stand for May 7th (0507), in MM-DD (American style), and the last four (0915) the time, 9:15 in the morning.

Instead of using plain numbers to change the time, you can use options similar to that of the date tool. For example:

touch -d '5 May 2000' some_file.txt

You can also use --date= instead of -d. Also have a look at the date command under Section 8.1 for examples on using -d and --date= (the syntax for the date part is exactly the same when using -d or --date).

Splits files into several smaller files.

Use the -b xx option to split into xx bytes, also try -k for kilobytes, and -m for megabytes. You can use it to split text files and any other files... you can use cat to re-combine the files.

This may be useful if you have to transfer something to floppy disks or you wish to divide text files into certain sizes.

Command syntax:

split -options file

This will split the input file into 1000 lines of input each (thats the default...), and output (using the above example), with the input name file, “fileaa” (1st part of file), “fileab” (2nd part of file), “fileac” (3rd part of file) etc. until the there is no more of the file left to split.

mmv is a mass move/copy/renaming tool that uses standard wildcards to perform its functions.

mmv's manual page is quite difficult to understand, I have only a limited understanding of this tool. However mmv supports some standard wildcards.

According to the manual the “;” wildcard is useful for matching files at any depth in the directory tree (ie it will go below the current directory, recursively).

An example of how to use mmv is shown below:

mmv \*.JPG \#1.jpg 

The first pattern matches anything with a “.JPG” and renames each file (the “#1” matches the first wildcard) to “.jpg”.

Each time you use a \(wildcard) you can use a #x to get that wildcard. Where x is a positive number starting at 1.

	mmv Homepage
	You can find mmv on the web here. Also be aware that certain options used with mmv are also applicable to other tools in the suite, these include mcp (mass copy), mad (mass append contents of source file to target name), mln (mass link to a source file).

	Tip:
	A Java alternative to mmv which runs on both GNU/Linux and Windows is available, Esomaniac

rename is a perl script which can be used to mass rename files according to a regular expression.

An example for renaming all “.JPG” files to “.jpg” is:

rename 's/\.JPG$/.jpg/' *.JPG 

	Finding rename
	You can get rename from various places. I would recommend trying CPAN Search Site, I found the script here Rename Script Version 1.4

Bash scripting is one way to rename files. You can develop a set of instructions (a script) to rename files. Scripts are useful if you don't have mmv or rename...

One way to this is shown below:

for i in *.JPG; 
do mv $i `basename $i JPG`jpg; 
done 

Note that the above script came from a usenet post. Unfortunately I do not know the author's name.

The first line says find everything with the “.JPG” extension (capitals only, because the UNIX system is case sensitive).

The second line uses basename (type man basename for more details) with the '$i' argument. The '$i' is a string containing the name of the file that matches. The next portion of the line removes the JPG extension from the end and adds the jpg extention to each file. The command mv is run on the output.

An alternative is:

for i in *.JPG; 
do mv $i ${i%%.JPG}.jpg; 
done

The above script renames files using a built-in bash function. For more information on bash scripting you may like to see the advanced bash scripting guide, authored by Mendel Cooper.

Tells you the date (and the time) and is also used to set the date/time.

To set the date, type date MM:DD:YYYY (American style date) where MM is month, DD is the number of days within the month and YYYY is the year.

For example to set the date to the 1st January 2000 you would type:

date 01:01:2000

To set the time (where the -s option is to set a new time), type:

date -s hh:mm:ss

Another useful option you can use is --date=“string” (or -d “string”) option to display a date from x days ago or in x days (or x weeks, months, years et cetera). See the examples below.

Examples:

date --date="3 months 1 day ago"

Will print the date 3 months and 1 day ago from the current date. Note that --date=”x month x day ago” and -d “x month x day ago” are equivalent.

date -d "3 days"

The above command will print the date 3 days in the future from now.

Typing cal will give you the calendar of the present month on your screen, in the nice standard calendar format. There are various options to customise the calendar, refer to the info/man page.

Example:

cal -y year

Will display a calendar for a specific year, simply use cal -y to print the calendar for the current year.

cal 2 2004

This will display the calendar for February 2004

You can look through the information in the relevant area of the proc filesystem, under the directory of either /proc/ide/ or /proc/ide?/hd? where the first question mark is a number and the second is a letter (starting with 'a').

For example:

cd /proc/ide0/hda

Under this directory there will be various information on the hard drive or cdrom connected.

Using fdisk with the -l option will output information on any hard drives connected to the system and information on their partitions (for example, the type of partition).

Information relating to using fdisk to partition hard disks can be found in your distributions documentation, the fdisk manual page or online.

	Root Access Required
	This command needs root access to work

Mount a device. Attach the device to the file-system hierarchy (the tree ( / )). This needs to be done so you can access the drive (see below, Section 9.1 for an example).

'Unmount' a device. The command umount (no 'n') unmount's a device. It removes it from the file-system hierarchy (the tree ( / )). This needs to be done before you remove a floppy/CDROM or any other removable device (see below, Section 9.1 for an example).

Where “win” would be the place you want it mounted and “wincomp” is the IP address or name of your windows computer.

	Please note
	Using ping/smbmount/ssh or other UNIX system programs with a computer name rather than IP address will only work if you have the computer listed in your /etc/hosts file. Here is an example: 192.168.1.100 new This line says that their is a computer called “new” with IP address 192.168.1.100. Now that it exists in the /etc/hosts file I don't have to type the IP address anymore, just the name “new”.

smbmount is a tool from the samba package, it can mount a remote windows file-system onto your current computer.

Un-mounting uses the same syntax as 'umount', as listed above, or you may like to use:

smbumount /mountpoint

Here are some more examples of how to mount a file-system:

mount -t ext2 /dev/fd0 /mnt/floppy 
mount -t iso9660 /dev/hdb /mnt/cdrom 
mount -t iso /tmp/image_file /mnt/iso_file/ -o loop 

	The -t option
	On any system running a newer version of the Linux kernel the -t option is not always necessary and can be left out.

Examples of how to unmount a file-system (necessary before you eject/remove disk):

umount /mount_point

An example unmount point could be “/mnt/floppy” or “/mnt/cdrom”

Shutdown the computer immediately (don't power down). Note that in UNIX systems this kind of shutdown means to go to “ single-user mode”. Single-user mode is a mode where only the administrator (root) has access to the computer, this mode is designed for maintenance and is often used for repairs.

For example this would take you to single user mode

shutdown now

Shutdown (-h = halt) the computer immediately. It begins the shutdown procedure, press CTRL-C (break-key) to stop it. After the end of the command you can also leave a message in quotation marks which will be broad-casted to all users, for example:

shutdown -h now "Warning system malfunction, self-destruct imminent"

This would halt the system and send the message to anyone who is currently logged in.

	Shutting down at a particular time
	You can also put a time that the system should shutdown instead of “now”. Typing “+x minutes” (any number of minutes is appropriate) or you can even set an exact time. For example to shutdown at 11:50 type: shutdown -h 11:50

	Shutdown -h vs poweroff
	On some systems, shutdown -h and halt do not actually turn the system's power off. On systems that do not power off with these commands use the poweroff command

The same as shutdown -h now doesn't take any options, this command simply shuts down immediately.

Shutdown ( -r = reboot) the computer immediately. It begins the reboot procedure, press CTRL-C (break-key) to stop it. After the end of the command you can also leave a message in quotation marks which will be broad-casted to all users, for example:

shutdown -r now "Warning system rebooting, all files will be destroyed"

This would reboot the system and send the message to anyone who was logged in.

	Rebooting at a particular time
	You can also put a time that the system should reboot instead of “now”. Typing “+x minutes” (any number of minutes is appropriate) or you can even set an exact time. For example to reboot at 11:50 type: shutdown -r 11:50

The same as shutdown -r now, doesn't take any options, simply reboots the computer immediately.

(key-combination) May be used from a terminal to reboot or shutdown, it depends on your system configuration. Note that this doesn't work from an xterminal. CTRL-ALT-DEL begins the reboot/shutdown immediately, the user does not have to be logged in.

You can change the behaviour of CTRL-ALT-DEL from rebooting

To disable CTRL-ALT-DEL from rebooting your computer (or to have it do something different), you can edit the /etc/inittab file (as root). Here is how it looks on a Mandrake/Mandriva Linux system: # Trap CTRL-ALT-DEL ca::ctrlaltdel:/sbin/shutdown -t3 -r now Note that the # means a comment (and is not used). If you simply put a # (hash) before the command it would disable it (it would become a comment). You could also change the command it runs for example if you changed the -r to a -h the computer would turn off instead of rebooting, or you could have it do anything you want. It's up to your creativity to make it do something interesting.

Will give you a list of the processes running on your system. With no options, ps will list processes that belong to the current user and have a controlling terminal.

Example options include:

• -aux --- list all running processes (by all users with some information).

• -a --- list all processes from all users.

• -u --- list more information including user names, %cpu usage, and %mem usage et cetera.

• -x --- list processes without controlling terminals.

• -l --- display different information including UID and nice value.

• --forest --- this makes it easier to see the process hierarchy, which will give you an indication of how the various processes on your system interrelate (although you should also try pstree).

For example to list all running processes with additional information, simply type:

ps -aux

Displays the processes in the form of a tree structure (similar to how tree does it for directories).

Use the -p option to show process id's.

Example:

pstree -p

This would list all processes and their id's.

This command is useful for finding the process id of a particular process when you know part of its name.

Use the -l option to list the name of the process as well and the -u option to search via a particular user(s).

Normally pgrep will only return the pid number; this way you can use it with other commands.

Examples:

kill $(pgrep mozilla)

This would kill any process name that starts with mozilla. Note that this is the same as using pkill (see below).

If you are unfamiliar with the $( ) part of this command, please refer to Section 6.4.

To list processes id's and names type:

pgrep -l process_name

Displays the 'top' (as in CPU usage) processes, provides more detail than ps.

top also provides an updated display, it has many options that make it fully customisable, refer to the manual or info page for details.

To kill processes on your system, you will need their pid's or id's . Use ps or pstree to find out the process id's (pid's), or use jobs to find out id's.

	killall and pkill - kill a process by name
	pkill and killall can be a lot easier to use than kill. pkill allows you to type part of the name of a process to kill it, while killall requires the full process name. See below for more information.

Examples:

kill pid

Simply kill a process (allow it time to save it's files and exit)

kill %id

Same as above, except it uses an id instead of a pid, you need to use a % (percent) when using an id to kill.

kill -kill pid

Force a process to be killed (won't allow files to be saved or updated); only use when necessary because all data that the program had will be lost.

There are also many other kill options such as kill -HUP (hangup)... refer to the manual/info pages for more information.

Kill a process by it's name, uses names instead of process id's (pid's). Use -v to have killall report whether the kill was successful or not and -i for interactive mode (will prompt you before attempting to kill).

	pkill - a little like a killall with regular expressions
	pkill is another command that allows processes to be killed but does so using regular expressions. See below for more information.

For example:

killall -iv mozilla

Would kill anything named “mozilla” and prompt you before each kill and report whether the kill was successful or not. Unfortunately you need to get the name exactly right for killall to work, you would need to use “mozilla-bin” to kill the mozilla browser. If you want something where you don't need to know the exact name try pkill (below).

pkill is used to kill processes according to an extended regular expression. Use the -u option to kill using a user name(s) and process name (for example to only kill a process of a certain user). pkill can also send specific signals to processes.

For normal usage simply type:

pkill process_name

Note that the “process_name” doesn't have to be an exact match...

Or to kill the “process_name” of only the users “fred” and “anon” type:

pkill -u fred anon process_name

skill is used to send a command/username/tty a particular signal.

skill has a number of options available to ensure correct interpretation (otherwise it just guesses what it is), simply type skill -option(s)

• -L --- list the various signals that can be sent

• -u --- specify a username; this is obviously followed by the user name or a space-seperated list of usernames.

• -p --- process id (followed by the process id)

• -c --- command name (this is the same as killall)

• -t --- (tty number)

• -v --- verbose mode

• -i --- interactive mode.

skill can be used to stop, continue, or kill processes using the username, command name or process id (or send them any variety of signals you like).

Useful example:

skill -STOP abusive_user_name

The above command will stop all of that users processes, this will cause his screen to freeze until you type:

skill -CONT abusive_user_name

This would tell that all processes may continue as before. Note that this would only work if you are root. Also note you can list more than one user name with the command so it will apply to multiple users.

The break key, will kill (break, stop) something that's running on your terminal.

Prints currently running jobs, as in processes you have executed within the shell.

Backgrounds a process. To start a program in the background (so it doesn't take over the terminal) use an “&” (ampersand) sign at the end of the command. You usually use CTRL-Z to suspend something you are currently using. You can simply use bg to resume in the background the last job suspended...

Command syntax:

bg job_number

or

bg job_name

Bring a process to the foreground, so you can interact with it. The process will use your current terminal. Note simply use fg to foreground the last job number suspended...

You can bring jobs to the foreground by name or by number (use jobs to find the number).

Command syntax:

fg job_number

or

fg job_name

Sets the priority for a process. nice -20 is the maximum priority (only administrative users can assign negative priorities), nice 20 is the minimum priority. You must be root to give a process a higher priority, but you can always lower the priority of your own processes...

Example:

nice -20 make

Would execute make and it would run at maximum priority.

Changes the priority of an existing command. You may use the options -u to change the priorities of all processes for a particular user name and -g to change priorities for all processes of a particular group. The default is to change via the process id number.

Example:

renice +20 2222

This would change the priority of process 2222 to +20 (minimum priority).

snice works very similarly to skill, only it changes the priority of the process(es). Its function is similar to that of renice.

To use options (to ensure correct interpretation) you simply type snice -option(s):

• -u --- specify a username; this is obviously followed by the user name or a space-seperated list of usernames.

• -p --- process id (followed by the process id)

• -c --- command name (this is the same as killall)

• -t --- tty number

• -v --- verbose mode

• -i --- interactive mode.

Example:

snice -10 -u root

This would increase the priority of all root's processes.

UNIX systems use scripts to control “daemons” which provide “services” (for example your sound output) to run a UNIX system. UNIX systems consist of a variety of services (daemons).

A “daemon” is a system process which runs in the background (zero interaction) performing a particular task.

Daemons normally have a “d” on the end of their name and either listen for certain events or perform a system task, for example sshd listens for secure shell requests to the particular machine and handles them when they occur.

Daemons usually perform critical system tasks such as control swap-space, memory management and various other tasks.

service is a shell script available on Mandrake/Mandriva and Redhat systems which allows you to perform various tasks on services.

• Use the -s option to print the status of all services available

• Use the -f option followed by a service name to restart that particular service.

• Use the -R option to restart all services (note that this will kill any current services running, including the X windows system).

For example to restart the daemon sshd you would type:

service -f sshd

You may also execute the shell script directly from /etc/init.d. Simply go to that directory then type ./script_name.

Executing the script should return the options it can take, by default they will be:

• restart --- this will make the service stop and then start again.

• start --- this option will start a service (assuming its not running).

• stop --- this option will stop a service (assuming its running).

• status --- this option will tell you about the service

Used to change your login shell.

To list the shells available type:

chsh --list-shells

Simply type chsh then [Enter], then type the name of the shell you would like to use every time you login.

Change finger information.

The information this command changes is reflected in the /etc/passwd file, use this utility to update your real name, office and home phone numbers (if they exist).

Use the -f option to change a users full name. Use this tool as either chfn or chfn user_name (usable by root only).

Command syntax:

chfn user_name

Changes the password of a user. You will need to be root if you want to change other users passwords.

Simply type passwd to change your own password or to change another users password type:

passwd username

A traditional UNIX system text editor, should be on any UNIX system. It requires learning a few key combinations, but is very powerful, and it is also quite small. vi is well known for its minimal use of resources.

	vim
	vim - vi improved. A newer version of the vulnerable vi editor. Many systems use vim rather than vi.

More than just a text editor. This text editor has a steep learning curve but is also very powerful, it is both advanced and quite large. emacs can do anything, surf the internet, chat, play games and many other tasks.

There are too many different text editors to list here. Have a look on the internet, either search for them using any search engine or you will find many of them at Sourceforge or Freshmeat.

With no options it shows the first ten lines of a text file.

Use head -n x (where “x” is a number) to display the first x lines.

Try head -F to use a continually updated version of head (if the file changes it will be reloaded and displayed), please note that using this option will run head is a continuous loop so you'll need to use CTRL-C to exit.

For example:

head -n 20 somelog.txt 

Will display the top 20 entries of the file “somelog.txt”.

With no options it shows the last ten lines of a file.

Use tail -n x (where “x” is a number) to display the last x lines.

Try tail -F to use a continually updated version of tail (if the file changes it will be reloaded and displayed), please note that using this option will run tail is a continuous loop so you'll need to use CTRL-C to exit.

For example:

tail -n 20 somelog.txt

Will display the last 20 entries of the file “somelog.txt”.

Views text, can scroll backwards and forwards. Has many different options which are all described in the manual page.

When less is already running, use :n and :p (type a colon then the character) to move to the next and previous files (when there are multiple open files).

Command syntax:

less filename.txt

Or using a tool (in this example cat):

cat file.txt | less

Displays text, one page full at a time, more limited than less. In this case less is better than more.

more filename.txt

Or using a tool (is this example cat):

cat file.txt | more

Combines (concatenates) multiple documents into one document. Can be used on individual files as well.

Some useful options:

• -b --- number all non-blank lines

• -n --- number all lines.

Also try using nl to number lines (it can do more complex numbering), you will find it under under this section, Section 11.4

Example:

cat filepart1 filepart2 filepart3 > wholefile.txt

This will combine (concatenate) filepart1, filepart2 and filepart3 into the single file “wholefile.txt”.

Combines (concatenates) multiple documents into one document and outputs them in reverse order. Can also be used on individual files. Notice that tac is cat written backwards.

Example:

tac filepart1 filepart2 filepart3 > wholefile.txt

This will combine (concatenate) filepart1, filepart2 and filepart3 into the single file but have each of the files written in reverse.

Many commands can be prefixed with a “z” to read/work within a gzip compressed file.

Some examples are zcat, zless, zmore, zgrep, zcmp, zdiff.

There are many utilities for working with text within compressed files without trying to manually de-compress them somewhere first...most begin with a “z”. You will find some of them mentioned over here, Section 15.3.

There are also a few commands that prefixed with a “bz” to read/work within a file compressed with bzip2.

The tools are bzcat, bzless, bzgrep. You will find some of them mentioned over here, Section 15.3.

Word count, count how many words you have in a text document. Can also be used to count the lines or bytes within the file.

Use the options -w for words, -l for lines and -c for bytes. Or simply run wc with no options to get all three.

Command syntax:

wc -option file.txt

To run various readability tests on a particular text file. Will output scores on a number of different readability tests (with no options).

Command syntax:

style -options text_file

	Find style in the diction package
	This command is part of the diction package and does not appear to be used too often these days

Determines whether or not two files differ, works on any type of file. Very similar to diff only it compares on the binary level instead of just the text.

Compares two text files and output a difference report (sometimes called a "diff") containing the text that differs between two files.

Can be used to create a 'patch' file (which can be used by patch).

Example:

diff file1.txt file2.txt

diff will output a '>' (followed by the line) for each line that isn't in the first file but is in the second file, and it will output a '<' (followed by the line) for each line that is in the first file but not in the second file.

Instead of giving a difference report, it outputs the files in two columns, side by side, separated by spaces.

Same as diff except for three files.

Compares two files, line-by-line and prints lines that are unique to file1 (1st column), unique to file2 (2nd column) and common to both files (3rd column).

Use comm with the -1, -2, or -3 to suppress the printing of those particular lines. Simply run comm to have all three listed (ie. unique to files 1 and 2 and common to both).

Command syntax:

comm file1 file2

To output a list of words in the system dictionary that begin with a given string -- this is useful for finding words that begin with a particular phrase or prefix.

Give the string as an argument; it is not case sensitive.

Command syntax:

look string

Sorting text with no options the sort is alphabetical. Can be run on text files to sort them alphabetically (note it also concatenates files), can also be used with a pipe '|' to sort the output of a command.

Use sort -r to reverse the sort output, use the -g option to sort 'numerically' (ie read the entire number, not just the first digit).

Examples:

cat shoppinglist.txt | sort

The above command would run cat on the shopping list then sort the results and display them in alphabetical order.

sort -r shoppinglist.txt

The above command would run sort on a file and sort the file in reverse alphabetical order.

Advanced sort commands:

sort is a powerful utility, here are some of the more hard to learn (and lesser used) commands. Use the -t option to use a particular symbol as the separator then use the -k option to specify which column you would like to sort by, where column 1 is the first column before the separator. Also use the -g option if numeric sorting is not working correctly (without the -g option sort just looks at the first digit of the number). Here is a complex example:

sort -t : -k 4 -k 1 -g /etc/passwd | more 

This will sort the “/etc/passwd” file, using the colon ':' as the separator. It will sort via the 4th column (GID section, in the file) and then sort within that sort using the first (name) to resolve any ties. The -g is there so it sorts via full numbers, otherwise it will have 4000 before 50 (it will just look at the first digit...).

Will put two lines together assuming they share at least one common value on the relevant line. It won't print lines if they don't have a common value.

Command syntax:

join file1 file2

Prints selected parts of lines (of a text file), or, in other words, removes certain sections of a line. You may wish to remove things according to tabs or commas, or anything else you can think of...

Options for cut:

• -d --- allows you to specify another delimiter, for example ':' is often used with /etc/passwd:

  cut -d ':' (and probably some more options here) /etc/passwd

• -f --- this option works with the text by columns, separated according to the delimiter. For example if your file had lines like “result,somethingelse,somethingelse” and you only wanted result you would use:

  cut -d ',' -f 1 /etc/passwd

  This would get you only the usernames in /etc/passwd

• “,” (commas) --- used to separate numbers, these allow you to cut particular columns. For example:

  cut -d ':' -f 1,7 /etc/passwd

  This would only show the username and the shell that each person is setup for in /etc/passwd.

• “-” (hyphen) --- used to show from line x to line y, for example 1-4, (would be from lines 1 to line 4).

  cut -c 1-50 file1.txt

  This would cut (display) characters (columns) 1 to 50 of each line (and anything else on that line is ignored)

• -x --- where x is a number, to cut from line 1 to “x”

• x- --- where x is a number, to cut from “x” to the end.

  cut -5, 20-, 8 file2.txt

  This would display (“cut”) characters (columns) 1 to 5, 8 and from 20 to the end.

To spell check a file interactively, prompts for you to replace word or continue. aspell is said to be better at suggesting replacement words, but its probably best to find out for yourself.

aspell example:

aspell -c FILE.txt

This will run aspell on a particular file called “FILE.txt”, aspell will run interactively and prompt for user input.

ispell example:

ispell FILE.txt

This will run ispell on a particular file called “FILE.txt” ispell will run interactively and prompt for user input.

Is used to change the uppercase letters in a file name to lowercase (or vice versa).

You could also use tr to do the same thing...

cat fileName.txt | tr '[A-Z]' '[a-z]'  > newFileName.txt

The above would convert uppercase to lowercase using the the file “fileName.txt” as input and outputting the results to “newFileName.txt”.

cat fileName.txt | tr '[a-z]' '[A-Z]' > newFileName.txt

The above would convert lowercase to uppercase using the the file “fileName.txt” as input and outputting the results to “newFileName.txt”.

chcase (a perl script) can be found at the chcase homepage.

(format) a simple text formatter. Use fmt with the -u option to output text with "uniform spacing", where the space between words is reduced to one space character and the space between sentences is reduced to two space characters.

Example:

fmt -u myessay.txt

Will make sure the amount of space between sentences is two spaces and the amount of space between words is one space.

Puts lines from two files together, either lines of each file side by side (normally separated by a tab-stop but you can have any symbols(s) you like...) or it can have words from each file (the first file then the second file) side by side.

To obtain a list of lines side by side, the first lines from the first file on the left side separated by a tab-stop then the first lines from the second file. You would type:

paste file1.txt file2.txt

To have the list displayed in serial, first line from first file, [Tab], second line from first file, then third and fourth until the end of the first file type:

paste --serial file1.txt file2.txt

	This command is very simple to understand if you make yourself an example
	Its much easier if you create an example for yourself. With just a couple of lines, I used "first line first file" and "first line second file" et cetera for a quick example.

Will convert tabs to spaces and output it. Use the option -t num to specify the size of a “tapstop”, the number of characters between each tab.

Command syntax:

expand file_name.txt

Will convert spaces to tabs and output it.

Command syntax:

unexpand file_name.txt

Eliminates duplicate entries from a file and it sometimes greatly simplifies the display.

uniq options:

• -c --- count the number of occurances of each duplicate

• -u --- list only unique entries

• -d --- list only duplicate entries

For example:

uniq -cd phone_list.txt

This would display any duplicate entries only and a count of the number of times that entry has appeared.

(translation). A filter useful to replace all instances of characters in a text file or "squeeze" the whitespace.

Example:

cat some_file | tr '3' '5' > new_file

This will run the cat program on some file, the output of this command will be sent to the tr command, tr will replace all the instances of 3 with 5, like a search and replace. You can also do other things such as:

cat some_file | tr '[A-Z]' '[a-z]' > new_file

This will run cat on some_file and convert any capital letters to lowercase letters (you could use this to change the case of file names too...).

	Alternatives
	You can also do a search and replace with a one line Perl command, read about it at the end of this section.

The number lines tool, it's default action is to write it's input (either the file names given as an argument, or the standard input) to the standard output.

Line numbers are added to every line and the text is indented.

This command can do take some more advanced numbering options, simply read the info page on it.

These advanced options mainly relate to customisation of the numbering, including different forms of separation for sections/pages/footers etc.

Also try cat -n (number all lines) or cat -b (number all non-blank lines). For more info on cat check under this section: Section 11.2

There are two ways you can use nl:

nl some_text_file.txt

The above command would add numbers to each line of some_text_file. You could use nl to number the output of something as shown in the example below;

grep some_string some_file | nl

To search and replace text in a file is to use the following one-line Perl command[4]:

$ perl -pi -e "s/oldstring/newstring/g;" filespec [RET]

In this example, “oldstring” is the string to search, “newstring” is the string to replace it with, and “filespec” is the name of the file or files to work on. You can use this for more than one file.

Example: To replace the string “helpless” with the string “helpful” in all files in the current directory, type:

$ perl -pi -e "s/helpless/helpful/g;" * [RET]

Also try using tr to do the same thing (see further above in this section).

The following filters allow you to change text from Dos-style to UNIX system style and vice-versa, or convert a file to other formats. Also note that many modern text editors can do this for you...

This converts Microsoft-style end-of-line characters to UNIX system style end-of-line characters.

Simply type:

dos2unix file.txt

This does the same as dos2unix (above).

Simply type:

fromdos file.txt

fromdos can be obtained from the from/to dos website.

This converts UNIX system style end-of-line characters to Microsoft-style end-of-line characters.

Simply type:

unix2dos file.txt

This does the same as unix2dos (above).

Simply type:

todos file.txt

todos can be obtained from the from/to dos website.

This filter converts Microsoft word documents into plain ASCII text documents.

Simply type:

antiword file.doc

You can get antiword from the antiword homepage.

Converts text files between various formats including HTML and dozens of different forms of text encodings.

Use recode -l for a full listing. It can also be used to convert text to and from Windows and UNIX system formats (so you don't get the weird symbols).

	Warning
	By default recode overwrites the input file, use '<' to use recode as a filter only (and to not overwrite the file).

UNIX system text to Windows text:

recode ..pc file_name

Windows text to UNIX system text:

recode ..pc/ file_name

UNIX system text to Windows text without overwriting the original file (and creating a new output file):

recode ..pc < file_name > recoded_file

(Windows to UNIX system style conversion only). While tr is not specifically designed to convert files from Windows-format to UNIX system format by doing:

tr -d '\r' < inputFile.txt > outputFile.txt

The -d switch means to simply delete any occurances of the string. Since we are looking for '\r', carriage returns it will remove any it finds, making the file a UNIX system text file. You can read more about tr over here, Section 11.4.

Looks for text within files. For example:

grep this_word this_file.txt 

Example options:

• -v --- this option is used to display lines which do not contain the string.

• -n --- this option displays the line numbers

• -w --- this option makes grep match the whole word

• -A x or -B x (where x is a number) --- display “x” lines After or Before the section where the particular word is found.

• -r or rgrep --- search for text within files recursively.

This command uses regular expressions, for more information please see, Section 20.4.2.

For example, this command would look in the file “rpmlist.txt” for anything starting with “rpm”:

grep rpm rpmlist.txt

Or you could use it like this, to search through the output of another file:

rpm -qa | grep ogg

The first command lists all RPM's installed on your system, the second finds any containing the string “ogg” and outputs them.

A "recursive" version of grep (this is a different program to grep). This will search all the files in the current directory and all it's subdirectories and print the names of the files and the matching line. Follows similar syntax to grep (see above). You could also use grep with the -r option to achieve the same affect.

This version of grep calls grep with the -F option. This will look for literal strings only, it won't use or expand any kind of regular expression.

For example you could type:

fgrep 'a$*b?' file.txt

And fgrep would look for the string “a$*b?” in the file “file.txt”.

This command is used to configure network interfaces, or to display their current configuration. In addition to activating and deactivating interfaces with the “up” and “down” settings, this command is necessary for setting an interface's address information if you don't have the ifcfg script.

Use ifconfig as either:

ifconfig

This will simply list all information on all network devices currently up.

ifconfig eth0 down

This will take eth0 (assuming the device exists) down, it won't be able to receive or send anything until you put the device back “up” again.

Clearly there are a lot more options for this tool, you will need to read the manual/info page to learn more about them.

Use ifup device-name to bring an interface up by following a script (which will contain your default networking settings). Simply type ifup and you will get help on using the script.

For example typing:

ifup eth0

Will bring eth0 up if it is currently down.

Use ifdown device-name to bring an interface down using a script (which will contain your default network settings). Simply type ifdown and you will get help on using the script.

For example typing:

ifdown eth0

Will bring eth0 down if it is currently up.

Use ifcfg to configure a particular interface. Simply type ifcfg to get help on using this script.

For example, to change eth0 from 192.168.0.1 to 192.168.0.2 you could do:

ifcfg eth0 del 192.168.0.1
ifcfg eth0 add 192.168.0.2

The first command takes eth0 down and removes that stored IP address and the second one brings it back up with the new address.

The route command is the tool used to display or modify the routing table. To add a gateway as the default you would type:

route add default gw some_computer

Performs a simple lookup of an internet address (using the Domain Name System, DNS). Simply type:

host ip_address

or

host domain_name

The "domain information groper" tool. More advanced then host... If you give a hostname as an argument to output information about that host, including it's IP address, hostname and various other information.

For example, to look up information about “www.amazon.com” type:

dig www.amazon.com

To find the host name for a given IP address (ie a reverse lookup), use dig with the `-x' option.

dig -x 100.42.30.95

This will look up the address (which may or may not exist) and returns the address of the host, for example if that was the address of “http://slashdot.org” then it would return “http://slashdot.org”.

dig takes a huge number of options (at the point of being too many), refer to the manual page for more information.

(now BW whois) is used to look up the contact information from the “whois” databases, the servers are only likely to hold major sites. Note that contact information is likely to be hidden or restricted as it is often abused by crackers and others looking for a way to cause malicious damage to organisation's.

(GNU Web get) used to download files from the World Wide Web.

To archive a single web-site, use the -m or --mirror (mirror) option.

Use the -nc (no clobber) option to stop wget from overwriting a file if you already have it.

Use the -c or --continue option to continue a file that was unfinished by wget or another program.

Simple usage example:

wget url_for_file

This would simply get a file from a site.

wget can also retrieve multiple files using standard wildcards, the same as the type used in bash, like *, [ ], ?. Simply use wget as per normal but use single quotation marks (' ') on the URL to prevent bash from expanding the wildcards. There are complications if you are retrieving from a http site (see below...).

Advanced usage example, (used from wget manual page):

wget --spider --force-html -i bookmarks.html

This will parse the file bookmarks.html and check that all the links exist.

Advanced usage: this is how you can download multiple files using http (using a wildcard...).

Notes: http doesn't support downloading using standard wildcards, ftp does so you may use wildcards with ftp and it will work fine. A work-around for this http limitation is shown below:

wget -r -l1 --no-parent -A.gif http://www.website.com[6]

This will download (recursively), to a depth of one, in other words in the current directory and not below that. This command will ignore references to the parent directory, and downloads anything that ends in “.gif”. If you wanted to download say, anything that ends with “.pdf” as well than add a -A.pdf before the website address. Simply change the website address and the type of file being downloaded to download something else. Note that doing -A.gif is the same as doing -A “*.gif” (double quotes only, single quotes will not work).

wget has many more options refer to the examples section of the manual page, this tool is very well documented.

	Alternative website downloaders
	You may like to try alternatives like httrack. A full GUI website downloader written in python and available for GNU/Linux

curl is another remote downloader. This remote downloader is designed to work without user interaction and supports a variety of protocols, can upload/download and has a large number of tricks/work-arounds for various things. It can access dictionary servers (dict), ldap servers, ftp, http, gopher, see the manual page for full details.

To access the full manual (which is huge) for this command type:

curl -M

For general usage you can use it like wget. You can also login using a user name by using the -u option and typing your username and password like this:

curl -u username:password http://www.placetodownload/file

To upload using ftp you the -T option:

curl -T file_name ftp://ftp.uploadsite.com

To continue a file use the -C option:

curl -C - -o file http://www.site.com

Secure shell, remotely login on a machine running the sshd daemon. Once you are logged in you have a secure shell and are able to execute various commands on that computer such as copy files, reboot the computer, just like it was your own GNU/Linux PC.

Or you can use ssh with a full hostname to connect to a remote machine (as in across the internet).

Examples:

ssh hostname

Connect to a remote system with your current username, you will obviously need the password of the user on the other machine.

ssh username@hostname 

Connect to a remote system with your a different username, you will obviously need the password of the user on the other machine.

Secure copy, part of the ssh package. Allows you to copy files from one computer to another computer, use -r to copy recursively (copy entire directories and subdirectories).

scp's syntax is always

scp machineToBeCopiedFrom machineToBeCopiedTo

Where either machine can be a local directory (on the current filesystem /) or a remote machine. Remote machines are usually machinesFullName:/directory (if you omit the directory part it will just assume the home directory of the username you are logging in with).

The example below copies all files from the current directory (not including any directories), the command will login to “new” using the username of the person currently logged in on the local computer, the files will be copied to the root directory of the remote computer called “new” (which is probably on the LAN):

scp * new:/

You could also copy files from another computer to another computer. Let's say you are on a computer called “p100”. And you want to copy files (and directories) from “hp166” (in the /tmp directory and anything below that) to “new” and put the files in new's temporary directory. You could do:

scp -r hp166:/tmp new:/tmp

Assuming you were logged in as “fred” you would need passwords for user “fred” on the computers hp166 and new. Add an user_name@ before the computer name to login under a different user name.

For example to perform the above command with user “root” on hp166 and “anon” on new you would type:

scp -r root@hp166:/tmp anon@new:/tmp

To copy from a remote machine to a local computer you simply do things in reverse:

scp remoteMachine:/mystuff/* .

This will copy files on the remote machine in the directory “mystuff” to your local computer.

	Remote Machines
	Please note that when working with a remote machine you need to have a : (colon) after the machine name even if you want the files in their home directory. Otherwise the command will fail.

Secure ftp, another part of the ssh package. This command is similar to ftp but uses an encrypted tunnel to connect to an ftp server and is therefore more secure than just plain ftp.

The command usage is very similar to ftp (the command-line tool), sftp (once running) uses commands such as help (for help), put (send files to the server), get (download files from the server) and various others, refer to the manual page and internal documentation for further details.

	Graphical programs
	Sometimes its easier to manage files with a GUI, many of these programs do have good GUI equivalents, try searching the internet or sites like Sourceforge or Freshmeat.

Compute an md5 checksum (128-bit) for file “file_name” to verify it's integrity. You normally use the “ md5sum -c” option to check against a given file (often with a “.asc” extention) to check whether the various files are correct, this comes in handy when downloading isos as the checking is automated for you.

Command syntax:

md5sum file_name

This command will make a random password of length ten characters. This password generator creates passwords that are designed to be hard to guess. There are similar alternatives to this program scattered around the internet.

Change file access permissions for a file(s).

There are two methods to change permissions using chmod; letters or numbers.

Examples:

chmod u+rw somefile

This would give the user read and write permission.

chmod o-rwx somefile

This will remove read/write/execute permissions from other users (doesn't include users within your group).

chmod a+r somefile

This will give everyone read permission for the file.

chmod a=rx somefile

This would give everyone execute and read permission to the file, if anyone had write permission it would be removed.

Numbers can be added together so you can specify read/write/execute permissions; read+write = 6, read+execute = 5, read+write+execute = 7

Examples:

chmod 777 somefile

This would give everyone read/write/execute permission on “this_file”. The first number is user, second is group and third is everyone else (other).

chmod 521 somefile

This would give the user read and execute permission, and the group write permission (but not read permission!) and everyone else execute permission. (Note that it's just an example, settings like that don't really make sense...).

Changes the ownership rights of a file (hence the name 'chown' - change owner). This program can only be used by root.

Use the -R option to change things recursively, in other words, all matching files including those in subdirectories.

Command syntax:

chown owner:group the_file_name

Only the person who created the file within a directory may delete it, even if other people have write permission. You can turn it on by typing:

chmod 1700 somedirectory (where 1 = sticky bit)

or (where t represents the sticky bit)

chmod +t somedirectory

To turn it off you would need to type:

chmod 0700 somefile (where the zero would mean no sticky bit)

or (where t represents the sticky bit)

chmod -t somefile

Note that the permissions aren't relevant in the numbers example, only the first number (1 = on, 0 = off).

An example of a sticky directory is usually /tmp

Allow SUID/SGID (switch user ID/switch group ID) access. You would normally use chmod to turn this on or off for a particular file, suid is generally considered a security hazard so be careful when using this.

Example:

chmod u+s file_name

This will give everyone permission to execute the file with the permissions of the user who set the +s switch.

	Security Hazard
	This is obviously a security hazard. You should avoid using the suid flag unless necessary.

Change file system attributes (works on ext2fs and possibly others...). Use the -R option to change files recursively, chattr has a large number of attributes which can be set on a file, read the manual page for further information.

Example:

chattr +i /sbin/lilo.conf[7]

This sets the 'immutable' flag on a file. Use a '+' to add attributes and a '-' to take them away. The +i will prevent any changes (accidental or otherwise) to the “lilo.conf” file. If you wish to modify the lilo.conf file you will need to unset the immutable flag: chattr -i. Note some flags can only be used by root; -i, -a and probably many others.

Note there are many different attributes that chattr can change, here are a few more which may be useful:

• A (no Access time) --- if a file or directory has this attribute set, whenever it is accessed, either for reading of for writing, it's last access time will not be updated. This can be useful, for example, on files or directories which are very often accessed for reading, especially since this parameter is the only one which changes on an inode when it's opened.

• a (append only) --- if a file has this attribute set and is open for writing, the only operation possible will be to append data to it's previous contents. For a directory, this means that you can only add files to it, but not rename or delete any existing file. Only root can set or clear this attribute.

• s (secure deletion) --- when such a file or directory with this attribute set is deleted, the blocks it was occupying on disk are written back with zeroes (similar to using shred). Note that this does work on the ext2, and ext3 filesystems but is unlikely to work on others (please see the documentation for the filesystem you are using). You may also like to see shred, please see Chapter 7

(list attributes). This will list if whether a file has any special attributes (as set by chattr). Use the -R option to list recursively and try using the -d option to list directories like other files rather than listing their contents.

Command syntax:

lsattr

This will list files in the current directory, you may also like to specify a directory or a file:

lsattr /directory/or/file

tar -cvpf name_of_file.tar files_to_be_backed_up

This would create a tape archive (no compressing).

tar -zxvpf my_tar_file.tar.gz

This would extract files (verbosely) from a gzipped tape archive.

rsync is a replacement for the old rcp (remote-copy) command. It can use ssh for encryption and is a very flexible tool, it can copy from local machine to local machine, from local to remote (and vice-versa), and to and from rsync servers.

rsync uses an advanced differencing algorithm, so when to copies or syncs something it will (a) only copy new/changed files and (b) if the files have being changed it will copy the differences between the files (not the entire file). Using this method rsync saves time and bandwidth.

rsync also has advanced exclusion options similar to GNU tar. rsync has a well written manual page, for further information read the rsync documentation online or type:

man rsync

If you wish to visit the rsync site you will find it over here

gzip is the GNU zip compression program and probably the most common compression format on UNIX-like operating systems.

gzip your_tar_file.tar

This will compress a tar archive with GNU zip, usually with a .gz extension. Gzip can compress any type of file, it doesn't have to be a tar archive.

gunzip your_file.gz 

This will decompress a gzipped file, and leave the contents in the current directory.

bzip2 is a newer compression program taht offers superior compression to gzip at the cost of more processor time.

bzip2 your_tar_file.tar 

This will compress a tar archive with the bzip2 compression program, usually with a .bz extension. bzip2 can compress any type of file, it doesn't have to be a tar archive.

bunzip2 your_file.tar.bz2 

This will decompress a file compressed by bzip2, and leave the contents in the current directory.

Use zipinfo to find detailed information about a zip archive (the ones usually generally used by ms-dos and windows, for example winzip).

Command syntax:

zipinfo zip_file.zip

Will run grep to look for files within a zip file (ms-dos style, for example winzip) without manually decompressing the file first.

Command syntax:

zipgrep pattern zip_file.zip

Used to recover files from a damaged bzip2 archive. It simply extracts out all the working blocks as there own bzip2 archives, you can than use bzip2 -t on each file to test the integrity of them and extract the working files.

Will convert a file that is zipped or gzipped to a file compressed using bzip2.

Command syntax:

bzme filename

Installed RPM's