To find the form it is easiest for you to enter the homepage of the browser and look to put a link Add site, Add URL, new URL, or something. That link will take you to the registration form or, failing that, to the page that explains how you must register in that particular form.

Still, there are some basic registration procedures often repeated in the search engines:

For indexes

The search engines that have categories where we can find sites categorized by topic. It usually has to navigate to the category in which you want to include the web. There he seeks the “add page” (or something) and is the form for registration.

For search engines

They have robots that travels over the Internet constantly for new pages to be included in the search. These search engines often have a form accessible from the home page, with the appropriate link. Do not browse the categories to access the form.

Obvious in several search engines to register a task can be a bit expensive and the same heavy, then you have to go search to search again and again entering the same data. Fortunately there are tools multiregistro. These tools allow us to register our site on different search engines by entering the data once the page
web.

There are two types of tools multiregistro:

Windows applications, like any other program, but that his goal is to register in search engines. Such tools are being sold, or you can find shareware (in ww.tucows.com for example), but typically limited in their use.

Online tools, these enable us to from the Internet, and usually free, registered in various search engines. They are usually not as powerful as before, but more useful and accessible for being free.

Oh the hacks in CSS. I always say that not be implemented, but sometimes come so well that it is impossible to live without them. 

One that is very comfortable, and easy to remove then-is an underscore “_” followed by an attribute for the blessed Internet Explorer can interpret it and other browsers do not pass anything. A clear example that may prove to solve some problems is:

h2 (margin: 0 0 10px 0;
_margin: 0 0 20px 0;
)

This simply makes the element <h2> in Firefox, Opera and other browsers a bottom margin of 10px. In contrast, using a hack with the property _ on margin: causes Internet Explorer to ignore-the laws of weight margin: 0 0 10px 0; by the value 20px.
Well, this understanding can you go making a big idea of the amount of things you can fix and leave to the millimeter of perfect standards between browsers that understand the Internet Explorer. Now, as within a few months, but I say until the end of 2007 and, until 2009 when many users have Internet Explorer 7 installed, we have to try the beta crap they have now. To do this, we can not use more of the underscore hack, but use another, which also goes equally well for Internet Explorer 6:

h2 (margin: 0 0 10px 0; / * works in all * /
* margin 0 0 55px 0; / * works in both IE6 and 7 * /
_margin: 0 0 20px 0; / * works only in IE6, not IE7 * /
)

In advance they made it clear that this does not validate with the validation tool, but it brings me loose anyway. This does not affect the semantics of my documents but how it is displayed in a browser.

The first place is the very word “password”, since it is the more different people that use them. “123456″ or “qwerty” are other most used on the Web, although none of them meets the minimum safety requirements, as the mixture of letters and numbers, or use a larger number of characters.

It is noteworthy that the word “monkey” (monkey in Spanish) is in sixth place of the expressions used when blocking access to an account.

This is the full list:

1. passwod
2. 123456
3. qwerty
4. abc123
5. letmein
6. monkey
7. myspace1
8. password1
9. blink182
10. (user name)

CAUSE: Drivers incompatible or poorly made

EXPLANATION: This error indicates that a kernel-mode process or driver tried to access a memory address for which no permits. It usually occurs because the code is a pointer that refers to a portion of memory that does not correspond to the process. This causes a violation of the separation process in Windows and a stop to prevent overwriting data or code of another process.

ARTICLES
General Information on STOP 0×0000000A
Troubleshooting “Stop 0×0A” Messages in Windows
Troubleshooting a Stop 0×0000000A Error in Windows XP
STOP 0×0000000A Error Message When You Change from AC Power to DC Power
Windows XP Restarts When You Try to Shut Down Your Computer
STOP 0×0000000A Irql_Not_Less_or … During Windows XP Upgrade
0×0000000A Error Message When You Fast Switch Between Users
STOP 0×0000000A Windows XP restarts when you try to shut down your computer
STOP 0×0000000A Computer automatically restarts after you upgrade to Windows XP
STOP 0×0000001D or STOP 0×000000A Stop Error Occurs in Ndis.sys
STOP 0×0000000A How to Troubleshoot Hardware and Software Driver Problems in Windows XP
STOP 0×0000000A How to Debug a System After You Receive Stop Error IRQL_NOT_LESS_OR_EQUAL
STOP 0×0000000A Error Occurs After You Install an HP ScanJet 5100c or 5200c Scanner
STOP 0×0000000A Error Message Occurs When You Use Routing and Remote Access with NAT and VPN
Eject Request May Cause “Stop 0xA” Error Message
STOP 0×0000000A Error Message and Computer Stops Responding When You Use Dial-up RAS Connection
STOP 0×0000000A When You Dual Boot with Windows NT 4.0 on the Same Partition

STOP 0×0000001E (KMODE_EXCEPTION_NOT_HANDLED)

CAUSE: Drivers incompatible or poorly made, serious bugs software, hardware.

Explanation: The kernel exception handler found that a process has tried to execute an invalid instruction.

ARTICLES:
Possible Resolutions to STOP 0×0A, 0×01E, and 0×50 Errors
STOP 0×0000001E Error Message During Setup
STOP 0×0000001E Error Message During Windows XP Setup
STOP 0×0000001E Error Message in Ntoskrnl.exe
STOP 0×0000001E KMODE_EXCEPTION_NOT_HANDLED in Win2k.sys
STOP 0×0000001E Error Message from Aspi32.sys KMODE_EXCEPTION_NOT_HANDLED
STOP 0×0000001E Error Occurs in Win32k.sys in Windows 2000
STOP 0×0000001E Error Message in Win32k.sys in Windows XP
STOP 0×0000001E in Usbhub.sys with Surprise Removal of Plug and Play USB Hub
STOP 0×0000001E in Win32k.sys When You Quit a Program
STOP 0×0000001E in Win32k.sys When Using Animated Mouse Pointers
STOP 0×0000001E on Windows 2000 Server
STOP 0×0000001E Error Message After Changing Color Depth
STOP 0×0000001E Error Message Printing with HP DesignJet Printer Driver from a Terminal Services Client
STOP 0×0000001E Error Message When You Print from a Windows 2000 Terminal Services Client

STOP 0×00000024 (NTFS_FILE_SYSTEM)

Cause: Hard disk damaged cables in bad condition, damaged file system

EXPLANATION: Windows can not access the NTFS partition where their files

STOP 0×0000007E Error in Kbdclass.sys When You Try to Shut Down WinXP

ARTICLES:
STOP 0×00000024 in Ntfs.sys
Troubleshooting Stop 0×24 or NTFS_FILE_SYSTEM Error Messages
STOP 0×23 (or STOP 0×24) When restarting PC after installing PC-Magic Encrypted Magic Folders

STOP 0×00000050 (PAGE_FAULT_IN_NONPAGED_AREA)

CAUSE: incompatible drivers, incompatible software, faulty RAM, faulty board or card

EXPLANATION: A driver or program has requested a page from an invalid memory address.

ARTICLES:
Possible Resolutions to STOP 0×0A, 0×01E, and 0×50 Errors
Easy CD Creator 5.0 Does Not Function In Windows XP
STOP 0×00000050 Error starting Windows after connecting a scanner
You receive a STOP 0×00000050 Error When You Restart Microsoft Message Queuing
Damaged Font Causes STOP 0×00000050 Error Message in the Win32k.sys File in Windows 2000
Stop Error Occurs When You Start the Computer for the First Time
STOP 0×00000050 Error Message When You Are Using a CD-ROM
STOP 0×00000050 Error Message While Installing Windows NT 4.0
STOP 0×00000050 in Usbhub.sys with Surprise Removal of Plug and Play USB Hub
STOP 0×00000050 in Udfs.sys Viewing Files on DVD
Error Message STOP 0×00000050 Printing to Windows NT 4.0 Print Server
“Stop 0×1E” or “Stop 0×50″ with Terminal Services Client Print Session
STOP 0×00000050 Error Message in Win32k.sys
STOP 0×00000050 Error Message When USB Device Is Connected
STOP 0×00000050 Error Message When You Rename a Large Number of Files on Windows 2000
STOP 0×00000050 Error Message When You View Files on a DVD
Page_Fault_In_Non-PAGED_AREA STOP 0×00000050 Error After Installing Service Pack 1 (SP1)
STOP 0×00000050 Error starting Windows after connecting a scanner
STOP 0×00000050 (0xffffffe0, 0×00000001, 0xf30da010, 0×00000000) PAGE_FAULT_IN_NONPAGED_AREA

STOP 0×00000077 (KERNEL_STACK_INPAGE_ERROR)

CAUSE: Bad sectors on the swap file, IDE cables defective virus

EXPLANATION: One-page report requested by the kernel could not be read from the swap file to RAM.

ARTICLES:
Common Causes of STOP Messages 0×00000077 and 0×0000007A
Troubleshooting Stop 0×00000077 or KERNEL_STACK_INPAGE_ERROR

STOP 0×0000007B (INACCESSIBLE_BOOT_DEVICE)

CAUSE: New motherboard or controller, changing disk to another PC, virus

EXPLANATION: Windows can not find the partition where your files. It is a situation similar to the error 0×000000ED

ARTICLES:
After relocating boot disk
Troubleshooting STOP 0×0000007B or 0×4, 0,0,0 Error
STOP 0×0000007B Error After Moving Windows 2000 System Disk to Another System
STOP 0×0000007B Error After You Move the Windows XP System Disk to Another Computer
STOP 0×0000007B Error Message When You Start Your Computer
STOP 0×0000007B Error Message When You Restart Computer
STOP 0×0000007B Caused by Missing [SysprepMassStorage] Section on Windows XP sysprep Images
STOP 0×0000007B Error Occurs When You Press F6 to Load Drivers During Unattended Windows Setup
Troubleshooting STOP 0×0000007B Errors in Windows XP
STOP 0×0000007b Is Generated When You Boot to a Mirrored Dynamic Disk
STOP 0×0000007B Error Message Is Generated While Converting Basic Disk to Dynamic
Using Sysprep May Result in “Stop 0×7b (Inaccessible Boot Device)” on Some Computers
STOP 0×0000007B After you remove or reinstall Roxio Easy CD Creator 5
STOP 0×0000007B Can not Upgrade with the MSDN Version of Windows XP
Installing Windows 2000 from a USB CD-ROM Drive May Cause a “Stop 0×7B” Error
Windows Hangs at “Loading Machine Info” with HighPoint UltraDMA ATA/66 Controller
Error: “INACCESSIBLE_BOOT_DEVICE” after cloning to a different size drive
How to use Sysprep with Ghost

NOTE: Before you move a disk with Windows 2000 or XP to another PC, you have to load into the system a generic IDE driver:

Remove Atapi.sys, Intelide.sys, Pciide.sys, and the% SystemRoot% Pciidex.sys CacheI386Driver.cab Driver (or SPx.CAB) and copied to% SystemRoot% System32Drivers.
Download this file and double click on it to add it to record
The official Microsoft article is this

STOP 0×0000007E (SYSTEM_THREAD_EXCEPTION_NOT_HANDLED)

CAUSE: Drivers or incompatible software, BIOS incompatible, incompatible hardware

EXPLANATION: A system process has generated an exception that has not been processed by the exception handler.
If the error occurs when connecting a USB device, it is because the USB bus is being used at 100% already. Connect the device into another USB controller or other device to stop before connecting again.
If the error is in Kbdclass.sys, is caused by the utility Logitech iTouch. Download the latest version of http://www.logitech.com.

ARTICLES:
STOP 0×0000007E Error in Kbdclass.sys When You Try to Shut Down WinXP
STOP 0×0000007E Error Message After You Upgrade to Windows XP
STOP 0×0000007E Error When Registering Olemsg32.dll or Cdo.dll Files
STOP 0×0000007E Occurs in Usbhub.sys If USB Bandwidth Consumption Exceeds 100 Percent
STOP 0×0000007E “Error Message When You Install Windows XP Disk Image from a Remote Installation Services Server

STOP 0×0000007F (UNEXPECTED_KERNEL_MODE_TRAP)

CAUSE: Faulty hardware, usually RAM or motherboard, incompatible software

Explanation: A process or a kernel driver has been found that there is enough space on the stack for the transaction that was intended.
One of the most common causes is Norton Antivirus (Symantec official details here)

ARTICLES:
General Causes of STOP 0×0000007F Errors
STOP 0×0000007F Errors - General Causes
STOP 0×0000007F Error Message or Your Computer Unexpectedly Restarts
STOP 0×0000007F Windows Stops Responding With STOP Error 0×7F
STOP 0×0000007F Computer Turns Off During Text-Mode Setup if it is too hot
STOP 0×0000007F During Setup on Hewlet Packard Pavilion 7840
STOP 0×0000007F on Windows 2000 with InoculateIT Enterprise Edition Installed
STOP 0×0000007F on Windows 2000 Using Veritas Netbackup with Open File Manager Software
Terminal Server Unexpectedly Restarts or You Receive Stop Error 0×0000007F
STOP 0×0000007F Error Message May Be Displayed When the WQuinn QuotaAdvisor 4.1 Program Is Installed

ices Server

STOP 0×0000008E (KERNEL_MODE_EXCEPTION_NOT_HANDLED)

CAUSE: Hardware, drivers or incompatible BIOS. Most often bad RAM or nvidia drivers.

EXPLANATION: A kernel process has been an exception is not processed by the exception handler. It is similar to the error 0×0000007F.

ARTICLES:
STOP 0×0000008E Error Message During Windows XP Setup
STOP 0×0000008E Error Message Occurs in Wdmaud.sys
STOP 0×0000008E Error Message Occurs When You Change the Hardware Acceleration Setting
STOP 0×0000008E Error Message on Blue Screen and Your Computer Does Not Enter Hibernation or Standby After You Remove an IEEE 1394 Storage Device
STOP 0×0000008E “Failed To Install Product Catalog” Error Message When You Install Windows XP

STOP 0×0000009F (DRIVER_POWER_STATE_FAILURE)

CAUSE: Driver does not work correctly with energy saving features

ARTICLES:
Troubleshooting STOP 0×0000009F Error Messages in Windows 2000
Troubleshooting a STOP 0×0000009F Error in Windows XP
STOP 0×0000009F in Ntoskrnl.exe When Shutting Down or Restarting Computer
STOP 0×0000009F Computer hangs at shutdown or “Can not find enough resources”
Cluster Server May Generate STOP 0×0000009F During Shutdown

STOP 0×000000C2 (BAD_POOL_CALLER)

CAUSE: Driver or wrong software

ARTICLES:
How to Debug or Stop 0×000000C2 Error Messages
How to Debug Stop 0×000000C2 Error Messages in Windows XP
STOP 0×000000C2 Computer with ATI FURY MAXX hangs after upgrade to Windows XP
STOP 0×000000C2 After you install IomegaWare
STOP 0×000000C2 BAD_POOL_CALLER When you upgrade from Windows 2000
“Stop 0xC2 BAD_POOL_CALLER” Error Message on Print Server
A “Stop 0×000000C2″ Error Occurs When You Try to Close a File on a Network Share

STOP 0×000000D1 (DRIVER_IRQL_NOT_LESS_OR_EQUAL)

CAUSE: Driver badly done

Explanation: The cause is the same as the 0×0000000A error, but this time is known to be a safe driver.

ARTICLES:
STOP 0×000000D1 Error Message in Tcpip.sys
STOP 0×000000D1 Error Message When You Turn Your Computer Off
STOP 0×000000D1 Error Message When You Start Windows XP
STOP 0×000000D1 Second Mylex AcceleRAID SCSI Controller Causes Error Message
STOP 0×000000D1 WRQ AtGuard Program causes error message in Windows XP
Kbdclass.sys STOP 0×000000D1 Error Message When You Try to Shut Down the Computer
STOP 0×000000D1 Error Message With RAM Problems or Damaged Virtual Memory Manager
STOP 0×000000D1 Error in Atmlane.sys
Error Message Reports STOP 0×000000D1 in Serial.sys When Serial Device or Driver Verifier Is in Use
STOP 0×000000D1 Computer Restarts After You Quickly Insert and Remove a PC Card

STOP 0×000000EA (THREAD_STUCK_IN_DEVICE_DRIVER)

CAUSE: Driver, typically the graphics card, not cool

Explanation: The driver has entered an endless cycle, repeating the same instructions again and again.

ARTICLES:
STOP 0×000000EA ErrMsg Running Video-Intensive Programs
STOP 0×000000EA THREAD_STUCK_IN_DEVICE_DRIVER

STOP 0×000000ED (UNMOUNTABLE_BOOT_VOLUME)

CAUSE: New motherboard or controller, IDE cables defective or inadequate, changes in the connection of the disks

EXPLANATION: Windows can not access the partition where your files

ARTICLES:
STOP 0×000000ED Error Message When Volume on IDE Drive with Caching Enabled Is Mounted
STOP 0×000000ED Error Message When You Restart Your Computer or Upgrade to Windows XP

STOP 0xC0000005

“Unhandled Exception c0000005″ Error Message During Windows Startup
Printing Reports PRB-Causes Exception Error C0000005
FIX-C0000005 Error With CLOSE ALL in Project Hook BeforeBuild
FIX-C0000005 Fatal Error With TRANSFORM () on Long Strings
FIX-C0000005 Error With SQL SELECTs Repeated Using BETWEEN (á)
FIX-C0000005 Fatal Error Using DIRECTORY (”— dirname “)
FIX-C0000005 Fatal Error With MODIFY WINDOW SCREEN in EXE
FIX-C0000005 Fatal Error With Invalid Property Name
FIX-C0000005 Fatal Error with Unknown Var in Include File
FIX-C0000005 Fatal Error After Saving FormSet Add Cancel in DE

STOP 0xC0000218 (UNKNOWN_HARD_ERROR)

CAUSE: Files corrupted or deleted registry, faulty RAM

EXPLANATION: Windows can not load the registry files are missing or damaged because

ARTICLES:
0xC0000218 - UNKNOWN_HARD_ERROR
How to Recover from a Corrupted Registry that Prevents Windows XP from Starting
How to Troubleshoot a Stop 0xC0000218 Error

STOP 0xC000021A (STATUS_SYSTEM_PROCESS_TERMINATED)

CAUSE: Software or incompatible drivers

Explanation: A user-mode subsystem (WinLogon or CSRSS for example) has had a serious error.

ARTICLES:
How to Troubleshoot a Stop 0xC000021A
STOP 0xC000021A Computer Hangs When you log on to a Terminal Services session
0xC000021A STOP Error Message Occurs If You Download a RIPrep Image
STOP 0xC000021A Caused by GoBack
STOP 0xC000021A in Winlogon Caused by PCAnywhere
STOP 0xC000021A Installing Internet Information Services Can Cause Problems in Windows XP

STOP 0xC0000221 (STATUS_IMAGE_CHECKSUM_MISMATCH)

CAUSES: Files modified version in disk access, faulty RAM

EXPLANATION: To verify that the files that load when Windows starts have not been modified, a checksum is calculated at the time of loading and compared with stored there. If they do not, it generates this error.

Today, digital media are susceptible to substitution, modification, and replication, unless they are explicitly protected in order that they can rely on these communications.

We define a secure system as one in which the cost of breaking into the system is greater than the value of the information contained in it, both in money and personal risk.

Aspects to ensure the documents:

1. Identity / Blame, that the parties involved are who they seem, that is, who signs the document, who signs it.

2. Confidentiality, the document is only available to the parties involved, ie for verifiers.

3. Integrity, or handling of documents: the documents are received as they were created by the author.

4. No Repudiation. Proof of the issuance of the document, which the author can not deny having signed the document.

5. The Date and Time Certain of the Firm “Secure Time Stamp” which has been generated, and has received the document. 6. Access self-service and information.

Architecture PKI or Public Key Infrastructure:

The PKI architecture is reflected in the “Internet Certificate and CRL Profile RFC 3280, specified by the Internet Engineering Task Force, whose website is located at the URL www.ietf.org.
1) The Public Key Infrastructure or PKI:

It is the integration of:

a) The public key cryptography or asymmetric, used for digital signatures,

b) The symmetric key cryptography used to encrypt,

c) The Message Digest or Hash, and

d) The Management of pairs of public / private key (no commitment of the private key

through a process of secure distribution of keys.)

The Public Key Cryptography or asymmetric: It aims to distribute symmetric keys securely. It is based on the use of a pair of keys, one public and one private, for each entity. The Private Key must remain secret and under the control of the user. Use it to encrypt - decrypt is demonstrating that you possess, and thus is guaranteed the authenticity and confidentiality, ed identity. The public key can and should be freely distributed as widely. Those keys that are characterized by:
are different,
are mathematically related,
can not get private key from the public. Each unique key can decrypt what the other has been encrypted, therefore, a.-with the public key of the subscriber, whosoever can encrypt a message, which can only be decrypted by the subscriber’s private key, the confidentiality is achieved.

b.-the subscriber’s public key, anyone can decrypt a message, to verify the identity of the document that was encrypted by the subscriber using his private key.

Its implications are as follows: a. “The subscriber can establish the integrity and origin (author) of information (data) sent to another participant, such information digitally signed, encrypted with your private key.

b. “He who receives the information can use the subscriber’s associated public key to validate that comes from the subscriber (private key holder) and verifying the integrity of information.

Symmetric Key Cryptography and Secret:

It is based on the use of a single key between the parties involved, subscriber and verifier.

The encryption process uses a symmetric key algorithm, the key, the message and the message digest and is very complicated to use software to get the reverse route.

Algorithms: Algorithm DSA Digital Signing of irreversible type, supported by Java, or RSA Rivest Shamir Adleman, reversible type, which is already prepared to use digital signatures and encryption.
The Message Digest Value:

The “Message Digest” or “Hash” is a short version and fixed length of a message, you can not recover from the Message Digest. It is completely different if you change a single bit of the original message.

The subscriber gets it apartir of, message digest algorithms like SHA-1, Ripe_MD, or digital signature algorithms include as DSA or RSA, plus the original message, and the subscriber’s private key.

And deciphering the verifier obtains the digital signature received from the subscriber using the subscriber’s public key and digital signature algorithm.

Results in a value or Message Digest Value.

The aim is that the verifier to ensure the integrity of transmitted data, which is done by comparing the value of the message digest decrypted by the verifier using its private key, and it has received, decoded by the subscriber’s public key. If they are equal, confirming the integrity of the message.

3) The PKIX Model:

The PKIX model is the model of the entities that manage public key infrastructure, designating their functions and protocols.

Entities 1 Finals (sought to be identified)
The subject of a certificate, your identity is guaranteed by a certifying authority.

These may be end users, the authority to register a certification authority in the name of who acts, or even a certification authority when it is certified by another certification authority.

2nd Certification Authorities (CA)
Represent the source of credibility for the public key infrastructure.

Who issued the certificates, digitally signed with your private key.

Certify that the public key in a certificate assigned to an end entity, that entity actually corresponds to the end. See: “CA Trust.pdf” in www.pkiforum.org.

Verisign is the best known representative.

3rd Registration Authority or Registration Authority (RA)
Make the process of registration of end entities commissioned by the certifying authority.

Validates the attributes of individual requesting the certificate,

Check that the subject possesses the private key to record,

Build shared secrets that enable the initialization process and certification.

Generate the key pair public / private partnership, see ANSI X.9 standards.

Validates the parameters of public keys presented for registration.

4th Repositories or Repositories ”

Method to store information on PKI, as may be certificates and CRLs for access by end entities or their delegates. Their objective is to obtain the final authority on the confirmation:
revocation status of certificates of other users, and

validation of the “Certification Path”, or certificate chain.

5th CRL Issuers or “Certificate Revocation List Issuers”

Issuers of Certificate Revocation Lists are acting on behalf of the Certification Authority, being optional but highly desirable character. These are lists of certificates that are no longer valid and therefore that can not be trusted. Certificates are revoked in cases in which:

a) the private key is compromised, b) have changed the attributes of the certificate.

Certification procedure:

1 Request to the Certifying Authority a certificate by the end entity, through the Registration Authority in order that the Certification Authority guarantees the identity of the final.

2 The Certification Authority verifies that each user is who claims to be and that the public key to enter on the certificate really belongs.

3 The end entity certificate is digitally signed, encrypted with the private key of the Certification Authority.

4th turn, the certification authority is certified by other / s Authors Certification.

5 º The certificate is distributed globally, ie the largest number of potential recipients.

Digital Certificates

These are documents that confirm the identity of a person or entity, linked with a public key associated with the private key. Concerns are twofold:

1 - That the subscriber’s public key can be accessed by verifiers or participants interested in validating and verifying the digital signature of the subscriber.

2-that participants can have confidence that the public key received by the verifier is actually the subscriber.

Contents of Certificate

These are the main fields including as content
Unique identifier or serial No. of the certificate. International, and developed

The digital signature algorithm employed. by “Internet Engineering Task

Data from the Certification Authority: Unique ID for the Force.

certificate issuer.
Dates of issue and expiry of the public and private key.

Public key of the certificate holder.

Uses of Certificate

1. Personal:

a) Full name or pseudonym. Digital Certificates

b) Telephone No. (s).

c) physical address and e-mail.

d) identity card.

e) Occupation and qualifications.

f) Cargo and business.

g) Group (s) of affiliation.

2. Professionals:

a) For legal persons of the above plus: b) Name of the legal person. c) Power of attorney of the certificate holder.

Concept of “Chain Certification”

A Certification Authority may in turn be certified by other / s, Certification Authorities, with its digital signature, up to the Root Certification Authority, which forms the “certificate chain” or “Certification Path” of any certificate until his “Anchorage Truth” or “Trust Anchor”, which ends in the Root Certificate Authority Root Certificate. The root certificate is a certificate signed himself, and issued by the Root Certification Authority.

Therefore end entities must validate the certificate chain to verify that digital certificates really certify that the public key is who they say they are starting to validate it by the “Trust Anchors.

Types of Digital Certificate
Class 1 Certificates:

They are issued only to individuals. It verifies the identity of these and therefore can not authenticate. They confirm that the name or pseudonym and certificate subject form an unambiguous subject name.
Class 2 Certificates:

They are issued only to individuals, and confirm that the information provided by the Subscriber does not conflict with information from reliable databases owned by a U.S. (Broadcast Entity) or ERL (Local Registration Authority), including the identity the subject and other data from the Subscriber.

a) Class 2 Certificates are not recognized (Class 2 type 1), used for low-risk transactions as subscription services of the Information Society.

b) Class 2 Certificates recognized (Class 2 type 2), can be used as stand legally recognized electronic signatures, obtain reasonable assurance of the identity of the Subscriber, automatically comparing the applicant’s name, address and other personal information contained in the license application with the information contained in databases owned by the EE or ERL.
Class 3 Certificates are issued to:
Individual s: requires the submission of evidence substantiating the identity of the subject’s identity, people at a Local Registration Authority (ERL) or its delegate, such as a notary public.

O rganization s: are issued to individuals with signature capabilities within an organization, tested the capacity of attorney signed by evidence, and the organization through business organizations confirm their identity.

3 .- The certification policies and practices, CPS and CP.

Certification Practice Statement (CPS)
Describe the practices employed in issuing and managing certificates. It governs the management of public key infrastructure, and could also include a description of the services offered, and details of procedures for managing the certificate life cycle, operational information, etc..

The Certification Practice Statement provides a legal framework that describes the obligations and responsibility assumed margins of the Certification Authority and their rights with the holders of certificates issued by it.

Certification Policy (CP)
It consists of a set of rules that indicate the applicability of a certificate to a particular community and / or class of applications with common security requirements.

Generally looks at the requirements of high-level policy.

An old story.
Although the rise of recent usability is mainly due to the dissemination of the work of the “Guru” Nielsen, which includes as one of the fundamental principles minimalist design, the fact is that this discipline has long existed, although other garments. We refer to Science
of Man-Computer Interaction (Human Computer Interaction “).

Already at the beginning of the dissemination of the first microcomputer there was an interest in studying how people behave with automatic devices for information. Since conducting controlled research is expensive and requires time, was confined to academia and the aerospace research. But today is available a body of results that can benefit the design of our websites and interactive applications.

This body of principles continues to increase as further research and continue to generate new results. We can not expect the design guidelines and the guidelines we solve all problems.

But let us now see how we can use the results of HCI in a seemingly mundane task such as Web design. We summarize the main results of research in a number of tips that should be taken into account.

Pages packed. ..

How many times have you wasted time searching for important information between all text and graphics of a page?. Without taking into account the mental effort involved and the possibility to make a mistake and overlook our goal.

The paracer designers suffer from a “horror vacui” which requires them to fill every possible gap, perhaps because they think their presence is a sign of lack of preparation. But they have to take into account that a user will not only visit your website, but if he drops by, we must facilitate the task and to decide quickly if we have something that interests you and be clear what it is. In addition, the page load “heavy”, especially if you have pictures, is a drag on the positive perception that could have visitors.

In several studies, some NASA has calculated that the optimal percentage of active screen should not exceed 20 to 60%. Of course, these results were obtained with no possibility of static screens scroll.

If tactical information displays show only the information strictly necessary to carry out the task and the simplest way possible, why do not we the same?.

In summary, you should use the smallest possible number of items per screen. If there are items you will not need all the world is better not to present them and give them only on demand.

These recommendations become paramount as we move to an environment where resources are more limited display, such as WAP or PDA.

Simple is hard to create.

Well, I am convinced that each screen should not be too loaded, but how do I get it, especially if I have much information to teach?. The answer is, eliminating redundancies and combining information. It is present near the most similar, which also guarantees its rapid localization, since the page will have a pleasant and effective visual structure.

To do this we must solve the following issues:

Number of groups and groupings:
This is a conceptual architectural problem. It’s about finding the best categorization that enables effective representation. To do so each group must be significant, and the number of groups and elements of each group must be appropriate, neither too small nor too much.

Format:
How will differentiate the groups of information among themselves?. “Separated by white space?, How edges?, How colors?, How a combination of the above?. There are both factors that can interact that might be better to make several proposals and select the best results provided for the task, but in general the physical clustering usually provides the best results.

But designing a website just from our visual training as a graphic piece more or as a more corporate image would be a wrong path.

A site that meets the objectives of our client’s visual communication can be very poor at other factors like ease of use, ease of finding information, download speed, legibility or accessibility. And how good we like our design to us or our client, these factors eventually a decisive influence on the end-users will have.

In other words, if users seeking information not found or become frustrated when trying to perform the tasks for which they entered the site, evidently of little use our efforts to improve visual quality. Users will quickly abandon or elsewhere. With a single click will suffice.

It is here where we encounter the concept of usability.

A definition of usability

The usability of a product or system is an empirical measure and on its usefulness, ease of learning, performance and appreciation of its users.

This definition is applicable to all types of products and systems, not only to websites or software products. For example could measure the usability of a system of urban signage, a tube of toothpaste or the telephone.

Usability can not be determined by evaluating a product in isolation. It is determined for a particular set of users in a given context of use. That’s why we say it is a relative measure. and that is why we do not believe that there are absolute rules of usability and equally applicable in all situations.

Design Usability seen

Some usability experts often describe the graphic design applied to the web as a kind of decorative layer (the “Look and Feel”) to be added to the prototypes once passed user tests.

On these positions must be said that research to users is not the same as design. The research and usability tests give us information on problems identified and we can draw a few lines of action to resolve them but not enough to conceive the final design with all its elements.

At the other extreme, many of the sites we design are not evaluated on their usability, is at the hands of our own inexperience, lack of resources, or perhaps because of the absence of a more comprehensive and multidisciplinary projects to address.

In the commercial websites users can disregard for economic losses. But this may be more severe on the websites of state agencies or essential public services should not only aim for higher goals and usability for a wider audience, but also begin to comply with the accessibility specifications. By not doing so, they are excluding a very high percentage of the population from access to information and the ability to manage transactions across the network.

One solution: the user-centered design

The methods of user-centered design allow us to achieve usability goals much higher than we could achieve using only intuition, recipes or calculating what we assume that users will do with the site (or product).

Many of the techniques are based on involving users in all stages of design. It is not designed for the users but the design with users.

But this is not so simple. For example do a usability test requires knowledge, time, dedication and experience. In addition, we must get to the right users and allocate some budget to pay them.

The test basically provide a list of tasks to users and watch them or film them trying to complete each task without our help. It’s incredibly rewarding to watch the users frustrated again and again with our design. No interaction design conceived only from our intuition or experience will be infallible. That’s why it is advisable to begin testing with low-fidelity prototypes (even paper), in the early stages of the design process.

The organizational structure and labeling of a site also should be designed from the mental model of users. For example, the technique of sorting cards (card sorting) allows us to determine how users classified, grouped and labeling information to include.

The design and usability need to be supplemented

Design as a discipline can provide knowledge and enriching experiences for usability and accessibility. For example in areas such as typography, readability, emphasis, style, color theory, space, composition and visual balance.

Usability and Information Architecture design methods provide user-centered, assessment techniques, the heuristic principles, 40 years of studies on Human Computer Interaction (HCI), all previous experiences from the web interface design Graphical User (GUI) and the contribution of science as archival and library for organizing and labeling information shared spaces.

The design and usability can and should be supplemented as disciplines. The benefits can be clearly seen from both sides. A good visual design does not exclude the usability but the favors, the same way that a high degree of usability and user compliance contribute to improving the image of any company or institution.

We have all heard of TFT, LCD, Plasma and OLED, and even combinations of them, as TFT LCD, and many more without knowing they differ from each other. With this guide aims to explain the advantages and disadvantages of these technologies and to clarify concepts.

TFT: First we should clarify that it is not a TFT display technology itself, but it is simply a special type of transistor that achieved with improved image quality. Its use is more common with LCD screens, as explained below.

LCD and TFT LCD: LCD technology uses liquid crystal molecules are placed between different layers that polarize and rotate as you want to display one color or another. Its main advantage, besides its small size, is the energy savings. When these transistors TFT screens use then we are talking of TFT LCDs, which are the models more common today.

PLASMA: Unlike LCDs, plasma displays use phosphors with rare gases excited to display pixels and give them color. Although invented in 1964 but the technology is lagging in terms of level of implementation of the 3 we have mentioned, because its price is higher (although increasingly the difference is less) and yet their quality is much best. Specifically provides greater viewing angle than a LCD screen, better contrast and more realism from the colors displayed.

OLED: Finally, this technology also has a few years and that’ll also slowly but constantly seeing. This is a variant of the classic LED, but where the emission layer has an organic component. Surely you’ve heard that OLED displays have the advantage of requiring no backlight, thus saving much more energy than any alternative. Moreover, its cost is also lower. However, its usage time is not as good as the older technologies they have discussed.

1 .- Paypal:
Paypal is an American company of the eBay group present in 55 countries, this is definitely the cheapest if not free.
Cobra 2.9% for every sale made more than USD $ 0.35 cents, that is if you’re selling a product worth $ 50 was deducted $ 1.80 per transaction.
Count Sets in minutes and is one of the most important companies.

In my personal opinion paypal is the most trusted and secure, you can register .

2 .- 2checkout:
2checkout can sell products with tangible and intangible, although his website is in English You can set a page in Spanish collection.
The setup cost is $ 49.00 dollars, after your account is generating the source code and puts it on their site ventas.Cuando the client terminates the purchase is redirected to a thank you page you can set.

Cobra 5.5% commission plus USD $ 0.45 for each sale made, namely whether it is a product of $ 50 was deducted $ 3.2 per transaction.

3 .- ClickBank:
It is another U.S. company with millions of users worldwide. Only allows you to sell digital products like software, e-boks, etc. and the great advantage is that it allows creating and managing your affiliate program, the cost to purchase one pair this service is $ 49.95.
The commissions for each sale are discounted at 7.5% plus $ 1 dollar, that is if you have a product of $ 50 will be taken out $ 4.75 per transaction.

As you can see cheaper payment system is paypal and also the most used worldwide.

We begin with a brief recap on the basics of servlet development, then we show how to build a Web application to contain them. Explain the use of Web Application Archives (WARs), and then see how to deploy a web application environments listed above.
Developing Servlets

Servlets were designed to allow the extension of a server providing any service. However, currently only supports HTTP and JSP pages. In the future, a developer could extend an FTP or SMTP server using servlets.
Generic Servlets

A servlet extends the functionality of a server providing a specific service within a well defined framework. It is a small piece of Java code - usually a single class - that provide a specific service. For example, an HTTP servlet could provide to a client of a bank the details of their deposits and withdrawals recently. Another HTTP servlet could allow a client to see, and even edit your email.

To deploy a servlet usually requires the configuration of an application server. When the server encounters a particular type of application, it invokes the servlet, passing the details on the application and a response object to return the result.

All servlets implement the interface as javax.servlet.Servlet either directly - in the case of generic servlets - or indirectly, in the case of HTTP servlets or JSP. Javax.servlet.Servlet The interface includes the following important methods:

* Init ():
Define any initialization code that should run when the servlet is loaded into memory.
* Service ():
The main method called when the servlet receives a service request. Define a set of processing logic provided by the servlet.
* Destroy ():
Define any required cleanup code before removing the servlet from memory.

When the servlet container first loads a servlet invokes the init () method to initialize the servlet. Then as applications are made to run the servlet, the servlet container repeatedly calls the service () method of the servlet. Finally, when the servlet container does not need the servlet calls the destroy () method of the servlet and download it from memory. Notes that over the lifetime of a simple servlet example, the methods init () and destroy () are invoked only once, while the service () method will be invoked many times - one every time you make a request to run the servlet.
HTTP Servlets

HTTP servlets extend the javax.servlet.http.HttpServlet class. This class extends the class javax.servlet.GenericServlet, which in turn implements javax.servlet.Servlet. The HttpServlet class overrides the service () method so that it can handle different types of HTTP requests: DELETE, GET, OPTIONS, POST, PUT, and TRACE. For each of these types of requests, the HttpServlet class provides the methods used doXXX ().

Although we can override the service () method in our servlet class, there is rarely any need to. More often want to overwrite methods doXXX () individuals. If you override the service () method, we must be careful that the methods doXXX () by default only be called if super.service call or invoke directly.

For most applications will want to overwrite methods doPost () and doGet (), since they normally handle data sent by a user form from an HTML FORM.

To summarize, when we write our HTTP servlets, we should:

1. Import least servlet classes:
* Javax.servlet.ServletException
* Javax.servlet.http.HttpServlet
* Javax.servlet.http.HttpServletRequest
* Javax.servlet.http.HttpServletResponse
2. Make the class public
3. Make the class extend HttpServlet
4. DoXXX methods overwrite () appropriate to implement our logical request / response ..

A Servlet Example: RequestDetails

In the example below we have illustrated a simple HTTP servlet. The first line simply defines what belongs to the servlet package. The next block of code imports the classes used in this servlet. Then comes the servlet class definition. As you can see, the class extends HttpServlet RequestDetails.

The body of RequestDetails defines two methods: doGet () and doPost (). The method doGet () defines the core functionality of this servlet. The method doPost () simply calls doGet (). Therefore, the servlet handles GET and POST requests in the same way.

The method doGet () constructs an HTML page that contains details of the HTTP request sent to the server. Look at the two first lines of the method. The first line selects the content type of the response. In general, we will build an HTML page, in which case the content type should be configured as text / html. The second line of the method doGet () gets a reference to an output stream PrintWriter. All output to return to the client is written to this output stream:

org.stevengould.javaworld package;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/ **
* This class provides a simple example of a servlet, and
* Illustrates some of the information available from an
* HTTP request.
* /
public class extends HttpServlet (RequestDetails
/ **
* Handler for all GET requests. We simply dump out the
* RequestHeader information, followed by the body of
* The request.
* @ Param request the HTTP request submitted to the
* Server for processing. It is this object that
* Contains the details of the requested URL, and
* It is the details of this object that we
* Output as a response.
* @ Param response the response object to be used to
* Send the result back to the client.
* @ Exception IOException thrown if a communications
* Error occurs.
* @ exception ServletException if the GET request could
* Could not be handled
* /
public void doGet (HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException (
response.setContentType ( “text / html”);
PrintWriter out = response.getWriter ();
out.println ( “<html>”);
out.println ( “<head>”);
out.println ( “Request Details <title> Example </ title>”);
out.println ( “</ head>”);
out.println ( “<body>”);

out.println ( “<h3> HTTP Request Header </ h3>”);
out.println ( “<table border=’1′>”);
out.println ( “<tr bgcolor=#e0e0e0>”);
out.println ( “<td> <strong> Name </ strong> </ td>”);
out.println ( “<td> <strong> Value </ strong> </ td>”);
out.println ( “</ tr>”);
Enumeration e = request.getHeaderNames ();
while (e.hasMoreElements ()) (
String name = (String) e.nextElement ();
String value = request.getHeader (name);
out.println ( “<tr>”);
out.println ( “<td bgcolor=#e0e0e0>” + name + “</ td>”);
out.println ( “<td>” + value + “</ td>”);
out.println ( “</ tr>”);
)
out.println ( “</ table>”);

out.println ( “<h3> HTTP Request Information </ h3>”);
out.println ( “<table border=’1′>”);
out.println ( “<tr bgcolor=#e0e0e0>”);
out.println ( “<td> <strong> Name </ strong> </ td>”);
out.println ( “<td> <strong> Value </ strong> </ td>”);
out.println ( “</ tr>”);
out.println ( “<tr>”);
out.println ( “<td bgcolor=#e0e0e0> Method: </ td>”);
out.println ( “<td>” + request.getMethod ()+”</ td> “);
out.println ( “</ tr>”);
out.println ( “<tr>”);
out.println ( “<td bgcolor=#e0e0e0> Request URI: </ td>”);
out.println ( “<td>” + request.getRequestURI ()+”</ td> “);
out.println ( “</ tr>”);
out.println ( “<tr>”);
out.println ( “<td bgcolor=#e0e0e0> Protocol: </ td>”);
out.println ( “<td>” + request.getProtocol ()+”</ td> “);
out.println ( “</ tr>”);
out.println ( “<tr>”);
out.println ( “<td bgcolor=#e0e0e0> PathInfo: </ td>”);
out.println ( “<td>” + request.getPathInfo ()+”</ td> “);
out.println ( “</ tr>”);
out.println ( “<tr>”);
out.println ( “<td bgcolor=#e0e0e0> Remote Address: </ td>”);
out.println ( “<td>” + request.getRemoteAddr ()+”</ td> “);
out.println ( “</ tr>”);
out.println ( “</ table>”);

out.println ( “<hr>”);
Date date = new Date ();
out.println ( “align=center> Page generated on” + date);

out.println ( “</ body>”);
out.println ( “</ html>”);

out.close ();
)

/ **
* For POST requests, we will simply perform the same
* operations as for GET requests. The best way to do this
* Is to simply invoke the doGet () method with the appropriate
* Parameters.
* @ Param request the HTTP request submitted to the server
* For processing. It is this object that contains
* The details of the requested URL, and it is the
* Details of this object that we output as a
* Response.
* @ Param response the response object to be used to send a
* Result back to the client.
* /
public void doPost (HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException (
doGet (request, response);
)
)

Compiling the Servlet

As servlets use Java extension classes (classes that are not part of the main JDK) make sure you correctly select the CLASSPATH before attempting to compile any servlet. The Java compiler needs to find the javax.servlet .* classes and packages (found in the file j2ee.jar in J2EESDK 1.4). Apart from this, the compilation is done with another program like Java:

javac RequestDetails.java

Create a Web Application

Now that we’ve created the servlet, we need to think about deploying it. The Java Servlet 2.2 specification introduced at least two important characteristics: a Web application and Web application archive (WAR). according to the Servlet specification 2.2:
Note:
A Web application is a collection of servlets, HTML pages, classes and other resources that can be packaged and run on several different containers venderores.

The WARs are just Java files in a Web application with a different extension to distinguish them from the commonly used JARs.

Prior to the Servlet 2.2 specification, was quite different between different servlet containers deploy servlets - formerly also called servlet engines. The 2.2 specification standardized the deployment between containers, bringing Java code portability one step further. We will see the power of this later in this article when illustrates creating a simple Web application that is deployed on Apache Tomcat as well in WebLogic Server without modification or recompilation.
Directory Structure Web Application

The Servlet 2.2 specification defines the directory structure for files of a Web application. The top directory - or root directory - should have the name of the application and define the document root for our Web application. All files under this root can be served to the customer except those files that are under the special directory META-INF and WEB-INF in the root directory. All private files - such as the servlet class files - should be stored under the WEB-INF.

The following figure shows the directory structure of a Web application:

To create a Web application, start by creating this directory structure. Take your class file compiled and Situala servlet in WEB-INF/classes directory. If we define our servlet is part of a package, we must follow Java standard rules and create the appropriate subdirectories for the JVM can find our classes. For example, if your servlet is defined in a package com.mycompany.myproject, we should create the following directory structure:

… / WEB-INF
| –
classes
| –
com
| –
mycompany
| –
myproject

Place your Java classes in the subdirectory myproject.

A useful alternative to copy the class files to the appropriate directory is configure our build environment (a Makefile or IDE) to save the compiled classes directly in the required directories. Doing this will save this step during development.
Modifying the Deployment Descriptor

Now all our files should be in place to create our first Web application. At this point, we need to perform another task: Update the deployment descriptor to register with our servlet container. To easily create a deployment descriptor, simply edit an existing one. Below we have a skeleton of a web.xml file:

xml version = “1.0″ encoding = “ISO-8859-1″?

DOCTYPE web-app PUBLIC
“- / / Sun Microsystems, Inc. / / DTD Web Application 2.2 / / EN”
“http://java.sun.com/j2ee/dtds/web-app_2_2.dtd”>

<web-app>

<! - Your definitions go here ->

</ web-app>

We insert our servlet deployment descriptors from the labels <web-app> and </ web-app> on this file. The deployment descriptor of a servlet must include the following tags (in this order):

<servlet>

<servlet-name> name </ servlet-name>

<servlet-class> package.nombre.MiClass </ servlet-class>

</ servlet>

They are also allowed before the closing </ servlet> several optional tags, which define the properties of execution of the servlet,. These tags define properties as parameters inicilización whether or not the servlet should be loaded in the Arran roles below, and display properties (including large and small icons, screen name and a description).

Until now, our deployment descriptor described the servlet to the servlet container. Then we describe when the servlet container must invoke the servlet - we refer to as mapping. In other words, we describe how a URL is mapped to the servlet. In the web.xml file, the URLs are mapped like this:

<servlet-mapping>

<servlet-name> name </ servlet-name>

<url-pattern> pattern </ url-pattern>

</ servlet-mapping>

OK, enough theory. An example of a deployment Descritor a real application. Below we see the minimal web.xml file that describes our sample servlet RequestDetails:

xml version = “1.0″ encoding = “ISO-8859-1″?

DOCTYPE web-app PUBLIC
“- / / Sun Microsystems, Inc. / / DTD Web Application 2.2 / / EN”
“http://java.sun.com/j2ee/dtds/web-app_2_2.dtd”>

<web-app>

<servlet>
<servlet-name> RequestDetails </ servlet-name>
<servlet-class> org.stevengould.javaworld.RequestDetails </ servlet-class>
</ servlet>

<servlet-mapping>
<servlet-name> RequestDetails </ servlet-name>
<url-pattern> SampleServlet </ url-pattern>
</ servlet-mapping>

</ web-app>

As you can see on the label mapping, we selected the URL / servlet SampleServlet to map our RequestDetails.

That’s it! We created our first web application that contains a single servlet. Now we should be able to deploy this application on any servlet container compatible with the specification 2.2.

This lets us know how to work with and deploying our web applications as a way of development. However, in a production environment, maintain related files together is more convenient. In the next section, we will see how to create Web application file files (WARs) that do exactly this.
Create WARs

As mentioned above, a WAR file is simply a JAR file with the extension changed to reflect its different purpose. We have seen the directory structure required for a Web application. To create a WAR file, use this same directory structure.

To create a WAR for our application, go to the root directory that contains our Web application and type the following command:

cv0f myWebApp.war jar.

Notice the obligatory point that at the end of the line, it tells the jar program to archive the current directory.

The above jar command will create a file called myWebApp.war WAR. Then we’ll see how to deploy this WAR file on Tomcat 3.2 and WebLogic Server 6.0.
Deploying Web Applications in Tomcat 3.2

Tomcat 3.2 serves as a reference implementation for Java Servlet 2.2 specification. For the purpose of this article we have assumed that you are using Tomcat 3.2.1 or later.

To deploy our web application on Tomcat, copy the root directory of your application - which contains web.xml and subidrectorios - the subdirectory webapps / ROOT / our Tomcat installation. We might want to save a copy of the default Web application before overwrite.

Under Unix, for example, if we have installed Tomcat in the / opt/jakarta-tomcat-3.2.1, we should copy the servlet classes under the directory:

/ opt/jakarta-tomcat-3.2.1/webapps/ROOT /

If you run Tomcat under Windows and have installed in the C: \ Program Files \ Jakarta-Tomcat-3.2.1, we should copy the servlet classes under the directory:

C: \ Program Files \ Jakarta-Tomcat-3.2.1 \ webapps \ ROOT \

The subdirectory webapps / ROOT / WEB-INF / classes directory is the default Tomcat will look at your Java class. If we have defined our servlets that belong to a package, we should follow Java standard rules and create the appropriate subdirectories for the JVM can find our classes, as we did before. For example, if we define our com.mycompany.myproject servlet in a package, then we should have the directory structure shown in the figure below:

Our classes are in the subdirectory Java myproject.

This is all you need. There is no further configuration. RequestDetails Continuing the example, try copying the files from the Web application in the default Web application for Tomcat.
Test the Servlet

To test your servlet, start the Tomcat server, open your Web browser, and enter a URL as follows:

http:// (address): (port) / (servletName)

Where:

* Address is the name or IP address of the host running Tomcat. We can use localhost if the browser is running on the same machine as Tomcat.
* Port is the port that Tomcat listens. The default is port 8080.
* ServletName the servlet name we want to invoke. Should correspond to the value contained in the labels <url-pattern> </ url-pattern> deployment descriptor file.

For example, if Tomcat is running on the same machine as the browser and is listening on default port (8080), we can test our servlet example RequestDetails (which is mapped to the URL SampleServlet) by opening the following URL:

http://localhost:8080/SampleServlet

Notice the little work required to deploy a Web application. Copy some files and try. This ease of use make it possible Java Servlet 2.2 specification and use of deployment descriptors.

Now that we have seen how to deploy servlets in Tomcat, see how to deploy a servlet in WebLogic Server.
Deploying Web Applications in WebLogic Server 6.0

Although WebLogic Server 5.1 was the first version of WebLogic Server to provide support for the Java Servlet 2.2 and Web applications, WebLogic Server 6.0 has some important improvements that simplify the deployment of Web applications (both in expanded form as packaged as a WAR file) .
Using the Console to deploy WARs

With our copy of WebLogic Server running, we started the WebLogic Server Console. Assuming a default installation, the console can be brought from the localhost machine by opening the following URL in a Web browser:

http://localhost:7001/console

We ask for name and user password system before allowing the move to console.

To deploy our WAR file, once you’ve accessed the Console:

1. We press on her Web Applications node in the left pane of the console.
2. In the right pane, click “Install a new Web Application …”
3. You type the full path and name of our WAR file, or use the Browse button … to locate it.
4. Press the Upload button.

That is all. If everything went correctly, you should see our application website listed under Web Applications in the left pane of the console. You might need to refresh the view to appear.

As an alternative to using the WebLogic Server Console, you can copy the complete directory structure of the Web application as we did when we deploy to Tomcat.
Manually Deploying Web Applications

Normalmetne when you think of doing tasks manually, or by hand, the automatic reaction is to wait until the task is a bit more complicated than the equivalent machine. In the case of Web applications deployed under WebLogic Server 6.0, the manual approach is so easy, if not more, than using the console.

Simply copy our WAR file or the directory structure of our entire Web application subdirectory config / mydomain / applications of our WebLogic Server distribution (where mydomain is the name of our WebLogic Server domain). As soon as our files have been copied, WebLogic Server deploys the Web application.
Test the Servlet

To test your servlet, open your Web browser, and enter a URL as follows:

http:// (address): (port) / (servletName)

Where:

* Address is the name or IP address of the machine running WebLogic Server. We can use localhost if the browser is running on the same machine as WebLogic Server.
* Port is the port on which WebLogic Server listens. The default is port 7001.
* ServletName the servlet name we want to invoke. Should correspond to the value contained in the labels <url-pattern> </ url-pattern> deployment descriptor file.

For example, if WebLogic Server is running on the same machine as the browser and is listening on default port (7001), we can test our servlet example RequestDetails (which we are mapped to the URL SampleServlet) by opening the following URL:

http://localhost:7001/SampleServlet

Again, the deployment of our web application or WAR file is only required us to copy a few files and test the servlet - no configuration required.
Reconfigure Web Applications

Once we have deployed our web application on WebLogic Server, we can use the Console to configure and reconfigure the application. According make changes in any of the settings, details are automatically written in the WebLogic Server config.xml file. The next time you use them up this file to configure our application.