use WWW::Mechanize;

sub getGeoLocation($$){
    my $ip = shift;
    my $mech = shift;
    
    $mech->submit_form(
        form_name => 'ip',
        fields    => { ip  => $ip
        }
    );
    print "$ip\nCountry: $1\n" if( $mech->content() =~ m/<b>IP Country Name<\/b>:&nbsp;&nbsp;<font color='#980000'> (.+?)<\/font>/ig);
    print "Region: $1\n" if( $mech->content() =~ m/<strong>IP Address Region<\/strong>: <font color='#980000'>(.+?)<\/font>/ig);
    print "City: $1\n\n" if( $mech->content() =~ m/<b>IP Address City<\/b>:&nbsp;&nbsp; <font color='#980000'>(.+?)<\/font>/ig);
}

my $url = 'http://www.find-ip-address.org/ip-address-locator.php';
my $mech = WWW::Mechanize->new();
$mech->agent_alias( 'Windows IE 6' );
$mech->get( $url );
open(IN,"$ARGV[0]") or die "Unable to find the input file: $!";
foreach my $ip (<IN>){
    chomp($ip);
    getGeoLocation($ip, $mech);
}
close(IN)

Advantages of disk partitioning

1) U can have multiple Operating systems on a single hard drive.

E.g.: Windows and UNIX on the same HDD.

2) Lets say some data on one partition is lost. Disk Partition allows the contents on the corrupted partition to be reinstalled without affecting other partitions.

3) U can have multiple file systems.

E.g.: ext3 on /root, ext2 on /var…Etc.

4) Parts of the system may be shared (using Samba or NFS).  While modern systems allow the sharing of part of a partition (that is, some directory and all its contents) security can be difficult to enforce.  It usually works better to share whole partitions

5) Disk partitions can be mounted as read-only.  On a production web server for example, most of the system is static and could be mounted as read-only.

6) The boot partition must be readable by the system BIOS.  If the bootable partition is also the root partition then the whole root partition must be readable by BIOS.

Disadvantages of disk partitioning:

1) They cannot be moved, although they can be resized and copied.

2) The directories /bin, /lib, and /etc should never be separate partitions. At boot time only / is mounted initially.  The init program needs to access files in /etc and the boot-up scripts need access to commands in /bin, which may depend on files in /lib.  Kernel modules required to complete the boot process are also kept in /lib.

3) Some .so (or shared object) files in /bin will be required at the boot time.

Partitions:

The HDD is a block device as considered in UNIX. SCSI and Serial ATA drives are labeled as /dev/sd* while IDE drives are labeled as /dev/hd*.

Partitions are divided in to three types: primary, extended, logical.

A primary partition is a partition which has its information stored in the MBR(master boot record). As an MBR is about 512 bytes. So only 4 partitions can be defined as primary partitions (For E.g., /dev/sda1 to /dev/sda4).

An extended partition is a special primary partition (meaning the extended partition must be one of the four possible primary partitions) which contains more partitions. Such a partition didn’t exist originally, but as four partitions were too few, it was brought to life to extend the formatting scheme without losing backward compatibility.

A logical partition is a partition inside the extended partition. Their definitions aren’t placed inside the MBR, but are declared inside the extended partition.

Partition Map:

This is a typical partition map on a 40 GB Hard disk

/              2GB

swap        1GB

/boot        200MB

/home       1.5 GB

/tmp         512MB

/var          7GB

/opt          1.5GB

/usr/local   1.5GB

Example of disk partitioning using ‘fdisk’ tool:

This example is done on my vmware machine taking a HDD space of 8GB.

1) fdisk /dev/sda

Command (m for help): p
Disk /dev/sda: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x3e5b064c

Device Boot      Start         End      Blocks   Id  System


‘p’ argument is used for printing the partition table. Presently there are no disk partitions created.
For all arguments check ‘m’

2)Create swap partition.
Command (m for help): n
Command action
e   extended
p   primary partition (1-4)
p

Partition number (1-4): 1
First cylinder (1-1044, default 1):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-1044, default 1044): +200M
‘n’ argument is used for creating a new partition. We are creating a primary partition of size 200MB. We will mount the /boot on this partition /dev/sda1.Check if the partition is created successfully by the ‘p’ argument.

Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          25      200781   83  Linux

3) Create extended partition.
Command (m for help): n
Command action
e   extended
p   primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (26-1044, default 26):
Using default value 26
Last cylinder or +size or +sizeM or +sizeK (26-1044, default 1044): +512M

We are creating the swap partition here. Let it be 512MB. Generally we keep the swap space as double the size of RAM size.

Check out the partitions.

Command (m for help): p
Disk /dev/sda: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x3e5b064c
Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          25      200781   83  Linux
/dev/sda2              26          88      506047+  83  Linux


Change the partition type. Make it as swap.

Command (m for help): t
Partition number (1-4): 2
Hex code (type L to list codes): 82
Changed system type of partition 2 to 82 (Linux swap / Solaris)


Print the partitions.

Command (m for help): p
Disk /dev/sda: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x3e5b064c

Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          25      200781   83  Linux
/dev/sda2              26          88      506047+  82  Linux swap / Solaris


4)Now we create an extended partition. And put all other partitions as logical partitions inside this extended partition.

Command (m for help): n
Command action
e   extended
p   primary partition (1-4)
e
Partition number (1-4): 3
First cylinder (89-1044, default 89):
Using default value 89
Last cylinder or +size or +sizeM or +sizeK (89-1044, default 1044): 1000MB

Command (m for help): p
Disk /dev/sda: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x3e5b064c
Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          25      200781   83  Linux
/dev/sda2              26          88      506047+  82  Linux swap / Solaris
/dev/sda3              89        1000     7325640    5  Extended


5) Now we create all the logical partitions inside the extended partition /dev/sda3.


Command (m for help): n
Command action
l   logical (5 or over)
p   primary partition (1-4)
l

Command (m for help): p
Disk /dev/sda: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x3e5b064c
Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          25      200781   83  Linux
/dev/sda2              26          88      506047+  82  Linux swap / Solaris
/dev/sda3              89        1000     7325640    5  Extended
/dev/sda5              89        1000     7325608+  83  Linux

6) In the same manner i added all the logical volumes.

Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          25      200781   83  Linux  (/boot)
/dev/sda2              26          88      506047+  82  Linux swap / Solaris(swap)
/dev/sda3              89        1044     7679070    5  Extended
/dev/sda5              89         211      987966   83  Linux(/)
/dev/sda6             212         334      987966   83  Linux(/opt)
/dev/sda7             335         397      506016   83  Linux(/tmp)
/dev/sda8             398         641     1959898+  83  Linux(/var)
/dev/sda9             642         824     1469916   83  Linux(/home)
/dev/sda10            825        1044     1469916  83  Linux(/usr/local)

7) the next process is setting the file system and mounting them on hard drive. We use the commands mke2fs for setting the file system as ext2 and mkswap to set the swap file system.

When things Gone Wrong…

A problem with having partitions is that you can run out of space in one partition while other have access capacity. When this type of problem occurs we have to backup all the existing data in archives and re-format the disk, and restore the data. This should be a avoided. One common hack we can do is use a symlink. For eg.., /usr/local have no disk space to install the mplayer. u can install the mplayer in /opt and can create a link to /usr/local (mkdir /opt/mplayer; ln -s /opt/mplayer /usr/local/mplayer).

The problem with this approach is u will have too many symlinks and it can make maintenance difficult. Modern UNIX systems have virtual partitions called logical volumes (LVM).

The Key idea is to get an image of the partition in the form of file. dd utility copies the specified input file to the specified output file possible conversions. Here the input and output sizes can be specified.

The dd command is used for a lot of purposes.
For example, it can be used to extract parts of binary files and write into the middle of floppy disks; it is used by the Linux kernel Makefiles to make boot images. It can be used to copy and convert magnetic tape formats, convert between ASCII and EBCDIC, swap bytes, and force to upper and lowercase.

Since dd command was modeled using the JCL language it uses “keyword=value” format for its parameters.Unlike other unix commands uses the “–keyword value” format as parameters.

Operands:
if=file
Specifies the file from which data is to be copied.
of=file
Specifies the file to which the data should be copied.
ibs=n
specifies the input block size in bytes(n bytes).
obs=n
specifies the output block size in bytes.
bs=n
sets both ibs and obs to n bytes.
count=n
Copies only n input blocks.
skip=n
Skips n input blocks before copying.
iseek=n
Seeks n blocks from beginning of input file before copying.
oseek=n
Seeks n blocks from beginning of output file before coying.
seek=n
sets both iseek and oseek to n blocks.

Examples:
1)    The following example creates an iso image from the cdrom.
dd if=/dev/cdrom  of=image.iso bs=1M
In this example the input file is the /dev/cdrom for which the cd will be attached.The output file is the image.iso  and block size of 1Mb is read and write to image.iso from /dev/cdrom

2)    Wipe the entire partition. (*Warning don’t try this*)
dd if=/dev/urandom of=/dev/sda2
this will wipe the /dev/sda2 partition with random data.

3)    Create a hard drive backup.
dd if=/dev/sda2 | gzip > /data/sda2.img.gz.
In the above example the if parameter is /dev/sda2 partition on which the / file system is mounted. The of parameter is null it means that the of uses the standard output. So the stdout is piped to gzip utility and compressed

Device File System.

Device file system includes:

• Device Files
• Device nodes or special files.

These Device Files appear in the file system as if it were the ordinary files.
For example, /dev/hda1 for hard disk first partition , /dev/cdrom for cdrom.

What does these device files do?

1. Device files often provide simple interfaces to peripheral devices, such as printers.
2. Also be used to access specific resources on those devices, such as disk partitions.
3. They can be used as data sinks and random number generators.

Most of these devices in a Unix operating system must be accessed through special files called Device Nodes, which are located in the /dev directory.There are 2 types of device nodes

1. Character special files.
2. Block special files.

There are two main types of devices and therefore device nodes, character and block.

Character Device: Character device read or write data as a stream of characters. Some character devices are keyboard and terminals.

Block Device: A block device is one that stores information in fixed size blocks. Common block sizes are between 128 bytes and 1k bytes. Each block may be read independently of the others, so the device allows random access to each block.Some Block devices are hard disks , cdrom drives.

Pseudo-Devices: Device nodes on Unix-like systems do not necessarily have to correspond to physical devices. Nodes that lack this correspondence form the group of pseudo-devices.
/dev/null            :                Accepts and discards all input;produces no output.
/dev/full             :                Always Full device.
/dev/loop          :                Loop Device
/dev/zero          :               Produces a continuous stream of NULL (zero value) characters.

The Following are the general prefixes used to identify the device nodes in /dev directory.
* fb: frame buffer
* fd: floppy disks
* hd: IDE hard disks
* lp: printers
* par: parallel ports
* pt: pseudo-terminals (virtual terminals)
* s: SCSI devices in general, notably hard disks (but also SATA and USB disks)

• scd: SCSI audio-oriented optical disc drives
• sd: SCSI hard disks (also SATA or USB disks)
• sg: SCSI generic devices
• sr: SCSI data-oriented optical disc drives
• st: SCSI magnetic tapes

* tty: (physical) terminals
*ttyS: serial ports

dmesg command is used to write the kernel messages to standard output.

Kernel is the core of the Operating System. The first part of the Operating System that is being loaded during the boot process is kernel.

Kernel controls virtually everything on the system. A numerous messages will be shown on the display screen as computer boots up. This messages show the hardware devices that the kernel detects and whether it is able to configure them or not.

How Does dmesg work?

Command dmesg obtains its data from the Kernel Ring Buffer. In general Buffer is a temporary amount of space associated with every device like hard disk; printer. A ring buffer is a buffer of fixed size for which any new data added to it overwrites the oldest data in it.

How to use dmesg?

Usage of dmesg:

dmesg [options]

Invoking dmesg without any of its options (which are rarely used) causes it to write all the kernel messages to standard output.

dmesg | less

Example, the following command lists all references to USB (universal serial bus) devices in the kernel messages:

dmesg | grep -i usb

Following tells dmesg to show all serial ports (which are represented by the string tty):

dmesg | grep -i tty

The dmesg and grep combination can also be used to show how much physical memory (i.e., RAM) is available on the system:

dmesg | grep -i memory

The output of dmesg is maintained in the log file /var/log/dmesg.

cat /var/log/dmesg | less.

BIOS is a software that interacts with CPU and Operating System at the boot time.It is usually stored in the Flash memory chip on the motherboard.

What is bootstrapping?

A computer consists of a CPU for performing caluclations,along with some memory for storing the data the processor is using and some peripheral devices such as keyboard,monitor..etc.

In the computer the memory used by the processor is stored in RAM which is volatile.In another way when we turn off a computer it is nothing but a collection of hardware components that will do nothing until reprogrammed. This reprogramming that occurs when we turn on the computer is called bootstrapping. In a more logical sence the loading of the Operating System is called bootstrapping or booting the computer.

How Boot Strpping Occurs?

When you turn on your computer, the BIOS does several things. This is its usual sequence:

1) Check the RAM settings.

2) Load Interrupt handlers and device drivers.

3) Initialize registers and power management.

4) Perform the power-on self-test (POST).

5) Display system settings.

6) Determine which devices are bootable

7) Initiate the bootstrap sequence

The first thing the BIOS does is it checks the information stored on the RAM. RAM provides the BIOS with information regarding the system changes.Interrupt handlers are small pieces of software that act as translators between the hardware components and the operating system. For example, when you press a key on your keyboard, the signal is sent to the keyboard interrupt handler, which tells the CPU what it is and passes it on to the operating system. The device drivers are other pieces of software that identify the base hardware components such as keyboard, mouse, hard drive and floppy drive. Since the BIOS is constantly intercepting signals to and from the hardware, it is usually copied, or shadowed, into RAM to run faster. A power-on self-test (POST) for all of the different hardware components in the system to make sure everything is working properly.

The dmesg command prints the messages that occur during the boot process to standard output.

CMOS & BIOS

Older Pc’s such as IBM XT contained the DIP switches in order to store the hardware settings. Whenever if a floppy drive is added you have to take off the pc cover and start configuring the DIP switches, which was a hard job. Fortunately IBM developed the CMOS chip to store the hardware settings. CMOS is a kind of RAM (Random Access Memory). RAM is volatile, which means that whenever you power off, the entire memory would be erased. However CMOS requires very little power which will be supplied by the on-board battery.

CMOS chips pass on the Information to the BIOS when the system is turned on. CMOS stores information such as boot order (the order the computer looks for information, such as A drive first, C drive second, and so on), real-time system clock, calendar settings, hardware passwords, hard drive configuration settings, and the installed memory (RAM). Essentially the CMOS chip stores data for the BIOS so that a computer can boot up properly.