XML Signature Standard
The W3C XML Signature standard provides a specification for creating and using digital signatures in XML. You use XML Signature to provide authentication when transmitting documents. You can use XML Signature with any content, including XML data. You can sign just a portion of a document, in the same way that you can encrypt just part of it.

Authenticating XML documents is difficult, however, because their structure may change even when the data in them does not. Most digital signature methods treat the structure of a document as significant when generating the unique value, or message digest, that can be used to validate the document’s authenticity To address this, the W3C uses XML Canonicalization. This specification defines how to generate a canonical form of an XML document. This is a highly formalized version of the XML document. Two XML documents that differ textually as a result of comments, empty tags, or line breaks for example, but have the same logical structure will produce identical canonical documents.

The basic structure of a digital signature is as follows, where ? indicates zero or one occurrence and * indicates zero or more occurrences:

<Signature ID?>
<SignedInfo>
<CanonicalizationMethod/>
<SignatureMethod/>
(<Reference URI? >
(<Transforms>)?
<DigestMethod>
<DigestValue>
</Reference>)+
</SignedInfo>
<SignatureValue>
(<KeyInfo>)?
(<Object ID?>)*
</Signature>

Signature is the root element, and its ID attribute is an optional one used to identify the signature. The mandatory SignedInfo element represents the data that is signed. Then the CanonicalizationMethod element provides the canonicalization algorithm that has been applied to the signed data. The Reference element provides a reference to the data object being signed. This element contains the Transforms, DigestMethod, and DigestValue child elements, which describe how the signed data object has been compiled. The KeyInfo element enables you to obtain the key to validate the signature. Note that, although this element is qualified when used in encryption, it does not need to be qualified when used with digital signatures because it is part of the digital signature namespace.

The following is an example of a signature:

<Signature Id=”ENTSecureSig”
xmlns=”http://www.w3.org/2000/09/xmldsig#”>
<SignedInfo>
<CanonicalizationMethod Algorithm=
“http://www.w3.org/TR/2001/REC-xml-c14n-20010315″/>
<SignatureMethod Algorithm=
“http://www.w3.org/2000/09/xmldsig#dsa-sha1″/>
<Reference URI=
“http://www.w3.org/TR/2000/REC-xhtml1-20000126/”>
<DigestMethod Algorithm=
“http://www.w3.org/2000/09/xmldsig#sha1″/>
<DigestValue>
j6lwx3rvEPO0vKtMup4NbeVu8nk=
</DigestValue>
</Reference>
</SignedInfo>
<SignatureValue>MC0CFFrVLtRlk=…</SignatureValue>
<KeyInfo>
<KeyValue>
<DSAKeyValue>
<P>…</P><Q>…</Q><G>…</G><Y>…</Y>
</DSAKeyValue>
</KeyValue>
</KeyInfo>
</Signature>

The Signature element declares the XML Signature namespace. The Reference element identifies the W3C XHTML specification as the object that’s being signed in this case. The DigestMethod element’s Algorithm attribute indicates that the SHA-1 algorithm was used to generate a hash, or message digest of this, the value of which is indicated in DigestValue. Everything within the SignedInfo element is canonicalized according to the Canonical XML specification indicated by the CanonicalizationMethod element. Then the DSA algorithm specified by the Algorithm attribute in SignatureMethod is used to produce the SignatureValue, which is the digest of everything in the SignedInfo element. KeyInfo specifies what key should be used to validate this signature – in this case, DSA keys. The P, Q, G, and Y elements are used only with DSAKeyValue and specify DSA public key values.

For this signature to be validated, the contents of SignedInfo must be canonicalized, and then processed with the algorithm specified in SignatureMethod using the public key supplied by KeyInfo. If the value this produces matches the one in SignatureValue, the signature is valid. For the signed data to be validated, its unsigned version is retrieved using the Reference URI, processed according to DigestMethod, and compared to the value in DigestValue.

As a summary on Encrypting and authenticating of XML data, XML Encryption enables you to encrypt an entire document, a specific element, or the content of a specific element. It also facilitates the transmission of data between more than two parties and ensures end-to-end security rather than party-to-party security. XML Signature provides authentication when using web services. It enables users to receive data that is signed by the sender and to verify the integrity of the data.

XML Encryption encrypts data using the following elements – EncryptedData, CipherData, CipherValue, CipherReference, and EncryptionMethod. These elements are in the http://www.w3.org/2001/04/xmlenc# namespace. XML encryption is key-based and can be asymmetric or symmetric.

The W3C XML Signature standard provides a specification for creating and using digital signatures in XML. You can sign just a portion of a document, in the same way that you can encrypt just part of it. XML Signature relies on XML Canonicalization to generate a canonical form of an XML document. This ensures that the data in a document can still be verified even if its structure changes.

Tag wars
In the early days of the Web, HTML proved to be an extremely popular authoring language. With HTML, publishing content to the Web was easy – you inserted some tags into a document using a text editor and uploaded the document to a web site, where it could be read by anybody with a browser. However, this very simplicity was a drawback, because the people who were actually developing web browsers wanted to include exciting new features that were not supported by early versions of HTML. So these developers decided to create their own tags, which could only be interpreted properly by their browsers. This threatened to lead to a situation where the type of web page you could visit would depend on the browser you were using. Clearly what was needed was an agreed HTML standard.

The W3C to the rescue
The need for a body to develop common standards for the Web led to the formation, by Tim Berners-Lee in 1994, of the World Wide Web Consortium (W3C). A specification that has been approved by members of the W3C and is appropriate for widespread use is published as a recommendation document.

One of the most important initial tasks for the W3C was to develop a standard for HTML, and in 1995 this body was busily working on HTML 3.0, a badly needed update for the two previous versions – HTML 1.0 and HTML 2.0. However, the draft specification for HTML 3.0 included many new tags, most of which were not, and would not, be supported by browsers available at the time. So the W3C changed tack – instead of attempting to cram in lots of new features, it focused on what was currently supported. HTML 3.0 was abandoned and, in 1996, the W3C published its recommendation for HTML 3.2, which represented the consensus on HTML at that time.

The next recommendation after HTML 3.2 described the widely used HTML 4.0, released in 1997, and was followed in 1999 by a recommendation for HTML 4.01.

The latest recommendation – XHTML 1.0
XHTML 1.0 is W3C’s recommendation for the latest version of HTML. XHTML 1.0 is a hybrid of XML – another, more powerful markup language called the Extensible Markup Language – and HTML 4.01. XHTML 1.0 is specified in three “flavors”:

• XHTML 1.0 Transitional – if you are a developer creating web pages for the general public, you should use this “flavor” because it allows you to take advantage of XHTML features such as Cascading Style Sheets, and you only have to make small changes to your documents to accommodate users viewing your pages with older browsers that don’t support XHTML
• XHTML 1.0 Strict – this is used when you want your document to be free of any tags associated with the layout of text
• XHTML 1.0 Frameset – this is useful when you want to use HTML Frames to partition the browser window into two or more frames

Watch out for old tags
If you read the documentation for XHTML 1.0, you will see that some tags and attributes are deprecated – which means that, although they are supported in XHTML 1.0, they may not be supported in future versions. As a result, you are strongly urged not to use the deprecated tags and attributes on the list provided by the W3C.

However, one of the difficulties is that some browsers may not support the tag that replaces a deprecated one. For example, in XHTML 1.0, the <applet> tag is deprecated in favor of <object>, but recent versions of Netscape Navigator do not support <object>. In this case, you may be forced to use <applet>, even though it is not recommended.

Return of the tag wars – proprietary extensions
You might think that with the release of XHTML 1.0, everybody is happy – that all web site developers adhere to this specification when creating web pages and all browsers provide full support for this code. Nothing is ever this neat, however, and browser developers have included features that are not part of the current recommendation. These features are called proprietary extensions, because they supposedly “extend” the existing standard, although in most cases it’s possible to adhere to the current recommendation and develop the features that these extensions offer.

Two (in)famous proprietary extensions are the <marquee> and <blink> tags. Neither is part of XHTML 1.0, and in any case both are browser-specific – the <marquee> tag is supported by Internet Explorer but not by Netscape Navigator, and the <blink> tag is supported by Netscape Navigator but not Internet Explorer. For these and other reasons, such extensions should be avoided.

Stick to the recommendation and check your code
When creating web pages, it’s always a good idea to conform to the latest recommendation from the W3C, who will even check any code you send them to see if it is valid. And you should test any pages you develop with several browsers and older versions of these browsers.

There are a lot of different setup or connection method for VOIP. The most normal VOIP that we usually use will be SKYPE, which is a communication software that able to perform voice call from computer to computer. I use to use this software to contact my friend who stay far a ways from me, different state and oversea, we chating with VOIP few hour without need to paid any extra changes. VOIP also is a recomended tools for those couple who like to contact each others to have casual talk, without worry about the phone bills.

Other then home usage, business voip system will be the best and effective way to reduce calling cost for businesses, now a day, a lot of company invest on VOIP system at their company, and save thousand of dollar per month. Further more, business voip system also reduce those equipment such as PABX which take a big space to located at a company, all this equipment require maintanance cost.

As per my experience, as mention before on category 7 cable, a lot company start to invest in Cat 7 cable because 1 port can install up to 4 IP phone with using VOIP system, which save a lot of cabling cost.

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.

Now a day, a lot of our mobile phone has already embedded with GPS device, human tent to depend on GPS system when heading to some location that they never went before. My self have some experience when hang out with friend, they are heading to some rural area, I was surprise is the GPS tracking device able to bring us there.

Few month back, there are a Dragon Boat Race Competition around my area, and the organizer has install the GPS tracking device on each other the dragon boat. During those boat race far away from the seaside,  the audience focus on the GPS system which monitoring where the boat actual location. Every one was very excited because this kind of system consider very new over here.

I come across this website name LandAirSea, selling variety ofGPS Tracking device include teen tracking, vehicle tracking, passive tracking, real time tracking and fleet management as well. For those who wish to have GPS update, this website also provide a lot GPS related news! Worth to pay a visit

Brands of commercial UNIX
Some of the most famous and widely used brands of UNIX include Sun’s Solaris and Hewlett Packard’s HP-UX.

Solaris is a binary-compatible operating system, which means that Sun have gone to some lengths to ensure that one version of their UNIX will run on all of their hardware. Solaris also features integrated Java support, although Java can be downloaded for any UNIX
distribution.

Sun also manufacture UNIX for Intel hardware as well as their own proprietary hardware.

By comparison, HP manufacture four different versions of their operating system, each fine tuned for a specific purpose. Hewlett Packard’s UNIX variants all support both RISC architecture and the new breed of Itanium chips from Intel.

Other commercial UNIX variants include IBM’s AIX and Silicon Graphics’s IRIX system.

Brands of open source UNIX
There are an increasingly large number of offshoots of open-source UNIX. However, two names are significant: BSD and Linux.

BSD UNIX is one of the oldest forms of UNIX in existence, and pioneered such technologies as the TCP/IP stack and virtual memory. It’s widely in use across the Internet as a web server.

Linux is a port of the UNIX kernel to i386 (Intel) hardware, and is one of the fastest growing and most widespread UNIXes in use today. In fact, some hardware vendors who traditionally developed proprietary UNIX systems now offer the choice of shipping their
hardware with Linux installed. For example, even though IBM have their own proprietary UNIX, they now offer the option of shipping their xSeries servers with Linux pre-installed.

As a conclusion on choosing Unix, UNIX comes in two main flavors: commercial and open source. The strength of commercial UNIX lies in its support and stability, while open source’s strength lies in innovation and portability. Well known commercial UNIXes include Sun Solaris and Hewlett Packard’s HP-UX. Well known open-source UNIXes include BSD and Linux.

Few week back when we go for Gunung Jerai, my friend was suggest to visit bukit merah water park again, decide to make it after Chinese New Year. Morning plan for swimming, and afternoon plan for Jungle tracking, and probably over night there.

When talking about swimming, this is the worst thing I ever have. I still remember about my 5 year old time, my father send me to swimming club to have swimming class, unfortunately, I was scare, and not really learn anything there. Now when go any place swimming, I told my friend I only know how to “play water”

Currently is time for me to prepare swim wear, since I long time never go for “play water” already. I know there are some shop in town area selling women’s swimwear and mens swimwear, but I do have a friend, they need to look for plus size swimwear since they hv extra body size. i have browse some swim wear website, found a lot of nice swimwear,

Using encryption and authentication with web services
As web services become more prevalent, the issue of security becomes more important. Encryption and authentication are vital tools for achieving secure web services.

Security protocols such as Transport Layer Security (TLS) and Secure Sockets Layer (SSL) enable you to encrypt data and transmit it safely over the Internet. However, these protocols have a number of shortfalls, in that they provide security only between the two parties sending and receiving data at a particular moment in a transaction, rather than among all the parties in a multi-part online information exchange. For example, SSL can encrypt all details of an online purchase you make. This ensures that your credit card number is encrypted when sent to an online merchant, but it cannot ensure that the merchant then sends the number securely to a credit card verification service. XML Encryption serves to address these shortfalls. It enables you to:

• encrypt specific parts of the data being transmitted
• provide end-to-end security

This means that you can choose to encrypt an entire document, a specific element, or the content of a specific element. For example, in an online transaction, you may need to encrypt the credit card details, but not the product details. In this case, you would encrypt a specific element or the content of a specific element rather than encrypting the entire document. You can also transmit data between more than two parties and ensure end-to-end security rather than party-to-party security. This provides opportunities for more advanced e-commerce applications.

Digital signatures provide authentication when using web services. They enable users to receive data that is signed by the sender and to verify the identity of the sender and the integrity of the document – that is to verify that the data has not been altered since it was sent.

Encryption and authentication can be used together to provide powerful security solutions. The W3C has published recommendations for both encryption and digital signatures using XML. However, these are only specifications. They do not provide implementation details. To implement XML Encryption or XML Signatures, you’ll need to create programs that use these standards.

Encrypting data using XML
The W3C’s XML Encryption standard provides a way to encrypt any data. That data can be an entire document, a specific element, or the content of an element. Also, it doesn’t necessarily have to be XML. The standard then specifies a way to create an XML document to store the encrypted data.

Data is encrypted using the following elements – EncryptedData, CipherData, CipherValue, CipherReference, and EncryptionMethod.

Encrypted data generally takes the following format, where ? indicates zero or one occurrence and * indicates zero or more occurrences of an element or attribute:

<EncryptedData Id? Type? MimeType? Encoding?>
<EncryptionMethod/>?
<ds:KeyInfo>
<EncryptedKey>?
<AgreementMethod>?
<ds:KeyName>?
<ds:RetrievalMethod>?
<ds:*>?
</ds:KeyInfo>?
<CipherData>
<CipherValue>?
<CipherReference URI?>?
</CipherData>
<EncryptionProperties>?
</EncryptedData>

The EncryptedData element identifies the section of an XML document that holds encrypted information. If an entire document is encrypted, this element will serve as the root element for the encrypted document. The EncryptedData element can have the following child elements – EncryptionMethod, ds:KeyInfo, CipherData, and EncryptionProperties. The EncryptionMethod element specifies the encryption algorithm used. The ds:KeyInfo element contains information on the key used to encrypt and decrypt the data. For example, it can provide the public key that was used for encryption.

The CipherData element can contain a CipherValue or a CipherReference element. The CipherValue element contains the encrypted data, whereas the CipherReference element provides a URI describing the location of the encrypted data. Finally, the EncryptedData element can contain an optional EncryptionProperties element, which describes the properties of the encrypted data, such as when it was generated.

For example, say you want to encrypt the following document:

<?xml version=”1.0″ ?>
<booking
xmlns=”http://www.easynomadtravel.com/securebookings”>
<vacation>
<destination>Acapulco</destination>
<startDate>2004-05-14</startDate>
<endDate>2004-05-28</endDate>
</vacation>
<customer>
<name>Jonathan Gold</name>
<creditCard>
<cardNumber>1234898888999968</cardNumber>
<cardType>VISA</cardType>
<validTo>2005-01-31</validTo>
<creditCard>
</customer>
</booking>

Encrypting the entire file would result in the following code:

<?xml version=”1.0″ ?>
<EncryptedData xmlns=”http://www.w3.org/2001/04/xmlenc#”
MimeType=”text/xml”>
<CipherData>
<CipherValue>A23B45C56</CipherValue>
</CipherData>
</EncryptedData>

All of the encrypted data is contained within the EncryptedData element. This element is in the XML Encryption namespace, whose URI is http://www.w3.org/2001/04/xmlenc#, and whose recommended namespace prefix is xenc. The MimeType attribute specifies the format of the original data. Note that the CipherValue in this example is a sample. A real CipherValue would probably be considerably longer.

Encrypting the creditCard element only would result in a document such as:

<?xml version=”1.0″ ?>
<booking
xmlns=”http://www.easynomadtravel.com/securebookings”>
<vacation>
<destination>Acapulco</destination>
<startDate>2004-05-14</startDate>
<endDate>2004-05-28</endDate>
</vacation>
<customer>
<name>Jonathan Gold</name>
<EncryptedData Type=
“http://www.w3.org/2001/04/xmlenc#Element”
xmlns=”http://www.w3.org/2001/04/xmlenc#”>
<CipherData>
<CipherValue>A23B45C564587</CipherValue>
</CipherData>
</EncryptedData>
</customer>
</booking>

Only the encrypted creditCard element is contained in the EncryptedData element. All other elements in the document are visible. Once again, the EncryptedData element uses the http://www.w3.org/2001/04/xmlenc# namespace. However, this time it also uses the Type attribute with the value http://www.w3.org/2001/04/xmlenc#Element. Note the word Element at the end of the URI. This indicates that an element is encrypted.

Alternatively, you could encrypt just the credit card number, in which case the resulting document would be as follows:

<?xml version=”1.0″ ?>
<booking xmlns=
“http://www.easynomadtravel.com/securebookings”>
<vacation>
<destination>Acapulco</destination>
<startDate>2004-05-14</startDate>
<endDate>2004-05-28</endDate>
</vacation>
<customer>
<name>Jonathan Gold</name>
<creditCard>
<cardNumber>
<EncryptedData Type=
“http://www.w3.org/2001/04/xmlenc#Content”
xmlns=”http://www.w3.org/2001/04/xmlenc#”>
<CipherData>
<CipherValue>A23B45C564587</CipherValue>
</CipherData>
</EncryptedData>
</cardNumber>
<cardType>VISA</cardType>
<validTo>2005-01-31</validTo>
<creditCard>
</customer>
</booking>

This time all tags remain visible. Only the content of the cardNumber element has been encrypted. Again, the EncryptedData element uses the http://www.w3.org/2001/04/xmlenc# namespace. However, it uses the following value for the Type attribute – http://www.w3.org/2001/04/xmlenc#Content. The word Content at the end of this URI indicates that the content of an element is being encrypted.

XML encryption is key-based. Key-based encryption can be asymmetric or symmetric. Asymmetric encryption uses public and private keys. You use an algorithm to generate both keys. Then you send your public key to anyone who wants to send encrypted data to you. They use the public key to encrypt the data and then send the encrypted data to you. Then you use your private key to decrypt the data. Symmetric encryption uses secret keys. Using symmetric encryption, you exchange a secret key with someone who wants to send encrypted data to you. Then you can both use the secret key to encrypt and decrypt data.

In a document that uses encryption, the ds:KeyInfo element contains information about the key:

<ds:KeyInfo>
<EncryptedKey>?
<AgreementMethod>?
<ds:KeyName>?
<ds:RetrievalMethod>?
<ds:*>?
</ds:KeyInfo>?

Note that these elements use the ds namespace prefix because they occur in the XML Signature namespace rather than in the XML Encryption namespace. For example,

<EncryptedData xmlns=”http://www.w3.org/2001/04/xmlenc#”
Type=”http://www.w3.org/2001/04/xmlenc#Element”/>
<EncryptionMethod Algorithm=
“http://www.w3.org/2001/04/xmlenc#tripledes-cbc”/>
<ds:KeyInfo xmlns:ds=
“http://www.w3.org/2000/09/xmldsig#”>
<ds:KeyName>Jonathan Gold</ds:KeyName>
</ds:KeyInfo>
<CipherData>
<CipherValue>A23B45C564587</CipherValue>
</CipherData>
</EncryptedData>

The KeyInfo and KeyName elements are qualified to indicate they belong to the XML Signature namespace.

The data in this code sample has been encrypted using the Triple DES algorithm. This is specified using the Algorithm attribute in the EncryptionMethod element:

<EncryptionMethod Algorithm=
“http://www.w3.org/2001/04/xmlenc#tripledes-cbc”/>

The KeyInfo element declares the XML Signature namespace:

<ds:KeyInfo xmlns:ds=
“http://www.w3.org/2000/09/xmldsig#”>

Triple DES uses symmetric keys, and the KeyName element is used here to indicate that the key used is Jonathan Gold’s.

<ds:KeyName>Jonathan Gold</ds:KeyName>

Alternatively, you could use the AES algorithm to encrypt the data:

<EncryptedData Id=’ED’
xmlns=’http://www.w3.org/2001/04/xmlenc#’>
<EncryptionMethod Algorithm=
‘http://www.w3.org/2001/04/xmlenc#aes128-cbc’/>
<ds:KeyInfo xmlns:ds=
‘http://www.w3.org/2000/09/xmldsig#’>
<ds:RetrievalMethod URI=’#EK’
Type=”http://www.w3.org/2001/04/xmlenc#EncryptedKey”/>
<ds:KeyName>Antonia Suares</ds:KeyName>
</ds:KeyInfo>
<CipherData>
<CipherValue>A23B45C564587</CipherValue>
</CipherData>
</EncryptedData>

This time the value of the Algorithm attribute in the EncryptionMethod element is http://www.w3.org/2001/04/xmlenc#aes128-cbc, to indicate 128-bit AES. The RetrievalMethod element is used to identify KeyInfo information that is stored remotely.

The ‘HT’ part – hypertext
Hypertext – invented by Ted Nelson in the 1960s – is really a special type of database format in which individual documents can be linked to each other in any number of ways. The links between different documents are called hyperlinks – these are the embedded instructions within a document that link it to another document. On the Web, hyperlinks are typically indicated by blue text. When you click the blue text, you are brought to another related file or web page.

As its name implies, the World Wide Web is a single huge hypertext system in which an enormous amount of individual web pages are connected by an enormous number of hyperlinks. Of course, most web pages include other media elements besides text, such as graphics, animation, and audio, so the Web is more accurately described as a hypermedia system.

The ‘M’ – markup
Markup refers to the characters or symbols that you place within a document to determine how the document will look when printed or displayed. Markup indicators can also give a document its logical structure.

In HTML, these indicators are usually called tags, which are the characters or words enclosed in angle brackets that you can see in any HTML document if you open it in your browser and select View – Source (Internet Explorer) – or View – Page Source (Netscape Navigator).

Opening tags mark the start of the tagged part of the document affected by the tag and have a pair of angle brackets <>, whereas closing tags, which mark the end of the tagged section, have a forward slash within a pair of angle brackets </>. Characters inside the brackets determine what the tag actually does. So, for example, these are the opening <b> and closing </b> bold tags. If you surround some text in an HTML document with the <b> and </b> tags, the text inside the tags will be displayed as bold if the document is opened by an HTML interpreter, such as a web browser. Other common tags include the opening <body> and closing </body> tags for marking the body of a document, the opening <ul> and closing </ul> tags for bulleted lists, and the opening <tr> and closing </tr> table row tags.

You can also add hyperlinks to your document by using the opening <a href = “URL”> and closing </a> tags, where URL is the address of the web page or resource that will be opened or called when the user clicks the link. In essence, HTML is the set of markup indicators, or tags, that you can insert into a file so that it can be displayed as a web page.

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.