rooted@localhost

2011-06-29T23:32:00.000-07:00

Global Menu - Ubuntu Lucid

Setting up global menu in lucid

install the global menu package.

2011-03-15T10:54:00.000-07:00

Enable Google Calendar in Mozilla Sunbird

Only Mozilla Sunbird 0.8+ and Lightning in Thunderbird support CalDAV sync. Please note that this is considered an experimental feature with limited technical assistance available.

To set up CalDAV support for Google Calendar in Mozilla Sunbird, follow these steps:

1. Open the Sunbird application and select File > New Calendar.

2. Select On the Network and click Next.

3. Select the CalDAV format option.

4. In the Location field, enter [ https://www.google.com/calendar/dav/ [ your Google Calendar ID ] /events ] and click Next.

Your Google Calendar ID for your primary calendar is just your email address, but for all other calendars the Calendar ID will be in the form of [ long string of characters]@group.calendar.google.com. You can get the Calendar ID by clicking the down arrow next to your calendar at calendar.google.com and selecting 'Calendar Settings'.

Be sure to use https in your URL, as an http address will not work.

5. Enter a name and select a color for your calendar.

6. In the pop-up screen, enter the following information:

Username: This is the complete email address you use with Google Calendar (including the part after the @ sign). If you're using Google Apps, be sure to enter your Google Apps email address.

Password: This is the password you use to sign in to Google Calendar

7. Click OK.

Your Google Calendar will now appear in the Calendar tab of Mozilla Sunbird, and Sunbird will sync any changes to and from Google Calendar.

2011-02-25T09:30:00.000-08:00

Hi this is just a test to check how the read more condition works. well thanks to the document provided at http://www.blogspottutorial.com/2007/12/make-post-summary-readmore-function.html

If you are a beginner, possible you'd feel to surprise when seeing the articles in my blog presenting only shares first paragrap or second paragrap, and to read for full article, you must click Read more... link. Alright.. please don't feel surprise, i will discuss about this now.

The function like that called Post Summary. You can make a post summary function with add a little code to your template code. But this code is for new blogger template (beta) and does not work at classic template.

Please follow the steps below :

NIX Education Center

2011-02-07T08:26:00.000-08:00

NIX Education Center

SIMPLYFYING LEARNING

Launching courses @ 50% discount for first 30 Students. All the courses will be taught by Tutors who have worked in the industry and have more than 10 yrs of combined experience.

Course Structure

1. Basic Computer Applications & Internet Course

Course Description: This course mainly focuses on Basics on Computer, its history and its applications. The introduction to MS Office suite which is now required to perform almost every work related to computers. This course also shows you how to use internet for communication safely and effectively. The course is well suited for the person who wants to get familiar with computer technology and its applications and usage.

a. Computer Fundamentals

b. System and application software

c. Microsoft word 2007

d. Microsoft Excel 2007

e. Microsoft Powerpoint 2007

f. Internet( use of mails, chats)

g. Introduction to HTML

@ 2500INR/-

Only

Microsoft Outloook 2007

i. Basic Networking fundamentals

j. E-Commerce

Price: 5000/- INR

Duration: 1 Month

2. Advanced Computer Applications and Basics of programming & networking

Course Description: The course offers learning of advanced excel and provides working knowledge of operating systems like Windows. Also it gives you the foundation for programming, database , networking and linux. This course is suited for people who want to pursue computer related field in the future.

a. Advanced Microsoft Excel 2007

b. Software Installation

c. User Management

d. Printer Management

e. Introduction to C/C++ and Java

f. Introductory lessons on Business communications.

g. Introduction to UNIX/LINUX

h. Basics of DBMS(database Management Systems)

@ 2500INR/-

Only

Networking fundamentals

j. Virtualization concepts

Price: 5000INR/-

Duration: 1 Month

JOB READY COURSES

The following courses are for the people who wants to get into IT industry or the people who already into IT but want to enhance the skills and position in the industry.

v LINUX (RHCE)

Course Description : This course is for users of Linux (or Unix) who want to start building skills in system administration on Red Hat Enterprise Linux, to a level where they can attach and configure a workstation on an existing network. This course provides intensive hands-on training on Red Hat Enterprise Linux.

Price : 9000

Offer price to first 20 students : 6000

v Learning DBMS with IBM DB2

Course Description : DB2 is an IBM’s Database which is a direct competitor to Oracle databases. DB2 has high market demand and very less supply. The course teaches the fundamentals of database management system and prepares you to handle the DB2 database.

Price : 8000

Offer price to first 20 students : 5000

v Bash/Unix Shell scripting

Course Description : This course is developed for application developers and system administrator who are already familiar with unix/linux OS. The course provides an overview of the various Linux commands and their use in manipulating and searching files and directories and in navigating the file system in Linux. The course also describes the features of Linux shell and the concept of creating shell scripts.

Price : 6000

Offer price to first 20 students : 3000

v Solaris

Course Description : This course is for students or working professionals aspiring to be Sun Certified System Administrator for Solaris 9/10 Operating Environment. This course will also prepare you for the solaris administration exam.

Price : 9000

Offer price to first 20 students : 6000

LEARNING WITH US

· Easy to comprehend Course Material

· The training will be provided with lots of examples

· Emphasis will be on the application and practical use of computer than theory

· Industry experienced Tutors

· Practical Exams will be held after each session.

· Participation Certificate

· Lab facility can be utilized after classes

· Preparation help for Certification Exams.

For registration, enquiry or any query. Please feel free to contact us on….

Address: ShopNo.11,Gurusharnma Complex,

Vishrali Naka, Near Raigad Bazar

Takka, Old Panvel.

Call us : Ajay Singh , 9172526060

Om Prakash Singh: 9833375149

Mail us : mailxtoajay@gmail.com

Linux on Laptop.

2008-03-20T13:02:00.000-07:00

Tried Gusty Gibbon Ubuntu 6.10 on Compaq f733AU works fine without any major problems. some tweaking required in udev/rules/70-persistent-net-rules.. rest everything works fabulous..

Now am trying Debian Etch 4.0r3 on the same laptop will submit complete reveiw when done with the same.

Managing Disk Spaces with LVM in Linux.

2007-07-22T21:05:00.001-07:00

Bryce Harrington and Kees Cook have come together to write this informative article titled 'Managing Disk Space with LVM' which explains the ins and outs creating, modifying and deleting of LVM in Linux.

The Linux Logical Volume Manager (LVM) is a mechanism for virtualizing disks. It can create "virtual" disk partitions out of one or more physical hard drives, allowing you to grow, shrink, or move those partitions from drive to drive as your needs change. It also allows you to create larger partitions than you could achieve with a single drive.

Traditional uses of LVM have included databases and company file servers, but even home users may want large partitions for music or video collections, or for storing online backups. LVM and RAID 1 can also be convenient ways to gain redundancy without sacrificing flexibility.

This article looks first at a basic file server, then explains some variations on that theme, including adding redundancy with RAID 1 and some things to consider when using LVM for desktop machines.

LVM Installation

An operational LVM system includes both a kernel filesystem component and userspace utilities. To turn on the kernel component, set up the kernel options as follows:

Device Drivers --> Multi-device support (RAID and LVM)

    [*] Multiple devices driver support (RAID and LVM)
    < >   RAID support
    <*>   Device mapper support
    < >     Crypt target support (NEW)

You can usually install the LVM user tools through your Linux distro's packaging system. In Gentoo, the LVM user tools are part of the lvm2 package. Note that you may see tools for LVM-1 as well (perhaps named lvm-user). It doesn't hurt to have both installed, but make sure you have the LVM-2 tools.

LVM Basics

To use LVM, you must understand several elements. First are the regular physical hard drives attached to the computer. The disk space on these devices is chopped up into partitions. Finally, a filesystem is written directly to a partition. By comparison, in LVM, Volume Groups (VGs) are split up into logical volumes (LVs), where the filesystems ultimately reside (Figure 1).

Each VG is made up of a pool of Physical Volumes (PVs). You can extend (or reduce) the size of a Volume Group by adding or removing as many PVs as you wish, provided there are enough PVs remaining to store the contents of all the allocated LVs. As long as there is available space in the VG, you can also grow and shrink the size of your LVs at will (although most filesystems don't like to shrink).

Figure 1. An example LVM layout (Click to view larger image)

Example: A Basic File Server

A simple, practical example of LVM use is a traditional file server, which provides centralized backup, storage space for media files, and shared file space for several family members' computers. Flexibility is a key requirement; who knows what storage challenges next year's technology will bring?

For example, suppose your requirements are:

400G  - Large media file storage
 50G  - Online backups of two laptops and three desktops (10G each)
 10G  - Shared files

Ultimately, these requirements may increase a great deal over the next year or two, but exactly how much and which partition will grow the most are still unknown.

Disk Hardware

Traditionally, a file server uses SCSI disks, but today SATA disks offer an attractive combination of speed and low cost. At the time of this writing, 250 GB SATA drives are commonly available for around $100; for a terabyte, the cost is around $400.

SATA drives are not named like ATA drives (hda, hdb), but like SCSI (sda, sdb). Once the system has booted with SATA support, it has four physical devices to work with:

/dev/sda  251.0 GB
/dev/sdb  251.0 GB
/dev/sdc  251.0 GB
/dev/sdd  251.0 GB

Next, partition these for use with LVM. You can do this with fdisk by specifying the "Linux LVM" partition type 8e. The finished product looks like this:

# fdisk -l /dev/sdd

Disk /dev/sdd: 251.0 GB, 251000193024 bytes
255 heads, 63 sectors/track, 30515 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Device            Start   End      Blocks      Id  System
/dev/sdd1         1       30515    245111706   8e  Linux LVM

Notice the partition type is 8e, or "Linux LVM."

Creating a Virtual Volume

Initialize each of the disks using the pvcreate command:

# pvcreate /dev/sda /dev/sdb /dev/sdc /dev/sdd

This sets up all the partitions on these drives for use under LVM, allowing creation of volume groups. To examine available PVs, use the pvdisplay command. This system will use a single-volume group named datavg:

# vgcreate datavg /dev/sda1 /dev/sdb1 /dev/sdc1 /dev/sdd1

Use vgdisplay to see the newly created datavg VG with the four drives stitched together. Now create the logical volumes within them:

# lvcreate --name medialv  --size 400G
# lvcreate --name backuplv --size  50G
# lvcreate --name sharelv  --size  10G

Without LVM, you might allocate all available disk space to the partitions you're creating, but with LVM, it is worthwhile to be conservative, allocating only half the available space to the current requirements. As a general rule, it's easier to grow a filesystem than to shrink it, so it's a good strategy to allocate exactly what you need today, and leave the remaining space unallocated until your needs become clearer. This method also gives you the option of creating new volumes when new needs arise (such as a separate encrypted file share for sensitive data). To examine these volumes, use the lvdisplay command.

Now you have several nicely named logical volumes at your disposal:

/dev/datavg/backuplv     (also /dev/mapper/datavg-backuplv)
/dev/datavg/medialv      (also /dev/mapper/datavg-medialv)
/dev/datavg/sharelv      (also /dev/mapper/datavg-sharelv)

Selecting Filesystems

Now that the devices are created, the next step is to put filesystems on them. However, there are many types of filesystems. How do you choose?

For typical desktop filesystems, you're probably familiar with ext2 and ext3. ext2 was the standard, reliable workhorse for Linux systems in years past. ext3 is an upgrade for ext2 that provides journaling, a mechanism to speed up filesystem checks after a crash. ext3's balance of performance, robustness, and recovery speed makes it a fine choice for general purpose use. Because ext2 and ext3 have been the defaults for such a long time, ext3 is also a good choice if you want great reliability. For storing backups, reliability is much more important than speed. The major downside to ext2/ext3 is that to grow (or shrink) the filesystem, you must first unmount it.

However, other filesystems provide advantages in certain situations, such as large file sizes, large quantities of files, or on-the-fly filesystem growth. Because LVM's primary use is for scenarios where you need extreme numbers of files, extremely large files, and/or the need to resize your filesystems, the following filesystems are well worth considering.

For large numbers of small files, ReiserFS is an excellent choice. For raw, uncached file I/O, it ranks at the top of most benchmarks, and can be as much as an order of magnitude faster than ext3. Historically, however, it has not proven as robust as ext3. It's been tested enough lately that this may no longer be a significant issue, but keep it in mind.

If you are designing a file server that will contain large files, such as video files recorded by MythTV, then delete speed could be a priority. With ext3 or ReiserFS, your deletes may take several seconds to complete as the filesystem works to mark all of the freed data blocks. If your system is recording or processing video at the same time, this delay could cause dropped frames or other glitches. JFS and XFS are better choices in this situation, although XFS has the edge due to greater reliability and better general performance.

With all these considerations in mind, format the partitions as follows:

# mkfs.ext3 /dev/datavg/backuplv
# mkfs.xfs /dev/datavg/medialv
# mkfs.reiserfs /dev/datavg/sharelv

Mounting

Finally, to mount the file systems, first add the following lines to /etc/fstab:

/dev/datavg/backuplv   /var/backup     ext3       rw,noatime    0 0
/dev/datavg/medialv    /var/media      xfs        rw,noatime    0 0
/dev/datavg/sharelv    /var/share      reiserfs   rw,noatime    0 0

and then establish and activate the mount points:

# mkdir /var/media /var/backup /var/share
# mount /var/media /var/backup /var/share

Now your basic file server is ready for service.

Adding Reliability With RAID

So far, this LVM example has been reasonably straightforward. However, it has one major flaw: if any of your drives fail, all of your data is at risk! Half a terabyte is not an insignificant amount to back up, so this is an extremely serious weakness in the design.

To compensate for this risk, build redundancy into the design using RAID 1. RAID, which stands for Redundant Array of Independent Disks, is a low-level technology for combining disks together in various ways, called RAID levels. The RAID 1 design mirrors data across two (or more) disks. In addition to doubling the reliability, RAID 1 adds performance benefits for reads because both drives have the same data, and read operations can be split between them.

Unfortunately, these benefits do not come without a critical cost: the storage size is cut in half. The good news is that half a terabyte is still enough for the present space requirements, and LVM gives the flexibility to add more or larger disks later.

With four drives, RAID 5 is another option. It restores some of the disk space but adds even more complexity. Also, it performs well with reads but poorly with writes. Because hard drives are reasonably cheap, RAID 5's benefits aren't worth the trouble for this example.

Although it would have made more sense to start with a RAID, we waited until now to introduce them so we could demonstrate how to migrate from raw disks to RAID disks without needing to unmount any of the filesystems.

In the end, this design will combine the four drives into two RAID 1 pairs: /dev/sda + /dev/sdd and /dev/sdb + /dev/sdc. The reason for this particular arrangement is that sda and sdd are the primary and secondary drives on separate controllers; this way, if a controller were to die, you could still access the two drives on the alternate controller. When the primary/secondary pairs are used, the relative access speeds are balanced so neither RAID array is slower than the other. There may also be a performance benefit to having accesses evenly distributed across both controllers.

First, pull two of the SATA drives (sdb and sdd) out of the datavg VG:

# modprobe dm-mirror 
# pvmove /dev/sdb1 /dev/sda1 
# pvmove /dev/sdd1 /dev/sdc1 
# vgreduce datavg /dev/sdb1 /dev/sdd1 
# pvremove /dev/sdb1 /dev/sdd1

Then, change the partition type on these two drives, using filesystem type fd (Linux raid autodetect):

Device Boot      Start         End      Blocks   Id  System
/dev/sdb1               1       30515    245111706  fd  Linux raid autodetect

Now, build the RAID 1 mirrors, telling md that the "other half" of the mirrors are missing (because they're not ready to be added to the RAID yet):

# mdadm --create /dev/md0 -a -l 1 -n 2 /dev/sdd1 missing
# mdadm --create /dev/md1 -a -l 1 -n 2 /dev/sdb1 missing

Add these broken mirrors to the LVM:

# pvcreate /dev/md0 /dev/md1
# vgextend datavg /dev/md0 /dev/md1

Next, migrate off of the raw disks onto the broken mirrors:

# pvmove /dev/sda1 /dev/md0 
# pvmove /dev/sdc1 /dev/md1 
# vgreduce datavg /dev/sda1 /dev/sdc1 
# pvremove /dev/sda1 /dev/sdc1

Finally, change the partition types of the raw disks to fd, and get the broken mirrors on their feet with full mirroring:

# fdisk /dev/sda1
# fdisk /dev/sdc1
# mdadm --manage /dev/md0 --add /dev/sda1
# mdadm --manage /dev/md1 --add /dev/sdc1

That's quite a few steps, but this full RAID 1 setup protects the LVM system without having to reinstall, copy or remount filesystems, or reboot.

Network Access of Files

A file server isn't much use if you can't get files off of it. There are many ways to serve files, but the most common and powerful is Network File System (NFS). NFS allows other *nix machines to mount the file shares for direct use. It's also pretty easy to set up on Linux.

First, make sure the file server has NFS enabled in the kernel (2.6.15 in this example):

File systems
 Network File Systems

 <*> NFS file system support
  [*]   Provide NFSv3 client support
  <*> NFS server support
  [*]   Provide NFSv3 server support

Rebuild and reinstall the kernel and then reboot the file server. If you'd like to avoid rebooting, build NFS as a module and then load it with modprobe nfsd.

Next, start the NFS service. Your Linux distro will have an init script to do this. For instance, on Gentoo, you'll see:

/etc/init.d/nfs start 
 * Starting portmap ...      [ ok ]
 * Mounting RPC pipefs ...   [ ok ]
 * Starting NFS statd ...    [ ok ]
 * Starting NFS daemon ...   [ ok ]
 * Starting NFS mountd ...   [ ok ]

You can double-check that NFS is running by querying portmapper with the command rpcinfo -p | grep nfs:

program  vers proto port  service
100003    2   udp   2049  nfs
100003    3   udp   2049  nfs
100003    2   tcp   2049  nfs
100003    3   tcp   2049  nfs

Next, you must specify which directories the NFS service should export. Add the following to /etc/exports:

/var/backup    192.168.0.0/24(rw,sync)
/var/media     192.168.0.0/24(rw,sync)
/var/share     192.168.0.0/24(rw,sync)

This lists the directories to share, the machines (or networks) to permit to mount the files, and a set of options to control how the sharing works. The options include rw to allow read-write mounts and sync to force synchronous behavior. sync prevents data corruption if the server reboots in the middle of a file write, but sacrifices the performance advantages that async would provide.

Next, export these file shares from the NFS service:

# exportfs -av
exporting 192.168.0.0/24:/var/backup
exporting 192.168.0.0/24:/var/media
exporting 192.168.0.0/24:/var/share

Now, mount these file shares on each machine that will use them. Assuming the file server is named fileserv, add the following lines to the client machines' /etc/fstab files:

# Device               mountpoint    fs-type   options    dump  fsckorder
fileserv:/var/backup   /var/backup   nfs       defaults   0     0
fileserv:/var/media    /var/media    nfs       defaults   0     0
fileserv:/var/share    /var/share    nfs       defaults   0     0

Finally, create the mountpoints and mount the new shares:

# mkdir /var/backup /var/media /var/share
# mount /var/backup /var/media /var/share

Now all the machines on your network have access to large, reliable, and expandable disk space!

Backup Strategies

As you rely more heavily on this new LVM-enabled disk space, you may have concerns about backing it up. Using RAID ensures against basic disk failures, but gives you no protection in the case of fire, theft, or accidental deletion of important files.

Traditionally, tape drives are used for backups of this class. This option is still viable and has several advantages, but it can be an expensive and slow solution for a system of this size. Fortunately, there other options using today's technology.

rsync is a powerful utility for copying files from one system to another, and it works well across the Internet. You could set up a backup system at a friend's house in a different city and arrange to periodically send backups there. This is easy to do with cronjob:

04 4 * * 4  rsync --delete -a /var/backup/ fileserv.myfriend.org:/backup/myself/backup \
    > /var/log/crontab.backup.log 2>&1

Another approach is to attach a pair of external RAID 1 hard drives to your file server using Firewire, USB, or eSATA. Add one drive to /dev/md0 and the other to /dev/md1. Once the mirroring is complete, remove the drives and store them in a safe place offsite. Re-mirror weekly or monthly, depending on your needs.

Growth and Reallocation

Suppose that over the next year, the storage system fills up and needs to be expanded. Initially, you can begin allocating the unallocated space. For instance, to increase the amount of space available for shared files from 10GB to 15GB, run a command such as:

# lvextend -L15G /dev/datavg/sharelv # resize_reiserfs /dev/datavg/sharelv

But over time, all the unallocated disk space will be used. One solution is to replace the four 250G drives with larger 800G ones.

In the case where you use RAID 1, migration is straightforward. Use mdadm to mark one drive of each of the RAID 1 mirrors as failed, and then remove them:

# mdadm --manage /dev/md0 --fail /dev/sda1
# mdadm --manage /dev/md0 --remove /dev/sda1
# mdadm --manage /dev/md0 --fail /dev/sdc1
# mdadm --manage /dev/md0 --remove /dev/sdc1

Pull out the sda and sdc hard drives and replace them with two of the new 800G drives. Split each 800G drive into a 250G partition and a 550G partition using fdisk, and add the partitions back to md0 and md1:

# fdisk /dev/sda
# fdisk /dev/sdc
# mdadm --manage /dev/md0 --add /dev/sda1
# mdadm --manage /dev/md1 --add /dev/sdc1

Repeat the above process with sdd and sdb to move them to the other two new drives, then create a third and fourth RAID device, md2 and md3, using the new space:

# mdadm --create /dev/md2 -a -l 1 -n 2 /dev/sda2 /dev/sdd2
# mdadm --create /dev/md3 -a -l 1 -n 2 /dev/sdb2 /dev/sdc2

Finally, add these to LVM:

# pvcreate /dev/md2 /dev/md3
# vgextend datavg /dev/md2 /dev/md3

The file server now has 1.6TB of fully redundant storage.

LVM and Desktops

So far, we've talked only about LVM and RAID for secondary disk space via a standalone file server, but what if you want to use LVM to manage the space on a regular desktop system? It can work, but there are some considerations to take into account.

First, the installation and upgrade procedures for some Linux distributions don't handle RAID or LVM, which may present complications. Many of today's distros do support it, and even provide tools to assist in creating and managing them, so check this first.

Second, having the root filesystem on LVM can complicate recovery of damaged file systems. Because boot loaders don't support LVM yet, you must also have a non-LVM /boot partition (though it can be on a RAID 1 device).

Third, you need some spare unallocated disk space for the new LVM partition. If you don't have this, use parted to shrink your existing root partition, as described in the LVM HOWTO.

For this example, assume you have your swap space and /boot partitions already set up outside of LVM on their own partitions. You can focus on moving your root filesystem onto a new LVM partition in the partition /dev/hda4. Check that the filesystem type on hda4 is LVM (type 8e).

Initialize LVM and create a new physical volume:

# vgscan
# pvcreate /dev/hda4
# vgcreate rootvg /dev/hda4

Now create a 5G logical volume, formatted into an xfs file system:

# lvcreate rootvg ---name rootlv -size 5G
# mkfs.xfs /dev/rootvg/rootlv

Copy the files from the existing root file system to the new LVM one:

# mkdir /mnt/new_root
# mount /dev/rootvg/rootlv /mnt/new_root
# cp -ax /. /mnt/new_root/

Next, modify /etc/fstab to mount / on /dev/rootvg/root instead of /dev/hda3.

The trickiest part is to rebuild your initrd to include LVM support. This tends to be distro-specific, but look for mkinitrd or yaird. Your initrd image must have the LVM modules loaded or the root filesystem will not be available. To be safe, leave your original initrd image alone and make a new one named, for example, /boot/initrd-lvm.img.

Finally, update your bootloader. Add a new section for your new root filesystem, duplicating your original boot stanza. In the new copy, change the root from /dev/hda3 to /dev/rootvg/rootlv, and change your initrd to the newly built one. If you use lilo, be sure to run lilo once you've made the changes. For example, with grub, if you have:

title=Linux
  root (hd0,0)
  kernel /vmlinuz root=/dev/hda3 ro single
  initrd /initrd.img

add a new section such as:

title=LinuxLVM

  root (hd0,0)
  kernel /vmlinuz root=/dev/rootvg/root ro single
  initrd /initrd-lvm.img

Conclusion

LVM is only one of many enterprise technologies in the Linux kernel that has become available for regular users. LVM provides a great deal of flexibility with disk space, and combined with RAID 1, NFS, and a good backup strategy, you can build a bulletproof, easily managed way to store, share, and preserve any quantity of files.

Replace a bad disk in a mirrored volume group

2007-07-21T01:03:00.001-07:00

1. unmirrorvg workvg hdisk7
2. reducevg workvg hdisk7
Note: migrate the lv copies of the disk if you get any errors like lvcopies on disk.

3. rmdev -l hdisk7 -d

replace the disk drive, let the drive be renamed hdisk7

4. extendvg workvg hdisk7
5. mirrorvg workvg hdisk7

Note: By default in this example, mirrorvg will try to create 2 copies for logical volumes in workvg. It will try to create the new mirror

Access Control List (ACL's) on AIX.

2007-07-18T04:58:00.001-07:00

Well. We speak so much of security and make secure system, in concerns of that here I am explaining how to put ACL's on AIX system. As I presume its just the brief description of ACL on AIX system. You can also find how to put ACL's on my previous article.

As there is an interactive way to do it but well here I'll be only trying it to do with files.

1. Create/Identify the file on which we need to put acl's
# touch alctest2

2. Get the acl's which exist on the file.
# ls -l acltest2
-rw-r--r-- 1 root system 0 Jul 18 17:15 acltest2
# aclget acltest2
*
* ACL_type AIXC
*
attributes:
base permissions
owner(root): rw-
group(system): r--
others: r--
extended permissions
disabled

3. Now we will collect all the acl's permission in an outputfile called as acldefs.
# aclget -o acldefs acltest2

4. Edit the file acldefs. and make the necessary changes as you want in the file.
for eg:
Base permissions
AIXC ACL specific base permissions are the traditional file-access modes assigned to the file
owner, file group, and other users. The access modes are read (r), write (w), and execute/search
(x).
Note: AIXC ACL type Base Permissions will be same as the file mode bits stored in the file
system object’s inode headers. That is, the information in base mode bits is same as the
value returned by file system when stat is performed on the file system object.
In an access control list, base permissions are in the following format, with the Mode parameter
expressed as rwx (with a hyphen (-) replacing each unspecified permission):
base permissions:
owner(name): Mode
group(group): Mode
others: Mode

Attributes
Three attributes can be added to an access control list:
setuid (SUID)
Set-user-ID mode bit. This attribute sets the effective and saved user IDs of the process to
the owner ID of the file on execution.
setgid (SGID)
Set-group-ID mode bit. This attribute sets the effective and saved group IDs of the process
to the group ID of the file on execution.
savetext (SVTX)
Saves the text in a text file format.
above attributes are added in the following format:
The attributes: SUID, SGID, SVTX

Extended permissions
AIXC ACL extended permissions allow the owner of a file to more precisely define access to that
file. Extended permissions modify the base file permissions (owner, group, others) by permitting,
denying, or specifying access modes for specific individuals, groups, or user and group
combinations. Permissions are modified through the use of keywords.
The permit, deny, and specify keywords are defined as follows:
permit
Grants the user or group the specified access to the file deny Restricts the user or group from using the specified access to the file specify Precisely defines the file access for the user or group a user is denied a particular access by either a deny or a specify keyword, no other entry can If override that access denial.
The enabled keyword must be specified in the ACL for the extended permissions to take effect.
The default value is the disabled keyword.
In an AIXC ACL, extended permissions are in the following format:
extended permissions:
enabled | disabled
permit Mode UserInfo...:
deny Mode UserInfo...:
specify Mode UserInfo...:

Use a separate line for each permit, deny, or specify entry. The Mode parameter is expressed as
rwx (with a hyphen (-) replacing each unspecified permission). The UserInfo parameter is
expressed as u:UserName, or g:GroupName, or a comma-separated combination of u:UserName and
g:GroupName.
Note: If more than one user name is specified in an entry, that entry cannot be used in an access
control decision because a process has only one user ID.

5. After changing the files for necessary ACL permission's save the file as we are going to use this file for our future input values.

6. Now to put the acl on the other file with as per the changes you made in your file.

# aclput -i acldefs acltest3

This will put the acl's on the file with the values specfied in the acldefs file. and now you can play with acl's

Note: To copy acl's from one file to another.

# aclget filename | aclput filename1

That's all for ACL's for now. Will write about NFS4 ACL's on AIX

Access Control List + Solaris

2007-07-12T04:55:00.001-07:00

All the commands are fired from (% - user) prompt not (# - root) so do not confuse with the #es there with root prompt. They are the command output.

The ACL facility allows you to define more than just the usual eight permission bits for a file or directory. You can define a list of users (based on user-id or name) and groups (again, number or name) that you want to have access to a file. For each user or group getting special access, you can define read, write, or execute access permission.

There are only two commands that you need to learn for Solaris ACLs. They are setfacl for setting a file's ACLs and getfacl for reading them. There are also a bunch of system and library calls that make the ACL facility available to programs. One confusing aspect of ACLs is that, in essence, every file already has an ACL entry. Running getfacl on a normal file reveals some ACL information:

% cd /usr/tmp
% touch foo
% ls -l foo
-rw-r--r--   1 pbg      staff          0 Jul 22 13:35 foo

% getfacl foo
# file: foo
# owner: pbg
# group: staff
user::rw-
group::r--              #effective:r--
mask:rwx
other:r--

This ACL information is merely getfacl's interpretation of the Unix permissions on the file. The user, group and other information is a straightforward display of the permission bits for those fields. The mask field is very similar to the Unix umask method. It defines the maximum permissions allowed for users (other than the owner) and groups. Even if a user or group has permissions set that exceed the mask, the mask limits their access. The #effective display shows, for each user (except the owner) and group, the effect that the mask has on the permissions. The #effective output is the one to look at to determine exactly who can access the file and exactly what they are allowed to do.

To set an ACL for a file, use the command setfacl:

% setfacl -m user:jeff:rw- foo

% ls -l foo
-rw-r--r--+  1 pbg      staff          0 Jul 22 13:52 foo

% getfacl foo

# file: foo
# owner: pbg
# group: staff
user::rw-
user:jeff:rw-           #effective:r--
group::r--              #effective:r--
mask:r--
other:r--

The -m option tells setfacl that I want to modify the ACLs for the file. Use the -s option to set the entire mode, but then you must type in the user, group, and other access bits as well:

% setfacl -s user::rw-,group::r--,other:---,mask:rw-,user:jeff:rw- foo

To set general user, group, and other permissions, use the field::perms identifier. To set ACLs for individual users and groups, use the field:uid or gid:perms identifier.

But back to our previous example. Notice that the effective access for user Jeff is unchanged, he can still only read the file, not write to it. That's the result of the mask being applied to his permissions. To grant Jeff the access desired, I need to:

% setfacl -m mask:rw- foo
% getfacl foo

# file: foo
# owner: pbg
# group: staff
user::rw-
user:jeff:rw-           #effective:rw-
group::r--              #effective:r--
mask:rw-
other:r--

Now Jeff has read and write permissions to the file, while all others have only read access. Of note is the slight change in behavior of the ls command. Any file with specific ACL information is shown with a + at the end of the permission field. Unfortunately, find doesn't seem to have an option to find all files with ACL lists.

As well as setting an ACL for the directory, you can set a default ACL for the directory. This default ACL is used to set the ACL on every file created within the directory. The only way I managed to get directory ACLs to work was using the -s option with a very-long parameter string:

% setfacl -s user::rwx,group::rw-,mask:r--,other:rw-,default:user::rw-,\
default:group::r-x,default:mask:rwx,default:other:r-x bar

% ls -ld bar
drwxr--rw-+  2 pbg      staff        512 Jul 22 14:11 bar

% getfacl bar

# file: bar
# owner: pbg
# group: staff
user::rwx
group::rw-              #effective:r--
mask:r--
other:rw-
default:user::rw-
default:group::r-x
default:mask:rwx
default:other:r-x

Now set a default ACL, and create a file in the directory:

% setfacl -m default:user:jeff:rwx bar

% getfacl bar

# file: bar
# owner: pbg
# group: staff
user::rwx
group::rw-              #effective:r--
mask:r--
other:rw-
default:user::rw-
default:user:jeff:rwx
default:group::r-x
default:mask:rwx
default:other:r-x
default:user::rw-
default:user:jeff:rwx
default:group::r-x
default:mask:rwx
default:other:r-x

% touch bar/test

% getfacl bar/test

# file: bar/test
# owner: pbg
# group: staff
user::rw-
user:jeff:rwx           #effective:r--
group::r--              #effective:r--
mask:r--
other:r--

There are several other aspects of ACLs, including deleting ACLs and using abbreviations and permission bit numbers (rather than symbols). This information is provided on the appropriate manual pages.

To use ACLs over an NFS mount, both the client and server must be running Solaris 2.5 or better. If the client is running 2.5 but the server is running 2.4 or lower, you'll see an error such as:

% touch foo
% getfacl foo

# file: foo
# owner: pbg
# group: staff
user::rw-
group::r--              #effective:r--
mask:rwx
other:r--

% setfacl -m user:jeff:rw- foo
foo: failed to set acl entries
setacl error: Operation not applicable

You'll get a similar error if you try to use ACLs in a swapfs-based directory (such as /tmp). Finally, there's a "non-feature" of ACLs when used with tar. tar itself works well with files that have associated ACLs. Unfortunately, the tar file is not readable under previous SunOS and Solaris operating systems.

It is also important to note that ACLs "stick" to a file during copy and rename operations. To remove the ACL from a file use setfacl -d for each entry. When the last entry is removed, the "+" disappears from the file's ls display.

File Permissions

2007-06-18T22:01:00.001-07:00

Search Files on their file permissions.

World readable

Normal users should not have access to configuration files or passwords. An attacker can steal passwords from databases or web sites and use them to deface--or even worse, delete--data. This is why it is important that your file permissions are correct. If you are sure that a file is only used by root, assign it with the permissions 0600 and assign the file to the correct user with chown.

World/Group writable

Finding world-writable files and directories

# find / -type f \( -perm -2 -o -perm -20 \) -exec ls -lg {} \; 2&gt;/dev/null &gt;writable.txt

# find / -type d \( -perm -2 -o -perm -20 \) -exec ls -ldg {} \; 2&gt;/dev/null &gt;&gt;writable.txt

This will create a huge file with permission of all files having either write
permission set to the group or everybody. Check the permissions and eliminate
world writable files to everyone, by executing /bin/chmod o-w on the
files.

SUID/SGID files

Files with the SUID or SGID bit set execute with privileges of the owning
user or group and not the user executing the file. Normally these bits are used
on files that must run as root in order to do what they do. These files can lead
to local root compromises (if they contain security holes). This is dangerous
and files with the SUID or SGID bits set should be avoided at any cost. If you
do not use these files, use chmod 0 on them or unmerge the package that
they came from (check which package they belong to by using equery; if
you do not already have it installed simply type emerge
gentoolkit). Otherwise just turn the SUID bit off with chmod -s.

Finding setuid files

# find / -type f \( -perm -004000 -o -perm -002000 \) -exec ls -lg {} \; 2&gt;/dev/null &gt;suidfiles.txt

This will create a file containing a list of all the SUID/SGID files.

List of setuid binaries

/bin/su

/bin/ping

/bin/mount

/bin/umount

/var/qmail/bin/qmail-queue

/usr/bin/chfn

/usr/bin/chsh

/usr/bin/crontab

/usr/bin/chage

/usr/bin/expiry

/usr/bin/sperl5.6.1

/usr/bin/newgrp

/usr/bin/passwd

/usr/bin/gpasswd

/usr/bin/procmail

/usr/bin/suidperl

/usr/lib/misc/pt_chown

/usr/sbin/unix_chkpwd

/usr/sbin/traceroute

/usr/sbin/pwdb_chkpwd

By default Gentoo Linux does not have a lot of SUID files (though this depends
on what you installed), but you might get a list like the one above. Most of
the commands should not be used by normal users, only root. Switch off the SUID
bit on ping, mount, umount, chfn, chsh,
newgrp, suidperl, pt_chown and traceroute by
executing chmod -s on every file. Don't remove the bit on su,
qmail-queue or unix_chkpwd. Removing setuid from those files will
prevent you from su'ing and receiving mail. By removing the bit (where
it is safe to do so) you remove the possibility of a normal user (or an
attacker) gaining root access through any of these files.

The only SUID files that I have on my system are su, passwd,
gpasswd, qmail-queue, unix_chkpwd and pwdb_chkpwd.
But if you are running X, you might have some more, since X needs the elevated
access afforded by SUID.

SUID/SGID binaries and Hard links

A file is only considered deleted when there are no more links pointing to it.
This might sound like a strange concept, but consider that a filename like
/usr/bin/perl is actually a link to the inode where the data is
stored. Any number of links can point to the file, and until all of them are
gone, the file still exists.

If your users have access to a partition that isn't mounted with nosuid
or noexec (for example, if /tmp, /home, or
/var/tmp are not separate partitions) you should take care to
ensure your users don't create hard links to SUID or SGID binaries, so that
after Portage updates they still have access to the old versions.

To check how many links a file has, you can use the stat command.

Stat command

$ stat /bin/su

  File: `/bin/su'

  Size: 29350           Blocks: 64         IO Block: 131072 regular file

Device: 900h/2304d      Inode: 2057419     Links: 1

Access: (4711/-rws--x--x)  Uid: (    0/    root)   Gid: (    0/    root)

Access: 2005-02-07 01:59:35.000000000 +0000

Modify: 2004-11-04 01:46:17.000000000 +0000

Change: 2004-11-04 01:46:17.000000000 +0000

To find the SUID and SGID files with multiple links, you can use find.

Finding multiply linked suid/sgid binaries

$ find / -type f \( -perm -004000 -o -perm -002000 \) -links +1 -ls

Configure a Physical Interface After System Installation

2007-06-17T11:59:00.000-07:00

* Determine the IPv4 addresses that you want to use for the additional interfaces.

* Ensure that the physical interface to be configured has been physically installed onto the system.

* If you have just installed the interface, perform a reconfiguration boot before proceeding with the next task.

Determine which interfaces are currently configured on the system.
# dladm show-link

Configure and plumb each interface
# ifconfig plumb up

for eg. for interface name pcn0 type:
# ifconfig pcn0 plumb up

Assign an IP address.
# ifconfig netmask +

for eg. you would do:
# ifconfig pcn0 192.168.84.3 netmask + 255.255.255.0

Verify that the newly configured interfaces are plumbed and configured, or “UP.”
# ifconfig -a

Check the status line for each interface that is displayed. Ensure that the output contains an UP flag on the status line, for example:
pcn0: flags=1000843 mtu 1500 index 2

To make the interface configuration persist across reboots, perform the following steps:

1. Create an /etc/hostname.interface file for each interface to be configured. For example, to add a pcn0 interface, you would create the following file:
# vi /etc/hostname.pcn0

2. Edit the /etc/hostname.interface file.
At a minimum, add the IPv4 address of the interface to the file.

3. Add entries for the new interfaces into the /etc/inet/ipnodes file.

4. Add entries for the new interfaces into the /etc/inet/hosts file.

5. Perform a reconfiguration boot.
# reboot -- -r
6. Verify that the interface you created in the /etc/hostname.interface file has been configured.
# ifconfig -a

AIX Training Center in Mumbai

2007-06-09T10:30:00.000-07:00

Dear Friends,

We have been working in UNIX platform since the last 3-4 years and we realized that industry is in need of quality training in IBM AIX. Till now we could'nt find any IBM AIX Training centers in our premises. So we decided to take the responsibility of imparting the knowledge we earned to the upcoming unix generation.

Here starts our training centre.

Shubham Computers
Opposite RANA Towers
Kalwa.

We will be very glad and thankful if you pass this info to your friend circle.

Sijo James
sijojamesn@gmail.com

*****The pessimist sees difficulty in every opportunity. The optimist sees opportunity in every difficulty****

Ethernet Bonding

2007-06-05T07:26:00.000-07:00

First thing to know is that this stuff is in the kernel and there is a good doc in your kernel source tree under Documentation/networking/bonding.txt this has a lot more detail than I am going to provide here.

A virtual network interface gets created, bond0 in my case, this gets done in /etc/modules.conf

alias bond0 bonding
options bond0 miimon=100 mode=balance-rr

The above creates the bond0 interface and sets some options. It will check the MII state of the card every 100 milliseconds for state change notification. It will also use their round robin balancing policy. More on the various options for these and many more in bonding.txt

RedHat's RC scripts support this bonding configuration without much modification though there aren't any GUI tool to configure it. RedHat network config gets stored in /etc/sysconfig/network-scripts/ifcfg-int

You need to create a config file for the bond0 interface, ifcfg-bond0

DEVICE=bond0
BOOTPROTO=none
ONBOOT=yes
IPADDR=192.168.70.101
NETMASK=255.255.255.0
NETWORK=192.168.70.0
BROADCAST=192.168.70.255
GATEWAY=192.168.70.1

And for each network card that belongs to this group you need to modify the existing files to look more or less like this:

DEVICE=eth0
BOOTPROTO=none
ONBOOT=yes
TYPE=Ethernet
MASTER=bond0
SLAVE=yes

Once you created these for each of your ethernet cards you can reboot or restart your networking using service network restart and you should see something like this:

bond0     Link encap:Ethernet  HWaddr 00:0D:60:9D:24:68
       inet addr:192.168.70.101  Bcast:192.168.70.255 Mask:255.255.255.0
       UP BROADCAST RUNNING MASTER MULTICAST  MTU:1500  Metric:1
       RX packets:58071 errors:0 dropped:0 overruns:0 frame:0
       TX packets:1465 errors:0 dropped:0 overruns:0 carrier:0
       collisions:0 txqueuelen:0
       RX bytes:4315472 (4.1 Mb)  TX bytes:120360 (117.5 Kb)

eth0      Link encap:Ethernet  HWaddr 00:0D:60:9D:24:68
       UP BROADCAST RUNNING SLAVE MULTICAST  MTU:1500  Metric:1
       RX packets:26447 errors:0 dropped:0 overruns:0 frame:0
       TX packets:1262 errors:0 dropped:0 overruns:0 carrier:0
       collisions:0 txqueuelen:1000
       RX bytes:1992430 (1.9 Mb)  TX bytes:95078 (92.8 Kb)
       Interrupt:16

eth1      Link encap:Ethernet  HWaddr 00:0D:60:9D:24:68
       UP BROADCAST RUNNING SLAVE MULTICAST  MTU:1500  Metric:1
       RX packets:31624 errors:0 dropped:0 overruns:0 frame:0
       TX packets:203 errors:0 dropped:0 overruns:0 carrier:0
       collisions:0 txqueuelen:1000
       RX bytes:2323042 (2.2 Mb)  TX bytes:25282 (24.6 Kb)
       Interrupt:17

You can tcpdump the individual interfaces to confirm that traffic goes shared between them, weirdly though on my machine my tcpdump on eth0 and eth1 does not show incoming traffic just outgoing, dumping bond0 works a charm though.

To test it I just turned the power off to one of my switch modules, the networking dies for a couple of seconds but soon resumes without a problem. I am sure I could tweak the times a bit but for now this is all I need.

UNIX Questions and Answers

2007-05-09T08:54:00.001-07:00

UNIX Questions and Answers

Most answers refer to Solaris 2.x systems

Hardware Issues

Configuration Issues

NFS Issues

General Issues

Software issues

Jumpstart setup and configuration (currently unavailable - being re-written)
Veritas command line arguments
Legato command line commands
Raid Manager 6.22 and A1000
Solstice Disksuite (SDS) setup and configuration
Solstace Disksuite (SDS) mirror root disk
Samba setup and config
SSH steup (currently unavailable - being re-written)
clearcase checkin
Read audio player for Solaris
how can i build a html page of system configurations
Graphical FTP programs for X
What X windows Managers are there
Free X server for 95/98/2000/NT"
Microsoft Internet explorrer and outlook express for solaris

Networking issues

How do i view and set the open boot prom settings

From the unix prompt use eeprom. From the ok prompt use devaliases, printenv, nvedit and nvalias.

Back to Contents

How do i stop people logging in ?

If the file /etc/nologin exists then only root can login. Whatever the contents of the file are are displayed to whoever is attempting a login.

Back to Contents

How do i boot over the net via a different interface

From the ok prompt type


show-nets

This will display the possible interfaces. Select an interface then type


nvalias net ^Y

This will set the selected interface to the alias net.

Back to Contents

How do I solve Keyboard Translation
Errors?

The most likely cause of this is an incorrect XKeysymDB file or an
incorrect pointer to it. Try looking in /usr/openwin/lib or
/usr/openwin/lib/X11. The Installation and Administration
manual for the application should have some information about this.

If logged in as root from another system try
/usr/openwin/bin/kbd-mode -a

Back to Contents

Why do I get the error Stale NFS
Handle?

This was probably caused by a directory being deleted while another
system was NFS mounted into it. The best action is to cd
out of the directory and perform a umount. Sometimes
halting and restarting the automount daemon is reqired, for example:

/etc/rc2.d/S74autofs [stop/start]. or

/etc/init.d/nfs.server [stop/start].

If none of these work, then it might have to be a reboot.

Back to Contents

How can I configure new devices without
rebooting?

It is advisable to halt and power off the system whenever you attach new
scsi devices. However, if this is not possible try this:

If possible stop the system with < STOP > < A >, connect the device and
type go
Type:

drvconfig

devlinks

tapes / disks (depending on the device attached)

Back to Contents

What does the error RPC Program not registered
mean?

Probably the NFS server has got itself a little confused. Check there is
an entry in /etc/dfs/dfstab

Try stopping and restarting the daemon, for example:

/etc/init.d/nfs.server [stop/start]

If this doesn't work, try a reboot.

Back to Contents

How do I tar to a remote system?

Tar to a remote drive:

tar cvfb - 20 filenames | rsh host dd of=/dev/rmt0 obs=20b

Tar from a remote drive:

rsh -n host dd if=/dev/rmt0 bs=20b | tar xvBfb - 20 filenames

Copying directory trees:

cd fromdir; tar cf - . | (cd todir; tar xfBp -)

Copy directory tree to another host:

cd fromdir; tar cf - * | rsh host "cd todir ; tar xf -"

Back to Contents

How do I copy directory structure with cpio?

Use find and cpio

cd fromdir; find . -name -print | cpio -pmd /todir

Back to Contents

How can I increase swap space?

Swapping onto a file system is faster than swapping to a file. If
possible, partition an area of disk as the additional swap area.
Otherwise, create a swap file with the command mkfile (see
man page), for example:

mkfile 100m swappy

Add the swap area with the command swap (see man page) for
example:

swap -a swappy

Back to Contents

Cetting a non sun cdrom to work

The main secret is to get the cdrom to talk in 512 byte sectors. If the cdrom does this then it will work.

Saturn.tlug.org This is a good FAQ to start with or try the Sun CD FAQ. or of course your manafacturs instruction book.

Back to Contents

How do I find out the speed of my machine?

Use the command psrinfo -v

Back to Contents

How do I carry out NFS performance tuning?

Start with the SMCC NFS Server Performance and Tuning Guide

This is a pkgadd of SUNWabhdw and adds the guide to answerbook

SUNWadhdw is on the "Software Supplement for the Solaris 2.6 Operating
Environment" CD.

Use the command /usr/bin/nfsstat to view the NFS statistics

Back to Contents

What hardware diagnostic programs are
there?

Use SunVTS. This is available on the Software Supplement for the Solaris
2.6 Operating Environment CD.

If you have a fibre problem then try STORtools. You will probably need
a fibre loopback cable in order to get the most out of this.

Back to Contents

How do I make a file system bootable after a
restore?

If you have reinstalled the / file system from backup (ie
ufsdump) then you will need to recreate the boot block on
the boot disk. This is done using the installboot command (
read the man page ), for example:

installboot /usr/platform/`uname -i`/lib/fs/ufs/bootblk /dev/rdsk/c?t?d?s?

Back to Contents

How do I dual host a system?

Install the network card and cable it up. Make sure that any
jumpersettings are set.
Add the second interface name and IP to the hosts file and Name
Service.
Edit the file /etc/hostname.interface where
interface is the type, for example, le1 hme1
Reboot the sysyem or manually set it up with ifconfig
(see manual page)

ifconfig hmse1 plumb

ifconfig hmse1 IP-Address

You may also need to perform an add route (see manual page)

route add net destination gateway metric
Back to Contents

How do I find out what patches are on a
system?

Use the command showrev -p

Use the command patchdiag -l this also lists patches you should install.

You
will need do download a copy from sun. If you have access try
downloading from http://sunsolve.sun.com.sunsolve/patchdiag this is a
tar compressed file.

There is a tar file of patchdiag on this site but i have not set up ftp at the moment of writing this page.

Back to Contents

How much memory does my system have?

Use the command prtconf and grep for the
memory, for example:

prtconf |grep Memory

If you need to know what memory sims are in what slot use the perl script from Micron. A sample script is.

Sample of Memcom Script Remeber to get an official copy.

Back to Contents

How can I play audio CDs and MP3 on my system?

For CD

Download a copy of Workman from Midwinter.com

If you have problems with sound then it might be that you cannot use
the internal sound card and will have to plug speekers int the cd
plater itself.

However this might work

edit /etc/rmmount.conf and add

action cdrom action_workman.so

/usr/local/bin/workman

try this before any other cdrom actions

For MP3 files look to the following site

Opensound

If you wish to read an audio cd under solaris and copy the files to
wav, mpeg, etc then you need the program galette available from Galette

Once you have the files stored as wav files you need to convert them to MP3 using Blade

Back to Contents

What useful Solaris commands are there
for finding out what's going on?

This is a definite RTFM, but start with these:

ps, iostat, nfsstat,
sar, netstat, snoop,
mpstat, rpcinfo, truss,
prtdiag, crash, psrinfo,
prtconf, arp and uptime

try looking at the enclosed perl script to get an idea of wht to look for.

Perl script to look at how the system is performing

Back to Contents

How do I connnect a Zip Drive?

Helpful info from Iomega at

Zip Drives on Sun

basically edit /etc/format.dat and add :-

disk_type = "Zip" \

	: ctlr = SCSI\

	: ncyl = 2046 : acyl = 2 : pcyl = 2048 : nhead = 2\

	: nsect = 40 : rpm : bpt = 20480                   



partition = "Zip" \

        : disk = "Zip" : ctlr = SCSI \

        : 2 = 0, 192480 : 2 = 0, 1159168

Jazz Drives on Sun
Back to Contents

Why do I get .nfsxxxx files on NFS mounted
filesystems?

These are temporary files used by the system to guarantee data
reliability over the unreliable nfs mount. These can be left behind by
an application or process that has terminated abnormally.

Back to Contents

How do I stop printing a banner page?

If this is for just one print, use the -o option, for
example:

lp -o nobanner name

Otherwise, edit the file /etc/lp/interfaces/printername and
change the option nobanner to yes.

Back to Contents

How can I find out and set shared memory?

Use the command ipcs to view what is set.

If you wish to change them, edit /etc/systems and reboot
with -r.

Typically, you would edit one or more of msgsys,
semsys, shmsys.

Check out the sun docunemt on shared memory sunworld document on shared memory

Back to Contents

Number of inodes used and free

use the command df -F ufs -o i

Back to Contents

What block size is my file system

use the command mkfs -m /dev/dsk/c?t?d?s?

look at the bsize value (you need to be root to run this)

Back to Contents

How do I find out which clients are NFS mounting
a server?

Use the command dfmounts

Back to Contents

How do I get rid of defunct processes?

These are caused by an application or process crashing, terminating
abnormally, getting confused
etc. Look for the parent process of these and kill or refresh it.

Back to Contents

What version of bind am I running?

try /usr/ccs/bin/what /usr/sbin/in.named |grep named

Solaris 2.6 bind 4.9.4-P1 



Solaris 2.5.1 bind 4.9.3-P1

Back to Contents

How can I change the hostid?

There are several ways to do this, try:

Squirrel
FAQ

Back to Contents

Why am I having problems mounting a floppy?

Back to Contents

How do I configure dtlogin for other window managers?

You need to create an Xresourses file to start the window manager.

cd /usr/dt/config/C/Xresources.d
copy Xresources.ow to a new name of your window manager ie Xresourses.kde.

Now edit your Xresources.kde file. Making the changes for your window manager

I.e.

Dtlogin*altDtsIncrement: True

Dtlogin*altDtName: KDE Desktop

Dtlogin*altDtKey: /usr/local/kde/bin/startkde

Dtlogin*altDtStart: /usr/local/kde/bin/startkde

Dtlogin*altDtLogo: KDElogo

copy the KDE logo KDElogo.pm to /usr/dt/appconfig/icons/C/KDElogo.pm

Back to Contents

Dual headed sun system

Try looking at infodoc 11669.

OPenwin
openwin -dev /dev/cgsix0 left -dev /dev/cgsix1 right

CDE

edit Xservers with

:0 Local local_uid@console root /usr/openwin/bin/Xsun :0 -dev /dev/cgsix0 -dev /dev/cgsix1 right

How do I configure CDE?

The control panel

In this example I will add the workman cd player to the control panel.

Copy the CDE config file dtwm.fp from /usr/dt to your homedirectory/.dt/types

Create an icon and place it in ~.dt/icons. it should have a .m.pm extension.

ie. Player.m.pm

Edit the dtwm.fp file
and add following. In this case I am adding it between the help and
trash areas. the position hints is 13 so it should appear towards the
right between the help (book) icon and the trash (waste bin) icon.

CONTROL cdplayer

{

  TYPE                  icon

  CONTAINER_NAME        Top

  CONTAINER_TYPE        BOX

  POSITION_HINTS        13

  PUSH_ACTION           cdplayer

  ICON                  Player

}

Create a file for what to do when the button is pushed. In the example
it is called cdplayer. The file has a .dt extension IE cdplayer.dt. The
contents of this file are.

ACTION cdplayer

{

     LABEL         cdplayer

     TYPE          COMMAND

     EXEC_STRING   /usr/local/bin/workman

     ICON          somename

     WINDOW_TYPE   NO_STDIO

     DESCRIPTION   starts cdplayer

}

The mouse menu

copy the mouse menu from /usr/dt/config/C/sys.dtwmrc to you home directory ~/.dt/types/dtwmrc.



edit the dtwnrc file adding or removing mouse options. In this case we will create an applications submenu and put the cdplayer in that submenu. 



Firstly add the applications menu to the main menu by instering a line like this



"Applications"                      f.menu apps

in the DtRootMenu section.  approx line 38

then  hgo to the botton of the file and create the application menu. ie. 



Menu apps

{

APPLICATIONS" f.title

"CD Player" f.exec "/usr/local/bin/workman"

}

Back to Contents

How do I stop colour flashing?

Back to Contents

How do i communicate between systems using scokets

There are several ways to do this.  Below is an example of a perl program that sends the string 

"hey now hey now now. Sing this corrosion to me " to port 1250 on a system called mission.

On the mission server there is a program which is called via inetd that picks up this incomming 

line and writes it to a file /tmp/outfile.  the program is called read-socket.pl





Sample /etc/inetd.conf entry

read-socket stream tcp nowait neville /export/home/neville/read-socket.pl



Sample /etc/services entry

read-socket     1250/tcp



Sample sending program  (send-line.pl)

#!/usr/bin/perl

use IO::Socket;

$sock = new IO::Socket::INET (PeerAddr =&gt; 'mission',

                              PeerPort =&gt; 1250,

                              Proto    =&gt; 'tcp',

                             );

die "Socket could not be created.  Reason $! \n"  unless $sock;

print $sock "hey now hey now now. Sing this corrosion to me\n";

close ($sock);



Sample sending program  (send-file.pl)

#!/usr/bin/perl

use IO::Socket;

my $FILETOSEND = "/tmp/crappy";

open (INFILE, $FILETOSEND) || die "cannot open file: $FILETOSEND \n";

$sock = new IO::Socket::INET (PeerAddr =&gt; 'mission',

                              PeerPort =&gt; 1250,

                              Proto    =&gt; 'tcp',

                             );

die "Socket could not be created.  Reason $! \n"  unless $sock;

#now do the sending

select  ($sock);

while (&lt; INFILE &gt; )

	{	

	print $_;

}

close ($sock);

close ($INFILE);



Sample reading program  (read-socket.pl)

#!/usr/bin/perl

open (OUT,  "&gt;/tmp/outfile") || die "cannot open output file \n";

print OUT &lt; STDIN &gt;

close (OUT);



Sample reading program as a deamon (not using /etc/system and /etc/services)

#!/usr/bin/perl

use IO::Socket;

$sock = new IO::Socket::INET (PeerPort =&gt; 1250,

                              Proto    =&gt; 'tcp',

                              Listen   =&gt; 10,

                              Reuse    =&gt; 1,

                             );

die "Cannot start deamon on socket  Reason $! \n"  unless $sock;

while ($this_connection = $server-&gt;accept())

{

print $this_connection;

}

close ($sock);

Back to Contents

How do i find out what resources a running process is using

Use the proc commands below and others. 

/usr/proc/bin/pmap -x $PID   (see what memory is used)

/usr/proc/bin/pldd $PID         (see what shared libraries are used)

/usr/proc/bin/pwdx $PID         (see what the working directory is)



Download a copy of memtool from Sun.  ftp://playground.sun.com/pub/memtool

Back to Contents

How can i program in curses?

If you plan to use curses to do an interface try looking at this site. It might make life easier for you

SCRMGR curses interface

Back to Contents

Get system hardware configuration

Run the command /usr/platform/arch-type/sbin/prtdiag -V

Back to Contents

Run jobs in background during times of light system loading

Try this site
Idalize program

Back to Contents

System stats in html format

Get a copy of DHTMLR (Do HTML Report) forom the belew site.

this is a shell script that gets system info and builds web pages.
DHTMLR program from the Sunsolve site Belgium

Back to Contents

Graphical FTP front ends for X

There are quite a few graphical front ends for ftp available. Below are
a couple of them. Also try looking at the KDE and GNOME sites.

GNU licenses Graphical ftp

llnl xdir

Back to Contents

Security issues and Solaris

Um yes well probably quite a few bits to add here. lets try

Security FAQ Page

Back to Contents

Info on old sun hardware

This is a 7 part document

Back to Contents

Microsoft Internet Explorer and Outlook express for Solaris

Download it from

Internet Explorer

Back to Contents

How to prevent stack overflow

add noexec_user_stack to the file /etc/system

Back to Contents

How to tell if you are in 32 or 64 bit mode

use the command isainfo -v

Back to Contents

Disable CDROM popup under CDE

comment out the stdvolcheck stuff from

/usr/dt/config/sessionetc

Back to Contents

Stop FTP users from logging in

Set their shell in /etc/passwd to /bin/false. Then edit /etc/shells and add a line /bin/false.

Back to Contents

Check for disk errors

Use the commands

iostat -e or iostst -E or netstat -k

Back to Contents

Firewall information

Probably a lot to say here lets start with

Commonly scanned firewall sockets

Back to Contents

Performance tuning information

Probably a lot to say here lets start with

Performance tuning and look see stuff

Back to Contents

Xerox NeWSprinter20 Toner

As far as i can tell this is the toner Xerox XP 15/20

Back to Contents

Connecting a Sun Monitor to a PC

You will need to get a fixed frequency card. Look at this site.

Monitor world

Back to Contents

Connecting a PC Monitor to a Sun

You will need to get a 13W3 to VGA connector.

Some monitors (Notably Sony based ones) will just work. Plug it it and reboot.

If not you will need to set up your monitor configurations at the NVRAM.

To set the NVRAM you need the following info.

Back to Contents

Pinouts for Scsi, Video, Audio, Parallel, serial, etc

A good site to start looking at is:

Pinouts.com

Back to Contents

What is my screen resolution, etc

Under the X11 environment run the command xdpyinfo. If not running X
then you will need to look at one of the frame buffer config commands.

Unfortunatly these are framebuffer specific but try

System/Framebuffer	Command



Sparc4, Sparcx5 tcx	tcxconfig

x86			kdmconfig

Ultra creator		ffbconfig

Ultra PGX/M64		m64config

sparc ZX/TZX		leoconfig

sparc SX		cg14config

If you do not have the OS running but are at the OK pronpt try using nvedit.

Back to Contents

Upper to lower case traanslation using tr

#!/bin/sh

#translate filenames in uppercase to lowercase



for FILE in `ls`

do

        NEWNAME=`echo $FILE |tr [A-Z] [a-z]`

        mv $FILE $NEWNAME

done

Back to Contents

How to create solaris pkg'd

read this good article.

creating solaris packages

Back to Contents

Mb/Mhz rpm rule of thumb

A vague rule of thumb when looking at disk arrays is MB transfered is 10% of Mhz

for every 1000 rpm of disk you will get about 9 I/O's second therefore a 10,000rpm disk will have 90 I/O second

If these are in a stripe configuration of 5 working disks the the throughput

could be 400 I/O second

At the time of writing a fully populated D1000 could yeald up to 3000 I/O second

Back to Contents

Online & Offline processors and what running on a processor

useful commnads are mpstat, psrinfo, psrset, pbind

Back to Contents

Rename an e10000 domain

Take a look at this page to show how to remane a domain. The main thing
to remember is to rename the domain on the ssp as well as the domain
itself.
Renaming an E1000 Domain

Back to Contents

Unix Interview Questions???

2007-05-09T08:43:00.001-07:00

Linux admin interview questions

How do you take a single line of input from the user in a shell script?
Write a script to convert all DOS style backslashes to UNIX style slashes in a list of files.
Write
a regular expression (or sed script) to replace all occurrences of the
letter ‘f’, followed by any number of characters, followed by the
letter ‘a’, followed by one or more numeric characters, followed by the
letter ‘n’, and replace what’s found with the string “UNIX”.
Write a script to list all the differences between two directories.
Write a program in any language you choose, to reverse a file.
What are the fields of the password file?
What does a plus at the beginning of a line in the password file signify?
Using the man pages, find the correct ioctl to send console output to an arbitrary pty.
What is an MX record?
What is the prom command on a Sun that shows the SCSI devices?
What is the factory default SCSI target for /dev/sd0?
Where is that value controlled?
What happens to a child process that dies and has no parent process to wait for it and what’s bad about this?
What’s wrong with sendmail? What would you fix?
What command do you run to check file system consistency?
What’s wrong with running shutdown on a network?
What can be wrong with setuid scripts?
What value does spawn return?
Write
a script to send mail from three other machines on the network to root
at the machine you’re on. Use a ‘here doc’, but include in the mail
message the name of the machine the mail is sent from and the disk
utilization statistics on each machine?
Why can’t root
just cd to someone’s home directory and run a program called a.out
sitting there by typing “a.out”, and why is this good?
What is the difference between UDP and TCP?
What is DNS?
What does nslookup do?
How do you create a swapfile?
How would you check the route table on a workstation/server?
How do you find which ypmaster you are bound to?
How do you fix a problem where a printer will cutoff anything over 1MB?
What is the largest file system size in solaris? SunOS?
What are the different RAID levels?

Interview questions for Linux admin

Advantages/disadvantages of script vs compiled program.
Name a replacement for PHP/Perl/MySQL/Linux/Apache and show main differences.
Why have you choosen such a combination of products?
Differences between two last MySQL versions. Which one would you choose and when/why?
Main differences between Apache 1.x and 2.x. Why is 2.x not so popular? Which one would you choose and when/why?
Which Linux distros do you have experience with?
Which distro you prefer? Why?
Which tool would you use to update Debian / Slackware / RedHat / Mandrake / SuSE ?
You’re asked to write an Apache module. What would you do?
Which tool do you prefer for Apache log reports?
Your portfolio. (even a PHP guest book may work well)
What does ‘route’ command do?
Differences between ipchains and iptables.
What’s eth0, ppp0, wlan0, ttyS0, etc.
What are different directories in / for?
Partitioning scheme for new webserver. Why?

Unix/Linux programming interview questions

Question 1: What is the major advantage of a hash table? (Asked by Silicon Magic Corp. people)

Answer:
The major advantage of a hash table is its speed. Because the hash
function is to take a range of key values and transform them into index
values in such a way that the key values are distributed randomly
across all the indices of a hash table.

Question 2: What are the techniques that you use to handle the collisions in hash tables?(Asked by Silicon Magic Corp. people)

Answer:
We can use two major techniques to handle the collisions. They are open
addressing and separate chaining. In open addressing, data items that
hash to a full array cell are placed in another cell in the array. In
separate chaining, each array element consist of a linked list. All
data items hashing to a given array index are inserted in that list.

Question 3: In Unix OS, what is the file server? (Asked by Silicon Magic Corp. people)

Answer: The file server is a machine that shares its disk storage and files with other machines on the network.

Question 4: What is NFS? What is its job?(Asked by Silicon Magic Corp. people)

Answer:
NFS stands for Network File System. NFS enables filesystems physically
residing on one computer system to be used by other computers in the
network, appearing to users on the remote host as just another local
disk.

Question 5: What is CVS? List some useful CVS commands.(Asked by Silicon Magic Corp.people)

Anser:
CVS is Concurrent Version System. It is the front end to the RCS
revision control system which extends the notion of revision control
from a collection of files in a single directory to a hierarchical
collection of directories consisting of revision controlled files.
These directories and files can be combined together to form a software
release.

There are some useful commands that are being used very often. They are

cvs checkout

cvs update

cvs add

cvs remove

cvs commit

Unix/Linux administration interview questions

What is LILO?

LILO
stands for Linux boot loader. It will load the MBR, master boot record,
into the memory, and tell the system which partition and hard drive to
boot from.

What is the main advantage of creating links to a file instead of copies of the file?

A:
The main advantage is not really that it saves disk space (though it
does that too) but, rather, that a change of permissions on the file is
applied to all the link access points. The link will show permissions
of lrwxrwxrwx but that is for the link itself and not the access to the
file to which the link points. Thus if you want to change the
permissions for a command, such as su, you only have to do it on the
original. With copies you have to find all of the copies and change
permission on each of the copies.

Write a command to find all of the files which have been accessed within the last 30 days.

find / -type f -atime -30 > December.files

This
command will find all the files under root, which is ‘/’, with file
type is file. ‘-atime -30′ will give all the files accessed less than
30 days ago. And the output will put into a file call December.files.

What is the most graceful way to get to run level single user mode?

A: The most graceful way is to use the command init s.

If you want to shut everything down before going to single user mode then do init 0 first and from the ok prompt do a boot -s.

What does the following command line produce? Explain each aspect of this line.

$ (date ; ps -ef | awk ‘{print $1}’ | sort | uniq | wc -l ) >> Activity.log

A:
First let’s dissect the line: The date gives the date and time as the
first command of the line, this is followed by the a list of all
running processes in long form with UIDs listed first, this is the ps
-ef. These are fed into the awk which filters out all but the UIDs;
these UIDs are piped into sort for no discernible reason and then onto
uniq (now we see the reason for the sort - uniq only works on sorted
data - if the list is A, B, A, then A, B, A will be the output of uniq,
but if it’s A, A, B then A, B is the output) which produces only one
copy of each UID.

These UIDs are fed into wc -l which counts the lines - in this
case the number of distinct UIDs running processes on the system.
Finally the results of these two commands, the date and the wc -l, are
appended to the file "Activity.log". Now to answer the question as to
what this command line produces. This writes the date and time into the
file Activity.log together with the number of distinct users who have
processes running on the system at that time. If the file already
exists, then these items are appended to the file, otherwise the file
is created.

Solaris interview questions

List the files in current directory sorted by size ? - ls -l | grep ^- | sort -nr
List the hidden files in current directory ? - ls -a1 | grep "^\."
Delete blank lines in a file ? - cat sample.txt | grep -v ‘^$’ > new_sample.txt
Search for a sample string in particular files ? - grep .Debug. *.confHere grep uses the string .Debug. to search in all files with extension..conf. under current directory.
Display the last newly appending lines of a file during appendingdata to the same file by some processes ? - tail .f Debug.logHere tail shows the newly appended data into Debug.log by some processes/user.
Display the Disk Usage of file sizes under each directory in currentDirectory ? - du -k * | sort .nr (or) du .k . | sort -nr
Change to a directory, which is having very long name ? - cd CDMA_3X_GEN*Here original directory name is . .CDMA_3X_GENERATION_DATA..
Display the all files recursively with path under current directory ? - find . -depth -print
Set the Display automatically for the current new user ? - export
DISPLAY=`eval ‘who am i | cut -d"(" -f2 | cut -d")" -f1′`Here in above
command, see single quote, double quote, grave ascent is used. Observe
carefully.
Display the processes, which are running under yourusername ? - ps .aef | grep MaheshvjHere, Maheshvj is the username.
List some Hot Keys for bash shell ? - Ctrl+l . Clears the Screen. Ctrl+r . Does a search in previously given commands in shell. Ctrl+u - Clears the typing before the hotkey. Ctrl+a . Places cursor at the beginning of the command at shell. Ctrl+e . Places cursor at the end of the command at shell. Ctrl+d . Kills the shell. Ctrl+z . Places the currently running process into background.
 Display the files in the directory by file size ? - ls .ltr | sort .nr .k 5
How to save man pages to a file ? - man <command> | col .b > <output-file>Example : man top | col .b > top_help.txt
How to know the date & time for . when script is executed ? - Add
the following script line in shell script.eval echo "Script is executed
at `date`" >> timeinfo.infHere, .timeinfo.inf. contains date
& time details ie., when script is executed and history related to
execution.
How do you find out drive statistics ? - iostat -E
Display disk usage in Kilobytes ? - du -k
Display top ten largest files/directories ? - du -sk * | sort -nr | head
How much space is used for users in kilobytes ? - quot -af
How to create null file ? - cat /dev/null > filename1
Access common commands quicker ? - ps -ef | grep -i $@
Display the page size of memory ? - pagesize -a
Display Ethernet Address arp table ? - arp -a
Display the no.of active established connections to localhost ? - netstat -a | grep EST
Display the state of interfaces used for TCP/IP traffice ? - netstat -i
Display the parent/child tree of a process ? - ptree <pid> Example: ptree 1267
Show the working directory of a process ? - pwdx <pid> Example: pwdx 1267
Display the processes current open files ? - pfiles <pid> Example: pfiles 1267
Display the inter-process communication facility status ? - ipcs
Display the top most process utilizing most CPU ? - top .b 1
Alternative for top command ? - prstat -a

Blogging using Livewriter.

2007-05-09T07:02:00.001-07:00

Indeed after doing a search in google i am able to find out a blogging tool for windows thats live write. Well, it is a product of microsoft and it is good. As i haven't tested it a lot. but i am finding it usual till now. After downloading it from here and some teawking in my proxy settings i am able to configure it to work on my office's XP machine.

Converting delimited text to Excel

2007-05-07T11:54:00.000-07:00

Description Google Results

Non-technical people need to be able to work with data. They usually end up reaching for Excel or Access because we live in a malevolent Universe.

Fortunately for the Perl kids there are a couple excellent modules already done for you by our friends John McNamara (Spreadsheet::WriteExcel) and Kawai Takanori (Spreadsheet::ParseExcel). Here is an example of how you can turn Excel into delimited plain text: converting Excel to text.

Below is a very useful and fairly generic subroutine that can take all kinds of delimited files and turn them into straightforward Excel files.

Code

sub text_to_excel {
# %args should look something like...
# ( delimiter => "\t",
#   recordsep => "\n",
#        file => "/path/to/file.txt"
#        name => "Sheet Title" )
# the only required args are delimiter and file

# we require instead of use to save on if we never end up using it in
# a larger script or CGI, but use statements at the top of the script
# are clearer for other programmers to follow.
  require Spreadsheet::WriteExcel;
  require IO::Scalar;

  my %args = @_;
  my ( $delimiter, $recordsep, $file, $name ) =
      @args{qw( delimiter recordsep file name )};

  $delimiter and $file or
      die "Must provide at least delimiter and file as args to" .
          "delimited_text_to_excel().";

  -e $file or
      die "There is no file: $file\n";

  open F, "<", $file or croak("Can't open $file: $!");
  $/ = $recordsep || "\n";
  my @data = <F>;
  close F;
  $/ = "\n";

  my $xls_str;
  tie *XLS, 'IO::Scalar', \$xls_str;

  my $workbook  = Spreadsheet::WriteExcel->new(\*XLS);

  my $worksheet = $workbook->addworksheet($name||'Page 1');

  for ( my $row = 0; $row < @data; $row++ ) {

      chomp( my @line = split /$delimiter/, $data[$row] );

      for ( my $col = 0; $col < @line; $col++ ) {
          $worksheet->write_string($row, $col, $line[$col] || "");
      }
  }
  $workbook->close();
  return $xls_str;
}

Usage

use MIME::Lite;  # we want to mail our excel sheet

my $file     = '/data/profit_forcast';
my $name     = '2006 Profit Forcast';
my $xls_data = text_to_excel( file      => $file,
                            delimiter => "\t",
                            name      => $name );

# we've done all the work. $xls_data IS the excel file in a raw
# format. we could do anything with it now, including writing it to a
# file, but let's send it via email.

my $msg = MIME::Lite->new(From    => 'traitor@sedition.com',
                        To      => 'tuna@fish.net',
                        Cc      => 'traitor@sedition.com',
                        Subject => $name,
                        Type    => 'multipart/mixed')
  or die "PROBLEM opening MIME object: $!";

$msg->attach(Type        => 'application/vnd.ms-excel',
           Disposition => 'attachment',
           Data        => $xls_data,
           Filename    => $name . '.xls')
  or die "PROBLEM attaching Excel file: $!";

$msg->send() or die "PROBLEM sending MIME mail: $!";

print "Sent $name!\n";

Discussion

Anyone who’s dealt with delimited files before knows that this approach is missing a way to balance delimiters. Eg: If your field delimiter is a tab and your record delimiter is a newline and one of the text fields has a tab or a return character in it, it will wreck the results.

To work with this, I often use the NULL character (”\0”) as a field delimiter and a double (”\0\0”) as a record delimiter. It will never appear in regular files so you don’t have to resort to Text::Balanced or something to ensure your data integrity.

If you will ever have empty fields that cause the field delimiter to double up, you’ll have to get crafty and do something like “\0”.‘_RS_’.”\0” for the record separator.

$xls_data = text_to_excel( file      => '/path/to/file.txt',
                         delimiter => "\0",
                         recordsep => "\0\0",
                         name      => 'NULL delimited file' );

Commands.txt

2007-04-24T23:25:00.000-07:00

solaris commands

wipro-bby
wiprobby

1. /usr/bin/uname - display current OS name, versin, Architecture

2. /usr/bin/uptime - Display how long the system has been up

3. /usr/bin/prtconf - Displays out detailed hardware info.

4. /usr/bin/prstat - Display active process statistics with the top process taking the most resource.

5. /usr/platform/sun4u/sbin/prtdiag - Displays very detailes hardware info such as CPU speed, CPU chache and on what slots memory chips is installed.

6. /usr/bin/showrev - displays machine and software version info.

7. /usr/bin/w - display info on currently logged on users.

8. Adding users -
#useradd -d /export/home/username -m -s /bin/ksh
the -m option tells the useradd command to automatically create the home directory.
NOte: do not store user directory in /home as this directory is used by solaris automounter. the automountwer gives the user to login to many machines and automatically ahve their home directories mounted on that machines /home area.

9. to delete users. - /usr/bin/userdel
for eg. userdel -r - will delete the users home directory as well.

10. psrinfo -v - processor info.

11. netstat -rn - show the routing table.

12. ifconfig -a - show the network iface info.

13. explorer output
/opt/SUNWexplo/bin/explorer - it is an executable file used to generate the explorer output
/opt/SUNWexplo/etc/ - directory contains the explorer tar files.

14. passwd -sa --- for checking all system users password.

Network Configuration in Solaris.
1. to set the machine's name - /etc/nodename

2. using DNS edit: /etc/nsswitch.conf - look for line that starts with "hosts:"
add "dns" to the end of the line.
you can add the "dns" entry to the very beginning of the line, which changes the order in which solaris will do the name lookups. for eg. if you have "nis" before "dns" it will check in nis database first and try to resolve it from there and if you have files before dns it will look in the /etc/hosts files before it look in dns.

3. adding entries in /etc/resolv.conf
file: /etc/resolv.conf
search domainname.com
domain domainname.com
nameserver ns1
nameserver ns2

4. adding machines info in /etc/hosts file.
file:/etc/hosts
ipaddr hostame

5. edit the following files.
/etc/net/ticlts/hosts
/etc/net/ticolts/hosts
/etc/net/ticotsnord/hosts

6. editing the interface name files.
sun systems can have multiple network cards, and each of those cards answer to a different hostname you may also have to edit a file to assign the hostname to the main network card.. you may want a single server to respond to many hostnames. the main network interface is mainly "hme0".
to edit interface: /etc/hostname-interface

7. to edit netmask.
/etc/inet/netmasks
----------------------------------------------------------------------------------------------------------------------------
###Exporting Display
##logging on server A using VNC.
1.ssh server B
2.xhost server B
3.export display server A:1.0

##for automatic color schemes.
ls --color=auto

##for time styling
ls --time-style=+%d-%m-%y\&H%M

##adding alias in .profile
alias variable="alias name"
here "alias name" refers to any command which can be used in conjugtion.

##to show all the hidden files in one directory.
ls -d .*

##to remove empty lines using sed.
sed `/^$/d'

##password aging script in linux if chage is not working.
chage -l usernaem - most appropriate condition.
else
login as root.
grep the users in /etc/passwd file using:
#cut -d: -f1 /etc/passwd
#while read line do
#chage -l $users | grep "password expires" and line
#disply $users- your password will expire on

###Configuring Network.
##adding net up on command line.
#ifconfig eth0 netmask brodcast up

##adding the default gateway.
#route add default gw

##add the nameserver entries.
file: /etc/resolv.conf

#nmblookup -A -d1
#smblookup -LBC8 -I -U knopix % -w workcener name -d3

AIX commands.
#lscfg -vp | grep -p Cabinet --- to check the cabinet no. on IBM/AIX

#lsdev -Cc Tape --- to list the tape devices.

#rmdev -dl /dev/rmt0 --- to delete rmt0 device.

#cfgmgr -v --- reread the system hardware components and if iut finds any new thing. it will configure it accordingly.

#lsdev -Cc Tape --- configure the tape drive.

#cfgmgr --- same as above

#cat /etc/exclude.rootvg --- filesystems to exclude while taking complete system backup.

#lsvg -l rootvg --- list the volumme group called as rootvg

#smit mksysb --- the smit interface to take the system backup

#tail smit.log --- tail the log files to see smit is working fine.

#tctl -f /dev/rmt0 rewoffl -eject --- this will rewind the tape and will eject the tape device.

#restore -tvf /dev/rmt0 --- to list the contents of the tape device

#find ./log ./out -print | backup -ivf /dev/rmt0 | tee /tmp/log --- to take backup of some files from ./log and ./out directory on tape device rmt0 while logging and printing the output on the screen.

#restore -xqdvf /dev/rmt0 --- restoring the complete backup on the harddisk directory. the command must be fired from the parent directory to avoid confusions in where to restore dir. name.

########Grub.conf -- How it works
####Manually loading through the bootloader.

###This will boot the windows partition.
rootnoverify (hd0,0)
makeactive
chainloader +1
boot

###booting linux fron /dev/hda3 device
root (hd0,2)
kernel /boot/vmlinuz root=/dev/hda3 -s
boot
initrd /boot/initrd

####SHUTTING DOWN ORACLE 9i

1. ps -aef | grep pmon -> to check orcale instances running.
2. sqlplus /as sysdba
3. shutdown immediately
4. exit
5. ps -aef | grep ora
6. ps -aef | grep tltns
10. kill -9 ora9ibrn

### copies a single 1024 block from /dev/zero(a continuous stream of zero bytes) to the file new file.
dd if=/dev/zero of=new_file bs=1024 count=1

iostat -En will show the devices like c0t0d0.
product :- the last line gives the size of the disk
mount -F hsfs /dev/dsk/c0t0d0s0 /mnt

To see all of the slices on all of the disks the easiest thing is:
prtvtoc /dev/rdsk/*s2
To see all disks do this:
format < /dev/null chmod 550 /usr/lib/methods/cfgidecdrom mount -v cdrfs -o ro /devcd0 /cdrom smit cdrfs /usr/local/bin/scp locator -n locator -f useradd -d /para{home dir} -m -u 101 -g 501 paramatrix{user name} mail.debug /var/spool/mqueue/log Put this entry in /etc/syslog.conf DR.hostname.com ---put this entry in /etc/sendmail.cf fuser -km /media/cdrom [kill the process related to cdrom in aix.] df -k | awk '{print $4}' df -k | grep -v none | awk '{print $5}' | head -8 ; df -k | awk '{print $4}' | grep % df -k | awk '{print $5}' smitty tcpip smitty installp >/dev/null 2>&1 redirecting the cron log to /dev/null
hwclock --systohc sync date with hwclock

df -g |awk '{print $1}'
df -g |awk '{print $7}'
df -g |awk '{print $4}'

To Change the username and home permission of a user
groupmod -n sysadmin santosh
usermod -d /home/sysadmin -m -g sysadmin -l sysadmin santosh

vncserver -kill :1

psrinfo will give number of cpus in Sun Solaris

OGL Backup
cd /oraapps/oracle/prodcomn/admin

# find ./out ./log print | backup ivf /dev/rmtn

pscp.exe -pw 'password' "local machine path" user@host:/path/to/home/

df -g refresh
while :^Jdo^Jdf -g /kcf1dr /kcfdrvg^Jsleep 2^Jclear^Jdone

stopping one spd device
setsp -T -l3

3 is SPD number.

TIP
tip -9600 /dev/ttya
tip -9600 /dev/ttyb

changing users unsuccessful login attempt using sudo
sudo chsec -f /etc/security/lastlog -s username -a unsuccessful_login_count=0

mount -t ext3 -o acl

give rwx privileges to a user which does not belong to the group
setfacl -m u:prod:rwx test
checked the privileges using

getfacl -a test

opensssl rand -base64 6
----------------------------------------------------------------------------
Restoration of backup
# restore -xdvgf /dev/rmtn
n-> no. of the tape drive attached.

To rewind and ejject the tape
# tctl -f /dev/rmtn rewoffl

To list the contents of the tape drive
# restore -Tl -vf /dev/rmt0

To check user account status like locked, unlocked and when the password expires etc.. use
on
AIX:
chuser

Solaris
passwd -s username

Linux
Chage -l username

How to turn on rsh and rlogin on RedHat Enterprise Linux (RHEL 2.1/ 3.0)

2007-04-18T02:59:00.000-07:00

Enable them:

Turn on these three using chkconfig on both the nodes: rexec, rsh and rlogin.

# chkconfig rexec on
# chkconfig rsh on
# chkconfig rlogin on

xinetd

Restart xinetd to be sure.

# service xinetd restart

.rhosts

On hostA's root home directory (usually /root), create a .rhosts file, which has hostB in it.

# cat .rhosts
hostB

Similarly, create a .rhosts on hostB's root home directory which has hostA in it.

# cat .rhosts
hostA

hosts.allow

Now, edit /etc/hosts.allow on hostA:

#
# hosts.allow This file describes the names of the hosts which are
# allowed to use the local INET services, as decided
# by the '/usr/sbin/tcpd' server.
#
ALL : hostB

Edit /etc/hosts.allow on hostB:

#
# hosts.allow This file describes the names of the hosts which are
# allowed to use the local INET services, as decided
# by the '/usr/sbin/tcpd' server.
#
ALL : hostA

hosts.equiv

Edit /etc/hosts.equiv on hostA to have

# cat /etc/hosts.equiv
hostB

Edit /etc/hosts.equiv on hostB to have

# cat /etc/hosts.equiv
hostA

/etc/securetty

And finally, knock off /etc/securetty (rename it or worse, purge it) on both hostA and hostB

Now you are good to go.

Disclaimer: Use at your own risk. Don't flame me. It sure worked for me. Actual results may vary. Use ssh in place of rlogin/rsh/telnet and the like, as ssh is more secure.

Fail Login Configuration

2007-04-16T20:09:00.000-07:00

1. Open the /etc/pam.d/system-auth file for editing.
ensure that a backup done for the file which you are editing.

2. Add the following lines:

auth required pam_tally.so no_magic_root
account required pam_tally.so deny=2 no_magic_root

here the value of deny implies how many login attempts should faillog wait before locking the account for login.

3. Save the file and exit.
4. Test the configuration by attempting to login as a normal user, but using a wrong password.
5. Verify the failed count increments by running the command:

faillog -u
6. To disable faillog for one particular user faillog -m -1 -u username

ssh using keys.

2007-03-13T03:27:00.000-07:00

Here i will try to demonstrate how to use ssh keys to login to machines without password.
Since i did not got it to work with putty now. i will do it with two unix machines and will soon continue this post on to configure it with putty.

1. Check the ssh-server installed on your machine or not. if not download the packages openssh-clients and openssh-server from the respective downloads site.

2. create public and private keys using ssh-keygen

user@home$ ssh-keygen -t dsa ##this will create public and privatye keys.

3. scp the public key to the remote host on which you want to gain the access without password.
user@home$ scp .ssh/id_dsa.pub user@machineB:~/.ssh/authorized_keys ## from machine a to machine b.

4. Now login from Machine A to Machine B and check. it will work without password.

Points:
1. you must login from the account where you have kept the private key. since, you try to login from a diferent account you private key wo0n't be there and that time you will be thrown to a password prompt.
2. Check the permissions of the directory .ssh to be 700 and the permission of the authorized_keys files must be 600. or else it won't work.

The 10 Commands we never use.

2007-02-20T20:05:00.001-08:00

It takes years maybe decades to master the commands available to you at the Linux shell prompt. Here are 10 that you will have never heard of or used. They are in no particular order. My favorite is mkfifo.

pgrep, instead of:

# ps -ef | egrep '^root ' | awk '{print $2}'
1
2
3
4
5
20
21
38
39
...

You can do this:

# pgrep -u root
1
2
3
4
5
20
21
38
39
...

pstree, list the processes in a tree format. This can be VERY useful when working with WebSphere or other heavy duty applications.

# pstree
init-+-acpid
     |-atd
     |-crond
     |-cups-config-dae
     |-cupsd
     |-dbus-daemon-1
     |-dhclient
     |-events/0-+-aio/0
     |          |-kacpid
     |          |-kauditd 

     |          |-kblockd/0
     |          |-khelper
     |          |-kmirrord
     |          `-2*[pdflush]
     |-gpm
     |-hald
     |-khubd
     |-2*[kjournald]
     |-klogd
     |-kseriod 

     |-ksoftirqd/0
     |-kswapd0
     |-login---bash
     |-5*[mingetty]
     |-portmap
     |-rpc.idmapd
     |-rpc.statd
     |-2*[sendmail]
     |-smartd
     |-sshd---sshd---bash---pstree 

     |-syslogd
     |-udevd
     |-vsftpd
     |-xfs
     `-xinetd

bc is an arbitrary precision calculator language. Which is great. I found it useful in that it can perform square root operations in shell scripts. expr does not support square roots.

# ./sqrt
Usage: sqrt number
# ./sqrt 64
8
# ./sqrt 132112
363
# ./sqrt 1321121321
36347

Here is the script:

# cat sqrt
#!/bin/bash
if [ $# -ne 1 ]
then
        echo 'Usage: sqrt number'
        exit 1
else
        echo -e "sqrt($1)\nquit\n" | bc -q -i
fi

split, have a large file that you need to split into smaller chucks? A mysqldump maybe? split is your command. Below I split a 250MB file into 2 megabyte chunks all starting with the prefix LF_.

# ls -lh largefile
-rw-r--r--  1 root root 251M Feb 19 10:27 largefile
# split -b 2m largefile LF_
# ls -lh LF_* | head -n 5
-rw-r--r--  1 root root 2.0M Feb 19 10:29 LF_aa
-rw-r--r--  1 root root 2.0M 
 Feb 19 10:29 LF_ab
-rw-r--r--  1 root root 2.0M Feb 19 10:29 LF_ac
-rw-r--r--  1 root root 2.0M Feb 19 10:29 LF_ad
-rw-r--r--  1 root root 2.0M Feb 19 10:29 LF_ae
# ls -lh LF_* | wc -l
126

nl numbers lines. I had a script doing this for me for years until I found out about nl.

# head wireless.h
/*
 * This file define a set of standard wireless extensions
 *
 * Version :    20      17.2.06
 *
 * Authors :    Jean Tourrilhes - HPL
 * Copyright (c) 1997-2006 Jean Tourrilhes, All Rights Reserved. 

 */

#ifndef _LINUX_WIRELESS_H
# nl wireless.h | head
     1  /*
     2   * This file define a set of standard wireless extensions
     3   *
     4   * Version :    20      17.2.06
     5   * 
      6   * Authors :    Jean Tourrilhes - HPL
     7   * Copyright (c) 1997-2006 Jean Tourrilhes, All Rights Reserved.
     8   */

     9  #ifndef _LINUX_WIRELESS_H

mkfifo is the coolest one. Sure you know how to create a pipeline piping the output of grep to less or maybe even perl. But do you know how to make two commands communicate through a named pipe?

First let me create the pipe and start writing to it:

Then read from it:

ldd, want to know which Linux thread library java is linked to?

# ldd /usr/java/jre1.5.0_11/bin/java
        libpthread.so.0 => /lib/tls/libpthread.so.0 (0x00bd4000)
        libdl.so.2 => /lib/libdl.so.2 (0x00b87000)
        libc.so.6 => /lib/tls/libc.so.6 (0x00a5a000) 

        /lib/ld-linux.so.2 (0x00a3c000)

col, want to save man pages as plain text?
```
# PAGER=cat
# man less | col -b > less.txt
```

xmlwf, need to know if a XML document is well formed? (A configuration file maybe..)

# curl -s 'http://bashcurescancer.com' > bcc.html
# xmlwf bcc.html
# perl -i -pe 's@<br/>@<br>@g'  bcc.html
# xmlwf bcc.html
bcc.html
:104:2: mismatched tag

lsof lists open files. You can do all kinds of cool things with this. Like find which ports are open:

# lsof | grep TCP
portmap    2587   rpc    4u     IPv4       5544                 TCP *:sunrpc (LISTEN)
rpc.statd  2606  root    6u     IPv4       5585                 TCP *:668 (LISTEN)
sshd       2788  root    3u     IPv6       5991                 TCP *:ssh (LISTEN) 

sendmail   2843  root    4u     IPv4       6160                 TCP badhd:smtp (LISTEN)
vsftpd     9337  root    3u     IPv4      34949                 TCP *:ftp (LISTEN)
cupsd     16459  root    0u     IPv4      41061                 TCP badhd:ipp (LISTEN) 

sshd      16892  root    3u     IPv6      61003                 TCP badhd.mshome.net:ssh->kontiki.mshome.net:4661  (ESTABLISHED)

Or find the number of open files a user has. Very important for running big applications like Oracle, DB2, or WebSphere:

# lsof | grep ' root ' | awk '{print $NF}' | sort | uniq | wc -l
179

Bash Tips and Tricks

2007-02-16T04:31:00.000-08:00

Save a lot of typing with these handy bash features you won't find in an old-fashioned UNIX shell.

bash, or the Bourne again shell, is the default shell in most Linux distributions. The popularity of the bash shell amongst Linux and UNIX users is no accident. It has many features to enhance user-friendliness and productivity. Unfortunately, you can't take advantage of those features unless you know they exist.

When I first started using Linux, the only bash feature I took advantage of was going back through the command history using the up arrow. I soon learned additional features by watching others and asking questions. In this article, I'd like to share some bash tricks I've learned over the years.

This article isn't meant to cover all of the features of the bash shell; that would require a book, and plenty of books are available that cover this topic, including Learning the bash Shell from O'Reilly and Associates. Instead, this article is a summary of the bash tricks I use most often and would be lost without.

Brace Expansion

My favorite bash trick definitely is brace expansion. Brace expansion takes a list of strings separated by commas and expands those strings into separate arguments for you. The list is enclosed by braces, the symbols { and }, and there should be no spaces around the commas. For example:

$ echo {one,two,red,blue}
one two red blue

Using brace expansion as illustrated in this simple example doesn't offer too much to the user. In fact, the above example requires typing two more characters than simply typing:

echo one two red blue

which produces the same result. However, brace expansion becomes quite useful when the brace-enclosed list occurs immediately before, after or inside another string:

$ echo {one,two,red,blue}fish
onefish twofish redfish bluefish
$ echo fish{one,two,red,blue}
fishone fishtwo fishred fishblue
$ echo fi{one,two,red,blue}sh
fionesh fitwosh firedsh fibluesh

Notice that there are no spaces inside the brackets or between the brackets and the adjoining strings. If you include spaces, it breaks things:

$ echo {one, two, red, blue }fish
{one, two, red, blue }fish
$ echo "{one,two,red,blue} fish"
{one,two,red,blue} fish

However, you can use spaces if they're enclosed in quotes outside the braces or within an item in the comma-separated list:

$ echo {"one ","two ","red ","blue "}fish
one fish two fish red fish blue fish
$ echo {one,two,red,blue}" fish"
one fish two fish red fish blue fish

You also can nest braces, but you must use some caution here too:

$ echo {{1,2,3},1,2,3}
1 2 3 1 2 3
$ echo {{1,2,3}1,2,3}
11 21 31 2 3

Now, after all these examples, you might be thinking to yourself, "Gee, those are great parlor tricks, but why should I care about brace expansion?"

Brace expansion becomes useful when you need to make a backup of a file. This is why it's my favorite shell trick. I use it almost every day when I need to make a backup of a config file before changing it. For example, if I'm making a change to my Apache configuration, I can do the following and save some typing:

$ cp /etc/httpd/conf/httpd.conf{,.bak}

Notice that there is no character between the opening brace and the first comma. It's perfectly acceptable to do this and is useful when adding characters to an existing filename or when one argument is a substring of the other. Then, if I need to see what changes I made later in the day, I use the diff command and reverse the order of the strings inside the braces:

$ diff /etc/httpd/conf/httpd.conf{.bak,}
1050a1051
> # I added this comment earlier

Command Substitution

Another bash trick I like to use is command substitution. To use command substitution, enclose any command that generates output to standard output inside parentheses and precede the opening parenthesis with a dollar sign, $(command). Command substitution is useful when assigning a value to a variable. This is typical in shell scripts, where a common operation is to assign the date or time to a variable. It also is handy for using the output of one command as an argument to another command. If you want to assign the date to a variable, you can do this:

$ date +%d-%b-%Y
12-Mar-2004
$ today=$(date +%d-%b-%Y)
$ echo $today
12-Mar-2004

I often use command substitution to get information about several RPM packages at once. If I want a listing of all the files from all the RPM packages that have httpd in the name, I simply execute the following:

$ rpm -ql $(rpm -qa | grep httpd)

The inner command, rpm -qa | grep httpd, lists all the packages that have httpd in the name. The outer command, rpm -ql, lists all the files in each package.

Now, those of you who have experience with the Bourne shell might point out that you could perform command substitution by surrounding a command with back quotes, also called back-ticks. Using Bourne-style command substitution, the date assignment from above becomes:

today2=`date +%d-%b-%Y`
$ echo $today2
12-Mar-2004

There are two important advantages to using the newer bash-style syntax for command substitution. First, it can be nested more easily. Because the opening and closing symbols are different, the inner symbols don't need to be escaped with back slashes. Second, it is easier to read, especially when nested.

Even on Linux, where bash is standard, you still encounter shell scripts that use the older, Bourne-style syntax. This is done to provide portability to various flavors of UNIX that do not always have bash available but do have the Bourne shell. bash is backward-compatible with the Bourne shell, so it can understand the older syntax.

Redirecting Standard Error

Have you ever looked for a file using the find command, only to learn the file you were looking for is lost in a sea of permission denied error messages that quickly fill your terminal window?

If you are the administrator of the system, you can become root and execute find again as root. Because root can read any file, you don't get that error anymore. Unfortunately, not everyone has root access on the system being used. Besides, it's bad practice to be root unless it's absolutely necessary. So what can you do?

One thing you can do is redirect your output to a file. Basic output redirection should be nothing new to anyone who has spent a reasonable amount of time using any UNIX or Linux shell, so I won't go into detail regarding the basics of output redirection. To save the useful output from the find command, you can redirect the output to a file:

$ find /  -name foo > output.txt

You still see the error messages on the screen but not the path of the file you're looking for. Instead, that is placed in the file output.txt. When the find command completes, you can cat the file output.txt to get the location(s) of the file(s) you want.

That's an acceptable solution, but there's a better way. Instead of redirecting the standard output to a file, you can redirect the error messages to a file. This can be done by placing a 2 directly in front of the redirection angle bracket. If you are not interested in the error messages, you simply can send them to /dev/null:

$ find /  -name foo 2> /dev/null

This shows you the location of file foo, if it exists, without those pesky permission denied error messages. I almost always invoke the find command in this way.

The number 2 represents the standard error output stream. Standard error is where most commands send their error messages. Normal (non-error) output is sent to standard output, which can be represented by the number 1. Because most redirected output is the standard output, output redirection works only on the standard output stream by default. This makes the following two commands equivalent:

$ find / -name foo > output.txt
$ find / -name foo 1> output.txt

Sometimes you might want to save both the error messages and the standard output to file. This often is done with cron jobs, when you want to save all the output to a log file. This also can be done by directing both output streams to the same file:

$ find / -name foo > output.txt 2> output.txt

This works, but again, there's a better way to do it. You can tie the standard error stream to the standard output stream using an ampersand. Once you do this, the error messages goes to wherever you redirect the standard output:


$ find / -name foo > output.txt 2>&1

One caveat about doing this is that the tying operation goes at the end of the command generating the output. This is important if piping the output to another command. This line works as expected:


find -name test.sh 2>&1 | tee /tmp/output2.txt

but this line doesn't:


find -name test.sh | tee /tmp/output2.txt 2>&1

and neither does this one:


find -name test.sh 2>&1 > /tmp/output.txt

I started this discussion on output redirection using the find command as an example, and all the examples used the find command. This discussion isn't limited to the output of find, however. Many other commands can generate enough error messages to obscure the one or two lines of output you need.

Output redirection isn't limited to bash, either. All UNIX/Linux shells support output redirection using the same syntax.

Searching the Command History

One of the greatest features of the bash shell is command history, which makes it easy to navigate through past commands by navigating up and down through your history with the up and down arrow keys. This is fine if the command you want to repeat is within the last 10-20 commands you executed, but it becomes tedious when the command is 75-100 commands back in your history.

To speed things up, you can search interactively through your command history by pressing Ctrl-R. After doing this, your prompt changes to:

(reverse-i-search)`':

Start typing a few letters of the command you're looking for, and bash shows you the most recent command that contains the string you've typed so far. What you type is shown between the ` and ' in the prompt. In the example below, I typed in htt:

(reverse-i-search)`htt': rpm -ql $(rpm -qa | grep httpd)

This shows that the most recent command I typed containing the string htt is:

rpm -ql $(rpm -qa | grep httpd)

To execute that command again, I can press Enter. If I want to edit it, I can press the left or right arrow key. This places the command on the command line at a normal prompt, and I now can edit it as if I just typed it in. This can be a real time saver for commands with a lot of arguments that are far back in the command history.

Using for Loops from the Command Line

One last tip I'd like to offer is using loops from the command line. The command line is not the place to write complicated scripts that include multiple loops or branching. For small loops, though, it can be a great time saver. Unfortunately, I don't see many people taking advantage of this. Instead, I frequently see people use the up arrow key to go back in the command history and modify the previous command for each iteration.

If you are not familiar with creating for loops or other types of loops, many good books on shell scripting discuss this topic. A discussion on for loops in general is an article in itself.

You can write loops interactively in two ways. The first way, and the method I prefer, is to separate each line with a semicolon. A simple loop to make a backup copy of all the files in a directory would look like this:

$ for file in * ; do cp $file $file.bak; done

Another way to write loops is to press Enter after each line instead of inserting a semicolon. bash recognizes that you are creating a loop from the use of the for keyword, and it prompts you for the next line with a secondary prompt. It knows you are done when you enter the keyword done, signifying that your loop is complete:

$ for file in *
> do cp $file $file.bak
> done

And Now for Something Completely Different

When I originally conceived this article, I was going to name it "Stupid bash Tricks", and show off some unusual, esoteric bash commands I've learned. The tone of the article has changed since then, but there is one stupid bash trick I'd like to share.

About five years ago, a Linux system I was responsible for ran out of memory. Even simple commands, such as ls, failed with an insufficient memory error. The obvious solution to this problem was simply to reboot. One of the other system administrators wanted to look at a file that may have held clues to the problem, but he couldn't remember the exact name of the file. We could switch to different directories, because the cd command is part of bash, but we couldn't get a list of the files, because even ls would fail. To get around this problem, the other system administrator created a simple loop to show us the files in the directory:

$ for file in *; do echo $file; done

This worked when ls wouldn't, because echo is a part of the bash shell, so it already is loaded into memory. It's an interesting solution to an unusual problem. Now, can anyone suggest a way to display the contents of a file using only bash built-ins?

Remote Logins - Telnet

2007-02-16T04:30:00.000-08:00

An answer found from Linux Gazette for the question on Remote Logins and su.

Q. i am running red hat linux 6.1 and am encountering some problems i can login as root from the console but not from anywhere else i have to login as webmaster on all other machines on ntwk from nowhere, including the console, can i su once logged in as webmaster any help would be appreciated

Ans. :
Any of these should allow you to access your system through cryptographically secured authentication and session protocols that protect you from a variety of sniffing, spoofing, TCP hijacking and other vulnerabilties that are common using other forms of remote shell access (such as telnet, and the infamous rsh and rlogin packages).

If you really insist on eliminating these policies from your system you can edit files under /etc/pam.d that are used to configure the options and restrictions of the programs that are compiled against the PAM (pluggable authentication modules) model and libraries. Here's an example of one of them (/etc/pam.d/login which is used by the in.telnetd service):

#
# The PAM configuration file for the Shadow `login' service
#
# NOTE: If you use a session module (such as kerberos or NIS+)
# that retains persistent credentials (like key caches, etc), you
# need to enable the `CLOSE_SESSIONS' option in /etc/login.defs
# in order for login to stay around until after logout to call
# pam_close_session() and cleanup.
#

# Outputs an issue file prior to each login prompt (Replaces the
# ISSUE_FILE option from login.defs). Uncomment for use
# auth       required   pam_issue.so issue=/etc/issue

# Disallows root logins except on tty's listed in /etc/securetty
# (Replaces the `CONSOLE' setting from login.defs)
auth       requisite  pam_securetty.so

# Disallows other than root logins when /etc/nologin exists
# (Replaces the `NOLOGINS_FILE' option from login.defs)
auth       required   pam_nologin.so

# This module parses /etc/environment (the standard for setting
# environ vars) and also allows you to use an extended config
# file /etc/security/pam_env.conf.
# (Replaces the `ENVIRON_FILE' setting from login.defs)
auth       required   pam_env.so

# Standard Un*x authentication. The "nullok" line allows passwordless
# accounts.
auth       required   pam_unix.so nullok

# This allows certain extra groups to be granted to a user
# based on things like time of day, tty, service, and user.
# Please uncomment and edit /etc/security/group.conf if you
# wish to use this.
# (Replaces the `CONSOLE_GROUPS' option in login.defs)
# auth       optional   pam_group.so

# Uncomment and edit /etc/security/time.conf if you need to set
# time restrainst on logins.
# (Replaces the `PORTTIME_CHECKS_ENAB' option from login.defs
# as well as /etc/porttime)
# account    requisite  pam_time.so

# Uncomment and edit /etc/security/access.conf if you need to
# set access limits.
# (Replaces /etc/login.access file)
# account  required       pam_access.so

# Standard Un*x account and session
account    required   pam_unix.so
session    required   pam_unix.so

# Sets up user limits, please uncomment and read /etc/security/limits.conf
# to enable this functionality.
# (Replaces the use of /etc/limits in old login)
# session    required   pam_limits.so

# Prints the last login info upon succesful login
# (Replaces the `LASTLOG_ENAB' option from login.defs)
session    optional   pam_lastlog.so

# Prints the motd upon succesful login
# (Replaces the `MOTD_FILE' option in login.defs)
session    optional   pam_motd.so

# Prints the status of the user's mailbox upon succesful login
# (Replaces the `MAIL_CHECK_ENAB' option from login.defs). You
# can also enable a MAIL environment variable from here, but it
# is better handled by /etc/login.defs, since userdel also uses
# it to make sure that removing a user, also removes their mail
# spool file.
session    optional   pam_mail.so standard noenv

# The standard Unix authentication modules, used with NIS (man nsswitch) as
# well as normal /etc/passwd and /etc/shadow entries. For the login service,
# this is only used when the password expires and must be changed, so make
# sure this one and the one in /etc/pam.d/passwd are the same. The "nullok"
# option allows users to change an empty password, else empty passwords are
# treated as locked accounts.
#
# (Add `md5' after the module name to enable MD5 passwords the same way that
# `MD5_CRYPT_ENAB' would do under login.defs).
#
# The "obscure" option replaces the old `OBSCURE_CHECKS_ENAB' option in
# login.defs. Also the "min" and "max" options enforce the length of the
# new password.

password   required   pam_unix.so nullok obscure min=4 max=8

# Alternate strength checking for password. Note that this
# requires the libpam-cracklib package to be installed.
# You will need to comment out the password line above and
# uncomment the next two in order to use this.
# (Replaces the `OBSCURE_CHECKS_ENAB', `CRACKLIB_DICTPATH')
#
# password required       pam_cracklib.so retry=3 minlen=6 difok=3
# password required       pam_unix.so use_authtok nullok md5

This is from Debian machine (mars.starshine.org) and thus has far more comments (all those lines starting with "#" hash marks) than those that Red Hat installs. It's good that Debian comments these files so verbosely, since that's practically the only source of documentation for PAM files and modules.

In this case the entry that you really care about is the one for 'securetty.so' This module checks the file /etc/securetty which is classically a list of those terminals on which your system will allow direct root logins.

You could comment out this line in /etc/pam.d/login to disable this check for those services which call the /bin/login command. You can look for similar lines in the various other /etc/pam.d files so see which other services are enforcing this policy.

This leads us to the question of why your version of 'su' is not working. Red Hat's version of 'su' is probably also "PAMified" (almost certainly, in fact). So there should be a /etc/pam.d/su file that controls the list of policies that your copy of 'su' is checking. You should look through that to see why 'su' isn't allowing your 'webmaster' account to become 'root'.

It seems quite likely that your version of Red Hat contains a line something like:

# Uncomment this to force users to be a member of group root
# before than can use `su'. You can also add "group=foo" to
# to the end of this line if you want to use a group other
# than the default "root".
# (Replaces the `SU_WHEEL_ONLY' option from login.defs)
auth       required   pam_wheel.so

Classically the 'su' commands on most versions of UNIX required that a user be in the "wheel" group in order to attain 'root' The traditional GNU implementation did not enforce this restriction (since rms found it distasteful).

On my system this line was commented out (which is presumably the Debian default policy, since I never fussed with that file on my laptop). I've uncommented here for this example.

Note that one of the features of PAM is that it allows you to specify any group using a command line option. It defaults to "wheel" because that is an historical convention. You can also use the pam_wheel.so module on any of the PAMified services --- so you could have programs like 'ftpd' or 'xdm' enforce a policy that restricted their use to members of arbitrary groups.

Finally note that most recent versions of SSH have PAM support enabled when they are compiled for Linux systems. Thus you may find, after you install any version of SSH, that you have an /etc/pam.d/ssh file. You may have to edit that to set some of your preferred SSH policies. There is also an sshd_config file (mine's in /etc/ssh/sshd_config) that will allow you to control other ssh options).

In generall the process of using ssh works something like this:

Install the sshd (daemon) package on your servers (the systems that you want to access)
Install the ssh client package on your clients (the systems from which you'd like to initiate your connections).
Generate Host keys on all of these systems (normally done for you by the installation).

.... you could stop at this point, and just start using the ssh and slogin commands to access your remote accounts using their passwords. However, for more effective and convenient use you'd also:

Generate personal key pairs for your accounts.
Copy/append the identity.pub (public) keys from each of your client accounts into the ~/.ssh/authorized_keys files on each of the servers.

This allows you to access those remote accounts without using your passwords on them. (Actually sshd can be configured to require the passwords AND/OR the identity keys, but the default is to allow access without a password if the keys work).

Another element you should be aware of is the "passphrases" and the ssh-agent. Basically it is normal to protect your private key with a passphrase. This is sort of like a password --- but it is used to decrypt or "unlock" your private key. Obviously there isn't much added convenience if you protect your private key with a passphrase so that you have to type that every time you use an ssh/slogin or scp (secure remote copy) command.

ssh-agent allows you to start a shell or other program, unlock your identity key (or keys), and have all of the ssh commands you run from any of the descendents of that shell or program automatically use any of those unlocked keys. (The advantage of this is that the agent automatically dies when you exit the shell program that you started. That automatically "locks" the identity --- sort of.

There are alot of other aspects to ssh. It can be used to create tunnels, through which one can use all sorts of traffic. People have created PPP/TCP/IP tunnels that run through ssh tunnels to support custom VPNs (virtual private networks). When run under X, ssh automatically performs "X11 forwarding" through one of the these tunnels. This is particularly handy for running X clients on remote systems beyond a NAT (IP Masquerading) router or through a proxying firewall.

In other words ssh is a very useful package quite apart from its support for cryptographic authentication and encryption.

In fairness I should point out that there are a number of alternatives to ssh. Kerberos is a complex and mature suite of protocols for performing authentication and encryption. STEL is a simple daemon/client package which functions just like telnetd/telnet --- but with support for encrypted sessions. And there are SSL enabled versions telnet and ftp daemons and clients.

How do I lock out a user after a set number of login attempts?

2007-02-16T04:25:00.000-08:00

The PAM (Pluggable Authentication Module) module pam_tally keeps track of unsuccessful login attempts then disables user accounts when a preset limit is reached. This is often referred to as account lockout.

To lock out a user after 4 attempts, two entries need to be added in the /etc/pam.d/system-auth file:

auth        required        /lib/security/$ISA/pam_tally.so onerr=fail no_magic_root
account     required        /lib/security/$ISA/pam_tally.so deny=3 no_magic_root reset

The options used above are described below:

onerr=fail
If something strange happens, such as unable to open the file, this determines how the module should react.
no_magic_root
This is used to indicate that if the module is invoked by a user with uid=0, then the counter is incremented. The sys-admin should use this for daemon-launched services, like telnet/rsh/login.
deny=3The deny=3 option is used to deny access if tally for this user exceeds 3.
reset
The reset option instructs the module to reset count to 0 on successful entry.

See below for a complete example of implementing this type of policy:

auth        required      /lib/security/$ISA/pam_env.so
auth        required      /lib/security/$ISA/pam_tally.so onerr=fail
no_magic_root auth        sufficient    /lib/security/$ISA/pam_unix.so likeauth nullok
auth        required      /lib/security/$ISA/pam_deny.so
account     required      /lib/security/$ISA/pam_unix.so 
account     required      /lib/security/$ISA/pam_tally.so deny=5
no_magic_root reset  password    requisite     /lib/security/$ISA/$ISA/pam_cracklib.so retry=3
password    sufficient    /lib/security/$ISA/$ISA/pam_unix.so nullok use_authtok md5 shadow password
required      /lib/security/$ISA/$ISA/pam_deny.so  session
required      /lib/security/$ISA/$ISA/pam_limits.so session
required      /lib/security/$ISA/$ISA/pam_unix.so

For more detailed information on the PAM system please see the documentation contained under /usr/share/doc/pam-

For information on how to unlock a user that has expired their deny tally see additional Knowledgebase articles regarding unlocking a user account and seeing failed logins with the faillog command.

contributed by David Robinson

Good Morning.

2007-02-11T22:15:00.000-08:00

Well. Today is Monday. the most painful day of the week and unfortunatley it rained today. i don't know why and for what good reason this happened but it made it worst day today.

Some Cool Commands.

2006-11-06T06:35:00.000-08:00

alias

Create an alias, aliases allow a string to be substituted for a word when it is used as the first word of a simple command.

SYNTAX
alias [-p] [name[=value] ...]

unalias [-a] [name ... ]
If arguments are supplied, an alias is defined for each name whose value is given.

If no value is given, `alias' will print the current value of the alias.

Without arguments or with the `-p' option, alias prints the list of aliases on the standard output in a form that allows them to be reused as input.

`unalias' will remove each name from the list of aliases. If `-a' is supplied, all aliases are removed.

`alias' and `unalias' are BASH built-ins.

The first word of each simple command, if unquoted, is checked to see if it has an alias. If so, that word is replaced by the text of the alias. The alias name and the replacement text may contain any valid shell input, including shell metacharacters, with the exception that the alias name may not contain `='.

The first word of the replacement text is tested for aliases, but a word that is identical to an alias being expanded is not expanded a second time. This means that one may alias ls to "ls -F", for instance, and Bash does not try to recursively expand the replacement text.

If the last character of the alias value is a space or tab character, then the next command word following the alias is also checked for alias expansion.

There is no mechanism for using arguments in the replacement text, as in csh. If arguments are needed, a shell function should be used . Aliases are not expanded when the shell is not interactive, unless the expand_aliases shell option is set using shopt .

The rules concerning the definition and use of aliases are somewhat confusing. Bash always reads at least one complete line of input before executing any of the commands on that line. Aliases are expanded when a command is read, not when it is executed. Therefore, an alias definition appearing on the same line as another command does not take effect until the next line of input is read. The commands following the alias definition on that line are not affected by the new alias. This behavior is also an issue when functions are executed. Aliases are expanded when a function definition is read, not when the function is executed, because a function definition is itself a compound command. As a consequence, aliases defined in a function are not available until after that function is executed. To be safe, always put alias definitions on a separate line, and do not use alias in compound commands.

For almost every purpose, shell functions are preferred over aliases.

Examples

alias ls='ls -F'

Now issuing the command 'ls' will actually run 'ls -F'

Making an alias permanent:
Use your favorite text editor to create a .bash_aliases file, and type the alias commands into the file.
.bash_aliases will run at login (or you can just execute it with ..bash_aliases )
___________________________________________________________________

break

Exit from a for, while, until, or select loop

SYNTAX
break [n]
If n is supplied, the nth enclosing loop is exited. n must be greater than or equal to 1.

The return status is zero unless n is not greater than or equal to 1.

Example

for myloop in 1 2 3 4 5
do
echo -n "$myloop"
if [ "$myloop" -eq 3 ]
then
break # This line will break out of the loop
fi
done
break is a POSIX `special' builtin
____________________________________________________________

builtin

Run a shell builtin, passing it args, and return its exit status.

SYNTAX
builtin [shell-builtin [args]]
This is useful when defining a shell function with the same name as a shell builtin, retaining the functionality of the builtin within the function.

For example, to write a function to replace `cd' that writes the hostname and current directory
to an xterm title bar:
cd()

{

builtin cd "$@" && xtitle "$HOST: $PWD"

}
The return status is non-zero if shell-builtin is not a shell builtin command.
____________________________________________________________
cal

Display a calendar

SYNTAX
cal [-mjy] [[month] year]

options:

-m Display monday as the first day of the week.

-j Display julian dates (days one-based, numbered from January 1).

-y Display a calendar for the current year.

A single parameter specifies the 4 digit year (1 - 9999) to be displayed.

Two parameters denote the Month (1 - 12) and Year (1 - 9999).

If arguments are not specified, the current month is displayed.

A year starts on 01 Jan.
____________________________________________________________
case

Conditionally perform a command, case will selectively execute the command-list corresponding to the first pattern that matches word.

SYNTAX
case word in [ [(] pattern [| pattern]...) command-list ;;]... esac
The `|' is used to separate multiple patterns, and the `)' operator terminates a pattern list. A list of patterns and an associated command-list is known as a clause. Each clause must be terminated with `;;'.

The word undergoes tilde expansion, parameter expansion, command substitution, arithmetic expansion, and quote removal before matching is attempted. Each pattern undergoes tilde expansion, parameter expansion, command substitution, and arithmetic expansion. There may be an arbitrary number of case clauses, each terminated by a `;;'. The first pattern that matches determines the command-list that is executed.

Here is an example using case in a script that could be used to describe one interesting feature of an animal:
echo -n "Enter the name of an animal: "
read ANIMAL
echo -n "The $ANIMAL has "
case $ANIMAL in
horse | dog | cat) echo -n "four";;
man | kangaroo ) echo -n "two";;
*) echo -n "an unknown number of";;
esac
echo " legs."
The return status is zero if no pattern is matched. Otherwise, the return status is the exit status of the command-list executed.
____________________________________________________________
chroot

Run a command with a different root directory
'chroot' runs a command with a specified root directory. On many systems, only the super-user can do this.

SYNTAX
chroot NEWROOT [COMMAND [ARGS]...]

chroot OPTION
Ordinarily, filenames are looked up starting at the root of the directory structure, i.e. '/'

'chroot' changes the root to the directory NEWROOT (which must exist) and then runs COMMAND with optional ARGS.

If COMMAND is not specified, the default is the value of the `SHELL' environment variable or `/bin/sh' if not set, invoked with the `-i' option.

The only options are `--help' and `--version'
____________________________________________________________
cksum

Print CRC checksum and byte counts

Computes a cyclic redundancy check (CRC) checksum for each given FILE, or standard input if none are given or for a FILE of `-'.

SYNTAX
cksum [Option]... [File]...

cksum prints the CRC checksum for each file along with the number of bytes in the file, and the filename unless no arguments were given.

cksum is typically used to ensure that files transferred by unreliable means (e.g., netnews) have not been corrupted, by comparing the cksum output for the received files with the cksum output for the original files (typically given in the distribution).

The CRC algorithm is specified by the POSIX.2 standard. It is not compatible with the BSD or System V sum algorithms; it is more robust.

The only options are `--help' and `--version'.

____________________________________________________________
cmp

Compare two files, and if they differ, tells the first byte and line number where they differ.

You can use the `cmp' command to show the offsets and line numbers where two files differ. `cmp' can also show all the characters that differ between the two files, side by side.

SYNTAX
cmp options... FromFile [ToFile]

OPTIONS
Multiple single letter options (unless they take an argument) can be combined into a single command line word:
so `-cl' is equivalent to `-c -l'.

`-c'
Print the differing characters. Display control characters as a `^' followed by a letter of the alphabet and precede characters that have the high bit set with `M-' (which stands for "meta").

`--ignore-initial=BYTES'
Ignore any differences in the the first BYTES bytes of the input files. Treat files with fewer than BYTES bytes as if they are empty.

`-l'
Print the (decimal) offsets and (octal) values of all differing bytes.

`--print-chars'
Print the differing characters. Display control characters as a `^' followed by a letter of the alphabet and precede characters that have the high bit set with `M-' (which stands for "meta").

`--quiet'
`-s'
`--silent'
Do not print anything; only return an exit status indicating whether the files differ.

`--verbose'
Print the (decimal) offsets and (octal) values of all differing bytes.

`-v'
`--version'
Output the version number of `cmp'.

The file name `-' is always the standard input. `cmp' also uses the standard input if one file name is omitted.

An exit status of 0 means no differences were found, 1 means some differences were found, and 2 means trouble.

Example

$ cmp tnsnames.ora tnsnames.old

Notes
`cmp' reports the differences between two files character by character, instead of line by line. As a result, it is more useful than `diff' for comparing binary files. For text files, `cmp' is useful mainly when you want to know only whether two files are identical.

For files that are identical, `cmp' produces no output. When the files differ, by default, `cmp' outputs the byte offset and line number where the first difference occurs. You can use the `-s' option to suppress that information, so that `cmp' produces no output and reports whether the files differ using only its exit status.
Unlike `diff', `cmp' cannot compare directories; it can only compare two files.

____________________________________________________________
dc

Desk calculator

SYNTAX
dc

OPTIONS

-e EXPR --expression=EXPR Evaluate EXPR as DC commands.

-f FILE --file=FILE Read and evaluate DC commands from FILE.

-h --help Print a usage message summarizing the command-line options, then
exit.

-V --version Print the version information for this program, then exit.

To exit, use `q'.
DESCRIPTION
The desk calculator works with postfix notation; rather like many HP Calculators.
Basic arithmetic uses the standard + - / * symbols but entered after the digits

so entering:

100
0.5
*
p

will return 50
____________________________________________________________
dd

Dump Data - convert and copy a file (use for RAW storage)

SYNTAX
dd [OPTION]...

DESCRIPTION
The numeric-valued options below (BYTES and BLOCKS) can be followed by a multiplier: `b'=512, `c'=1, `w'=2, `xM'=M, or any of the standard block size suffixes like `k'=1024 (*note Block size::).

`if=FILE'
input file : Read from FILE instead of standard input.

`of=FILE'
output file : Write to FILE instead of standard output. Unless `conv=notrunc' is given, `dd' truncates FILE to zero bytes (or the size specified with `seek=').

`ibs=BYTES'
Read BYTES bytes at a time.

`obs=BYTES'
Write BYTES bytes at a time.

`bs=BYTES'
Both read and write BYTES bytes at a time. This overrides `ibs' and `obs'.

`cbs=BYTES'
Convert BYTES bytes at a time.

`skip=BLOCKS'
Skip BLOCKS `ibs'-byte blocks in the input file before copying.

`seek=BLOCKS'
Skip BLOCKS `obs'-byte blocks in the output file before copying.

`count=BLOCKS'
Copy BLOCKS `ibs'-byte blocks from the input file, instead of everything until the end of the file.

`conv=CONVERSION[,CONVERSION]...'
Convert the file as specified by the CONVERSION argument(s). (No spaces around any comma(s).)

Conversions:

`ascii'
Convert EBCDIC to ASCII.

`ebcdic'
Convert ASCII to EBCDIC.

`ibm'
Convert ASCII to alternate EBCDIC.

`block'
For each line in the input, output `cbs' bytes, replacing the input newline with a space and padding with spaces as necessary.

`unblock'
Replace trailing spaces in each `cbs'-sized input block with a newline.

`lcase'
Change uppercase letters to lowercase.

`ucase'
Change lowercase letters to uppercase.

`swab'
Swap every pair of input bytes. GNU `dd', unlike others, works when an odd number of bytes are read--the last byte is simply copied (since there is nothing to swap it with).

`noerror'
Continue after read errors.

`notrunc'
Do not truncate the output file.

`sync'
Pad every input block to size of `ibs' with trailing zero
bytes.
____________________________________________________________
diff

Display the differences between two files, or each corresponding file in two directories.
Each set of differences is called a "diff" or "patch". For files that are identical, `diff' normally produces no output; for binary (non-text) files, `diff' normally reports only that they are different.

SYNTAX
diff [options] from-file to-file
OPTIONS
Multiple single letter options (unless they take an argument) can be combined into a single command line word: so `-ac' is equivalent to `-a -c'.

-lines Show lines lines of context. This option is obsolete.

-a Treat all files as text and compare them line-by-
line, even if they do not seem to be text.

-b Ignore changes in amount of white space.

-B Ignore changes that just insert or delete blank
lines.

--brief
Report only whether the files differ, not the
details of the differences.

-c Use the context output format.

-C lines --context[=lines]
Use the context output format, showing lines (an integer) lines of context, or three if lines is not given. For proper operation, patch typically needs at least two lines of context.

--changed-group-format=format
Use format to output a line group containing differing lines from both files in if-then-else foRmat.

-d Change the algorithm to perhaps find a smaller set of changes. This makes diff slower (sometimes much slower).

-D name Make merged if-then-else format output, conditional on the preprocessor macro name.

-e
--ed Make output that is a valid ed script.

--exclude=pattern
When comparing directories, ignore files and subdirectories whose basenames match pattern.

--exclude-from=file
When comparing directories, ignore files and subdirectories whose basenames match any pattern contained in file.

--expand-tabs
Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files.

-f Make output that looks vaguely like an ed script but has changes in the order they appear in the file.

-F regexp
In context and unified format, for each hunk of differences, show some of the last preceding line that matches regexp.

--forward-ed
Make output that looks vaguely like an ed script but has changes in the order they appear in the file.

-h This option currently has no effect; it is present for Unix compatibility.

-H Use heuristics to speed handling of large files that have numerous scattered small changes.

--horizon-lines=lines
Do not discard the last lines lines of the common prefix and the first lines lines of the common suffix.

-i Ignore changes in case; consider upper- and lower-case letters equivalent.

-I regexp Ignore changes that just insert or delete lines that match regexp.

--ifdef=name
Make merged if-then-else format output, conditional
on the preprocessor macro name.

--ignore-all-space
Ignore white space when comparing lines.

--ignore-blank-lines
Ignore changes that just insert or delete blank lines.

--ignore-case
Ignore changes in case; consider upper- and lower-case to be the same.

--ignore-matching-lines=regexp
Ignore changes that just insert or delete lines that match regexp.

--ignore-space-change
Ignore changes in amount of white space.

--initial-tab
Output a tab rather than a space before the text of a line in normal or context format. This causes the alignment of tabs in the line to look normal.

-l Pass the output through pr to paginate it.

-L label
--label=label
Use label instead of the file name in the context format and unified format headers.

--left-column
Print only the left column of two common lines in side by side format.

--line-format=format
Use format to output all input lines in in-then-else format.

--minimal
Change the algorithm to perhaps find a smaller set of changes. This makes diff slower (sometimes much slower).

-n Output RCS-format diffs; like -f except that each command specifies the number of lines affected.

-N
--new-file
In directory comparison, if a file is found in only one directory, treat it as present but empty in the other directory.

--new-group-format=format
Use format to output a group of lines taken from just the second file in if-then-else format.

--new-line-format=format
Use format to output a line taken from just the second file in if-then-else format.

--old-group-format=format
Use format to output a group of lines taken from just the first file in if-then-else format.

--old-line-format=format
Use format to output a line taken from just the first file in if-then-else format.

-p Show which C function each change is in.

-P When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other.

--paginate
Pass the output through pr to paginate it.

-q Report only whether the files differ, not the details of the differences.

-r When comparing directories, recursively compare any subdirectories found.

--rcs Output RCS-format diffs; like -f except that each command specifies the number of lines affected.

--recursive
When comparing directories, recursively compare any subdirectories found.

--report-identical-files
-s Report when two files are the same.

-S file
When comparing directories, start with the file file. This is used for resuming an aborted comparison.

--sdiff-merge-assist
Print extra information to help sdiff. sdiff uses this option when it runs diff. This option is not intended for users to use directly.

--show-c-function
Show which C function each change is in.

--show-function-line=regexp
In context and unified format, for each hunk of differences, show some of the last preceding line that matches regexp.

--side-by-side
Use the side by side output format.

--speed-large-files
Use heuristics to speed handling of large files that have numerous scattered small changes.

--starting-file=file
When comparing directories, start with the file file. This is used for resuming an aborted comparison.

--suppress-common-lines
Do not print common lines in side by side format.

-t Expand tabs to spaces in the output, to preserve the alignment of tabs in the input files.

-T Output a tab rather than a space before the text of a line in normal or context format. This causes the alignment of tabs in the line to look normal.

--text Treat all files as text and compare them line-by-line, even if they do not appear to be text.

-u Use the unified output format.

--unchanged-group-format=format
Use format to output a group of common lines taken from both files in if-then-else format.

--unchanged-line-format=format
Use format to output a line common to both files in if-then-else format.

--unidirectional-new-file
When comparing directories, if a file appears only in the second directory of the two, treat it as present but empty in the other.

-U lines
--unified[=lines]
Use the unified output format, showing lines (an integer) lines of context, or three if lines is not given. For proper operation, patch typically needs at least two lines of context.

-v
--version
Output the version number of diff.

-w Ignore white space when comparing lines.

-W columns
--width=columns
Use an output width of columns in side by side format.

-x pattern
When comparing directories, ignore files and subdirectories whose basenames match pattern.

-X file
When comparing directories, ignore files and subdirectories whose basenames match any pattern contained in file.

-y Use the side by side output format.
In the simplest case, diff compares the contents of the two files from-file and to-file. A file name of - stands for text read from the standard input.

If from-file is a directory and to-file is not, diff compares the file in from-file whose file name is that of to-file, and vice versa. The non-directory file must not be -.

If both from-file and to-file are directories, diff compares corresponding files in both directories, in alphabetical order; this comparison is not recursive unless the -r or --recursive option is given.

GNU `diff' can show whether files are different without detailing the differences.
It also provides ways to suppress certain kinds of differences that are not important to you.

Most commonly, such differences are changes in the amount of white space between words or lines. `diff' also provides ways to suppress differences in alphabetic case or in lines that match a regular expression that you provide.

These options can accumulate; for example, you can ignore changes in both white space and alphabetic case.

End -of-Line markers
In operating systems that distinguish between text and binary files, `diff' normally reads and writes all data as text.

Use the `--binary' option to force `diff' to read and write binary data instead. This option has no effect on a Posix-compliant system like GNU or traditional Unix. However, many personal computer operating systems represent the end of a line with a carriage return followed by a newline.

On such systems, `diff' normally ignores these carriage returns on input and generates them at the end of each output line, but with the `--binary' option `diff' treats each carriage return as just another input character, and does not generate a carriage return at the end of each output line.

This can be useful when dealing with non-text files that are meant to be interchanged with Posix-compliant systems.

Suppressing Differences in Blank and Tab Spacing
The `-b' and `--ignore-space-change' options ignore white space at line end, and considers all other sequences of one or more white space characters to be equivalent.
With these options, `diff' considers the following two lines to be equivalent, where `$' denotes the line end:

Here lyeth muche rychnesse in lytell space. -- John Heywood$
Here lyeth muche rychnesse in lytell space. -- John Heywood $

The `-w' and `--ignore-all-space' options are stronger than `-b'. They ignore difference even if one file has white space where the other file has none. "White space" characters include tab, newline, vertical tab, form feed, carriage return, and space; some locales may define additional characters to be white space.
With these options, `diff' considers the following two lines to be equivalent, where `$' denotes the line end and `^M' denotes a carriage return:

Here lyeth muche rychnesse in lytell space.-- John Heywood$
He relyeth much erychnes seinly tells pace. --John Heywood

GNU `diff' can treat lowercase letters as equivalent to their uppercase counterparts, so that, for example, it considers `Funky Stuff', `funky STUFF', and `fUNKy stuFf' to all be the same.
To request this, use the `-i' or `--ignore-case' option.

Suppressing Lines Matching a Regular Expression
To ignore insertions and deletions of lines that match a regular expression, use the `-I REGEXP' or `--ignore-matching-lines=REGEXP' option.
You should escape regular expressions that contain shell metacharacters to prevent the shell from expanding them.

For example, `diff -I '^[0-9]'' ignores all changes to lines beginning with a digit.

However, `-I' only ignores the insertion or deletion of lines that contain the regular expression if every changed line in the hunk--every insertion and every deletion--matches the regular expression.

In other words, for each nonignorable change, `diff' prints the complete set of changes in its vicinity, including the ignorable ones. You can specify more than one regular expression for lines to ignore by using more than one `-I' option. `diff' tries to match each line against each regular expression, starting with the last one given.

Summarizing Which Files Differ
When you only want to find out whether files are different, and you don't care what the differences are, you can use the summary output format.
In this format, instead of showing the differences between the files, `diff' simply reports whether files differ.
The `-q' and `--brief' options select this output format.
This format is especially useful when comparing the contents of two directories. It is also much faster than doing the normal line by line comparisons, because `diff' can stop analyzing the files as soon as it knows that there are any differences.
You can also get a brief indication of whether two files differ by using `cmp'.

Using diff to patch a file
To show context around the differing lines GNU `diff' provides these output formats

Normal Format: An output format that shows each hunk of differences without any surrounding context
Context Format:: An output format that shows surrounding lines.
Unified Format:: A more compact output format that shows context.

`patch' can apply diffs by searching in the files for the lines of context around the differing lines; if those lines are actually a few lines away from where the diff says they are, `patch' can adjust the line numbers accordingly and still apply the diff correctly.

For more on patching files and producing commands that direct the `ed' text editor to edit a file - see `info diff'

____________________________________________________________
crontab (cron table)

Schedule a command to run at a later time

SYNTAX
crontab [ -u user ] file
crontab [ -u user ] { -l | -r | -e }

Key
-l List - display the current crontab entries.

-r Remove the current crontab.

-e Edit the current crontab using the editor specified by the
VISUAL or EDITOR environment variables.
After you exit from the editor, the modified crontab will be installed automatically.

Crontab is the program used to install, deinstall or list the tables used to drive the cron daemon in Vixie Cron.
Each user can have their own crontab, and though these are files in /var, they are not intended to be edited directly.

If the -u option is given, it specifies the name of the user whose crontab is to be tweaked. If this option is not given, crontab examines "your" crontab, i.e., the crontab of the person executing the command. Note that su can confuse crontab and that if you are running inside of su you should always use the -u option for safety's sake.

cron file is used to install a new crontab from some named file or standard input if the pseudo-filename `-' is given.

Each line in the cron table follows the following format: 7 fields left to right

Field Meaning
1 Minute (0-59)
2 Hour (2-24)
3 Day of month (1-31)
4 Month (1-12, Jan, Feb, ...)
5 Day of week (0-6) 0=Sunday, 1=Monday ...
or Sun, Mon, Tue, Wed, Thur, Fri
6 User that the command will run as
7 Command to execute

There are several ways of specifying multiple values in a field:

• The comma (',') operator specifies a list of values, for example: "1,3,4,7,8"
• The dash ('-') operator specifies a range of values, for example: "1-6", which is equivalent to "1,2,3,4,5,6"
• The asterisk ('*') operator specifies all possible values for a field. e.g. every hour or every day.

There is also an operator which some extended versions of cron support, the slash ('/') operator, which can be used to skip a given number of values. For example, "*/3" in the hour time field is equivalent to "0,3,6,9,12,15,18,21"; "*" specifies 'every hour' but the "/3" means that only the first, fourth, seventh...and such values given by "*" are used.

Cron will email to the user all output of the commands it runs, to silence this, redirect the output to a log file or to /dev/null

Example

Run /usr/bin/somecommand at 12.59 every day and supress the output (redirect to null)

59 12 * * * simon /usr/bin/somecommand >> /dev/null 2>&1

Permissions
If the allow file exists, then you must be listed therein in order to be allowed to use this command. If the allow file does not exist but the deny file does exist, then you must not be listed in the deny file in order to use this command. If neither of these files exists, then depending on site-dependent configuration parameters, only the super user will be allowed to use this command, or all users will be able to use this command.

____________________________________________________________
dircolors

Color setup for `ls', outputs a sequence of shell commands to set up the terminal for color output from `ls' (and `dir', etc.).

SYNTAX

eval `dircolors [options]... [file]`

If FILE is specified, `dircolors' reads it to determine which colors to use for which file types and extensions. Otherwise, a precompiled
database is used. For details on the format of these files, run `dircolors --print-database'.

The output is a shell command to set the `LS_COLORS' environment variable. You can specify the shell syntax to use on the command line, or `dircolors' will guess it from the value of the `SHELL' environment variable.

OPTIONS

`-b'
`--sh'
`--bourne-shell'
Output Bourne shell commands. This is the default if the `SHELL' environment variable is set and does not end with `csh' or `tcsh'.

`-c'
`--csh'
`--c-shell'
Output C shell commands. This is the default if `SHELL' ends with `csh' or `tcsh'.

`-p'
`--print-database'
Print the (compiled-in) default color configuration database. This output is itself a valid configuration file, and is fairly descriptive of the possibilities.
____________________________________________________________
dirs

Display the list of currently remembered directories.

SYNTAX
dirs [+N | -N] [-clpv]

OPTIONS
+N Displays the Nth directory (counting from the left of the list
printed by dirs when invoked without options), starting with
zero.

-N Displays the Nth directory (counting from the right of the list
printed by dirs when invoked without options), starting with
zero.

-c Clears the directory stack by deleting all of the elements.

-l Produces a longer listing; the default listing format uses a tilde to denote
the home directory.

-p Causes dirs to print the directory stack with one entry per
line.
-v Causes dirs to print the directory stack with one entry per
line, prefixing each entry with its index in the stack.
Description
Equivalent to `ls -C -b'; that is,by default files are listed in columns, sorted vertically, and special characters are represented by backslash escape sequences.

____________________________________________________________
du

Estimate file space usage, reports the amount of disk space used by the specified files and for each subdirectory.

SYNTAX
du [options]... [file]...

With no arguments, `du' reports the disk space for the current directory. Normally the disk space is printed in units of 1024 bytes, but this can be overridden

OPTIONS

`-a'
`--all'
Show counts for all files, not just directories.

`-b'
`--bytes'
Print sizes in bytes, overriding the default block size (*note Block size::).

`-c'
`--total'
Print a grand total of all arguments after all arguments have been processed. This can be used to find out the total disk usage of a given set of files or directories.

`-D'
`--dereference-args'
Dereference symbolic links that are command line arguments. Does not affect other symbolic links. This is helpful for finding out the disk usage of directories, such as `/usr/tmp', which are often symbolic links.

`-h'
`--human-readable'
Append a size letter such as `M' for megabytes to each size. Powers of 1024 are used, not 1000; `M' stands for 1,048,576 bytes. Use the `-H' or `--si' option if you prefer powers of 1000.

`-H'
`--si'
Append a size letter such as `M' for megabytes to each size. (SI is the International System of Units, which defines these letters as prefixes.) Powers of 1000 are used, not 1024; `M' stands for
1,000,000 bytes. Use the `-h' or `--human-readable' option if you
prefer powers of 1024.

`-k'
`--kilobytes'
Print sizes in 1024-byte blocks, overriding the default block size
(*note Block size::).

`-l'
`--count-links'
Count the size of all files, even if they have appeared already
(as a hard link).

`-L'
`--dereference'
Dereference symbolic links (show the disk space used by the file or directory that the link points to instead of the space used by the link).

`--max-depth=DEPTH'
Show the total for each directory (and file if -all) that is at most MAX_DEPTH levels down from the root of the hierarchy. The root is at level 0, so `du --max-depth=0' is equivalent to `du -s'.

`-m'
`--megabytes'
Print sizes in megabyte (that is, 1,048,576-byte) blocks.

`-s'
`--summarize'
Display only a total for each argument.

`-S'
`--separate-dirs'
Report the size of each directory separately, not including the sizes of subdirectories.

`-x'
`--one-file-system'
Skip directories that are on different filesystems from the one that the argument being processed is on.

`--exclude=PAT'
When recursing, skip subdirectories or files matching PAT. For example, `du --exclude='*.o'' excludes files whose names end in `.o'.

`-X FILE'
`--exclude-from=FILE'
Like `--exclude', except take the patterns to exclude from FILE, one per line. If FILE is `-', take the patterns from standard input.

On BSD systems, `du' reports sizes that are half the correct values for files that are NFS-mounted from HP-UX systems. On HP-UX systems, it reports sizes that are twice the correct values for files that are NFS-mounted from BSD systems. This is due to a flaw in HP-UX; it also affects the HP-UX `du' program.
____________________________________________________________
echo

Display message on screen, writes each given STRING to standard output, with a space between each and a newline after the last one.

SYNTAX
echo [options]... [string]...

OPTIONS

`-n'
Do not output the trailing newline.

`-E'
Disable the interpretation of the following backslash-escaped characters

`-e'
Enable interpretation of the following backslash-escaped
characters in each STRING:

`\a' alert (bell)

`\b' backspace

`\c' suppress trailing newline

`\e' escape `\f' form feed

`\n' new line

`\r' carriage return

`\t' horizontal tab

`\v' vertical tab

`\\' backslash

`\NNN'
the character whose ASCII code is NNN (octal); if NNN is not
a valid octal number, it is printed literally.

`\xnnn' the character whose ASCII code is the hexadecimal value nnn (one to three digits)
echo is a BASH built-in command
____________________________________________________________
factor

Print prime factors

SYNTAX
factor [number]...

factor option

If no number is specified on the command line, `factor' reads numbers from standard input, delimited by newlines, tabs, or spaces.

Example:

factor 369

output:

369
3
3
41

____________________________________________________________
find

Search a folder hierarchy for filename(s) that meet a desired criteria.

SYNTAX
find [path...] [expression]

find searches the directory tree rooted at each given file name by evaluating the given expression from left to right, according to the rules of precedence (see section OPERATORS), until the outcome is known (the left hand side is false for and operations, true for or), at which point find moves on to the next file name.

The first argument that begins with - ( ) , or ! is taken to be the beginning of the expression; any arguments before it are paths to search, and any arguments after it are the rest of the expression. If no paths are given, the current directory is used. If no expression is given, the expression `-print' is used.

find exits with status 0 if all files are processed successfully, greater than 0 if errors occur.

EXPRESSIONS
The expression is made up of options (which affect overall operation rather than the processing of a specific file,
and always return true), tests (which return a true or false value), and actions (which have side effects and
return a true or false value), all separated by operators. -and is assumed where the operator is omitted. If the
expression contains no actions other than -prune, -print is performed on all files for which the expression is
true.

OPTIONS
All options always return true. They always take effect, rather than being processed only when their place in the
expression is reached. Therefore, for clarity, it is best to place them at the beginning of the expression.

-daystart
Measure times (for -amin, -atime, -cmin, -ctime,-mmin,
and -mtime) from the beginning of today
rather than from 24 hours ago.

-depth
Process each directory's contents before the directory itself.

-follow
Dereference symbolic links. Implies -noleaf.

-help, --help
Print a summary of the command-line usage of find and exit.

-maxdepth levels
Descend at most levels (a non-negative integer) levels of directories below the command line arguments. `-maxdepth 0' means only apply the tests and actions to the command line arguments.

mindepth levels
Do not apply any tests or actions at levels less than levels (a non-negative integer). `-mindepth 1' means process all files except the command line arguments.

mount Don't descend directories on other filesystems. An alternate name for -xdev, for compatibility with some other versions of find.

noleaf
Do not optimize by assuming that directories contain 2 fewer subdirectories than their hard link count. This option is needed when searching filesystems that do not follow the Unix directory- link convention, such as CD-ROM or MS-DOS filesys tems or AFS volume mount points. Each directory on a normal Unix filesystem has at least 2 hard links: its name and its `.' entry. Additionally, its subdirectories (if any) each have a `..' entry linked to that directory. When find is examining a directory, after it has statted 2 fewer subdirectories than the directory's link count, it knows that the rest of the entries in the directory are non-
directories (`leaf' files in the directory tree).
If only the files' names need to be examined, there is no need to stat them; this gives a significant increase in search speed.

-version, --version
Print the find version number and exit.

-xdev Don't descend directories on other filesystems.

TESTS
Numeric arguments can be specified as

+n for greater than n,

-n for less than n,

n for exactly n.

-amin n
File was last accessed n minutes ago.

-anewer file
File was last accessed more recently than file was modified. -anewer is affected by -follow only if-follow comes before -anewer on the command line.

-atime n
File was last accessed n*24 hours ago.

-cmin n
File's status was last changed n minutes ago.

-cnewer file
File's status was last changed more recently than file was modified. -cnewer is affected by -follow only if -follow comes before -cnewer on the command line.
-ctime n
File's status was last changed n*24 hours ago.

-empty File is empty and is either a regular file or a directory.

-false Always false.

-fstype type
File is on a filesystem of type type. The valid filesystem types vary among different versions of Unix; an incomplete list of filesystem types that are accepted on some version of Unix or another is:
ufs, 4.2, 4.3, nfs, tmp, mfs, S51K, S52K. You can use -printf with the %F directive to see the types of your filesystems.

-gid n File's numeric group ID is n.

-group gname
File belongs to group gname (numeric group ID
allowed).

-ilname pattern
Like -lname, but the match is case insensitive.

-iname pattern
Like -name, but the match is case insensitive. For example, the patterns `fo*' and `F??' match the file names `Foo', `FOO', `foo', `fOo', etc.

-inum n
File has inode number n.

-ipath pattern
Like -path, but the match is case insensitive.

-iregex pattern
Like -regex, but the match is case insensitive.

-links n
File has n links.

-lname pattern
File is a symbolic link whose contents match shell pattern pattern. The metacharacters do not treat `/' or `.' specially.

-mmin n
File's data was last modified n minutes ago.

-mtime n
File's data was last modified n*24 hours ago.

-name pattern
Base of file name (the path with the leading directories removed) matches shell pattern pattern. The metacharacters (`*', `?', and `[]') do not match a `.' at the start of the base name. To ignore a directory and the files under it, use -prune; see an example in the description of -path.

-newer file
File was modified more recently than file. -newer is affected by -follow only if -follow comes before -newer on the command line.

-nouser
No user corresponds to file's numeric user ID.

-nogroup
No group corresponds to file's numeric group ID.

-path pattern
____________________________________________________________

____________________________________________________________
traceroute

Print the route packets take to network host.

SYNTAX
traceroute [options] host [packetsize]

OPTIONS

-d Turn on socket-level debugging.

-g addr Enable the IP LSRR (Loose Source Record Route) option in addition to the TTL tests, to ask how someone at IP address addr can reach a particular target.

-l Include the time-to-live value for each packet received.

-m max_ttl Set maximum time-to-live used in outgoing probe packets to max-ttl hops. Default is 30 hops.

-n Show numerical addresses; do not look up hostnames.
(Useful if DNS is not functioning properly.)

-p port Set base UDP port number used for probe packets to port.
Default is (decimal) 33434.

-q n Set number of probe packets for each time-to-live setting to the value n.
Default is 3.

-r Bypass normal routing tables and send directly to a host on an
attached network.

-s src_addr
Use src_addr as the IP address that will serve as the source address
in outgoing probe packets.

-t tos Set the type-of-service in probe packets to tos (default 0).
The value must be a decimal integer in the range 0 to 255.

-v Verbose-received ICMP packets (other than TIME_EXCEEDED and PORT_UNREACHABLE)
will be listed.

-w wait Set time to wait for a response to an outgoing probe packet to wait
seconds (default is 3 seconds).

____________________________________________________________
units

Convert units from one scale to another. The units are defined in an external data file. You can use the extensive data file that comes with this program, or you can provide your own data file to suit your needs. You can use the program interactively with prompts, or you can use it from the command line.

SYNTAX
units options [FROM-UNIT [TO-UNIT]]

OPTIONS

`-c'
`--check'
Check that all units and prefixes defined in the units file reduce to primitive units. The program will print a list of all units that cannot be reduced.

`--check-verbose'
Like the `-check' option, this option prints a list of units that cannot be reduced. But to help find unit definitions that cause endless loops, it lists the units as they are checked. If `units'
hangs, then the last unit to be printed has a bad definition.

`-o format'
`--output-format format'
Use the specified format for numeric output. Format is the same as that for the printf function in the ANSI C standard. For example, if you want more precision you might use `-o %.15g'.

`-f filename'
`--file filename'
Use filename as the units data file rather than the default units data file `units.dat'.

`-h'
`--help'
Print out a summary of the options for `units'.

`-q'
`--quiet'
`--silent'
Suppress prompting of the user for units and the display of statistics about the number of units loaded.

`-s'
`--strict'
Suppress conversion of units to their reciprocal units.

`-v'
`--verbose'
Give slightly more verbose output when converting units. When combined with the `-c' option this gives the same effect as `--check-verbose'.

`-V'
`--version'
Print program version number, tell whether the readline library has been included, and give the location of the default units data file.
To invoke units for interactive use, type `units' at your shell prompt. The program will print something like this:
1161 units, 53 prefixes
You have:

At the `You have:' prompt, type the quantity and units that you are converting *from*. For example, if you want to convert ten meters to feet, type `10 meters'. Next, `units' will print `You want:'. You should type the type of units you want to convert *to*. To convert to feet, you would type `feet'.

The answer will be displayed in two ways. The first line of output, which is marked with a `*' to indicate multiplication, gives the result of the conversion you have asked for. The second line of output, which is marked with a `/' to indicate division, gives the inverse of the conversion factor. If you convert 10 meters to feet, `units' will print

* 32.808399
/ 0.03048

which tells you that 10 meters equals about 32.8 feet. The second number gives the conversion in the reverse direction.

The `units' program can perform units conversions non-interactively from the command line. To do this, type the command, type the original units expression, and type the new units you want. You will probably need to protect the units expressions from interpretation by the shell using single quote characters.
If you type

units '2 liters' 'quarts'

then `units' will print

* 2.1133764
/ 0.47317647

and then exit. The output tells you that 2 liters is about 2.1 quarts, or alternatively that a quart is about 0.47 times 2 liters.

Unit expressions

In order to enter more complicated units or fractions, you will need to use operations such as powers, products and division. Powers of units can be specified using the `^' character as shown in the following example, or by simple concatenation: `cm3' is equivalent to `cm^3'. If the exponent is more than one digit, the `^' is required.

You have: cm^3
You want: gallons
* 0.00026417205
/ 3785.4118

You have: arabicfoot-arabictradepound-force
You want: ft lbf
* 0.7296
/ 1.370614

Multiplication of units can be specified by using spaces, a hyphen (`-') or an asterisk (`*'). Division of units is indicated by the
slash (`/').

You have: furlongs/fortnight
You want: m/s
* 0.00016630986
/ 6012.8727

Multiplication has a higher precedence than division and is evaluated left to right, so `m/s * s/day' is equivalent to `m / s s day' and has dimensions of length per time cubed. In effect, the first `/' character marks the beginning of the denominator of your unit. In particular, this means that writing `1/2 meter' refers to a unit of reciprocal length equivalent to .5/meter, which is probably not what you would intend if you entered that expression. To indicate division
of numbers, use the vertical dash (`|'). No spaces area permitted on either side of the vertical dash character.

You have: 1|2 inch
You want: cm
* 1.27
/ 0.78740157

Prefixes are defined separately from base units. In order to get centimeters, the units database defines `centi-' and `c-' as prefixes. Prefixes can appear alone with no unit following them. An exponent applies only to the immediately preceding unit and its prefix so that
`cm^3' or `centimeter^3' refer to cubic centimeters but `centi-meter^3' refers to hundredths of cubic meters. Only one prefix is permitted per unit, so `micromicrofarad' will fail, but `micro-microfarad' will work.

For `units', numbers are just another kind of unit. They can appear as many times as you like and in any order in a unit expression. For example, to find the volume of a box which is 2 ft by 3 ft by 12 ft in steres, you could do the following:

You have: 2 ft 3 ft 12 ft
You want: stere
* 2.038813
/ 0.49048148

You have: $ 5 / yard
You want: cents / inch
* 13.888889
/ 0.072

And the second example shows how the dollar sign in the units conversion can precede the five. Be careful: `units' will interpret `$5' with no space as equivalent to dollars^5.

Outside of the SI system, it is often desirable to add values of different units together. Sums of conformable units are written with the `+' character.

You have: 2 hours + 23 minutes + 32 seconds
You want: seconds
* 8612
/ 0.00011611705

You have: 12 ft + 3 in
You want: cm
* 373.38
/ 0.0026782366

You have: 2 btu + 450 ft-lbf
You want: btu
* 2.5782804
/ 0.38785542

The expressions which are added together must reduce to identical expressions in primitive units, or an error message will be displayed:

You have: 12 printerspoint + 4 heredium
Illegal sum of non-conformable units:
12 printerspoint reduces to 0.0042175176 m
4 heredium reduces to 20145.828 m^2

Because `-' is used for products, it cannot also be used to form differences of units. If a `-' appears before numerical digits as the very first character on the input line or if it appears immediately after a `+' then the number will be evaluated as a negative number. So you can compute 20 degrees minus 12 minutes by entering `20 degrees+-12 arcmin'. The `+' character is sometimes used in exponents like `3.43e+8'. Exponents of this form cannot be used when forming sums of units, but they may be used otherwise.

Unit definitions

The conversion information is read from a units data file which is called `units.dat' and is probably located in the `/usr/local/share' directory. If you invoke `units' with the `-V' option, it will print the location of this file. The default file includes definitions for all familiar units, abbreviations and metric prefixes. It also includes many obscure or archaic units.

Many constants of nature are defined, including these:
pi ratio of circumference to diameter
c speed of light
e charge on an electron
force acceleration of gravity
mole Avogadro's number
water pressure per unit height of water
Hg pressure per unit height of mercury
au astronomical unit
k Boltzman's constant
mu0 permeability of vacuum
epsilon0 permitivity of vacuum
G Gravitational constant
mach speed of sound

The database includes atomic masses for all of the elements and numerous other constants. Also included are the densities of various ingredients used in baking so that `2 cups flour_sifted' can be converted to `grams'. This is not an exhaustive list. Consult the units data file to see the complete list, or to see the definitions that are used.

The unit `pound' is a unit of mass. To get force, multiply by the force conversion unit `force' or use the shorthand `lbf'. (Note that `g' is already taken as the standard abbreviation for the gram.) The unit `ounce' is also a unit of mass. The fluid ounce is `fluidounce' or `floz'. British capacity units that differ from their US counterparts, such as the British Imperial gallon, are prefixed with `br'. Currency is prefixed with its country name: `belgiumfranc', `britainpound'.

The US Survey foot, yard, and mile can be obtained by using the `US' prefix. These units differ slightly from the international length units. They were in use until 1959, but for geographic surveys, they are still used. The acre is officially defined in terms of the US
Survey foot. If you want an acre defined according to the international foot, use `intacre'. The difference between these units is about 4 parts per million. The British also used a slightly
different length measure before 1959. These can be obtained with the prefix `UK'.

When searching for a unit, if the specified string does not appear exactly as a unit name, then the `units' program will try to remove a trailing `s' or a trailing `es'. If that fails, `units' will check for a prefix. All of the standard metric prefixes are defined.

To find out what units and prefixes are available, read the standard units data file.

All of the units and prefixes that `units' can convert are defined in the units data file.

____________________________________________________________
useradd

Create new user accounts or update default account information.
Unless invoked with the -D option, user must be given. useradd will create new entries in system files. Home directories and initial files may also be created as needed.

SYNTAX
useradd [options] [user]

OPTIONS
-c comment Comment field.

-d dir Home directory.
The default is to use user as the directory name
under the home directory specified with the -D option.

-e date Account expiration date.
date is in the format MM/DD/YYYY.
Two-digit year fields are also accepted.
The value is stored as the number of days since January 1, 1970.
This option requires the use of shadow passwords.

-f days Permanently disable account this many days after the password has expired.
A value of -1 disables this feature.
This option requires the use of shadow passwords.

-g group Initial group name or ID number.
If a different default group has not been specified using the -D option, the default group is 1.

-G groups Supplementary groups given by name or number in a comma-separated
list with no whitespace.

-k [dir] Copy default files to user's home directory.
Meaningful only when used with the -m option.
Default files are copied from /etc/skel/ unless an alternate dir is specified.

-m Make user's home directory if it does not exist.
The default is not to make the home directory.

-o Override. Accept a nonunique uid with the -u option. (Probably a bad idea.)

-s shell Login shell.

-u uid Numerical user ID. The value must be unique unless the -o option is used.
The default value is the smallest ID value greater than 99 and greater
than every other uid.

-D [options] Set or display defaults. If options are specified, set them.
If no options are specified, display current defaults. The options are:

-b dir Home directory prefix to be used in creating home directories.
If the -d option is not used when creating an account, the
user name will be appended to dir.

-e date Expire date. Requires the use of shadow passwords.

-f days Number of days after a password expires to disable an account.
Requires the use of shadow passwords.

-g group Initial group name or ID number.

-s shell Default login shell.

____________________________________________________________
users

Print login names of users currently logged in, print on a single line a blank-separated list of user names of users currently logged in to the current host.

SYNTAX
users [file]

With no file argument, `users' extracts its information from the file `/var/run/utmp'.

If a file argument is given, `users' uses that file instead. A common choice is `/var/run/wtmp'.

The only options are `--help' and `--version'.
Each user name corresponds to a login session, so if a user has more than one login session, that user's name will appear the same number of times in the output.

____________________________________________________________
env
Display, set, or remove environment variables, Run a command in a modified environment.

SYNTAX
env [OPTION]... [NAME=VALUE]... [COMMAND [ARGS]...]

OPTIONS

-u NAME
--unset=NAME Remove variable NAME from the environment, if it was in the environment.

-
-i --ignore-environment Start with an empty environment, ignoring the inherited enviornment. Arguments of the form `VARIABLE=VALUE' set the environment variable VARIABLE to value VALUE. VALUE may be empty (`VARIABLE='). Setting a variable to an empty value is different from unsetting it.

The first remaining argument specifies the program name to invoke; it is searched for according to the `PATH' environment variable. Any remaining arguments are passed as arguments to that program.

If no command name is specified following the environment specifications, the resulting environment is printed. This is like specifying a command name of `printenv'.

____________________________________________________________
watch

Execute a program periodically, showing output full screen

SYNTAX
watch [options] command command_options

Options

-n --interval=n Specify an interval to run command

-d --differences[=cumulative]] Highlight the differences between successive updates

-h --help Display Help

-v --version Display version
watch runs command repeatedly, displaying its output (the first screenfull). This allows you to watch the program output change over time. By default, the program is run every 2 seconds.

The --cumulative option makes highlighting "sticky", presenting a running display of all positions that have ever changed.

watch will run until interrupted.

Note that command is given to "sh -c" which means that you may need to use extra quoting to get the desired effect.

POSIX option processing is used (i.e., option processing stops at the first non-option argument). This means that command_options don't get interpreted by watch itself.

EXAMPLES
To watch for mail, you might do

watch -n 60 from

To watch the contents of a directory change, you could use

watch -d ls -l

If you're only interested in files owned by user joe, you
might use

watch -d 'ls -l | fgrep joe'

To see the effects of quoting, try these out

watch echo $$

watch echo '$$'

watch echo "'"'$$'"'"

You can watch for your administrator to install the latest
kernel with

watch uname -r

(Just kidding.)

Bugs
Upon terminal resize, the screen will not be correctly repainted until the next scheduled update. All differences highlighting is lost on that update as well.
Non-printing characters are stripped from program output. Use "cat -v" as part of the command pipeline if you want to see them.
____________________________________________________________
Date
By default, date pads numeric fields with zeroes. GNU date recognizes the following modifiers between `%' and a numeric directive.

`-' (hyphen) do not pad the field; useful if the output is intended for human consumption.

`_' (underscore) pad the field with spaces; useful if you need a fixed number of characters in the output, but zeroes are too distracting.

The - and _ are GNU extensions.

Here is an example illustrating the differences:

date +%d/%m -d "Feb 1"
=> 01/02
date +%-d/%-m -d "Feb 1"
=> 1/2
date +%_d/%_m -d "Feb 1"
=> 1/ 2

Setting the time
----------------
If given an argument that does not start with `+', `date' sets the system clock to the time and date specified by that argument (as described below). You must have appropriate privileges to set the system clock. The `--date' and `--set' options may not be used with such an argument. The `--universal' option may be used with such an argument to indicate that the specified time and date are relative to Coordinated Universal Time rather than to the local time zone.

The argument must consist entirely of digits, which have the following meaning:

MM month
DD day within month
HH hour
MM minute
CC first two digits of year (optional)
YY last two digits of year (optional)
SS second (optional)

The `--set' option also sets the system clock; see the next section.

Examples of `date'

* To print the date of the day before yesterday:
date --date='2 days ago'

* To print the date of the day three months and one day hence:
date --date='3 months 1 day'

* To print the day of year of Christmas in the current year:
date --date='25 Dec' +%j

* To print the current full month name and the day of the month:
date '+%B %d'

But this may not be what you want because for the first nine days of the month, the `%d' expands to a zero-padded two-digit field, for example `date -d 1may '+%B %d'' will print `May 01'.

* Print a date without the leading zero for one-digit days of the month, you can use the (GNU extension) `-' modifier to suppress The padding altogether.
date -d=1may '+%B %-d'

* Print the current date and time in the format required by many non-GNU versions of `date' when setting the system clock:
date +%m%d%H%M%Y.%S

* Set the system date and time
date --set="2002-6-29 11:59 AM"

* Set the system clock forward by two minutes:
date --set='+2 minutes'

* Print the date in the format specified by RFC-822, use `date
--rfc'. I just did and saw this:

Mon, 25 Mar 1996 23:34:17 -0600

* To convert a date string to the number of seconds since the epoch (which is 1970-01-01 00:00:00 UTC), use the `--date' option with The `%s' format. That can be useful in sorting and/or graphing and/or comparing data by date. The following command outputs the
number of the seconds since the epoch for the time one second later than the epoch, but in time zone five hours later (Cambridge, Massachusetts), thus a total of five hours and one second after the epoch:

date --date='1970-01-01 00:00:01 UTC +5 hours' +%s
18001

Suppose you had _not_ specified time zone information in the example above. Then, date would have used your computer's idea of the time zone when interpreting the string. Here's what you would get if you were in Greenwich, England:

# local time zone used
date --date='1970-01-01 00:00:01' +%s
1

* If you're sorting or graphing dated data, your raw date values may be represented as seconds since the epoch. But few people can look at the date `946684800' and casually note "Oh, that's the first second of the year 2000."

date --date='2000-01-01 UTC' +%s
946684800

To convert such an unwieldy number of seconds back to a more readable form, use a command like this:

date -d '1970-01-01 946684800 sec' +"%Y-%m-%d %T %z"
2000-01-01 00:00:00 +0000

Lo

2006-11-06T05:55:00.000-08:00

for

Expand words, and execute commands once for each member in the resultant list, with name bound to the current member.

SYNTAX
for name [in words ...]; do commands; done
If `in words' is not present, the for command executes the commands once for each positional parameter that is set, as if `in " $@"' had been specified (see Positional Parameters below.)
The return status is the exit status of the last command that executes. If there are no items in the expansion of words, no commands are executed, and the return status is zero. An alternate form of the for command is also supported:
for (( expr1 ; expr2 ; expr3 )) ; do commands ; done
First, the arithmetic expression expr1 is evaluated according to shell arithmetic expression rules. The arithmetic expression expr2 is then evaluated repeatedly until it evaluates to zero.

Each time expr2 evaluates to a non-zero value, commands are executed and the arithmetic expression expr3 is evaluated. If any expression is omitted, it behaves as if it evaluates to 1.

The return value is the exit status of the last command in list that is executed, or false if any of the expressions is invalid.

Positional Parameters
These are assigned from the shell's arguments when the shell is invoked, they can be reassigned using the set builtin command.
Positional parameter N may be referenced as ${N}, or as $N when N consists of a single digit. $1, $2 etc

Example

#! /bin/bash# List of manufacturersfor m in Apple Sony Panasonic "Hewlett Packard" Nokiado echo "Manufacturer is:" $mdone

# The above could also be written as a single line...
for m in Apple Sony Panasonic "Hewlett Packard" Nokia; do echo "Manufacturer is:" $m;done
____________________________________________________________________________________________________________

case

Conditionally perform a command, case will selectively execute the command-list corresponding to the first pattern that matches word.

eval

Evaluate several commands/arguments

SYNTAX
eval [arguments]
The arguments are concatenated together into a single command, which is then read and executed, and its exit status returned as the exit status of eval. If there are no arguments or only empty arguments, the return status is zero.

eval is a POSIX `special' builtin
____________________________________________________________________________________________________________

Conditionally perform a command.

SYNTAX
if test-commands; then
consequent-commands;
[elif more-test-commands; then
more-consequents;]
[else alternate-consequents;]
fi
The test-commands list is executed, and if its return status is zero, the consequent-commands list is executed.

If test-commands returns a non-zero status, each elif list is executed in turn, and if its exit status is zero, the corresponding more-consequents is executed and the command completes.

If `else alternate-consequents' is present, and the final command in the final if or elif clause has a non-zero exit status, then alternate-consequents is executed.

The return status is the exit status of the last command executed, or zero if no condition tested true.
____________________________________________________________________________________________________________

while

Execute consequent-commands as long as test-commands has an exit status of zero

SYNTAX
while test-commands; do consequent-commands; done
The return status is the exit status of the last command executed in consequent-commands, or zero if none were executed.
____________________________________________________________________________________________________________

until

Execute consequent-commands as long as test-commands has an exit status which is not zero.

SYNTAX
until test-commands; do consequent-commands; done
The return status is the exit status of the last command executed in consequent-commands, or zero if none was executed.

Shell scripts

2006-11-04T22:33:00.000-08:00

1. Alias
1.1. Defining alias
For commands that are used a lot, it's better to define an alias:
alias yourAlias='theRealCommand'
For example, in the following case, the command 'l' will call 'ls -al':
alias l='ls -al'
Note: The definition of the alias can be placed in .bashrc so that it will be defined for each new shell.
1.2. Deleting alias
To delete an alias, just call
unalias yourAlias
For example, to delete the cp alias, call
unalias cp
1.3. Temporarily disabling alias
If you want disable just for this time un alias, call
\alias parameter1 parameter2 ...
For example, you have defined such an alias
alias cp='cp -v'
and you want to copy something without showing what it is doing. Call
\cp file1 file2
1.4. Defining "function" instead of alias
It's not a good idea to define an alias to starting an application, because if the '&' character is not placed after the call, the application will block the shell until the application self will be closed.
For such case it's better to define a function:
functionName() { yourApplication yourParameters $* }
For example, in the following case, the command 'n myFile' will call 'nedit -rows 50 myFile':
n() { nedit -rows 50 $* & }
The '$*' indicates the list of arguments that you can give at the command line.
Note: The definition of the function can be placed in .bashrc so that it will be defined for each new shell.
2. Basic operations
2.1. Input command
2.1.1. Input
echo "A="
read A
echo "You entered $A"
2.1.2. Keypress
read -s -n2 -p "Hit a key " keypress
echo
echo "pressed '$keypress'"
-s: don't echo input
-n: accept only N characters of input
-p: echo the following prompt before reading input
If you want to show what key as been pressed, just remove the -s option.
2.2. Check arguments
if [ ! $# = 2 ]
then
echo " usage: `basename $0` first_argument second_argument"
exit 1;
fi
2.3. Check return code
`your_script`
if [ $? ]
echo "ERROR"
exit 1;
else
echo "OK"
fi
2.4. Print to screen and simultaneously log in a file
grep myword * tee -a file.log
2.5. Arithmetic calculations
expr 5 + 4
2.6. Logical operators
if [ "$a" -eq 24 ] && [ "$b" -eq 47 ]
if [ "$a" -eq 24 -a "$b" -eq 47 ]
if [ "$a" = rhino ] && [ "$b" = crocodile ]
See http://www.tldp.org/LDP/abs/html/abs-guide.html#ORREF" target="">Advanced Bash-Scripting Guide.
2.7. If ... else if ... else
if [ $A -gt 0 ]
then
echo "$A is bigger than zero"
elif [ $A -lt 0 ]
then
echo "$A is smaller than zero"
else
echo "$A is equal to zero"
fi
2.8. Sequence
A sequence of number can be indicates as following:
seq 0 9
Example:
for i in $(seq 0 9)
do
echo $i
done
3. Case
3.1. Changing case
To change the case from lowercase to uppercase:
echo "word" tr [:lower:] [:upper:]
To change the case from uppercase to lowercase:
echo "word" tr [:upper:] [:lower:]
To rename all files in a directory from lowercase to uppercase:
for i in *; do (echo $itr [:lower:] [:upper:]); done
4. File
4.1. Reading file line by line
exec < fileName
while read line
do
echo $line
done
LINES=( `cat "$FILE"` )
for LINE in ${LINES[@]}
do
echo $line
done
4.2. Remove commented lines from a file
sed '/^#/d' fileName
5. Find
5.1. Doing something only for searched elements
find PATH -name FILENAME -exec COMMAND {} \;
The
{}
indicates the output of the find command.
Example. Search all text file in home directory and copy them to /tmp:
find ~ -name "*.txt" -exec cp {} /tmp \;
5.2. Search in more specified directories
echo "/tmp/ /usr/" > directories
cat directories xargs -i find {} -name "*.txt"
6. Loop
6.1. For
for file in `ls *`
do
echo $file
done
6.2. For with list
LIST="one two three"
for ELEMENT in $LIST
do
echo $ELEMENT
done
6.3. While
while [ 1 ]
do
echo "hello";
done
7. Process
7.1. Own process id
To known the process id of the script it self, use the special variable
$$
Example:
echo "My process id is $$"
7.2. Pidof
Returns all the process having the specified name:
pidof nedit
17277 17270 17267
8. Shortcuts
8.1. Case
ALT + U: uppercase until end of word
ALT + L: lowercase until end of word
ALT + C: uppercase current char, lowercase the rest
8.2. Cut, copy, paste
CTRL + Y: paste
CTRL + U: cut begin of the line until char on the left
ALT + BACKSPACE: cut from current char to begin of current word
CTRL + K: cut from current char to end of line
8.3. Enter
CTRL + J: enter
CTRL + M: enter
CTRL + O: enter
8.4. History
CTRL + P: same as cursor up (history backwards)
CTRL + N: same as cursor down (history forwards)
CTRL + R: reverse search in history (from last command to first)
ALT + P: search in history (from first command to last)
!cucu: repeat last command started with the word cucu
8.5. Jumping
CTRL + A: jump to begin of the line
CTRL + E: jump to end of line
CTRL + F: same as cursor right
CTRL + B: same as cursor left
ALT + B: jump one word backwards
ALT + F: jump one word forwards
8.6. Process
CTRL + Z: send SIGSTOP to current process
CTRL + C: send SIGTERM to current process
CTRL + D: exit
8.7. Screen
CTRL + L: clear screen
CTRL + S: stop video scrolling
CTRL + Q: restart video scrolling
8.8. Others
CTRL + T: swap current char with them on the left
CTRL + H: backspace
CTRL + I: tabulator
9. Tricks
9.1. Beeping until key pressing
To announce to the user a long job has been done, the command
alarm
will beep until the user press a key.
9.2. Counting files
To get the number of files/directory present in the current directory:
ls wc -l
9.3. Extracting IP number from ifconfig
ifconfig eth0 grep inet cut -d : -f 2 cut -d \ -f 1
or using awk:
ifconfig eth0 awk -F ':' '/inet/ {print $2}' cut -f 1 -d ' '
9.4. Removing last slash in path
A="/usr/lib/"
B=${A/%\//}
echo $A
echo $B
9.5. Renaming file with blanks
find $DIR -maxdepth 1 -type f -print0 xargs -0 -n1 bash -c 'newname=${0// /_}; if [[ ! -e $newname ]];then eval mv \"$0\" $newname;fi;'
9.6. Wildcards
To get a list of specified files:
FILE='lib*.so'
or
FILE=`ls lib*.so`
10. Variables
10.1. Asking for returned value
When a script or programm is called, it returns a value giving informations about the result of its call (without error, error 1, error 2, ...).
This value is stored in the variable $? and can be easily checked.
myScript
echo $?
This value will be overwritten by the next call of a script or programm.
10.2. Defining and clearing
Normally, variables doesn't need to be declared. But if a variable is needed outside the script which declares it, it must be exported:
export MY_VARIABLE=Hello
Here how to verify that the variable has been correctly exported:
export grep MY_VARIABLE
To undo the operation:
unset MY_VARIABLE

Generate passwords with openssl

2006-11-01T07:11:00.000-08:00

write 6 random bits of base64-encoded data. This will produce an eight character string making a good unix (crypt based) password:

$ openssl rand -base64 6
$RcqcGq4h

This is an example used to generate a 16 character password

$ openssl rand -base64 12
$IEoOfT/LKimAf/sd

When random data goes through the base encoding process the string output is always a multiple of 4 possibly padded on the end with one or more '=' characters. So if you want a password that is not a multiple of 4 you need to artifically chop it where you want it.
An example used to generate a 37 character password:
with cut:

$ openssl rand -base64 37 cut -c1-37
$X/UhqF1I9qO57Uz8hPufpvbOLYCeuuvqnerUM

or sed:

$ openssl rand -base64 37 sed -e 's/^$.\{37\}$.*/\1/g' $sAPpFoGnbXnJrQc8Cl/QqrNwn0QK3hHrgANt1

or awk:

$ openssl rand -base64 37 awk 'BEGIN{FS=""} {for (i=1;i<=37;i++) printf("%s",$i);} {printf "\n"}'
$WhGWSCp8Y2uilxWfOfAyQXa4QqlE78uJeH3sn

Blade server

2006-10-30T06:12:00.000-08:00

IBM HS20 blade server. Two bays for SCSI hard drives can be noticed in the upper left area of the image.
Blade servers are self-contained computer servers, designed for high density. Whereas a standard rack-mount server can exist with (at least) a power cord and network cable, blade servers have many components removed for space, power and other considerations while still having all the functional components to be considered a computer. A blade enclosure provides services such as power, cooling, networking, various interconnects and management - though different blade providers have differing principles around what should and should not be included in the blade itself (and sometimes in the enclosure altogether). Together these form the blade system.
In a standard server-rack configuration, 1U (one rack unit, 19" wide and 1.75" tall) is the minimum possible size of any equipment. The principal benefit of, and the reason behind the push towards, blade computing is that components are no longer restricted to these minimum size requirements. The most common computer rack form-factor being 42U high, this limits the number of discrete computer devices directly mounted in a rack to 42 components. Blades do not have this limitation; densities of 100 computers per rack and more are achievable with the current generation of blade systems.
Server blade
In the purest definition of computing (a Turing machine, simplified here), a computer requires only;
memory to read input commands and data
a processor to perform commands manipulating that data, and
memory to store the results.
Today (contrast with the first general-purpose computer) these are implemented as electrical components requiring (DC) power, and in operation produce heat. Other components such as hard drives, power supplies, storage and network connections, basic IO (such as KVM and serial) etc. only support the basic computing function, yet add bulk, heat and complexity, not to mention moving parts that are more prone to failure than solid-state components.
In practice, these components are all required if the computer is to perform real-world work. In the blade paradigm, most of these functions are removed from the blade computer, being either provided by the blade enclosure (e.g. DC power supply), virtualised (e.g. iSCSI storage, remote console over IP) or discarded entirely (e.g. serial ports). The blade itself becomes vastly simpler, hence smaller and (in theory) cheaper to manufacture.
Blade enclosure
The enclosure (or chassis) performs many of the non-core computing services found in most computers. Non-blade computers require components that are bulky, hot and space-inefficient, and duplicated across many computers that may or may not be performing at capacity. By locating these services in one place and sharing them between the blade computers, the overall utilisation is more efficient. The specifics of which services are provided and how vary by vendor.
Power
Computers operate over a range of DC voltages, yet power is delivered from utilities as AC, and at higher voltages than required within the computer. Converting this current requires power supply units (or PSUs). To ensure that the failure of one power source does not affect the operation of the computer, even entry-level servers have redundant power supplies, again adding to the bulk and heat output of the design.
The blade enclosure's power supply provides a single power source for all blades within the enclosure. This single power source may be in the form of a power supply in the enclosure or a dedicated separate PSU supplying DC to multiple enclosures [http://h18004.www1.hp.com/products/quickspecs/12330_div/12330_div.html]. This setup not only reduces the number of PSUs required to provide a resilient power supply, but it also improves efficiency because it reduces the number of idle PSUs.
Cooling
Operating the electrical and mechanical components of a computer produces heat, which must be displaced to ensure proper function of all these components. Fans are the most common method used to remove this heat in computers, but these add bulk and more moving parts. The blade enclosure typically provides fans to remove hot air from within the blades.
A frequently underestimated conflict in the design of a high-performance computer is the trade-off between design for density and the ability of the fans to move hot air away from the system. Since much of the bulk of a traditional server is removed from a blade, it can be designed to allow for excellent airflow.
Networking
Computers are increasingly being produced with high-speed, integrated network interfaces, and most are expandable to allow for the addition of connections that are faster, more resilient and run over different media (copper and fiber). These may require extra engineering effort in the design and manufacture of the blade, consume space in both the installation and capacity for installation (empty expansion slots) and hence more complexity. High-speed network topologies require expensive, high-speed integrated circuits and media, while most computers do not utilise all the bandwidth available.
The blade enclosure provides one or more network buses to which the blade will connect, and either presents these ports individually in a single location (versus one in each computer chassis), or aggregates them into fewer ports, reducing the cost of connecting the individual devices. These may be presented in the chassis itself, or in networking blades.
Storage
While computers typically need hard-disks to store the operating system, application and data for the computer, these are not necessarily required locally. Many storage connection methods (e.g. FireWire, SATA, SCSI, DAS, Fibre Channel and iSCSI) are readily moved outside the server, though not all are used in enterprise-level installations. Implementing these connection interfaces within the computer presents similar challenges to the networking interfaces (indeed iSCSI runs over the network interface), and similarly these can be removed from the blade and presented individually or aggregated either on the chassis or through other blades.
In particular, the ability to boot the blade from a Storage Area Network (SAN) allows for an entirely disk-free blade, resulting in exceptional reliability and space utilisation.
Other blades
Since the blade enclosure provides a standard method for delivering basic services to computer devices, these can be leveraged by other types of devices. Blades providing switching, routing, SAN and fibre-channel access can be inserted into the enclosure to provide these services to all members of the enclosure.
Uses
http://en.wikipedia.org/wiki/Image:Pile_of_IBM_HS20s.jpg

A pile of IBM HS20 blade servers. Each "blade" has two 2.8 GHz Xeon CPUs, two 36 GB Ultra-320 SCSI hard drives and 2 GB RAM.
Blade servers are ideal for specific purposes such as web hosting and cluster computing. Individual blades are typically hot-swappable.
Although blade server technology in theory allows for open, cross-vendor solutions, at this stage of development of the technology, users find there are fewer problems when using blades, racks and blade management tools from the same vendor.
Eventual standardization of the technology might result in more choices for consumers; increasing numbers of third-party software vendors are now entering this growing field.
Blade servers are not, however, the answer to every computing problem. They may best be viewed as a form of productized server farm that borrows from mainframe packaging, cooling, and power supply technology. For large problems, server farms of blade servers are still necessary, and because of blade servers' high power density, can suffer even more acutely from the HVAC problems that affect large conventional server farms.

An IBM bladecenter, with an HS20 server partially removed. The top media tray can be switched between all servers.
History
Complete microcomputers were placed on cards and packaged in standard 19-inch racks in the 1970s soon after the introduction of 8-bit microprocessors. This architecture was used in the industrial process control industry as an alternative to minicomputer control systems. Programs were stored in EPROM on early models and were limited to a single function with a small realtime executive.
The name blade server appeared when cards included small hard disks or flash memory program storage. This allowed complete server operating systems to be packaged on the blade.
The architecture of blade servers is expected to move closer to mainframe architectures. Although current systems act as a cluster of independent computers, future systems may add resource virtualization and higher levels of integration with the operating system to increase reliability.
The first company to produce a blade server was Houston-based RLX Technologies (although not proven), which consisted of mostly former Compaq Computer Corp employees. RLX was later acquired by Hewlett Packard (HP) in 2005.
At present IBM remains the global leader in blade servers in terms of market share and revenue with their BladeCenter system and http://www.blade.org industry collaboration initiative. IBM also supports an Open Architecture called the "Blade Open Specification"
Other major players in the blade server market include Hewlett-Packard (HP), Dell, Rackable (Hybrid Blade) and Verari Systems.

rooted@localhost

NIX Education Center

NIX Education Center

Launching courses @ 50% discount for first 30 Students. All the courses will be taught by Tutors who have worked in the industry and have more than 10 yrs of combined experience.

Course Structure

JOB READY COURSES

Linux on Laptop.

Managing Disk Spaces with LVM in Linux.

LVM Installation

LVM Basics

Example: A Basic File Server

Disk Hardware

Creating a Virtual Volume

Selecting Filesystems

Mounting

Adding Reliability With RAID

Network Access of Files

Backup Strategies

Growth and Reallocation

LVM and Desktops

Conclusion

Replace a bad disk in a mirrored volume group

Access Control List (ACL's) on AIX.

Access Control List + Solaris

File Permissions

Configure a Physical Interface After System Installation

AIX Training Center in Mumbai

Ethernet Bonding

UNIX Questions and Answers

UNIX Questions and Answers

Hardware Issues

Configuration Issues

NFS Issues

General Issues

Software issues

Networking issues

Security issues

Firewall issues

Performance tuning issues

E10000

Unix Interview Questions???

Unix/Linux programming interview questions

Unix/Linux administration interview questions

Solaris interview questions

Blogging using Livewriter.

Converting delimited text to Excel

Commands.txt

How to turn on rsh and rlogin on RedHat Enterprise Linux (RHEL 2.1/ 3.0)

Fail Login Configuration

ssh using keys.

The 10 Commands we never use.

Bash Tips and Tricks

Brace Expansion

Command Substitution

Redirecting Standard Error

Searching the Command History

Using for Loops from the Command Line

And Now for Something Completely Different

Remote Logins - Telnet

How do I lock out a user after a set number of login attempts?

Good Morning.

Some Cool Commands.

Lo

Shell scripts

Generate passwords with openssl

Blade server