For those who had linux knowledge will have a lot of  advantage over IT field, due to linux is a open source, a lot of free application available in linux. One of the linux platform operating system I mention before is Ubuntu, You can actually request a Ubuntu Free CDs that deliver to your door step.

As mention on the free application, I do collect some Free Antivirus software for linux before, hope this Linux, The Complete Manual I share here will bring more benefit for those tech freak.

Download Linux The Complete Manual from MagBook here

DSL encompasses various protocols, including asymmetric DSL (ADSL), rate adaptive DSL (RADSL), high bit-rate DSL (HDSL), and symmetric DSL (SDSL). It also includes different subvariations, such as CAP-encoding ADSL versus discrete multitone (DMT)- encoding ADSL. The acronym xDSL is used to refer to the set of DSL protocols, rather than to a specific protocol.

DSL is available in several different bandwidths and flavors. The main types of DSL are ADSL – a DSL for which upload and download speeds are different, SDSL – in which upload and download speeds are the same, and Internet DSL (IDSL), which uses ISDN technology to deliver DSL. The minimum bandwidth for DSL is 128 Kbps, but speeds up to 52 Mbps are available.

If a DSL user connects via an Internet service provider (ISP), the connection to the ISP occurs over a LAN or WAN connection that the ISP has arranged with the local telephone company, rather than via the ISP’s standard modem bank. This connection may use, for example, 10Base-T Ethernet, T1, T3, Asynchronous Transfer Mode (ATM), or frame relay. The ISP then routes the data onto the Internet. Alternatively, a user may connect directly to a company network. DSL is always “on” – the connection is always available, ready to pass bits up and down the pipe, so there is no need to re-establish a connection each time you need to use it

The main limitation on DSL is that it is distance-sensitive. The signaling required for a DSL connection cannot travel more than a certain number of feet over the phone wire from the DSL equipment at the local phone switch. The bandwidth rate available to you will depend on the distance you are from the DSL equipment – the closer you are, the higher the bandwidth you can expect.

ISDN overview
Integrated Services Digital Network (ISDN) refers to a set of communication protocols proposed by telephone companies to permit telephone networks to carry data, voice, graphics, music, and video. ISDN was developed to permit faster access over existing telephone systems without the additional call setup time. It enables the simultaneous transmission of voice and data signals using end-to-end digital connectivity.

Because ISDN uses existing phone lines, it requires that the central office be within a certain distance, which limits service availability

With ISDN, bearer channels (B channels) carry voice and data signals. These channels occupy a bandwidth of 64 kilobits per second (kbps). Some switches limit B channels to a capacity of 56 kbps. A data channel (D channel) handles signaling at 16 kbps or 64 kbps, depending on the service type.

Computer applications other than ISDN use the letter “k” or “K” to represent 1024 bits (2^10). In ISDN terminology, however, “k” represents 1000 bits (10^3). Therefore, a 64 kbps channel carries data at a rate of 64,000 bits per second (bps).

There are two basic types of ISDN service – Basic Rate Interface (BRI) and Primary Rate Interface (PRI). BRI consists of two 64 kbps B channels and one 16 kbps D channel. It provides a total capacity of 144 kbps, which is adequate for most individual users.

PRI is intended for users with greater capacity requirements. Typically, the PRI channel structure includes 23 B channels plus one 64 kbps D channel, providing a total capacity of 1536 kbps. In Europe, PRI consists of 30 B channels plus one 64 kbps D channel, for a total capacity of 1984 kbps. It is also possible to support multiple PRI lines with one 64 kbps D channel using Non-Facility Associated Signaling (NFAS).

H channels provide a way to combine B channels. They are implemented as follows:
H0=384 kbps (6 B channels)
H10=1472 kbps (23 B channels)
H11=1536 kbps (24 B channels)
H12=1920 kbps (30 B channels) – International (E1) only

To access a BRI service, a customer needs to subscribe to an ISDN phone line and must be within 18,000 feet (about 5.5 km) of the telephone company’s central office. If a customer is further away from the central office, expensive repeater devices are required. Without these devices, ISDN service may not be available at all. Customers also need special equipment such as ISDN terminal adapters – sometimes incorrectly referred to as
“ISDN modems” – and a router with an ISDN interface to communicate with the phone company switch, and with other ISDN devices.

Background and foreground processes
An interactive process can run in the foreground or background. To place a process in the background, you use the command bg or the ampersand symbol (&). This lets you do other jobs while waiting for the command to finish. Let’s say you use the syntax

$ find / filename 2 > /dev/null | grep filename | tee result

A command using this syntax could take a long time to execute, especially if you have a lot of files and are listing several network drives. Only one job at a time can run in the foreground, so no further commands can be issued until the prompt returns. To continue working on the command line while it processes, you can execute the same command in the background, using the ampersand. For example, you could enter the command using the following syntax:

$ find / filename 2 > /dev/null | grep filename | >result &

After the command has been issued, the shell displays a message, which looks similar to the following:

$ find / filename 2> /dev/null | grep filename | >result &
[1] 60913
$

The number after the brackets, 60913, indicates the PID for the process, so the status of the background command can be monitored. You can run numerous commands in the background simultaneously.

When the background command has been completed, you will see a line like this:

[1]+ Done find / filename 2> /dev/null | grep filename | >result

Note that the output of a long job has to be redirected when it’s placed in the background. This prevents difficulties when you use the command prompt, because otherwise the output from the background command would continue to appear as you typed.
You use the bg command to send a command to the background while it is running. Initially, you press Ctrl+Z to stop the process, and then enter the bg command to place it in the background, where it resumes execution. Placing a process in the background clears the system, leaving the command line available for other uses.

If it is an interactive process, a message like this will occasionally appear:

[1]+ Stopped (tty output) telnet localhost

If a command is stopped, you can start it running again in the background using the bg command, as in

$ bg %1

To maintain control of the command and to return it to the foreground, you enter a percent symbol (%) before the command’s job number. You then use the fg command to return the process to the foreground, as in the following example:

$ fg %1

As a summary of linux processes part 1 and part 2. Processes perform tasks specified at the command line in Linux. Each process can initiate other processes. Process identity numbers (PIDs) let the shell keep track of which particular process it’s working on. The ps command displays information about each of the processes running under the shell. The bg command enables you to place a process in the background, so that you can do other jobs while waiting for the command to finish. A PID preceded by a percent symbol (%) and used with the fg command returns a process to the foreground.

The following table shows the three main categories of processes.

Linux can share its processing power, storage capabilities, and input and output mechanisms with several users, or with several processes created by one user. Processes such as user jobs, operating system tasks, mail, and background jobs like printing need to be monitored simultaneously by Linux.

PIDs
When a request is made to the shell, it assigns a specific identity number called a process identifier (PID) to the corresponding process. PIDs enable the shell to identify the process it’s working on and helps it to monitor the progress of this process. PIDs start at zero, beginning at boot time, and increase by one for each process being run. Once the highest system-determined number has been reached, such as 65,564, the procedure starts from zero again, skipping the PIDs for processes that are still active. Every new command creates at least one extra process. For example, to print a file called report.txt, you enter

$ lp report.txt

This creates an extra process – lp – on top of the already existing shell process that is running in the foreground. So the shell prompt reappears onscreen only after the lp command is finished, because only one process can occupy the foreground at any one time.

Parent and child processes
Each existing process becomes a parent process when it initiates a new process. The new process is referred to as a child process. For example, say you run a shell script called shellscript1 that contains an ls command. The shell executes a process called shellscript1, which in turn generates a process called ls. So the shell process becomes the parent of shellscript1, and shellscript1 then becomes the parent of ls.

A parent process bestows its environment upon the child process. A child process will include standard input (stdin), standard output (stdout), and standard error (stderr). So if you open a file in a shell script (its parent), the commands that follow in the script will retain the open file in their environment. However, the parent and child processes will remain unaffected by any changes in the environment that occur during the execution of a process. This is because the processes run independently of each other. Therefore, after the child process has been initiated, any files opened in either the parent or the child will not be available to the other process.

Using the ps command
You use the ps command to identify which processes are currently running in the system. It helps you to monitor the process running in the foreground, and allows you, as root, to see what other processes are running.

To list all current processes running under a User ID (UID), you type ps without using options or arguments. This returns the PIDs of the processes, the terminal they originated from, their current status, the CPU time used, and the command running in the processes. For example, the command could return output such as

$ ps
PID TTY TIME CMD
511 tty1 00:00:00 login
7062 tty1 02:34:59 bash
17079 tty1 00:00:00 ps

This output shows that the user’s startup shell is bash (PID 7062). The startup shell sometimes has a hyphen placed before it to differentiate it from any shells started afterwards. But some versions of the ps command don’t do this.

General users can display their own processes only using the ps command. However, superusers can use the ps command to list every process running in the system.

There are many complex options for the ps command. Some options determine the sets of processes to be produced, whereas others determine the output format. Some options are preceded by a dash (–) in the traditional Linux manner, but others are not. And sometimes the same letter produces completely different output depending on whether it has a dash or not. For instance, $ ps -a produces a full listing of all processes, but $ ps a produces a modified listing of all the processes in the current terminal. For a full listing of the different ps options, you can consult the man pages for ps.

For most purposes, a simple set of common options for the ps command provide sufficient power and flexibility. The -a option provides a listing of all processes currently running on all the terminals. The listing below shows the processes running under tty1 and tty2, for example:

$ ps -a
PID TTY TIME CMD
7062 tty1 02:34:5 bash
16894 tty2 00:00:00 bash
16906 tty2 00:00:00 startx
16913 tty2 00:00:00 xinit
16917 tty2 00:00:00 gnome-session
16927 tty2 00:00:00 gnome-smproxy
16933 tty2 00:00:00 enlightenment
16952 tty2 00:00:00 magicdev
16969 tty2 00:00:00 panel
16971 tty2 00:00:00 gmc
16988 tty1 00:00:00 ps

The f option, without a dash, uses ASCII characters to graphically represent a hierarchical view of the parent-child relationships between processes. This is particularly useful if you’re considering killing processes, because it helps you ensure that you don’t kill a child process accidentally when you kill a parent process. In the listing below, process 16906 is the parent of 16913, which in turn is the parent of 16917:

$ ps f –a
PID TTY STAT TIME COMMAND
16894 tty2 S 0:00 -bash
16906 tty2 S 0:00 sh /usr/X11R6/bin/startx
16913 tty2 S 0:00 \_ xinit /etc/X11/xinit/xinitrc — :0 –auth /root/.X
16917 tty2 S 0:00 \_ /usr/bin/gnome-session
7062 tty1 S 154:59 -bash
17105 tty1 R 0:00 ps f –a
16971 tty2 S 0:00 gmc –sm-client-id default10
16969 tty2 S 0:00 panel –sm-client-id default8
16952 tty2 S 0:00 magicdev –sm-client-id=default12
16933 tty2 S 0:00 enlightenment –clientId default2
16927 tty2 S 0:00 gnome-smproxy –sm-client-id default

Using the -l option with the ps command shows more detailed information in the process entry. This includes the parent PID (PPID), the size, the UID, the status, and the priority of a process. For example, the ps -l command might return output such as

$ ps -l
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
100 S 0 511 1 0 60 0 – 549 wait4 tty1 00:00:00 login
100 S 0 7062 511 0 70 0 – 808 wait4 tty1 02:34:59 bash
100 R 0 17115 7062 0 73 0 – 627 – tty1 00:00:00 ps

The PPID column shows the process that started each process. This is useful if you need to identify child processes.

Linux stores files in plain-text format. This allows you to use different processing, or filtering, utilities on the text. These utilities let you format, analyze, and manipulate text in many different ways. For example, you can format pages and paragraphs, check spelling, add page numbers and headers, and count the lines, words, and characters that a file contains.

Text-processing utilities

The general command syntax used for text-processing commands is

command [option ] filename(s)

Reading files
To work with files, you need to know what information they contain. One way of doing this is to use the cat command to display the contents of a file on your terminal screen. This command provides a number of options.

Options for the cat command

Viewer commands
A quicker way of viewing the contents of a file is by using viewer commands, which display the information at the start or end of a file. Examples of viewer commands include head and tail.

By default, the head command displays the first 10 lines of a file, and the tail command displays the last 10 lines of a file. Additional options can be used with these commands to view more specific areas of a file. For example, you can use the -n option with the commands to specify the number of lines they must display.

Pager commands
If a particular file is longer than one screen, it may scroll past too quickly for you to read it. You can scroll through documents at your own pace by using pager commands, which display documents one screen at a time. Examples of pager commands include less and more.

The more command is the original pager command and derives from the Berkeley version of UNIX. It enables you to move through a document in a forward direction only.

The less command was developed to replace the more command and provides a wider range of options for viewing files.

Pager command options

Quotas can specify

• the maximum amount of total disk space allotted to a user or group
• The maximum number of files a user or group can create

You assign quotas by partition, so an individual or group who creates files on two partitions may have a different quota for each partition, or a quota for only one of the two partitions.

User and group quotas
User quotas and group quotas are independent of each other – so the value of the group quota is not the sum of the values of the users’ quotas in a group. When a user attempts to create a file, Linux first checks if there is a group quota for the user’s group. If a group quota for the group to which the user belongs has already been filled, the user can’t create the file, regardless of the status of the user’s quota. To create the file, the user must change groups. Every file that an individual user creates counts towards the quota of the user’s group. If the user isn’t part of a quota-restricted group, or if group quotas aren’t switched on for a partition, the user can create files on the partition as long as the user’s quota isn’t filled.

Hard and soft limits
When you set quotas, you can specify both a hard and a soft limit. When a user exceeds a soft limit, a warning is issued, but the user can continue to create files for the duration of a grace period. The default grace period is seven days, but the administrator can change this period. At the end of the grace period, the user must reduce their disk usage so that they don’t exceed the soft limit. The soft limit acts as a warning to the user that they are approaching a hard limit. When the user reaches a hard limit, they can no longer create files at all.

Viewing quotas
The quota command checks the file system in the /etc/fstab directory for quotas and reports them. As a root user, you can use the quota command to view the quotas of any user or group on a system. Users can check their own quotas and the quotas of any groups to which they belong. The syntax for viewing quotas is

quota option who

In the syntax, who can be either a username or a group name.

The following options are used with the quota command:

• g checks a group quota
• u checks a user quota
• q checks which quotas have been filled

Users can use the -g option and the -u option together, to check both their user and group quotas.

The repquota command reports quotas and provides a summary of disk usage for a specified file system. So you can see how many files a user or group owns in a file system and how much space they occupy. The syntax for using the repquota command is

repquota options file_system

The following table shows the repquota command options.

Options for the repquota command

As for the quota command, the root user can use the repquota command to view all quotas in the system, whereas other users can view only their own user and group quotas.

Filename completion characters

Filename completion characters are metacharacters that enable you to abbreviate filenames or directory names. This saves time and lets you process files selectively, even if you don’t know their full names or locations.

Commonly used filename completion characters are included in the table below.

Filename completion characters

The * character (asterisk) is the most frequently used file completion character. You can use the string b*, for example, to match all the filenames beginning with the letter “b”. You can also use multiple asterisks to define a file. For example, *xx*.gif retrieves any filename that contains “xx” anywhere in its name and that has the .gif extension.

The ? character (question mark) represents any single character, so the string ??? refers to all files with a three-letter name. This special character is more restrictive than the asterisk, because it requires the character to be present. For example, the code file?.txt signifies all files that begin with “file”, include one additional character, and have the .txt extension. So the filename “file1.txt” matches, but “file.txt” and “file01.txt” don’t.

Using [] characters (square brackets) allows for a more selective approach to retrieving files. The string [abc] will find files a, b, and c only. You can include a hyphen between characters inside the brackets to match a continuous range of characters. To specify the characters 0 through 9, for example, it is a lot easier and less time-consuming to type [0-9] rather than [0123456789]. If the brackets precede an asterisk, as in [0-9]*, filenames starting with any numbers between 0 and 9 are found. The pattern *[0-9] will match filenames ending with numbers between 0 and 9. Inserting an exclamation mark inside the brackets, as in [!b], will invert the pattern, matching any characters or ranges not specified in the brackets but ignoring those that are.

The $ (dollar sign) is used to identify shell variables at the command line. Variables are values that have been associated in memory with some kind of identifier. Variables have many uses in Linux. To give a simple example, a variable with the identifier PATH contains the list of directories within which the shell can search for executable files. To view this list, you invoke the following command:

echo $PATH

If you entered the command echo PATH, it would print the literal string “PATH”, rather than the value of the PATH variable, on your terminal.

The ~ character (tilde) enables you to refer quickly and easily to your home directory, no matter where in the file system you might be. Say that your current working directory is /usr/local/bin and you have a file called “usernames” in your own home directory, which you want to edit with vi. Rather than having to type the complete path to the file, you can just issue the command

vi ~/usernames

Quoting special characters

There are occasions when you might want to suppress the special meanings of metacharacters. A special character must be quoted in order to represent its own literal meaning rather than its special meaning to the shell. Quoting causes the shell to overlook the unique capabilities of special characters and negate parameter expansion. This mechanism uses the following quote symbols:

• \ (backslash)
• ” (double quotes)
• ‘ (single quotes)
• ` (backquote)

The backslash is also known as the bash shell escape character. This is because it turns off or “escapes” the special meaning of the character that follows it. For example, as we have already seen, the following command returns the value of the PATH environment variable:

echo $PATH

However, the following command will return the literal output “$PATH”, because the backslash negates the special meaning of the dollar sign:

echo \$PATH

If a line itself ends with a backslash, it acts as a continuation character for the line and the newline character is ignored.

Single quotes negate the translation of all special characters. They prevent the substitution of alternative values for the characters. For example, the following command will output a list of single-character filenames:

ls ?

However, this command will attempt to list the file with the literal name “?”:

ls ‘?’

Double quotes cause most metacharacter special meanings to be ignored. The exceptions to this rule are the dollar sign, backquote, and backslash. So double quotes have the effect of canceling the process of filename generation by the shell, but still allow the expansion of shell variables and command substitution. The dollar sign and backquote continue to function as special characters when included between double quotes. The backslash character only does so when it’s followed by a dollar sign, backquote, double quote, backslash, or a newline character. In these circumstances, the backslash itself is removed and the special meaning of the following character is ignored. This makes it possible to quote a double quote between double quotes if it is preceded by a backslash. For example, the commands echo”\”" or echo\” output a double quote character by suppressing the special meaning of the embedded double quote.

The backquote is still often used for command substitution, although the $() combination (a dollar sign and brackets) is generally preferred. The shell interprets the text between a pair of backquotes as a command before translating the rest of the command line. The output of the command replaces the original backquoted text.
In the following code, the double quotes disable the date command:

> echo “date”
date

However, the backquotes in this command enable command substitution to occur:

>echo ‘date’
Thu Jun 10 17:18:56 IST 2004

Advantages of using a shell

Greater control
A shell is a program that acts as an interface between the user and the operating system, just as a GUI does. However, a shell works without graphics – when you use one, you issue instructions to the operating system by typing in commands. In fact, the shell is often referred to as a command interpreter.

This may seem like a return to basic computing, but a command-line interface lets you exercise a degree of control over the operating system that would otherwise be lacking. There are a number of reasons for this:

• with a GUI, only the options provided by the interface are available to the user
• lack of space on a screen can limit the number of options that a GUI displays
• no standard methods exist within GUIs for performing standard command-line tasks, such as linking commands in sequences, redirecting output from one destination to another, or collecting commands into scripts

A disadvantage of using a command-line interface is that the user needs to learn a wide variety of sometimes cryptic commands and their associated options. However, the commands are more powerful and adaptable than their GUI counterparts, because they can be extended and fine-tuned through the use of options. An expert user of a command-line interface can issue complex commands very quickly. Techniques also exist to link multiple commands together with pipes and redirections, so that the output of one command becomes the input of another. Linux can interpret commands issued using the shell more quickly than GUI commands. This is because shell commands are nothing more than simple ASCII text. Some shells even enable you to define your own commands.

Automation of common tasks
A shell has another advantage over a GUI in that it keeps a history list of recently issued commands. This enables a user to step back and forth through this list, reusing commands at any point. In addition, a shell enables you to string commands together to form a shell script. These scripts work in a similar way to batch files, issuing multiple commands as one. You can use them to automate common tasks that would otherwise require you to issue several, consecutive commands.

Speed and efficiency
In hardware terms, a shell is a more attractive proposition than a GUI. Shells are much less resource-intensive than GUIs – they require less memory, for example. This means that a command issued in the shell will run more quickly and efficiently than the same command run in a GUI. It also means that a shell supports Linux’s multitasking environment, in which multiple tasks run simultaneously, more comfortably than a GUI, in which the GUI itself competes for CPU resources.

Shell evolution

Since its creation as a derivative of UNIX, Linux has given rise to a number of shells, which have evolved along with the operating system itself. When a new shell is developed, it doesn’t spell the end for all previous shells. Many different Linux shells are available, and each has particular strengths. The one you use depends on your own preferences and on the task you wish to undertake.

The default shell in most Linux installations is the Bourne Again shell, or /bin/bash. It is a successor to the Bourne shell, or /bin/sh, which was an early and less powerful Linux shell. The Bourne Again shell was created and is distributed by the Free Software Foundation. It offers features such as command-line editing and filename completion. It is an ideal first shell for Linux newcomers. In addition, bash supports the syntax used by another Linux shell called the C shell, or /bin/csh, which increases its flexibility.

You can find out which shell you’re running at any time by typing the command echo $SHELL at the shell prompt. The default shell is specified in the /etc/passwd file and can be changed there for each user.

Since we are talking about Linux here, you might want to know how to mount linux file system also understand on Linux File Types.

It is an important part of the role of the Linux system administrator to ensure that file systems are mounted correctly, whether at boot time or manually, to ensure that all required data is available at the expected locations.

Advantages of mounting Linux file systems and devices

Devices are mounted at predetermined directories below the root file system. These are usually, although not always, special directories created for the purpose. The file systems that belong under the /var, /home, and /usr directories, for example, are kept on separate partitions or devices from the root file system. Network machines are frequently configured so that the /home data for all machines is actually stored on a single Network File System (NFS) server, which is then mounted under the /home directory on each individual machine. This enables users to access their own home directories in the usual locations, regardless of which computers they are actually logged on at.

Because all devices and file systems appear below the root directory, the transition from one device or file system to another is entirely seamless. So a user can access a file on an NFS server over a network as though the file were on the local hard drive.

Linux makes it easy to expand the space available to overloaded file systems by mounting new partitions. For example, say the directory /home/project is filling up with so much data that it threatens to take over the hard drive on which it is stored. The system administrator can easily move the data from the existing /home/project to an empty disk partition with more available space, and remount the new partition at /home/project. To users, there won’t be a difference between the old configuration and the new one – they still access their files under /home/project, even though the files are now stored on a completely different hard drive.

It is important to mount file systems in the correct order. This is sometimes necessary to ensure that the mount point required by a given file system exists and is available when the mount command is issued. Taking the /home/project example again, the project data exists on one disk partition and all the remaining /home data is on another, including the /home/project directory under which the /home/project partition is to be mounted. Clearly, if an attempt is made to mount the /home/project partition before the /home partition, this will result in an error, as the /home/project directory doesn’t yet exist. The correct order is to mount the /home partition first, followed by the /home/project partition.

It is also important to be aware when mounting devices under a given directory that any files previously available under that directory will be hidden while the device is mounted. So any files that still remain in the /home/project directory of the /home partition will become invisible as soon as the /home/project partition is mounted in that directory. Furthermore, the disk space those files occupy will remain unavailable to the system until the project partition is unmounted. You should therefore check what already exists in a directory before you use it as the mount point for some other file system, to avoid duplicating files or wasting disk space.

File system mounting management

To assist in the management of file system mounting, a special directory called /mnt exists in most Linux distributions. This directory contains dedicated directories for mounting specific devices such as CD-ROM, floppy disk, and zip disk drives. This is a convenient way to ensure that such devices have a suitable mount point available to them at all times.

Removable media

It is impossible to access the data on removable media without mounting them first. To use a floppy disk drive, for example, you need to issue the mount command before the disk contents will be visible to the system.

Similarly, when you have finished using any kind of removable medium, it is very important to unmount the device using the umount command before removing the disk from the drive. This is because Linux improves efficiency by often storing information in memory buffers rather than writing it directly to the disk. If a removable disk is removed without being unmounted first, there is a high probability of data loss, just as there is from a hard drive if you shut down the system by turning off the power without running the proper shutdown procedure.