Linux is case-sensitive. For example: myfile, Myfile, and myFILE are three different files. Your password and login name are also case-sensitive. (This follows the tradition since both UNIX and the "c" programming language are case-sensitive.) Naming conventions for files and directories are identical. All the files and directories which I create (for myself, as a user) are lower-case, unless there is a very special reason to make it different. Most of Linux commands are also all lower case.
Filenames under Linux can be up to 256 characters long and they normally contain letters, numbers, "." (dots), "_" (underscores) and "-" (dashes). Other characters are possible but not recommended. In particular, it is not recommended to use special metacharacters: "*" (asterisk), "?" (question mark), " " (space), "$" (dollar sign), "&" (ampersand), any brackets, etc. This is because matacharacters have special meaning to the Linux shell (shell is something like COMMAND.COM, the command processor under DOS). It is possible to have space inside the filename, but we don't recommend it either--we use underscore "_" instead.
It is not possible at all to have '/' (slash) as a part of the filename because '/' is used to represent the top of the directory tree, and as a separator in the pathnames (the same as '\' is in DOS).Like in DOS, I cannot have a file called . or a file called .. (dot or two dots)--they mean current and parent directory respectively, exactly like in DOS.
To manipulate files with names that do contain matacharacters, I use a pair of ' (apostrophes), so that the metacharacters are quoted and therefore the shell does not interpret their meaning. For example, to remove a file my file* (contains space and asterisk), I would issue:
rm 'my file*'
Please note that I use a pair of ' (apostrophes) for quoting. Quoting with a pair of " (quotation marks) is generally weaker than quoting with ' . If you use " (quotation marks) some metacharacters may get interpreted.
Here is the meaning of some metacharacters:
* = Matches any sequence of zero or more characters (except for "." dot at the beginning of a filename).
? = Matches any single character.
[abC1] = Matches a single character in the enumerated set. In this example the set contains: 'a', 'b', 'C', and '1'.
[a-z] = Matches any lower-case letter.
[A-F] = Matches any upper-case letter from A to F.
[0-9] = Matches any single digit.
[a-zA-Z0-9] = Matches any letter (lower or upper case) or any digit.
Examples. This command will show any filename in the current directory, with the exception of filenames starting with "." (dot):
ls *
An equivalent to this command is to type just ls or dir (without the "*"). Files with names starting with "." are not shown because "." as the first character of a filename is not matched by "*". Think of files with names starting with "." as an equivalent of DOS hidden files. Use ls -a (list with the option "all") or ls .* to see these "dot" files. The dot-files are common in the user home directories and are typically used to contain user-level configurations.
This command will show any filename that contains a dot:
ls *.*
This command will show any filename that contains two dots:
ls *.*.*
Please note that Linux does not have "filename extensions" the way DOS does, but you can still use them. For example, i can have a file my_text.txt.zip. Some other DOS-kind file-naming features are completely absent ("Micros~1.doc" comes to mind).
This command will show all filenames in the current directory that start with "a" or "b", or any capital letter:
ls [abA-Z]*
As an example of problems that you might face when using non-recommended characters in a filename, try creating a file with a name starting with a dash and then remove it--there seems to be no way to do it (a dash normally introduces command options). E.g., the command
dir > -junk
will create such a funny file (like in DOS, the symbol ">" redirects the output from the dir command to a file named -junk). Since the regular way of removing the file -junk does not work, I use:
rm ./-junk
The dot slash at the beginning means "the current directory" and here just serves the purpose of hiding the leading dash so it is not interpreted as introducing an option to the rm command. The point here is that I rather stick to traditional naming conventions than face the occasional complications.
This is explained very nicely in the Linux System Administrator Guide (SAG), which should be available on your system. Try:
cd /usr/doc/LDP/sag
lynx sag.html
This will start a text-mode browser "lynx" to view this html book. You can also use any other browser, e.g. Netscape for Linux or Windows, to view this book. This book and other LDP books are actually quite easy to read.
Briefly, Linux contains five filesystems. These filesystems can reside on a single or different physical hard drives and/or hard drive partitions, depending on the size and need of your system. (A single filesystem can also be distributed between different physical devices, if needed.)
The root "/" filesystem contains basic operating system and maintenance tools. The content of this filesystem should be sufficient to start up the system and perform emergency maintenance and repairs if they were necessary.
/usr filesystem contains all commands, libraries, documentation, and other files that do not change during normal operation. This will also contain major applications, perhaps the ones that come with your distribution, for example Netscape.
/var filesystem contains files that change: spool directories, log files, lock files, temporary files, and formatted manual pages.
/home filesystem contains user files (users' own settings, customization files, documents, data, mail, caches, etc).
/proc filesystem contains entirely illusionary files. They don't really exist on the disk and don't take any space there (although ls -l will show their size). When viewing them, you really access information stored in memory. It is used to access information about the system.
The parts of the root filesystem are:
/bin--executables (binaries) needed during bootup that might be used by normal users.
/sbin--executables (system binaries) not intended for use by general users (users may still use them, but this directory is not on their PATH).
/etc--system-wide configuration files for your operating system.
/root--the home directory of the system administrator (called super-user or root).
/dev--device files. Devices appear on Linux as files so it is easy to write to them.
/mnt--mount points for removable media (floppy, cdrom, zipdrive), partitions of other operating systems (e.g. MS Windows), network shares, and anything else that is mounted on the file system temporarily. It normally contains a separate subdirectory for each mounting share. The contents of these drives/shares appears in these subdirectories--there are no drive letters on Linux.
/lib--shared libraries for programs that reside on the root filesystem.
/boot--files used by LILO (a bootstrap loader, the thing that loads first when the computer is booted and perhaps gives you an option which operating system to boot, if you have more than one OS on your computer). It typically also contains the Linux kernel, but this can be stored somewhere else, if only LILO is configured to know where it is.
/opt--optional large applications, for example kde under RedHat 5.2 (under RedHat 6.0, kde is distributed as any other X-windows distribution, main executables are in the /usr/bin directory).
/tmp--temporary files. This directory may clean up automatically.
/lost+found--files recovered during the filesystem repair.
The most interesting parts of the /usr filesystem are:
/usr/X11R6--X-windows system (version 11, release 6).
/usr/X11--the same as /usr/X11R6 (it is a symbolic link to /usr/X11R6).
/usr/X11R6/bin --lots of small X-windows apps, and perhaps symbolic links to the executables of some larger X-windows applications that reside in their own subdirectories somewhere else).
/usr/doc--Linux documentation.
/usr/bin and /usr/sbin--similar to their equivalents on the root filesystem (/bin and /sbin), but not needed for basic bootup (e.g. during emergency maintenance).
/usr/local--the installed "local user" applications, for example Netscape (each application in a separate subdirectory).
/usr/local/bin--perhaps smaller "user" apps, and symbolic links to the larger executables contained in separate subdirectories under /usr/local .
It is important to understand that all directories appear in a single directory tree, even if the directories are contained on different partitions, physical drives (including floppies, etc), or even if they distributed over the network. Therefore, there are no DOS-type "drive letters" under Linux.The directory system is well-established and standard on most Linux distributions (the small differences are being currently addressed by the Linux Standard Base). It is also quite similar to that found on many commercial UNIX systems.
Typing the name of the executable on the command line doesn't help? There are three possibilities.
The first possibility: you don't type the name of the executable correctly. Check the case--Linux is case sensitive! For example, typing "Pico" or "PICO" will not start the pico editor.
The second possibility: maybe the program is not on your PATH. Under Linux (or UNIX), an executable must be on your PATH to run it, and the current directory is NOT on your PATH. Type the full path to the executable before the executable name, or execute:
cd the_program_directory
./program_name
You must put the dot and slash in front of the program name or the program will NOT execute. (This is a security feature not to put one's current directory on the path. It makes "trojan horses" more difficult. A "trojan horse" is a malicious program that pretends to be something different than it really is.) The dot means "the current directory", and the slash "/" is a separator between the directory name and the filename (exactly as "\" in DOS).
You may check your path using:
echo $PATH
To learn how to change your PATH, or add your current directory to it, see the next answer.
If your executable is lost somewhere in your directory tree, you may want to find it using (for example):
find / -name "netscape"
to find a file named "netscape" searching from the root directory "/". You may be able to achieve the same result faster using:
locate netscape
(Locate runs faster because it relies on a pre-built database of files on your system. This database if updated by a background cron process that normally runs at night, so don't count on locate to find a file if you regularly switch off your computer for the night, or you search for a file that you just installed.)
Please note that the PATH is normally different for root than regular users (root's PATH includes /sbin and /usr/sbin whereas users' don't). Therefore users cannot execute command located in the "sbin" directories unless they specify the full path to the command. Also, if you become a superuser by executing the su command, you inherit the user's PATH, and to execute the command located in sbin, you need to specify the full path.
Conversely, if you need to learn where an executable which is on your PATH is located on your system (i.e., the executable runs by typing its name anywhere in the system, but you would like to know where it is), you may use something like this:
which netscape
which will show a full PATH to the executable program called "netscape".
The third possibility: maybe the file is not executable. If it should be, change the permissions to make it executable. E.g. (as root or the user who owns the file):
chmod a+x my_file
will make the file "my_file" executable for all users. Check if it worked using:
ls -l my_file
Read here if you don't understand the output of this command or the whole "third possibility".
The PATH is the list of directories which are searched for the program the execution of which you request. You can check your PATH using this command:
echo $PATH
which, on my system , shows the PATH for the user "yogin" to be:
/opt/kde/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/home/yogin/bin
The ":" is a separator, therefore the above PATH represents a list of directories as follows:
/opt/kde/bin
/usr/local/bin
/bin
/usr/bin
/usr/X11R6/bin
/home/yogin/bin
Here is the output from the command "echo $PATH" run on my system on the account "root":
/opt/kde/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/root/bin
You can change the PATH for all users on the system by editing the file /etc/profile and adjusting (as root) the line starting with "PATH=". I do it using the pico editor (as root):
pico -w /etc/profile
(The option -w turns off the wrap of long lines.)
Re-login for the change to take effect. To set up the PATH for an individual user only, edit the file /home/user_login_name/.bash_profile (please note the dot in front of the filename--files starting with a dot are normally invisible, you have to use ls -a to see them).
If you really want to have the current directory on your PATH, add "." (dot) to your PATH. When used in the place when directory name is expected, a dot means "the current directory". The specification for the path in /etc/.bash_profile may then look like this:
PATH="$PATH:$HOME/bin:"."
export PATH
This command takes the contents of the environmental variable called PATH (as set for all users in /etc/profile), and appends to it the name of your home directory as set by the variable HOME with an attached "/bin" and then a dot. Finally, the command assigns the resulting string back to the variable called PATH. It is necessary to use the command "export" after modifying PATH or any other user-environment variable, so that the variable is visible outside of the script that sets it.
In a text terminal, press <Ctrl><Alt><Del> (the "three-finger salute", you press the three keys simultaneously), wait for the shutdown process to complete, and turn off your machine only after it starts rebooting again. If you are in X-windows, first switch to a text terminal by pressing <Ctr><Alt><F1> (three keys simultaneously). Do not turn off your machine without the proper shutdown or else you may have disk error messages next time you boot. (Typically, the errors resulting from improper shutdown will be repaired automatically during the next boot, but occasionally more serious problem may result, and then you may need to repair the files manually or re-install!)
If you prefer your computer to go to a halt after you press <Ctrl><Alt><Del> (instead of the default reboot), you can set this up by editing the file /etc/inittab. This file specifies something like this:
# Trap CTRL-ALT-DELETE
ca::ctrlaltdel:/sbin/shutdown -t3 -r now
As root, replace the option "-r" to "-h" so that the same fragment reads:
# Trap CTRL-ALT-DELETE
ca::ctrlaltdel:/sbin/shutdown -t3 -h now
The line starting with "#" is just a comment (it is for humans, it does not have any effect on the computer).
Root can also use the shutdown command. This command can be used for either a local or remote shutdown of your computer, but is used mostly for remote shutdown when the local keyboard is not available so you cannot use <Ctrl><Alt><Del>. It can be also very useful if a program hangs so that the keyboard is no longer functional. For example:
telnet name_of_machine_with_no_operable_keyboard
[login as a user]
su
[give password]
Now either execute ps axu |more, find the process id of the offending command in the ps output and do
kill pid_of_offending_process, or reboot your machine with:
/sbin/shutdown -rn now
This command will shutdown really fast, bypassing standard (longer) shutdown procedure--useful when the system becomes really buggy (the option -n will make "shutdown" kill all the processes before rebooting).
Please note that for security reasons, you cannot login to a remote machine as root (e.g., over the telnet). You have to login as a user and then execute su and give a password to become a super user (root).
The shutdown command may also be used to execute a shutdown later. E.g. (as root):
/sbin/shutdown -r 23:59
will reboot the system 1 minute before midnight.
If the shutdown command is too long for you, you may want to try these two commands, which do exactly what their names suggest (as root):
reboot
halt
A fancy way to shut down your computer is to switch your system to the runlevel 0 (for halt) or runlevel 6 (for reboot). Try it using (as root):
init 0
The meaning of the different runlevels is explained in the file /etc/inittab and here.
Buggy programs do hang under Linux. A crash of an application should not, however, affect the operating system itself so it should not be too often that you have to reboot your computer. Linux servers are known to run for more than a year without a reboot. In our experience, a misbehaving operating system may be a sign of hardware or configuration problems: we repeatedly encountered problems with the Pentium processor overheating (the fan on the Pentium did not turn as fast as it should or it stopped altogether, the heat sink on the Pentium was plugged with dirt), bad memory chips, different timing of different memory chips (you may try re-arranging the order of the chips, it might help), wrong BIOS setup (you should probably turn off all the "advanced" options, Linux takes care of things by itself). The "signal 11" error message is typically associated with hardware problems and it most likely to manifest itself when you perform computing-intensive tasks: Linux setup, kernel compilation, etc.
Not really hanged. Some programs might give the uninitiated impression of hanging, although in reality they just wait for user input. Typically, this happens if a program expects an input filename as a command line argument and no input filename is given by the user, so the program defaults to the standard input (which is console). For example, this command
cat
may look like it's hanged but it waits for keyboard input. Try pressing <Ctrl>d (which means "end-of-file") to see that this will satisfy the cat command. Another example: I have seen many questions on the newsgroups about the "buggy" tar command that "hangs" when trying to uncompress a downloaded file, for example:
tar -zxv my_tar_file [wrong!]
This waits for user input too, since no option "-f filename" was specified so "my_tar_file" was not recognized as a filename. The correct command is:
tar -zxvf my_tar_filename
Please note that the filename must follow immediately after the option "f" (which stands for "filename). This WILL NOT work (very common mistake):
tar -zxfv my_tar_file [wrong!]
Any program (hanged or not) can be killed.A text-mode program in the foreground can often be killed by pressing <Ctrl>c. This will not work for larger applications which block the <Ctr>c, so it is not used on them accidentally. Still you can get back in control either by sending the program to the background by pressing <Ctrl>z (no guarantee this will work) or switching to a different terminal, for example using <Ctrl><Alt><F2> and login as the same user that hanged the program (this should always work). Once you are back in control, find the program you want to terminate, for example:
ps
This command stands for "print status" and shows the list of programs that are currently being run the current user. In the ps output, I find the process id (PID) of the program that hanged, and now I can kill it. For example:
kill 123
will kill the program with the process id (PID) of "123".
As user, I can only kill the processes I own (this is, the ones which I started). The root can kill any process. To see the complete list of all processes running on the system issue:
ps axu | more
This lists all the processes currently running (option "a"), even those without the controlling terminal (option "x"), and together with the login name of the user that owns each process ("u"). Since the display is likely to be longer than one screen, I used the "more" pipe so that the display stops after each screenful.
The kill command has a shortcut killall to kill programs by name, for example:
killall netscape
will kill any program with "netscape" in its name.
X-windows-based programs have no control terminals and may be easiest to kill using this (typed in an X-terminal):
xkill
to which the cursor changes into something looking like a death sentence; you point onto the window of the program to kill and press the left mouse button; the window disappears for good, and the associated program is terminated.
If your X-windows system crashes so that it cannot recover, it may be the easiest to kill the X-server by pressing <Ctrl><Alt><BkSpace>. After that, it may be a good idea to run ps axu, find any possible X-programs that might still be running, and kill them. If you don't do this, the misbehaving program that caused your X-windows to crash might cause trouble again.
If you have programs in the background, the operating systems will object your logging out, and issue a message like "There are stopped jobs". To override and logout anyway, just repeat the logout (or exit) command immediately --the background program(s) will be automatically terminated and you will be logged out.
Core files. When a program crashes, it often dumps a "core" into your home directory. This is accompanied by an appropriate message. A core is a memory image (plus debugging info) and is meant to be a debugging tool. If you are a user who does not intend to debug the program, you may simply delete the core:
rm core
or do nothing (the core will be overwritten when another core is ever dumped). You can also disable dumping the core using the command:
ulimit -c 0
Checked if it worked using:
ulimit -a
(This shows "user limits", the option "-a" stands for "all".) To make the option of disabling core dumps permanent for all users, edit the file /etc/profile (as root), where ulimit is set, and adjust the setting. Re-login for the changes to /etc/profile to take effect.
If you would like to see how a core file can be used, try (in the directory where you have a core file):
gdb -c core
This launches GNU debugger (gdb) on the core file "core" and displays the name of the program that created the core, signal on which the program was terminated, etc. Type "quit" to exit the debugger. To learn the meaning of different signals, try:
cat /usr/include/bits/signum.h |more
The (almost) only place on the harddrive that normal users (non-root) can write to is their home directory, which is /home/user_login_name.
This "home" directory is for all user files: settings, program configuration files, documents, data, netscape cache, mail, etc. As a user, you can create subdirectories under your home directory to keep yourself organized. Other users cannot read your files or write to your home directory unless you give them permission to do so.
Normal users can also see, read and execute many other files on the system (besides their home directory), but normally they cannot modify or remove (delete) them.
The "root" (also called "super user") is a special administrative account that has the power to modify any file on the system. It is not a good idea to habitually work on your system as root--if you do so, your mistakes can cost you dearly. Set up and use a normal user account for everyday work for yourself, another user account for your son, and yet another for your wife. The root account is typically the only account that exists on Linux after the initial installation. Thus you have to explicitly create "user" accounts for normal work for you Linux system.
A user account can be created by the user "root" using, for example:
adduser joe
passwd joe
[type the password for the user joe]
[retype the password for the user joe so as to avoiod mistakes]
So first, I logged in as "root". Then, on the command line, I issued the command "adduser" with the parameter (argument) "joe". This created the account "joe" on my Linux computer. Then, I issued the command "passwd joe" to change the password for the user "joe" to something fairly secure. Now, I can tell "joe" what her initial password is and she can login and change the password to to her liking. Please note that the account name (user login name, "joe") and the password are case-sensitive.Root can change any user's password, although s/he cannot read it. [Passwords are encrypted using a one-way encryption algorithm and only this encrypted version is stored on the system, in the file /etc/passwd, the "open" version is never stored. When you login, the password you type is encrypted again using the same one-way algorithm and compared with the already encrypted version stored in the file /etc/passwd (older systems) or /etc/shadow (newer systems) .]
The separation of the administrator and user makes Linux systems secure and robust--it even makes viruses under Linux difficult (the programs that a user runs can write only to his/her own directories, and therefore cannot affect the vital parts of the operating system).
It is customary that the user changes his/her password immediately after the first login, for example:
passwd
(current) UNIX password: pass_OLD
New UNIX password: pass_NEW
Retype New UNIX password: pass_NEW
In reality, the password will not appear on the screen as you type it (for security reasons). Take your if you are changing the password for the very first time--it can be difficult to type "blind".On the Linux system, the same password is used to:
- login on the text terminal,
- login on to a graphical (GUI) screen,
- unlock a locked text terminal,
- unlock a password-protected screen saver on a GUI (for example, KDE or GNOME).
Weak passwords are probably the most common source of security problems. Even at home, you may expose yourself to serious trouble because somebody may be able to hack your computer when you browse the Internet and read/delete your files or use your computer to do something really nasty to the local police computer network. Therefore, keep all login names/passwords secure, even at home. Once somebody accesses your computer (even as a user), he may find it quite easy to gain a root password (depending on how well-maintained/up-to-date your system is vs. how good a hacker s/he is).Here are some examples of hazardous passwords:
- No password (possible!).
- The word "password" (wow, this one is really weak!).
- Your login name (The login and the password the same? Hmm.).
- Your first name or the first name of your daughter, son, husband, wife, girlfriend, or any other first name. The number of first names in use is quite limited--check the dictionary "how to name your baby". Don't think that a first name you think of is secure because you are in India--Canada is really a multinational society.
- Your last name or any other last name. The number of last names is surprisingly limited! Just check the US census data to see that your "rare" last name from the abamamahaba island is very well represented in the US 30,000 most frequent last names. Another proof that we are all one family :))
- The nickname of your dog, wife, cannary or computer (very few nick names the humans use).
- Date of your birth, social security number, etc; Sequences of digits can be easily probed.
- Name of your company, department, workgroup, etc.
- Password written in the calendar on your desk or on the side of your computer.
- A password which you also use in an insecure public place, for example an Internet store or a mailing list.
- Any word which is in the English dictionary. The English dictionary does not contain so many words as it might seem. A skillful hacker can easily set a program to encrypt all dictionary words (100,000? that's under 1 MB!) and then compare all the encrypted strings to your encrypted password.
- Any other word, last name, first name, pet or swear word, no matter in what language. For a cracker, to cover most languages is only a small overhead if he already covered one. How many significant languages are there? 40? The point here is that the subset of words that the humans normally use if far far below the theoretical limit of random combination of characters.
- Any of the above with an addition of a number/letter at the beginning or the end. "sharam1" is really a very weak password.
A good password is relatively long (minimum 6 letters), contains a mixture of letters (upper and lower case, if possible), numbers and special characters, and is changed quite regularly (8-16 weeks?).
The system administrator can set the password policy (minimum length, requirement of special characters, password expiry) through the utility included in this configuration program (run as root):
linuxconf
under the menu "user account"-"policies"-"password & account policies". Normal users won't be able to set a password which is too short, is a dictionary word, or does not contain the prescribed number of non-alphanumeric characters (but the root can change any password to anything s/he likes, s/he will only be given a warning).
Also make sure that any file that contains a password (e.g., /root/.kde/share/config/kppprc) has proper secure permissions so that it cannot be read by anybody. For example, most likely you want:
chmod 600 kppprcIf you use "over the phone" Internet connection for just a couple of hours a week, you may be fine even with a relatively weak passwords on your system. But please really consider your system security if you use a cable modem, or are otherwise connected to the Internet for a significant amount of time.
Even if I never forget any passwords, I would still study this issue in detail because it can give me a hint on how my mother might be reading my ICQ chats history :-)
First method. The easiest way to solve your "forgotten root password" problem is to boot your Linux in the single-user mode, namely at the "lilo"prompt (during bootup) type:
linux single
This will make you "root" without asking for password. Now, being root, you may change the root password using this command (no knowledge of the old password required):
passwd
If it strikes you as insecure, that's because no computer system is secure if other people have physical access to your hardware. Nevertheless, I did not like the "linux single" hole on my home computer and plugged it by adding the following lines to my /etc/lilo.conf file (at the end of the "image=" section):
password="my_password"
restricted
[This "lilo" password is required when, at the LILO prompt during bootup, somebody enters the word "linux" with any parameter (normal bootup without any parameters will still be possible without a password).] For the changes to /etc/lilo.conf to take effect, I must re-run the command lilo . Since my lilo password is not encrypted, I must make /etc/lilo.conf readable only for root:
chmod 600 /etc/lilo.conf
Second Method. Another way to solve the "lost-root-password" problem is to boot your computer from the Linux boot diskette, find your Linux root partition on the hard drive, mount it, and edit the file /etc/shadow. (I can do it because after booting from the floppy, I become root without being asked for a password.) In the password file, I erase the encrypted password for root (for example, using the pico editor), so it is empty.The information about a user account is kept in plain-text files: /etc/passwd and /etc/shadow.For example, my /etc/shadow entry for "root" account may look like this:The file /etc/passwd contains "world-readable" information about all accounts on my computer Each line of this file contains information about one account. Each line has 7 colon-delimited fields (this means 8 entries separated by colons): login name, the letter "x", the numerical user ID, the numerical primary group ID for the user, comment field (for example, the full name of the user), the user's $HOME directory, the name of the shell (meaning the program that is run at login).
The balance of the information about accounts on my computer is stored in the file /etc/shadow. This file is more secure because normally only root can read it. In this file, each line describes "shadow" information about one account, and has 9 colon-delimited fiels: login name, encrypted password, days since Jan 1 1970 that password was last changed, days before password may be changed, number of days after which the password must be changed, number of days before password expiration to warn the user, number of days after password expiry that account is disabled, number of days since Jan 1 1970 that account is disabled, and a reserved field.
Some (older) UNIX or Linux systems do not contain the file /etc/shadow and store the encrypted user password in the second field of each line of the file /etc/passwd (the field which on newer systems contains just the letter x).
root:$1$BuPbmLAz$1G7.evIChyqaEI0TlZp0F.:11071:0:99999:7:-1:-1:134540356
and after the password is erased, it looks like this:
root::11071:0:99999:7:-1:-1:134540356
Now, the root account has no password, so I can reboot the computer and, at the login prompt, type "root" and for password just press ENTER (empty, no password). After a successful login, I immediately set the password for root using the command:
passwd
To make the "floppy access" to my system a little bit more difficult, I considered running a computer without a floppy drive :-) Unfortunately, Linux CDs are bootable these days. I set up my boot sequence (in the BIOS setup) so that the system boot from the hard drive before floppy and CDROM are tried, and added an "administrative" password on changes to the BIOS settings. Still, I worry that these BIOS passwords are so easily crackable and also one could remove my harddrive and connect it to another computer for reading :-) . I am considering an "encrypted file system" which is now available on Linux, but considering all the trouble associated with it, perhaps I will settle on locking my room :-) . If all this sound paranoid to you, it probably is--it just illustrates the point there is little computer security, even under Linux, if the potential cracker has physical access to your hardware.
If a regular (non-root) user forgets his/her password, this is not a problem since root can change any password. For example (as root):
passwd barbara
will prompt for a new password for the user "barbara" (no knowledge of old password required). If a user (non-root) wants to change his/her password, s/he will be asked for the old password first. (This is a security feature so nobody changes your password if you left your terminal unattended. )
A user account can be disabled or removed.To temporarily disable a user account, there is no need to change his/her password. Just put an asterisk "*" at the beginning of the second field (before the encrypted password) in the file /etc/shadow . The "*" means that no login is permitted for this account. When you want to restore the account, you just erase the star and the user account is back in operation, with its old password.
Here is an example entry from the file /etc/shadow with the password disabled for user "peter":To irreversibly remove a user account on my home computer, I do the following:peter:*$1$narMEFm6$fhA1puOU422HiSL5aggLI/:11193:0:99999:7:-1:-1:134539228
- log in as root
- log in as the user, to check if there is any new important mail:su doomed_user_login_name
logout- delete the user account
userdel doomed_user_login_name
- force-delete the user home directory with all its contents including any subdirectories:
rm -fr /home/doomed_user_login_name
Linux (the same as UNIX) is a secure, multiuser operating system, and this creates a level a complexity with "files permissions". Trouble with file permissions can lead to unexpected and nasty problems. Understanding file permissions is of uttermost importance to be able to administer any multiuser operating system (be it UNIX, WinNT, or Linux). My advice would be: learn the system of Linux (or any UNIX) file permission conventions, you will not regret it.
The permission conventions are the same for normal files and directories, so whatever is said about files below, applies also to directories. It is also important to remember that lower level directories (and the files the directories contain) inherit the permissions of their parents. Therefore don't expect to have any permissions to the subdirectory (or a file residing in it) if you don't have any to the parent.
File owners. Each file belongs to an owner (typically a login name) and to a group. The owner is typically the person who created (or copied) the file. The group often consists of one person--the owner, and has the name identical to that of the owner, but it does not need to be so. A file can be removed (erased) only the owner of the file, or a member of the group that owns the file, or the root. Yet other users may be able to modify or erase the content of the file if they are given the permission to do so--read on. The owner and group that owns the file will be shown in the output from the ls -l command (="list in the long format"). For example, the command:
ls -l junk
produced this output on my screen:
-rwx------ 1 yogin inca 27 Apr 24 14:12 junk
This shows the file "junk", belonging to the owner "yogin" and to the group "inca".
The ownership of a file can be changed using the commands chown (change owner) and chgrp (change group), which are normally executed by root:
chown peter junk
chgrp peter junk
ls -l junk
After executing the above 3 lines, the command ls-l junk produces this output on my screen:
-rwx------ 1 peter peter 27 Apr 25 20:27 junk
Changing the file ownership comes handy if you move/copy files around as root for use by other users. At the end of your housekeeping you typically want to hand-in the file ownership to the proper user.
File permissions. Now, an owner of a file can make the file accessible in three modes: read (r), write (w) and execute (x) to three classes of users: owner (u), members of a group (g), others on the system (o). You can check the current access permissions using:
ls -l filename
If the file is accessible to all users (owner, group, others) in all three modes (read, write, execute) it will show:
-rwxrwxrwx
Skip the first "-" (it shows "d" for directories, "-" for normal files, "l" for links, "c" for character devices, "b" for block devices). After this initial character, the first triplet shows the file permission for the owner of the file, the second triplet shows the permissions for the group that owns the file, the third triplet shows the permissions for other users. A "no" permission is shown as "-". Here is an output from the ls -l command on a file that is owned by root, for which the owner (root) has all permissions, but the group and other can only read and execute:
drwxr-xr-x 2 root root 21504 Apr 24 19:27 dev
The first letter "d" shows that the file is actually a directory.
You can change the permissions on the file which you own using the command chmod (="change mode"). For example, this command will add the permission to read the file "junk" to all (=user+group+others):
chmod a+r junk
In the command above, instead of "a" (="all"), I could have used "u", "g" or "o" (="user", "group" or "others"). Instead of "+" (="add the permission"), I could have used "-" or "=" ("remove the permission" or "set the permission"). Instead of "r" (="read permission"), I could have used "w" or "x" ("write permission" or "execute permission").
Second example. This command will remove the permission to execute the file "junk" from others:
chmod o-x junk
Instead of letters, one can also use numbers to specify the permissions. To understand how it works look at this:execute=1
write=2
read=4
The total permission for a class of users is the sum of the three. Thus:1 = execute only (seems unusual)
2 = write only (seems unusual)
3 = write and execute (seems unusual)
4 = read only (common)
5 = read and execute (common)
6 = read and write (common)
7 = read, write and execute (common).
The permission for all the three classes of users (owner, group, others) is obtained by gluing the three digits together one by one. For example, the command
chmod 770 junk
will give the owner and the group the completto of permissions, but no permissions to others. The command:
chmod 666 junk
gives all three classes of users (owner, group, others) the permissions to read and write (but not execute) the example file named "junk". Please note the "666". It is quite often used and, at least for one person I know, it is a proof that Linux (any UNIX for that matter) is a work of the devil >:-0.
This command:
chmod 411 junk
would give the owner the permission to read only, and the group and others to execute only. This one does not seem useful, but might be funny, at least for those North American Linux users who dial 411 (telephone number) for directory assistance. Mail me if you can think of any other funny permissions (maybe 007?).
The numerical way of representing file permissions is called "octal" because the numbers have base 8 (the decimal system's base is 10). The highest digit in the octal system is 7 (octal system has eight digits: 0 to 7, analogous to decimal system having ten digits: 0 to 9). The octal representation is really a convenient notation for the binary representation of file permissions, where each permission is flagged as "set" or "denied" with a one or zero and the total is represented as a string of zeroes and ones, as in this diagram:
user class: owner group others
example permissions: rwx rw- r--
absent permissions: --- --x -wx
binary representation of the permissions: 111 110 100
octal representation of the binary: 7 6 4
Default file permissions with umask. When a new file is created, it is given default permissions. On my system, these are:
-rw-r--r--
This means that files created by a user can be read and written to be the user, but only read by his/her group and others. Still, on my default RedHat system, users cannot read the files in the other users' home directories because the permissions on the home directories is:
drwx------
I can check the default file permissions given to my newly created files using:
umask -S
(The option "-S" stands for "symbolic" and tells umask to display the permissions in a easy-to-read form.)
I can change the default file permissions for newly created files using a command like:
umask u=rw,g=,o=
which will give the owner the read and write permissions on newly created files (r+w), and no permission to the group and others.
Using numbers to set default permissions with umask is more tricky. The number shows the permissions that you take away for users (opposite to chmod). Thus:
umask 000
will give full permissions to everybody on newly created files. The next example gives read and write permissions to the owner, and no for everybody else (perhaps that's what one may want):
umask 177To make the settings permanent for all users on the system, adjust the appropriate line(s) in the file /etc/profile .
The MP3 player might not be given enough processor power (it requires a lot of it). It could be that your system is lousy. Or you might be running too many cpu-intensive programs at the same time. Or, most likely, you may need to run the player with a higher priority. (The priority of a program can be set with the command nice -- see man nice or info nice). Try to run the player as root--programs run by root are given higher priority than those run by normal users. If this solves the problem, set the "suid" on the executable so all users are given the "effective user id" of the file ower (normally root) when running it, for example:
chmod a+s /usr/bin/xmms
will do the trick for the xmms program. The output from
ls -l /usr/bin/xmms
on my computer is now:
-rwsr-sr-x 1 root root 908k Feb 22 2000 /usr/bin/xmms
The first "s" indicates that the substitute-user-id (suid) bit is set. The second "s" indicates that the substitute-group-id (sgid) is also set. Thus anybody who executes x11amp is given the effective user id of the program owner and effective group id of the owner group, which in the example above is the user "root" and the group "root".
Setting the suid for a program could possibly become a security hole in your system. This is unlikely the case on a closed home network and when setting suid for a program origin of which is well traceable. However, even at home, I wouldn't suid a piece of code origin of which is uncertain, even if the setup instructions urged me to do so.
Some programs do however require suid for proper functioning, for example kppp (the popular modem "ppp" connection utility under the KDE graphical-user-interface desktop).If you have constant problems with a smooth performance of your system, or some "real time hardware" (e.g., CD writer) tends to crash, try to reduce the number of daemons on your Linux system. Run (as root) setup (RH specific command) and disable all the "services" that you don't require.
Using the "&" at the end of the command. For example, this will start licq (an icq client) in the x-terminal in the background, so that after issuing the command my x-terminal is not blocked.licq &
The process identification number, job_number, appears on the screen, so you can use it with related commands. The related commands are fg job_number (="foreground", bring the background process back to my immediate view/control), bg job_number (="background", send the process to the background), <Ctrl>z (send the current foreground process to the background), jobs (list the active jobs), kill process_ID (terminate the process, use the conmmand ps to find the process_ID of the process to kill).
The at command will execute the command(s) you specify at the date and time of your choice. For example, I could start playing music from my CDROM at 7 o'clock in the morning:
at 7:00
cdplay<Ctrl>d
In the example above, I entered the first line "at 7:00" on the command line and then pressed ENTER. To this, the at command displayed a prompt "at>". At this prompt, I entered my command "cdplay" and then pressed the control key and "d" simultaneously to finish the input. If instead of pressing <Ctrl>d , I pressed "ENTER", the next "at>" prompt would appear, at which I would be able to enter the next command to be executed right after "cdplay", also at 7:00. And so on, I could have had many commands scheduled for execution one by one starting at 7:00. After typing the last command, I would finish the input with <Ctrl>d. Think of the <Ctrl>d as sending "end-of-file" to the current input. Don't press <Ctrl>d twice because this will log you out--that's what <Ctrl>d does when entered straight on the Linux command line.
You can list the job you scheduled for execution using:
at -l
which will give you the numbered list of the jobs waiting.
If you changed your mind, you can remove a job from this list. For example:
atrm 8
will remove the job with the number eight on the list.
I could also schedule a job for execution much later, for example:
at 23:55 12/31/00
startx
would start my X-windowing system right on time for the new millennium (5 minutes before midnight on 31 of December 2000).
If you cannot execute the at command, check if the at daemon ("atd") is loaded (as root, use setup-"system services"). If you cannot execute the at command as a regular user although it works for root, check if the empty file /etc/at.deny exists and there is no file /etc/at.allow. This should be the default setup and it permits all the users to execute at. If you want only certain users to use at, create a file /etc/at.allow and list these users there.
For other options, check:
man at
If you wish to perform a processor-intensive job in a background when the system load is low, you may choose to use the batch command. For example, I could run setiathome (a program crunching data to help in search of extraterrestrial intelligence, SETI) using:
batch
at>setiathome<Ctrl>d
In this example, I entered the command batch and then, at the "at>" prompt, I entered the command which I wanted to be executed in the background. The job tries to start immediately, but goes ahead only when the system load is under 0.8 You can check the system load by inspecting the contents of the (virtual) file /proc/loadavg . For example:
cat /proc/loadavg
When a batch job finishes, the output is sent to me via e-mail.
Cron (a Linux process that performs background work, often at night) is set up by default on your RedHat system. So you don't have to do anything about it unless you would like to add some tasks to be performed on your system on a regular basis or change the time at which cron performs its duties.
Please note that some of the cron work might be essential for your system functioning properly over a long period of time. Among other things cron may:
- rebuild the database of files which is used when you search for files with the locate command,
- clean the /tmp directory,
- rebuilding the manual pages,
- "rotate" the log files, i.e. discard the oldest log files, rename the intermediate logs, and create new logs,
- perform some other checkups, e.g. adding fonts that you recently copied to your system.
Therefore, it may not be the best idea to always switch your Linux machine off for the night--in such a case cron will never have a chance to do its job. If you do like switching off your computer for nights, you may want to adjust cron so it performs its duties at some other time.
To find out when cron wakes up to perform its duties, have a look at the file /etc/crontab, for example:
cat /etc/crontab
It may contain something like this:
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
You can see that there are four categories of cron jobs: performed hourly, daily, weekly and monthly. You can modify those or add your own category. Here is how it works.
The columns in the entries show: minute (0-59), hour (0-23), day of month (1-31), month of year (1-12), day of week (0-6--Sunday to Saturday). The "*" means "any valid value".
Thus, in the example quoted, the hourly jobs are performed every time the computer clock shows "and one minute", which happens every hour, at one minute past the hour. The daily jobs are performed every time the clock shows 2 minutes past 4 o'clock, which happens once a day. The weekly jobs are performed at 22 minutes past four o'clock in the morning on Sundays. The monthly jobs are performed 42 minutes past four o'clock on the first day of every month. The directory with the script file that contain the command(s) to be executed is shown as the last entry on each line.
If you wanted your jobs to be performed at noon instead of 4 in the morning, just change the 4s to 12s. Cron wakes up every minute and examines if the /etc/crontab has changed so there is no need to re-start anything after you make your changes.
If you wanted to add a job to your cron, place a script which runs your job (or a link to your script) in the directory /etc/cron.hourly or cron.daily or /etc/cron.weekly, or /etc/cron.monthly .Here is an example of entry in /etc/crontab which causes a job to be performed three times a week (Mon, Wed, Fri):
02 4 * * 1,3,5 root run-parts/etc/cron.weekly
Swap is an extension of the physical memory of the computer. Most likely, you created a swap partition during the initial RedHat setup. You can verify the amount of swap space available on your system using:
cat /proc/meminfo
The general recommendation is that one should have: at least 4 MB swap space, at least 32 MB total (physical+swap) memory for a system running command-line-only, at least 64 MB of total (physical+swap) memory for a system running X-windows, and swap space at least 1.5 times the amount of the physical memory on the system.
If this is too complicated, you might want to have a swap twice as large as your physical (silicon) memory, but not less than 64 MB.
If you ever need to change your swap, here are some basics.
You can have several swap partitions, each up to approximately 124 MB. Here are the steps to create and enable a swap partition:
- Create the partition of the proper size using fdisk (partition type 82, "Linux swap").
- Format the partition checking for bad blocks, for example:
mkswap -c /dev/hda4
You have to substitute /dev/hda4 with your partition name. Since I did not specify the partition size, it will be automatically detected.
- Enable the swap, for example:
swapon /dev/hda4
To have the swap enabled automatically at bootup, you have to include the appropriate entry into your /etc/fstab file, for example:
/dev/hda4 swap swap defaults 0 0
If you ever need to disable the swap, you can do it with:
swapoff /dev/hda4
Swapping to files is usually slower than swapping to a raw partition, so this is not the recommended permanent swapping technique. Creating a swap file, however, can be a quick fix if you temporarily need more swap space. You can have up to 8 swap files, each with size of up to 16 MB. Here are the steps for making a swap file:
- Create a file with the size of your swap file:
dd if=/dev/zero of=/swapfile bs=1024 count=8192
This physically creates the swap file /swapfile, the block size is 1024 B, it contains 8192 blocks, the total size is about 8 MB. (The dd command copies files. In the example above, the input file (if) was /dev/zero, the output file (of) was /swapfile . You cannot use the cp (copy) command for creating a swap file because the swap file must be physically continuous on the hard drive.)
- Set up the file with the command:
mkswap /swapfile 8192
- Force writing the buffer cache to disk by issuing the command:
sync
- Enable the swap with the command:
swapon /swapfile
When you are done using the swap file, you can turn it off and remove:
swapoff /swapfile
rm /swapfile
You may also want to see the nice info written by Linus Torvalds himself:
man mkswap
A shell is the program that interprets what you type on the command line and decides what to do with it. A shell can also be invoked in a non-interactive way, for example to execute a pre-typed list of commands contained in a text file (a "shell script"). Think of a shell as an equivalent of the DOS "command.com" (command-line interpreter) and the shell script files as an equivalent of the DOS batch files (*.bat).
There are several shells available on the Linux system (if you installed them): bash ("Bourne Again" shell), sh (Bourne shell, standard on many UNIX systems), csh (C shell, with a syntax akin to the "c" programming language, available on most UNIX systems), pdksh (public domain Korn shell), tcsh (tiny C shell, often used on small systems), ash, zsh, and perhaps a couple more.
The default shell on my system (and most probably on yours too) is bash , which is an excellent and standard shell, and I really cannot see a reason why a newbie like myself would want to change it. bash is fully backwards-compatible with the Bourne shell (the most popular shell on UNIX) and incorporates many enhancements and best features from other shells. From a newbie prospective, the different shells are included with Linux for historical reasons and backwards-compatibility of shell scripts that may require a particular shell to run.You can determine the shell you are running using:
echo $SHELL
If you wanted to try another shell, type, for example:
tcsh
which will start the tiny c shell. When done, type
exit
which will return you to the previous shell (using exit on your first shell will log you out). You can find out how many shells you stacked on each other by displaying the shell level environmental variable:echo $SHLVL
The shell for each user is specified as the last field in the in the password file /etc/passwd . If you really wanted to change it, edit (as root) this file and replace the "/bin/bash" with the shell of your choice.
On my machine, the prompt may look like this:[stan@marie stan]$ _
Here "stan" is my login name, "marie" is the name of the computer, the second "stan" is the name of my current working directory, and "_" represents the cursor.
The prompt is set by the environmental variable called PS1. To display the current setting, I can use:
echo $PS1
The system-wide setting (for all users on the system) is in the file /etc/bashrc which on my system contains such a line:
PS1="[\u@\h \W]\$ "
To customize the prompt, you can edit the file /etc/bashrc (as root) and insert your text inside the quotes. Here is the meaning of some special codes:
\u - username of the current user,
\h - the name of the computer running the shell (hostname),
\W - the base of the name of the current working directory,
\w - the full name of the current working directory,
\$ - display "$" for normal users and "#" for the root,
\! - history number of the current command,
\# - number of the current command,
\d - current date,
\t - current time,
\s - name of the shell,
\n - new line,
\\ - backslash,
\[ - begin a sequence of non-printable characters,
\] - end a sequence of non-printable characters,
\nnn - the ASCII character corresponding to the octal number nnn.
$(date) - output from the date command (or any other command for that matter).Here is an example on how to add colour. See the next chapter for details about colour:
PS1="\[\033[1;32m\][\u@\h \W]\$\[\033[0m\] "
There is also the second-level prompt, set by a variable called PS2. The shell uses the second level prompt when additional input is needed, and on my system it is "> ". I don't worry too much about PS2, but it could be set the same way as PS1. There are even PS3 and PS4.
Colour can be produced on the text terminal using "ANSI escape sequences". For example:echo -e "\033[44;37;5m ME \033[0m COOL"
The above sets the background to blue, foreground white, blinking video, and prints " ME ", then resets the terminal back to defaults and prints " COOL". The "-e" is an option specific to the echo command--it enables the interprations of the special characters. The "\033[" introduces the escape sequence. The "m" means "set attribute" and thus finishes the sequence.
Change the "44;37;5" to produce different colour combinations--the number/order of codes do not matter. The codes to choose from are listed below:
Code Action/Color
---------------------------
0 reset all attributes to their defaults
1 set bold
2 set half-bright (simulated with color on a color display)
4 set underscore (simulated with color on a color display)
5 set blink
7 set reverse video
22 set normal intensity
24 underline off
25 blink off
27 reverse video off
30 set black foreground
31 set red foreground
32 set green foreground
33 set brown foreground
34 set blue foreground
35 set magenta foreground
36 set cyan foreground
37 set white foreground
38 set underscore on, set default foreground color
39 set underscore off, set default foreground color
40 set black background
41 set red background
42 set green background
43 set brown background
44 set blue background
45 set magenta background
46 set cyan background
47 set white background
49 set default background colorOther interesting codes:
\033[2J clear screen
\033[0q clear all keyboard LEDs (won't work from Xterm)
\033[1q set Scroll Lock LED
\033[2q set Num Lock LED
\033[3q set Caps Lock LED
\033[15;40H move the cursor to the line 15, column 40
\007 bell (beep)See man console_codes for more.
It works like this. Make sure that <NumLock> is on. Then press <Alt> and hold it. While <Alt> is pressed, key in on the numeric keypad these four digits: 0181. Now release <Alt> and the Greek letter mu "µ" appears. I find quite useful these characters from the PC character set encoding: 176 ° (degree), 177 ± (plus minus), 178 ² (square), 179 ³ (power 3), 181 µ (Greek mu), 0183 · (multiplication sign), 232 è (French accent agrave), 233 é (French accent aigu) 228 ä (German a-umlaut), 243 ó (Polish u-zamkniete), 248 ø (Scandinavian o-bar) 252 ü (German u-umlaut). Some other characters are also possible:
128 ? 147 ? 166 ¦ 185 ¹ 204 Ì 223 ß 242
ò
129 ? 148 ? 167 § 186 º 205 Í 224 à 243
ó
130 , 149 * 168 ¨ 187 » 206 Î 225 á 244
ô
131 f 150 - 169 © 188 ¼ 207 Ï 226 â 245
õ
132 ? 151 - 170 ª 189 ½ 208 Ð 227 ã 246
ö
133 ? 152 ~ 171 « 190 ¾ 209 Ñ 228 ä 247
÷
134 ? 153 ? 172 ¬ 191 ¿ 210 Ò 229 å 248
ø
135 ? 154 s 173 192 À 211 Ó 230 æ 249
ù
136 ^ 155 > 174 ® 193 Á 212 Ô 231 ç 250
ú
137 ? 156 ? 175 ¯ 194 Â 213 Õ 232 è 251
û
138 S 157 ? 176 ° 195 Ã 214 Ö 233 é 252
ü
139 < 158 ? 177 ± 196 Ä 215 × 234 ê
253 ý
140 ? 159 Y 178 ² 197 Å 216 Ø 235 ë 254
þ
141 ? 160 179 ³ 198 Æ 217 Ù 236 ì
255 ÿ
142 ? 161 ¡ 180 ´ 199 Ç 218 Ú 237 í
143 ? 162 ¢ 181 µ 200 È 219 Û 238 î
144 ? 163 £ 182 ¶ 201 É 220 Ü 239 ï
145 ? 164 ¤ 183 · 202 Ê 221 Ý 240 ð
146 ? 165 ¥ 184 ¸ 203 Ë 222 Þ 241 ñ
Create a text (ASCII) file that is to contain the shell script. For example, I would use the pico editor to write a script that runs the program tar with all the parameters usually necessary to uncompress a tarball downloaded from the Internet (I never seem to remember the tar options). I decided to call my script "untar":
pico untar
Since the file "untar" did not exist in my current directory, it was created by the pico text editor. Now, I type in the content of my script:
#!/bin/bash
echo this is the script file $0
echo untarring the file $1
# this calls tar with options -xvzf (extract, verbose, filter through gzip, input filename)
tar -xvzf $1
I save the file with <Ctrl>o and exit with <Ctrl>x
The first line of the script, starting with "#!" (called pound-bang), is special--it tells the shell what program should be used to interpret the script. In this example, the script is to be interpreted by the bash shell /bin/bash . The first line must start with #! or the script will never run (the file will be interpreted as just a text file). Other lines starting with # are comments for the author (readers, users) of the shell and are totally ignored by the computer.
The $0, $1, $2 ... in my script are the parameters passed to my script. For example, if I ran a script called "myscript" with seven parameters like this:
myscript a b c d e f g
then $0 would be seen inside "myscript" as having the value "myscript", $1 would have the value "a", $2 would be "b", $3 would be "c", etc.
On the second and third line of my example script, the command echo prints on the screen everything that follows on the same line, expanding $0 and $1 to the values of the parameters passed to the script. The fourth line is a comment written to myself to remind me what I was trying to achieve, just in case I ever had to modify my script. The fifth line performs the actual work.
Once the script is written, I make the text file executable to the file owner:
chmod u+x untar
and my script is ready to use:
./untar my_tar.tar.gz
Linux scripting is definitely rich, flexible, powerful and can be complex. However, it does not require special knowledge to write simple scripts for automation of common tasks. You just put together a group of often used commands, one by one, into a file. I use scripting because I am too lazy to type the same groups of commands over and over again.A really simple sequence of commands can be typed into a text file and passed to shell for execution using:
source my_file
[No need for the initial "pound bang" or executable permission.]
Normally, these characters are special to the shell:\ ' " ` < > [ ] ? | ; # $ ^ & * ( ) = <Space> <Tab> <Newline>
There are four different types of quotes: backslash (\), single quotes (apostrophes, '), double quotes (quotation marks, "), and backquotes (`).
The backslash \ means: disable the special meaning of the subsequent character.
Quoting with '' means: quote exactly, disabling any special characters inside the quotes.
Quoting with "" means: disable the special characters inside the quotes except for $ ` \
The pair `` means: do a command substitution inside the backquotes first. So what is inside the backquotes is executed by the shell first, and then the output is passed to the command outside the quotes. The same can be also acomplished with $(command) which nests better.
Examples. I can create a funny directory called "*" by either \ quoting or '' quoting:
mkdir \*
mkdir '*'This hides the special meaning of the "*" from the shell (without the quote it would mean "all files in the current directory").
There are three imporant streams: standard input ("stdin"), standard output ("stdout"), and standard error output ("stderr"). They all default to the console ("console" means the keyboard for the input and the screen for the output) but can be redirected.To redirect the standard output I use ">". For example:
dir my_dir > filelisting.txt
will redirect the standard output of the dir command into the textfile filelisting.txt and nothing should appear on my screen. The file can be subsecquently edited (e.g. with pico filelisting.txt) or embedded into a document.
To redirect the standard error, I need to use the construct "2>". For example:
dir my_dir 2> errorlisting.txt
The above will send the normal output onto the screen and nothing to the file unless dir produces an error. On error, nothing may go to my screen, and the file errorlisting.txt will contain the error message, which might be something like:
dir: my_dir: Permission denied
Finally, I can redirect both standard output and standard errror to a file using:
dir my_dir > file_and_error_listing.txt 2>&1
which first redirects the standard output to a textfile, and then redirect the standard error to the same location as the standard output.
In the examples above, if the file already existed, it will be overwritten. To append to an existing file, I use ">>" as in these examples:
dir my_dir >> filelisting.txt
dir my_dir 2>> errorlisting.txt
dir my_file >>file_and_error_listing.txt 2>&1If you are puzzled by the "2>" symbol, here briefly is how to rationalize it. The standard streams have standard descriptors. "0" is standard input, "1" standard output and "2" is standard error.
dir my_dir > file.txt
is short for
dir my_dir 1> file.txt
therefore the below redirects the standard error:
dir my_dir 2> file.txtOne can also use the symbol "|" to send ("pipe") the output from one command as input for another command. In this popular example, the output from dir is piped to more, which stops the display after each screenful:
dir | more
One can also split the output so it goes both to a file and the screen using "tee":
dir | tee filelisting.txt
This section so far dealt with redirecting standard output. Redirecting standard input is not nearly as useful as redirecting the output, but it can be done using a construct like this:
cat < my_file
There is also something called in-line redirection of the standard output, realized with "<<". Forget about it, seems of no use to me. Yet, here is an example if you really ever needed it (here, the ">" stands the secondary prompt):
cat << my_marker
> my_line_from_the_keyboard
> another line_from_the_keyboard
> my_marker [the marker of your choice ends the in-line redirection].
Normally, these characters have special meaning to the shell:\ ' " ` < > | ; <Space> <Tab> <Newline> ( ) [ ] ? # $ ^ & * =
Here is the meaning of some of them:
\ ' " and ' are used for quoting and were described before.
< and > are used for input/output redirection and were describe before.
| pipes the output of the command to the left of the pipe symbol "|" to the input of the command on the right of the pipe symbol.
; separates multiple command on a single line.
<Space> and <Tab> separate the command words.
<Newline> completes a command or set of commands.
( ) enclose command(s) to be launched in a separate shell (subshell). E.g. ( dir ).
{ } enclose a group of commands to be launched by the current shell. E.g. { dir }. It needs the spaces.
& causes the preceding command to execute in the background (i.e., asynchronously, as its own separate process) so that the next command does not wait for its completion.
* when filename is expected, it matches any filename except those starting with a dot.
? when filename is expected, it matches any single character.
[ ] when filename is expected, a pair of [] encloses the characters to be matched.
&& and connecting two commands
command1 && command2 will execute command2 only if command1 exits with the exit status 0 (no error). For example: cat file1 && cat file2 will display file2 only if displaying file1 succeeded.|| or connecting two commandscommand1 || command2 will execute command2 only if command1 exits with the exit status of non-zero (with an error). For example: cat file1 || cat file2 will display file2 only if displaying file1 didn't succeed.= assigns a value to a variable.Example. This command:$ preceeds the name of a variable to be expanded.
me=blahblah
assigns the value "blahblah" to the variable called "me". I can print the name of the variable using:
echo $meThe variables are either assigned using "=" or are one of the pre-defined (which cannot be assigned to):
$0 name of the shell or the shell script being executed.
$# number of the positional parameters to the command
$1 the value of the first positional parameter passed to the command. $2 is the second positional parameter passed to the command. etc. up to $9.
$* expands to all positional parameters passed to the command
$@ expands to all positional parameters passed to the command, but individually quoted when "$@" is used.
This whole thing shows the unnecessary complexity of the old UNiX. See man bash if you really need more.
The answer depends on what kind of package you downloaded. You can avoid many installation headaches if you download programs in the form of Red Hat binnary packages.o If the program is a RedHat binary package (*.rpm), I use the RedHat package manager rpm . First I read the info on the package content:
rpm -qpi my_new_file.rpm
This queries (mode "q", must be the first letter after the dash) the yet uninstalled package (option "p") so that it displays the info (option "i") which the package contains. If I want to install the program, I run (as root):
rpm -ihv my_new_file.rpm
This runs rpm telling it to install the package (mode "i", must be the first letter after the dash) while printing to the screen more information than usual (option "h"=display "hashes" to show the unpacking progress, option "v" = be verbose). The contents of the package is distributed to the directories where it belongs. After this installation, the program is ready to run, I just have to find where the executable is. If I have trouble finding the executable, this lists all the files that the package contains together with their destination directories:
rpm -qpl my_new_file.rpm
This queries (option "q") the yet uninstalled package (option"p") so that it displays the listing (option "l") of all the files the package contains.
There are also GUI front-ends to rpm: glint (very slow, comes with RH5.2), gnopro (confusing, comes with RH6.0), and kpackage (by far the best of the three but it has to be installed separately--check your favorite Linux software site to download it).
o If what you downloaded from the net is a Linux source code in a form of a compressed tarball, the procedure is longer and more troublesome than with the binary-only rpm. I typically install the program as root.
First, I change my current working directory to /usr/local :
cd /usr/local
Second, I decompress the tarball that I downloaded from the net:
tar -xvzf /home/the_directory_where_the_tarball_is/my_tarball.tar.gz
This extracts (option "x") the contents of the *.tar.gz (or *.tgz) tarball , unzips it (option "z") while talking to me more than usual (option "v" = verbose). Please note that the option "f" means "file", so the filename must immediately follow the letter "f". The contents of the tarball is extracted into a subdirectory which tar creates under my current working directory, which in this case is /usr/local/ . The tarball knows what the new subdirectory should be called.
If the tarball is not compressed, I may use:
tar -xvf /home/the_directory_where_the_tarball_is/my_tarball.tar
Third, I have a look if the new subdirectory was created and how it is called, then I cd into it:
cd the_new_program_subdir
Since some of the directories have long names, I use the great autocompletion option to save on typing--I just type the first few letters and then press <TAB> .
Fourth, most programs are compiled by executing these three commands:
./configure
make
make install
The above commands can take some time to complete (0.5 h?). If any of them fail, it might be an idea to read the README or INSTALL or whatever info is provided with the new program. Some programs may require customization of the environment (e.g. addition of their directory to the PATH) or installation of an additional library, or yet something else. It can sometimes be a pain. Very simple programs might not need the "./configure" or/and "make install" step, in which case "make" alone will do.
Fifth, if everything goes well, I find the executable in the new program. The names of executables display in green when running this command:
ls --color
Now, I can run the executable:
./the_executable
Sixth, if I plan to run the program more often, I create a symbolic link to the executable from the directory /usr/local/bin :
cd /usr/local/bin
ln -s /usr/local/the_new_program_subdir/the_executable .
This way, the executable (actually, a symbolic link to it) is on my PATH and it can be run by simply typing its name (no need to type the full path to the executable any more). Some programs will put the executable (or a link to it) in a bin directory so you can skip the last step.
o There are also programs distributed as "source code rpm" packages. They require installation of the *.rpm package with the "rpm" utility and then compilation of the source code by executing the same: "./configure ; make ; make install" sequence as for the sourcecode distributed as tarballs.
Go to Part 4: Linux Newbie Administrator
FAQ