Mubarak World

More Solaris tips

noreply@blogger.com (Mubarak World) — Wed, 21 Jan 2009 03:49:00 +0000

Create a directory and move into it at the same time

Question: How often do you create a new directory and then move into that directory in your next command? Answer: Almost always.

I realized this trend in my own work habits, so I created a simple shell function to do the hard work for me.

md () {
mkdir -p $1 && cd $1
}

This is a Bourne shell function named "md" that works for Bourne and Korn shell users. It can be easily adapted for C shell users.

Taking advantage of the -p option of the mkdir command, the function easily creates multi-level subdirectories, and moves you into the lowest level of the directory structure. You can use the command to create one subdirectory like this:

/home/al> md docs
/home/al/docs> _

or you can create an entire directory tree and move right into the new directory like this:

/home/al> md docs/memos/internal/solaris8
/home/al/docs/memos/internal/solaris8>

Easily convert man pages to text documents

Have you ever wanted to convert a man page into a plain text document?
I do this occasionally when I want to share information via an email or other document format.

I used to think this was difficult, but then I discovered a simple way to do it. Here's the wrong way to write the man page for the ls command into a text file named ls.bad:

man ls > ls.bad

This keeps all of the formatting characters in your document, which is generally not what you want. Here's a better way that eliminates those formatting characters:

man ls | col -b > man.txt

The col command with the -b option removes the undesirable backspace characters from the text stream, so the only thing left in your document is the text you want, in the format you want.

How to page more than one command at a time

Have you ever wanted to group a bunch of commands into a paging program like "page" or "more", but didn't know how?

As a system administrator, I always worry about certain things, like who's doing what, what processes are running, what the network traffic looks like, etc. One day I decided to create a simple alias that would combine all the commands I wanted into one big chunk of information. Then I realized that it wouldn't all fit into one screen.

Fortunately I knew how to group all of the commands together, so the "more" command could handle them as one set of input.

First, here's the wrong way to try to page a sequence of four commands:

date; netstat -i; whodo; ps -ef | more

The only command that gets paged properly here is the "ps -ef" command
--the rest of them scroll off the screen before you can read them.

Here's the correct way to page four commands so they're all controlled
by "more":

(date; netstat -i; whodo; ps -ef) | more

Once you find the commands you want to group together, you can combine them into an alias or shell program. I recommend a shell program for this, because a few "echo" statements sure make it easier to see where one command ends and the next command begins!

Changing a file's owner and group at the same time

Did you know that in Solaris 2.x you can change both the user and group ownership on a file at the same time by running /usr/ucb/chown?

For example, suppose you have a file called /export/home/grahamc/myfile that is owned by user 'grahamc' and group 'users'. To change the ownerships, you could type the following as root:

/usr/ucb/chown grahamc:users /export/home/grahamc/myfile

rather than typing:

/usr/bin/chown grahamc /export/home/grahamc/myfile
/usr/bin/chgrp users /export/home/grahamc/myfile

You can also recursively change ownerships with the -R option.

For more information, try: man -s 1b chown

Solaris Tips

noreply@blogger.com (Mubarak World) — Sun, 18 Jan 2009 21:27:00 +0000

As I start working again my OpenSolaris, I'm posting few tips i learned recently

Finding text strings in binary files

Ever wondered what's inside some of those binary files on your system (binary executables or binary data)? Several times I've gotten error messages from some command in the Solaris system, but I couldn't tell where the error was coming from because it was buried in some binary executable file.

The Solaris "strings" command lets you look at the ASCII text buried inside of executable files, and can often help you troubleshoot problems. For instance, one time I was seeing error messages like this when a user was trying to log in:

Could not set ULIMIT

I finally traced the problem down to the /bin/login command by running the "strings" command like this:

root> strings /bin/login | more

The strings command lists ASCII character sequences in binary files, and help me determine that the "Could not set ULIMIT" error was coming from this file. Once I determined that the error message I was seeing was coming from this file, solving the problem became a simple matter.

A vi macro to display line numbers

While the vi editor has been known to be a little rough around the edges, it still has some pretty nice features. One of those features is the ability to define cool macros. Here we'll show you how to create two macros--one to display line numbers of the file you're editing, and one to hide the line numbers.

First, create a file named .exrc in your home directory (or edit the current file if it already exists). This is the configuration file that vi reads when it is started. Put the following two lines into this file:

:map #1 :set number^M
:map #2 :set nonumber^M

(A very important note: create the ^M characters in this file by typing the key sequence [CTRL-V][CTRL-M]. This key sequence embeds an actual ^M character (the carriage return) into the file.)

Now, save this file and re-start vi. From vi's command-mode, you'll now be able to display line numbers beside your file contents by hitting the [F1] function key, and clear line numbers by hitting the [F2] key. If you like these macros, create your own powerful macros by following this same technique!

Use traceroute to find network problems

With the Internet and TCP/IP networks all around us, it's important to know a little bit about TCP/IP network troubleshooting. The Solaris "traceroute" command lets you trace the route your packets are taking to get from your current workstation to a remote workstation you're trying to reach.

For instance, suppose you're on the Internet and you're not getting an HTTP response from a remote server named www.zdtips.com. You try to "ping" the remote site like this:

ping www.zdtips.com

but get no answer. Is the remote server down, or is there a broken link between you and the remote site? Issue the following command to see where the problem lies:

traceroute www.zdtips.com

The traceroute command works its way through the network, and tells you the path it's taking to get to the destination site as it goes along. Watch for the point traceroute fails to learn more about the network segment that has failed. Of course you can also try this on working connections to learn more about how your Internet packets get from one site to another.

Using telnet's command mode

When you use the Solaris telnet command to log in from one site to another, don't forget that you can enter telnet's command mode at any time during
your session, usually by entering the following key sequence:

[CTRL] ] (the control key and right-bracket key at the same time)

When this is successful, you'll see the following prompt:

telnet>

Then, from the "telnet>" prompt, enter "?" to learn more about the available telnet commands. A few commands that will give you more help at the prompt are shown below:

display displays many current Telnet settings
send ? displays commands you can "send" to the remote site
set ? displays variables that can be set

One of my favorites (mostly when fooling around) is:

send ayt

which means "send this message: are you there?".

Keep commands running after you leave with nohup

It's 3 p.m., and you want to start a long job running. Unfortunately, you can't be sure that the job will finish by 5 p.m. when you need to leave, and the company is very strict about making sure you log off when you leave. However, if you log off the system, the job will be stopped. What can you do?

On Solaris systems you can use the "nohup" (no hang-up) command to keep jobs running long after you log off the system. Using nohup tells the system not to "hang-up" on your job after you've logged off the system.

Here's how to run the job, and keep it running after you log off:

root> nohup my-long-job &

This creates a file named "nohup.out" in the current directory that contains the standard output of the command ("my-long-job") you're running. Everyone is happy because the job keeps running, you get to leave at 5 p.m., and you're properly logged off the system.

Use rsh to run commands on somebody else's computer

Here's a hypothetical situation for you: On the "Sesame Street Network", you're logged into a Solaris workstation named "elmo", and you need to look at the man pages for the tar command. Unfortunately the man pages aren't installed on this workstation.

If you're on a network of Solaris computers like this, and you know that the man pages are installed on another workstation named "bigbird", the solution is simple. Simply run the man command on bigbird, like this:

elmo> rsh bigbird "man ksh" | more

This runs the "man ksh" command on bigbird, and pipes the output of the command into the "more" command on elmo.

Here's a few other "rsh" commands you can run on remote workstations:

rsh bigbird "who"
rsh ernie "ps -ef"
rsh grover "ls -al /home"

Use CDPATH to traverse file systems faster

If you're like many Solaris users and administrators, you spend a lot of time moving back and forth between directories in similar locations. For instance, you might often work in your home directory (such as "/home/al"), the /usr/local directories, web page directories, or other user's home directories in /home.

If you're often moving back-and-forth between the same directories, and you use the Bourne shell (sh) or Korn shell (ksh) as your login shell, you can use the CDPATH shell variable to save yourself a lot of typing, and quickly move between directories.

Here's a quick demo. First move to the root directory:

cd /

Next, if it's not set already, set your CDPATH shell variable as follows:

CDPATH=/usr/spool

Then, type this cd command:

cd cron

What happens? Type this and see what happened:

pwd

The result should be "/usr/spool/cron".

When you typed "cd cron", the shell looked in your local directory for a sub-directory named "cron". When it didn't find one, it searched the CDPATH variable, and looked for a "cron" sub-directory. When it found a sub-directory named cron in the /usr/spool directory, it moved you there.

You can set your CDPATH variable just like your normal PATH variable:

CDPATH=/home/al:/usr/local:/usr/spool:/home

Rearranging columns with awk

Have you ever had a column-oriented text file, similar to a spreadsheet, but the columns weren't in the order you wanted? For instance, suppose you had the following information in a file named "checkbook.orig":

COST DATE BALANCE
10.00 040198 1000.00
20.00 040298 980.00
30.00 040298 950.00

The information is good, but you'd prefer to have the DATE column first, followed by the COST information in the second column, and the BALANCE column third.

Using awk, you can easily rearrange the columns. The following command reads the data from the file named "checkbook.orig", and writes the data to a file named "checkbook.new":

awk '{print $2, $1, $3}' checkbook.orig > checkbook.new

This brief awk command reads each line of the original file, and for each line it reads, it writes an output line to the "new" file. As it writes each record to the new file, it rearranges the order of the columns, so that the columns now appear in the desired order!

If you prefer a little more control of the printed output, awk also has a "printf" function that's very similar to printf in the "C" programming language. Here's the same example, with a tab character in-between each column of the output:

awk '{printf ("%s\t%s\t%s\n", $2, $1, $3) }' checkbook.orig > checkbook.new

The awk command is a powerful programming utility that takes care of things like opening files and reading each line automatically, so all you have to do is tell awk how to process each line as it goes by.

Amazing audio applications for Linux

noreply@blogger.com (Mubarak World) — Sat, 17 Jan 2009 11:51:00 +0000

Ardour:

Ardour is a digital audio workstation. You can use it to record, edit and mix multi-track audio. You can produce your own CDs, mix video soundtracks, or just experiment with new ideas about music and sound.

Ardour capabilities include: multichannel recording, non-destructive editing with unlimited undo/redo, full automation support, a powerful mixer, unlimited tracks/busses/plugins, timecode synchronization, and hardware control from surfaces like the Mackie Control Universal. If you’ve been looking for a tool similar to ProTools, Nuendo, Pyramix, or Sequoia, you might have found it.

Audacity:

Audacity is a free, easy-to-use audio editor and recorder for Windows, Mac OS X, GNU/Linux and other operating systems. You can use Audacity to:

Record live audio.
Convert tapes and records into digital recordings or CDs.
Edit Ogg Vorbis, MP3, WAV or AIFF sound files.
Cut, copy, splice or mix sounds together.
Change the speed or pitch of a recording.
And more!

Grip:

Grip is a cd-player and cd-ripper for the Gnome desktop. It has the ripping capabilities of cdparanoia builtin, but can also use external rippers (such as cdda2wav). It also provides an automated frontend for MP3 (and other audio format) encoders, letting you take a disc and transform it easily straight into MP3s. Internet disc lookups are supported for retrieving track information from disc database servers.Grip works with DigitalDJ to provide a unified “computerized” version of your music collection.

Hydrogen:

Hydrogen is an advanced drum machine for GNU/Linux. It’s main goal is to bring professional yet simple and intuitive pattern-based drum programming which is able to be used either by itself, emulating a drum machine based on patterns, or via an external MIDI keyboard/sequencer software. Hydrogen compiles on Linux/x86 and MAC OSX, although the latter is still experimental.

Jokosher:

Jokosher is a simple and powerful multi-track studio. Jokosher provides a complete application for recording, editing, mixing and exporting audio, and has been specifically designed with usability in mind.

The developers behind Jokosher have re-thought audio production at every level, and created something devilishly simple to use.

LMMS:

LMMS aims to be a free alternative to popular (but commercial and closed- source) programs like FruityLoops/FL Studio, Cubase and Logic allowing you to produce music with your computer. This includes creation of loops, synthesizing and mixing sounds, arranging samples, having fun with your MIDI-keyboard and much more.

MusE:

MusE is a MIDI/Audio sequencer with recording and editing capabilities written by Werner Schweer. MusE aims to be a complete multitrack virtual studio for Linux.

Midi sequencing
Record/Playback/Import
Input filter
Audio sequencing
Record/Playback several mono/stereo inputs/outputs.
AudioGroups

soundKonverter:

soundKonverter is a frontend to various audio converters.

The key features are:
Audio conversion
Replay Gain calculation
CD ripping

Streamripper:

With the emergence of file sharing protocols such as Napster, Gnutella, and now Mojonation and Freenet, the average Internet user can download nearly any mp3 he wants in a matter of no time, but many times people don’t know what they want. Streamripper allows you to download an entire station of music. Many of these mp3 radio stations only play certain genres, so you can now download an entire collection of goa/trance music, an entire collection of jazz, punk rock, whatever you want.

Frozen-Bubble: Addictive Game for Linux

noreply@blogger.com (Mubarak World) — Sat, 17 Jan 2009 10:06:00 +0000

Frozen-Bubble has blissfully stolen hours and hours of my life with its addictive gameplay and flippin' awesome soundtrack. It's an easy game with a simple premise: shoot colors bubbles onto the game board in an attempt to match up three or more similarly colored bubbles. Doing so will cause them to fall from the board, taking connected bubbles with them. If you clear all of the bubbles, you move on to the next level. If the bubbles pile up and cover the entire screen, you lose the game and restart the entire level.

Because my description is probably dense and hard to grasp, here's a video. By the way, no one gets to make fun of my mad Frozen-Bubble skillz.

The developer website lists the features well:

Colorful 3D rendered penguin animations, 100 levels of 1p game, hours and hours of 2p game, nights and nights of 2p/3p/4p/5p game over LAN or Internet, a level-editor, 3 professional quality digital soundtracks, 15 stereo sound effects, 8 unique graphical transition effects, 8 unique logo eye-candies.

Let me emphasize again: the soundtrack is amazing. It sounds really, really good. And the multiplayer is a lot of fun, especially over the LAN.

Install frozen-bubble using Synaptic, the Add/Remove... dialog, or by typing the following into the Terminal:

sudo apt-get install frozen-bubble

Linux Shell Editing Shortcuts

noreply@blogger.com (Mubarak World) — Sat, 17 Jan 2009 09:36:00 +0000

One of the secrets power shell users know is that they don't really have to be great typists. They take advantage of the typing shortcuts the shell offers.

Fixing Mistakes

You probably know you can erase the last character by hitting the backspace key. But you can correct mistakes in a lot more ways than that.

First trick: Ctrl-U deletes everything back to the beginning of the line. No need to hold the backspace key down and wait while it repeats; a single Ctrl-U is much faster. It's great for when you change your mind about a command or want to clear the line and think about what to do next. Think of U as Undoing the line you were typing.

Next -- and my personal favorite -- is Ctrl-W to erase the last word. Like Ctrl-U, it's a lot faster than holding the backspace key down and waiting. But unlike Ctrl-U, it lets you keep some of what you already typed. Try it -- you'll be amazed how handy it is.

You may have noticed that you can use the left and right arrow keys while you're typing a line in the shell. But Home and End don't work to go to the beginning and end of a line -- how do you do that? The secret: type Ctrl-A to go to the beginning of the line, Ctrl-E to go to the end. To remember those two, think of A as being at the beginning of the alphabet while E just stands for "End".

If you move the cursor back while you're editing a line, with the left arrow or Ctrl-A, you might also be interested in Ctrl-K. It deletes from the cursor position to the end of the line.

Enabling editing shortcuts in other apps

Most of these editing shortcuts will work in lots of other Linux apps besides the shell, though not every program supports all of them. Try them in editors, mail programs, browsers.

In some programs and on some Linux distros, they aren't enabled by default. If you find them useful, you can turn them on for Firefox and any GTK-based applications by setting your Gnome key theme to "Emacs". To do that, either add the line

gtk-key-theme-name = "Emacs"

to a file named .gtkrc-2.0 in your home directory, or run this command:

gconftool-2 --set /desktop/gnome/interface/gtk_key_theme Emacs --type string

Test C++, Perl, PHP, Ruby or Python Code Online

noreply@blogger.com (Mubarak World) — Sun, 04 Jan 2009 07:53:00 +0000

Just go to codepad.org and enter your code in any of the following languages: C, C++, D, Haskell, OCaml, Perl, Plain Text, Python, Ruby, Scheme, and Tcl. Once you’ve entered your code you then have the option of either pasting and running your code to test it or just pasting it. If any errors are found in the code that you have written, Codepad will point out the error and give you an explanation of what you have done wrong along with the line in which that error occurs. Also, after entering your code, Codepad will create a page where you and others clan go to test and collaborate.

This is a simple free tool that allows both advanced and beginner-level programmers to test their code. Most appealing is the potential it offers for group collaboration.

It's usage looks like that:

C++:

int main(){
char hostname[] = "blogspot.com/";
printf("http://mubarakworld.%s", hostname);
return EXIT_SUCCESS;
}

Output:

1	http://mubarakworld.blogspot.com/

http://codepad.org/

Perl Myths

noreply@blogger.com (Mubarak World) — Thu, 01 Jan 2009 04:07:00 +0000

Perl Myths

Perl programming has it's share of myths. This presentation debunks a few popular ones with hard facts. Surprise yourself with the realities.

Perl 5.10 for People Who Aren't Totally Insane

noreply@blogger.com (Mubarak World) — Thu, 01 Jan 2009 03:59:00 +0000

All the hype about perl 5.10 can sound a little intimidating. User-level pragmata! Overloadable smartmatching operator! Thread-safe refkey hashes! For Pete's sake, have you heard about lexically scoped pluggable regexp engines?

It's enough to make you think that 5.10's changes are just for the hard-core perl hackers, but it couldn't be further from the truth! The new version of Perl is full of changes that are easy to use and pack lots of useful benefits for doing plain old every day Perl programming.

How to set up a home email server (without being spammed to death)

noreply@blogger.com (Mubarak World) — Wed, 31 Dec 2008 12:02:00 +0000

by RedHat Magazine Editorial Team

by Stuart Kirk

Why host your own mail?

There are many reasons to host your own email. Perhaps you don’t like the limits placed on you by your current ISP. Maybe they aren’t willing to host the domain you want, or give you the access you want. And if they do fit your needs, they want to charge a small fortune. Maybe you want complete privacy. Or perhaps you just want to access your email from anywhere using a web-based frontend. The list goes on and on…

There are several many ways to accomplish this task. Everyone has their preferred MTA program, but for the purposes of this article, we’ll use sendmail. The same can also be done using postfix, or exim. Each approach has its own merits.

Let’s get started.

Requirements

I’m going to assume that when setting up your email server, you’ll want to do so with your own personalized domain name. While I’m not going to explain how to register a domain name, if you’re unsure, you can always click here for an explanation on how to do so. The domain that I’ll refer to in this article will be mailjunkie.org, with the hostname of the machine being server1. I’m also going to assume, at least for now, that your IP address is static, and your inbound and outbound connections on port 25 are unrestricted.

The first thing you’ll need will be your physical infrastructure: a computer running Red Hat® Enterprise Linux®, a high-speed Internet connection, and a registered domain name. After you have installed Red Hat Enterprise Linux on your system you will want to make sure the following packages are installed:

dovecot
sendmail
sendmail-cf
squirrelmail
perl
gcc

There are other packages we will need later on.

Configuring your mail exchanger

After you’ve set up your domain name with your favorite registrar, you will need to configure your Mail Exchanger (MX) record. You will do this through your domain registrar. After you find the page that will allow you to set up your MX record, I recommend you do the following:

Setup the MX record in the format mx.yourdomain.com. So, for our
example domain, we would choose “mx.mailjunkie.org” as our MX record.
Configure your mail exchanger with a priority of 0 (zero).
Create a hostname/address (A RECORD) that associates mx.mailjunkie.org with the IP address that your ISP has assigned you.

After you’re done setting this up, you can test to see if it worked by dropping to a shell prompt and issuing the following command.
If your setup is correct, you should see some synthesis of:

[root@server1 ~]$ nslookup -query="MX" mailjunkie.org
Server:         127.0.0.1
Address:        127.0.0.1#53

Non-authoritative answer:
mailjunkie.org    mail exchanger = 0 mx.mailjunkie.org.

Authoritative answers can be found from:
mailjunkie.org    nameserver = dns4.name-services.com.
mailjunkie.org    nameserver = dns5.name-services.com.
mailjunkie.org    nameserver = dns1.name-services.com.
mailjunkie.org    nameserver = dns2.name-services.com.
mailjunkie.org    nameserver = dns3.name-services.com.
mx.mailjunkie.org       internet address = 1.2.3.4
dns1.name-services.com  internet address = 69.25.142.1
dns2.name-services.com  internet address = 216.52.184.230
dns3.name-services.com  internet address = 63.251.92.193
dns4.name-services.com  internet address = 64.74.96.242
dns5.name-services.com  internet address = 70.42.37.1

Please note that it may take some time for the changes you have made to propagate through DNS. If you check immediately after you make these changes and do not see your settings reflected, try a few minutes later.

Configuring s`endmail

The next step will be setting up and configuring sendmail. The process for doing this is somewhat arduous, so please read all of the information presented before beginning.

The file /etc/mail/sendmail.cf is the main configuration file
for sendmail. This “cf file” contains the directives that sendmail will
operate under. Much more friendly, however, is the file /etc/mail/sendmail.mc.
This “mc file” should be the base that you use for making all changes
to sendmail’s operating parameters. Additionally, the “cf file” is
created from the parameters listed in this “mc file”. Red Hat has done
a wonderful job creating a template for your “mc file” and as such,
the bulk of the changes that need to be made are just editing
directives that are already present. Below are the directives that you
must search for within your “mc file” and change accordingly:

DAEMON_OPTIONS(`Port=smtp,Addr=127.0.0.1, Name=MTA')dnl  - change to -  DAEMON_OPTIONS(`Port=smtp, Name=MTA')
LOCAL_DOMAIN(`localhost.localdomain')dnl                 - change to -  LOCAL_DOMAIN(`emailjunkie.org')
dnl MASQUERADE_AS(`mydomain.com')dnl                     - change to -  MASQUERADE_AS(`emailjunkie.org')
dnl FEATURE(masquerade_envelope)dnl                      - change to -  FEATURE(`masquerade_envelope')
dnl define(`SMART_HOST',`smtp.your.provider')            - change to -  define(`SMART_HOST',`your.trusted.smtp.relay')

Add in the line:

FEATURE(`allmasquerade')

Please note: You must replace “your.trusted.smtp.relay” with the name
of your ISP’s SMTP server. While omitting this change will not prevent
your e-mail server from operating properly, there are several filters
that are often employed that will block any “at home Cable, xDSL” port
25 connections for fear of spam.

After you have made these changes and are back in your server’s /etc/mail directory, run the command “make -C /etc/mail“. This compiles the “cf file” based on the instructions given in your “mc file”. Each time you make a change to your “mc file”, you must re-compile your “cf” file by issuing this command.

Edit your hosts file

Sendmail will make use of your /etc/hosts file, so you need to modify it so that mail is routed properly. Edit your /etc/hosts file and include a line that reads:

1.2.3.4     server1.mailjunkie.org

where 1.2.3.4 is the IP address that is assigned to you by your ISP.

Obtaining and installing MailScanner, SpamAssassin, and ClamAV

Out of the box, sendmail works to deliver mail only. As such,
you are quite vulnerable to spam and virus threats that will very
quickly become a problem if you do not take action early. These
three applications will process received mail and scan it for viruses
and spam before it is delivered. You can download the latest versions
of these applications from mailscanner.info.

Download the latest “for Red Hat, Fedora, and Mandrake Linux (and other
RPM-based Linux distributions)” release of MailScanner, as well as the
latest “ClamAV and SpamAssassin easy installation packages.”

The installation package for all of the applications is quite good; it
will resolve most of the dependencies that are required to gunzip, un-tar, and run both of these applications. As MailScanner checks for the presence of ClamAV when it installs, I recommend installing the SpamAssassin/ClamAV package first:

[root@server1 ~]# wget http://www.mailscanner.info/files/4/install-Clam-0.88.5-SA-3.1.7.tar.gz
[root@server1 ~]# tar zxvf install-Clam-0.88.5-SA-3.1.7.tar.gz
[root@server1 ~]# cd install-Clam-0.88.5-SA-3.1.7
[root@server1 install-Clam-0.88.5-SA-3.1.7]# ./install.sh

There will be significantly more output produced as ClamAV and
SpamAssassin are installed on your system. After they are installed,
you should see a message similar to this:

Now you need to install:
1) Razor-agents-sdk and Razor2 from http://razor.sourceforge.net/ and
2) DCC from http://www.rhyolite.com/anti-spam/dcc/

Follow the links above to download the three applications that will
assist SpamAssassin in processing your email. Below are the list of
commands I used to download and install them. For clarity, I have
removed all of the output that was produced for each command. You can
expect to see significantly more than what I have listed. What
is shown are the base commands to download, compile, and install the
helper applications.

[root@server1 ~]# wget http://umn.dl.sourceforge.net/sourceforge/razor/razor-agents-sdk-2.07.tar.bz2
[root@server1 ~]# wget http://umn.dl.sourceforge.net/sourceforge/razor/razor-agents-2.82.tar.bz2
[root@server1 ~]# wget http://www.rhyolite.com/anti-spam/dcc/source/dcc.tar.Z

[root@server1 ~]# bunzip2 razor-agents-sdk-2.07.tar.bz2
[root@server1 ~]# tar xvf razor-agents-sdk-2.07.tar
[root@server1 ~]# cd razor-agents-sdk-2.07
[root@server1 razor-agents-sdk-2.07]# perl Makefile.PL
[root@server1 razor-agents-sdk-2.07]# make
[root@server1 razor-agents-sdk-2.07]# make test
[root@server1 razor-agents-sdk-2.07]# make install
[root@server1 razor-agents-2.82]# cd ..

[root@server1 ~]# bunzip2 razor-agents-2.82.tar.bz2
[root@server1 ~]# tar xvf razor-agents-2.82.tar
[root@server1 ~]# cd razor-agents-2.82
[root@server1 razor-agents-2.82]# perl Makefile.PL
[root@server1 razor-agents-2.82]# make
[root@server1 razor-agents-2.82]# make test
[root@server1 razor-agents-2.82]# make install
[root@server1 razor-agents-2.82]# cd ..

[root@server1 ~]# tar zxvf dcc.tar.Z
[root@server1 ~]# cd dcc-1.3.42/
[root@server1 dcc-1.3.42]# ./configure
[root@server1 dcc-1.3.42]# make install
[root@server1 dcc-1.3.42]# cd ..

Now that these applications are installed, we can proceed to download, compile, and install MailScanner.

[root@server1 ~]# wget http://www.mailscanner.info/files/4/rpm/MailScanner-4.56.8-1.rpm.tar.gz
[root@server1 ~]# tar zxvf MailScanner-4.56.8-1.rpm.tar.gz
[root@server1 ~]# cd MailScanner-4.56.8-1
[root@server1 MailScanner-4.56.8-1]# ./install.sh

As with ClamAV and SpamAssassin, there will be a significant amount of output produced. You should, however, end up with:

Preparing...                ########################################### [100%]
 1:mailscanner            ########################################### [100%]
Good, SpamAssassin site rules found in /etc/mail/spamassassin

To activate MailScanner run the following commands:

service sendmail stop
chkconfig sendmail off
chkconfig --level 2345 MailScanner on
service MailScanner start

Now, before we issue the commands to start MailScanner, please be sure within the /etc/MailScanner/MailScanner.conf file, the following lines exist:

Virus Scanners = clamav
Use SpamAssassin = yes

These directives tell MailScanner to use ClamAV to scan for
viruses, and SpamAssassin to process email for spam. From here we can
issue the commands below to start MailScanner and begin processing
email. I highly recommend you view the /var/log/maillog
file while starting MailScanner and scan the output for undesirable
actions, as well as to verify that Mail is being processed properly.

[root@server1 MailScanner-4.56.8-1]# service sendmail stop
[root@server1 MailScanner-4.56.8-1]# chkconfig sendmail off
[root@server1 MailScanner-4.56.8-1]# chkconfig --level 2345 MailScanner on
[root@server1 MailScanner-4.56.8-1]# service MailScanner start

Setting up web access to your email

I am going to assume that you have your apache server running.
If you don’t you should review the steps to install and configure apache.

After you have verified that your web server is running, execute the following commands at your shell prompt:

[root@server1 ~]# chkconfig dovecot on
[root@server1 ~]# service dovecot start

These commands will start your IMAP server, which will be used by the Squirrel Mail package to access the mail stored on your server. With good luck, you should now have a fully functional, protected email server running. Keep in mind you may need to make changes to your /etc/mail/local-host-names file and /etc/mail/relay-domains file. Each case will be different, so I recommend you review your /var/log/maillog file and use the links provided to perform any final setting changes.

10 things every Perl hacker should know

noreply@blogger.com (Mubarak World) — Wed, 31 Dec 2008 10:53:00 +0000

As one of the easiest programming languages to use for whipping up quick, effective code for simple tasks, Perl attracts new users easily and has become an important and popular tool for getting things done. Before jumping fully into Perl programming, though, there are a few things you should know that will make your life easier, both when writing code and when asking for help from Perl experts.

1. Perl is not an acronym

Perl is sometimes known as the Practical Extraction and Report Language, because it's very practical, and it is very good at extracting data and creating reports using that data. It is also known humorously as the Pathologically Eclectic Rubbish Lister, for reasons that might become obvious after you've used it for a while. Both of these phrases are equally "official" and equally correct, but the language is not PERL. It was named Perl before either of those phrases was invented, and the language is in fact not technically an acronym at all. When speaking of the language, call it Perl, and when speaking of the parser (the interpreter/compiler), it is acceptable to call it perl, because that is how the command used to run it is spelled. One of the quickest ways to get identified as a know-nothing newbie when talking to Perl hackers is to call it PERL.

2. There is more than one way to do it

One of the main mottos of the Perl language and community is TIMTOWTDI, pronounced "Tim Toady". This one really is an acronym, and it stands for There Is More Than One Way To Do It. It's true of Perl on many levels, and is something important to keep in mind. While some ways to do something are often better than other ways to do the same thing, you can be sure that for pretty much everything you can do with Perl, there is more than one way to do it.

3. Use warnings and use strict

Warnings and the strict pragma are important weapons in the Perl hacker's arsenal for debugging code. Warnings will not prevent a program from executing, but will give helpful information on how the code can be fixed up.

The strict pragma will actually prevent the code from executing if a strict approach to programming style is not used, such as lexically scoping variables. Once in a while, a program might be better off without the strict pragma, but if you're new to Perl it will surely be a long time before you learn to recognize such situations, and until then you should just use it.

A Perl script with warnings turned on in the shebang line and the strict pragma used, on a standard UNIX system, would start like this:

#!/usr/bin/Perl -w
use strict;

Warnings can also be turned on with a use statement, like this:

#!/usr/bin/Perl
use strict;
use warnings;

A pragma, in Perl, is a preprocessor directive. In other words, it's an instruction sent to the compiler before the code is compiled for execution. Pragmas change how the compiler parses code.

4. Use taint checking

With the -T option on the shebang line of your program, you explicitly turn on taint checking. This is a security measure that checks all input for your program for "tainted" data, to help ensure that incoming data will not allow arbitrary code execution if a malicious user is trying to crack security on the system running your code. This is especially important in circumstances where you are using Perl/CGI scripts to process data from an HTML form on the Web. It can be combined with the -w option as -wT.

5. Use lexically scoped variables

You can use the my() operator to create variables using lexical scoping. In brief, this means that the scope of the variable is limited to the current context: if you declare a variable using my() inside a subroutine, the variable only exists inside that subroutine. The value of lexical scoping is that it protects different parts of modular code from one another.

For instance, if you're using a Perl module or library without knowing exactly what the code inside it looks like, using lexical variables can help to prevent accidentally assigning new values to variables that need to remain unchanged until later. It is especially important to use lexical scoping for your variables when writing modules and libraries in Perl. For those coming to Perl from other languages, you may know of the concept of lexically scoped variables as "private variables".

6. How to name your programs

Perl programs should have the appropriate file extension in their names. Many lower-quality Perl howtos simply use the .pl extension for everything, naming Perl scripts something like foo.pl. Technically, the .pl extension should be used for Perl libraries, not for executable Perl programs. For executable files, you should either use .plx or, if your operating system will allow it, no file extension at all. Perl modules, meanwhile, should use the .pm file extension. It is also considered good practice to use only alphanumeric characters and underscores in Perl script filenames, and to start those filenames with a letter (or underscore), similar to how you would start variable names.

7. How to use CPAN

The Comprehensive Perl Archive Network (CPAN) is a rich resource for finding freely available, reusable code. In particular, CPAN is where you'll find legions of Perl modules that can be used to enhance the functionality of your programs and reduce the time you spend writing them. The options you have for using CPAN vary from one operating system and Perl parser implementation to the next, but you can always browse CPAN using your Web browser. Perl implementations generally come with at least a command-line tool for installing Perl modules from CPAN.

8. How to use Perldoc

The online documentation for Perl is extensive and comprehensive, in the form of Perldoc. With Perldoc installed on your system, you can use it to access documentation on any of the standard Perl functions, installed modules, variables, and a slew of other things -- even Perldoc itself! It's like having one of the most complete programming reference books available right at your fingertips, for free, and searchable since it's in electronic format.

On some systems, Perldoc will be installed by default with Perl itself, and on others the process for installation should be self-evident. If you have problems getting Perldoc installed, you can always access the online Perldoc Website. Make sure you know how to use Perldoc, because it can make you a more effective Perl hacker in ways that just might surprise you.

9. Don't reinvent the wheel

You should use subroutines, modules, and libraries often. The point is to help you write code faster and keep that code from becoming unmanageable if you need the same functionality in multiple programs, or more than once in the same program. This is accomplished by separating blocks of code from the rest of your source code using subroutines, modules, and libraries. You're better off using a design for the wheel that already exists, rather than reinventing the wheel from scratch, most of the time. In addition, when you're reusing code from a subroutine, module, or library, and you need to improve that code somehow, you only need to change it in one place.

The term "subroutine" in Perl means roughly the same thing as "function" in C.

10. Regular expressions are your friends

Perl's regular expression syntax can help to make your source code look intimidating to the uninitiated, and as a result sometimes people new to Perl programming avoid regexen. This is, really, a mistake. Regular expressions add a great deal of power to the Perl programming language, often allowing the programmer to do something in three lines that might otherwise take fifty lines of code. Regular expressions are expressions made up of abbreviations for matching patterns in strings that can be used to find and manipulate smaller strings inside larger strings. It behooves the Perl hacker to learn regex syntax and learn it well.

Often Perl hackers and other programmers who use regular expressions will refer to them as "regexen" or "regexes" in the plural ("regex" singular). An alternate version of "regex" is "regexp", though why anyone would want to add that extra letter, making it more difficult to pronounce clearly, is beyond me.

Building custom subroutines in Perl

noreply@blogger.com (Mubarak World) — Wed, 31 Dec 2008 10:51:00 +0000

Every programming language comes with its own built-in functions or subroutines—every time you print() or join() something in Perl, you're actually using a built-in subroutine. But Perl also allows you to define your own custom subroutines, so that you can save yourself some time and effort when performing common tasks. I'll show you why subroutines are useful, and how to create your own.

Advantages of subroutines

Subroutines are convenient for three reasons:

They let developers break up long procedural scripts into smaller, easier to understand fragments. This makes code easier to debug, and simplifies locating the source of errors.
By identifying commonly-used tasks and then encapsulating those tasks into independent packages, subroutines make code reuse a reality. It's not uncommon for many Web developers to maintain their own library of commonly-used subroutines and import them whenever needed to quickly accomplish common tasks.
A subroutine is created once but invoked many times. So if a code update is needed in the future, the changes can be done in one spot (the subroutine definition) while the subroutine invocations remain untouched.

Defining a subroutine

Here's a simple example of a subroutine:

# define subroutine
sub makeJuice
{
print "Making lemon juice...";
}

Every subroutine follows a few basic rules:

The subroutine definition begins with the "sub" keyword, followed by the name of the subroutine. This name is what you use to invoke the subroutine in your scripts. The name may optionally be followed by parentheses.
The code that makes up the subroutine is enclosed within curly braces. This code is regular Perl code—you can use variables, loops, conditionals and all the usual Perl constructs inside it.
Subroutines may appear anywhere in a Perl script, or may even be imported from external files.

To call a subroutine, invoke it by preceding its name with an ampersand (&):

# call subroutine
&makeJuice();

When the Perl interpreter sees this call, it looks for the subroutine named makeJuice() and executes it. You can invoke the same subroutine as many times as you like. In this particular example, we call the makeJuice() subroutine four times:

#!/usr/bin/perl

# define subroutine
sub makeJuice
{
print "Making lemon juice...\n";
}

# call subroutine
&makeJuice();
&makeJuice();
&makeJuice();
&makeJuice();

The above script produces the following output:

Making lemon juice...
Making lemon juice...
Making lemon juice...
Making lemon juice...

Of course, there will come a time when you're fed up with all that lemon juice and would prefer something different. That's why subroutines can accept arguments, user-defined values passed to the subroutine when it is called and then processed by the code inside that subroutine. Let's see how to pass arguments to a subroutine.

Passing arguments to a Perl subroutine

Suppose I would like to give the makeJuice() subroutine more intelligence by telling it which flavor of juice to make:

&makeJuice("strawberry");

Invoking a subroutine with an argument is the easy part—I still need to write the code that accepts the argument and does something with it:

sub makeJuice
{
# retrieve the argument
my ($flavor) = shift (@_);

# and use it
print "Making $flavor juice...\n";
}

Perl has a somewhat unique way of handling subroutine arguments. All arguments passed to a subroutine are stored in a special @_ array. To retrieve the arguments, you have to look inside the array and extract them.

In the revised subroutine definition above, we use the shift() function to extract the first element of the array—the flavor—and assign it to a variable. This variable is then used in the call to print().

If you don't like the shift() syntax, you can also use "regular" array notation (indexing):

sub makeJuice
{
# retrieve the argument
my ($flavor) = $_[0];

# and use it
print "Making $flavor juice...\n";
}

This next listing is another, slightly more useful example:

#!/bin/perl
# define subroutine to convert between dollars and euros sub convertCurrency {
# get amount in $
my ($usd) = shift (@_);

# specify conversion rate
my $convRate = 0.82;

# print amount in euro
print "USD $usd = ", sprintf("%0.2f", $usd * $convRate), " EUR"; }

# invoke function with custom $ amount
&convertCurrency(100);

Here, the convertCurrency() subroutine performs the conversion between dollars and euros. The amount of USD to be converted is passed to the subroutine as an argument, and the output contains the corresponding amount in euros. Adding arguments to a subroutine thus immediately makes the subroutine more flexible and useful.

Sending back return values from a subroutine

Now, consider this variant on the convertCurrency subroutine from the previous example:

#!/usr/bin/perl

# define subroutine
sub convertCurrency
{
# get amount in $
my ($usd) = shift (@_);

# specify conversion rate
my $convRate = 0.82;

# convert value
$euro = $usd * $convRate;
}

# invoke function with custom $ amount
print &convertCurrency(100);

Even though the subroutine does not print any output, it does return a value, which can be caught and used by the main script. By default, this value is the last expression evaluated by the subroutine.

If you like, you can override this return value by specifying your own with a "return" statement:

#!/usr/bin/perl

# define subroutine to check file status
sub checkFileStatus {
# get file path
my ($file) = $_[0];

# test file status
# return 1 or 0
(-r $file) ? return 1 : return 0;
}

# invoke function with filename
# check return value and print appropriate message
$status = &checkFileStatus('/usr/local/mail.cf');

if ($status == 1)
{
print "File is readable\n";
} else {
print "File is not readable\n";
}

The "-r" test checks if the file is readable, and the subroutine sends back true or false to the caller depending on what it finds. The main script then checks this return value and prints an appropriate message.

You can also write a subroutine that returns an array instead of a scalar value:

#!/usr/bin/perl

# define subroutine to
# split an email address into
# user and domain
sub breakEmailAddress
{
# get address
my ($address) = shift(@_);

# split address on the @ symbol into an array
@components = split('@', $address);

# return array
return @components;

}

# split email address
# print the components
@output = &breakEmailAddress('john@some.domain.com');
print "Username is ", $output[0], "\nDomain is ", $output[1]; [/code]

Here is the output:

Username is john
Domain is some.domain.com

The top 5 Linux myths: Why you shouldn’t fear the penguin

noreply@blogger.com (Mubarak World) — Sat, 27 Dec 2008 11:03:00 +0000

Now, what to the do with the old computer, or even with the netbook? Why not give your old computer a new life by running Linux on it? It may seem like a scary thought, but chances are you have a few misconceptions about Linux and that’s keeping you from making the jump.

Here is a list of five of the biggest Linux myths out there and how you can make Linux your friend.

5. It won’t connect to an iPod or MP3 player.

This might not apply to everyone, but to some people who only have one computer it could be a big deal. Most people now have some sort of MP3 player, and need a computer to put music on it, with special software on top of that, especially with the iPod.

Now, of course, you can’t use the App Store without iTunes (which has some problems installing with WINE), but you can easily buy songs from Amazon MP3 store, or rip them from CDs. Most music players for Linux support MP3 players, and even iPods, some like Songbird even look like iTunes if you’re almost too comfortable with the program.

4. Linux is not compatible with Mac/Windows files.

This seems to be a general misconception about computers in general. A lot of people seem to think that files from one operating system won’t work on any other one. This is true about applications, but not for the files they use or create.

If you’re working with a word processor, chance are it can export files to .doc files, which just about any program can use. Music is usually stored in MP3, AAC or FLAC files, all of which are easily usable on any platform. Having compatible files is easily avoided if you use cross-platform applications such as OpenOffice, that way you dont have to worry about exporting to other file types

3. Linux can’t play games.

This might not be important to everyone, but to some people games are the main reason why they stick with Windows. Even if all they play is World of Warcraft, they don’t want to give up their games just because thy switch to another OS.

There’s actually a lot of games that are native to Linux, though most aren’t as pretty as the newest games. There are ways to play those new games on Linux, however. There’s Codeweaver’s Crossover and Crossover Games, Cedega, and WINE (Crossover is essentially a more stable, paid version of WINE). Between these three, most popular games are easily played. I run WarCraft III on Ubuntu Eee using WINE, and it can easily handle WoW or even games liek Team Fortress 2, assuming your computer can handle it, of course.

2. Apps are hard to find.

Most Linux distros come with a lot of useful software, but sometimes you might want to replace them with something else or find something else you might want ot need. Unlike Windows, and to a lesser extent Mac, there aren’t many retail box copies of Linux software. However, with a quick Google search for “Linux apps” I was able to find Linux Online’s application page. Or, if you’re running Ubuntu, there’s Get Deb, which not only lists Ubuntu software, but also makes it really simple to install them.

1. You have to learn command line/terminal

I can’t tell you how many times I’ve told people that I’m running Linux, and they immediately cringe at the idea of the terminal. Somewhere along the line, Linux got the reputation that it’s only usable by coders, or those who know a decent bit of code.

The same people that cringe are the same people that are surprised when I show them Ubuntu Eee. It’s possibly even more simple than Windows with the netbook remix UI, but Linux is easy even without that.

Some distributions such as openSUSE have a Windows-like start menu, some, like Ubuntu, have an applications drop menu that lists all your applications, making for an environment that should be easy for anyone. Most also use GNOME or KDE file browsers which are just as easy to navigate as Windows Explorer.

If you can possibly get past these scary ideas, I would recommend Ubuntu, or Ubuntu Eee for your Eee PC (soon to be Easy Peasy, with more netbooks supported). Also look for my article on useful applications for Linux that can replace your Windows or Mac Apps.

An A-Z Index of the Bash command line for Linux.

noreply@blogger.com (Mubarak World) — Thu, 25 Dec 2008 11:03:00 +0000

 alias    Create an alias
apropos  Search Help manual pages (man -k)
apt-get  Search for and install software packages (Debian)
aspell   Spell Checker
awk      Find and Replace text, database sort/validate/index
b
bash     GNU Bourne-Again SHell
bc       Arbitrary precision calculator language
bg       Send to background
break    Exit from a loop
builtin  Run a shell builtin
bzip2    Compress or decompress named file(s)
c
cal      Display a calendar
case     Conditionally perform a command
cat      Display the contents of a file
cd       Change Directory
cfdisk   Partition table manipulator for Linux
chgrp    Change group ownership
chmod    Change access permissions
chown    Change file owner and group
chroot   Run a command with a different root directory
chkconfig System services (runlevel)
cksum    Print CRC checksum and byte counts
clear    Clear terminal screen
cmp      Compare two files
comm     Compare two sorted files line by line
command  Run a command - ignoring shell functions
continue Resume the next iteration of a loop
cp       Copy one or more files to another location
cron     Daemon to execute scheduled commands
crontab  Schedule a command to run at a later time
csplit   Split a file into context-determined pieces
cut      Divide a file into several parts
d
date     Display or change the date & time
dc       Desk Calculator
dd       Convert and copy a file, write disk headers, boot records
ddrescue Data recovery tool
declare  Declare variables and give them attributes
df       Display free disk space
diff     Display the differences between two files
diff3    Show differences among three files
dig      DNS lookup
dir      Briefly list directory contents
dircolors Colour setup for `ls'
dirname  Convert a full pathname to just a path
dirs     Display list of remembered directories
dmesg    Print kernel & driver messages
du       Estimate file space usage
e
echo     Display message on screen
egrep    Search file(s) for lines that match an extended expression
eject    Eject removable media
enable   Enable and disable builtin shell commands
env      Environment variables
ethtool  Ethernet card settings
eval     Evaluate several commands/arguments
exec     Execute a command
exit     Exit the shell
expect   Automate arbitrary applications accessed over a terminal
expand   Convert tabs to spaces
export   Set an environment variable
expr     Evaluate expressions
f
false    Do nothing, unsuccessfully
fdformat Low-level format a floppy disk
fdisk    Partition table manipulator for Linux
fg       Send job to foreground
fgrep    Search file(s) for lines that match a fixed string
file     Determine file type
find     Search for files that meet a desired criteria
fmt      Reformat paragraph text
fold     Wrap text to fit a specified width.
for      Expand words, and execute commands
format   Format disks or tapes
free     Display memory usage
fsck     File system consistency check and repair
ftp      File Transfer Protocol
function Define Function Macros
g
gawk     Find and Replace text within file(s)
getopts  Parse positional parameters
grep     Search file(s) for lines that match a given pattern
groups   Print group names a user is in
gzip     Compress or decompress named file(s)
h
hash     Remember the full pathname of a name argument
head     Output the first part of file(s)
history  Command History
hostname Print or set system name
i
id       Print user and group id's
if       Conditionally perform a command
ifconfig Configure a network interface
ifdown   Stop a network interface
ifup     Start a network interface up
import   Capture an X server screen and save the image to file
install  Copy files and set attributes
j
join     Join lines on a common field
k
kill     Stop a process from running
killall  Kill processes by name
l
less     Display output one screen at a time
let      Perform arithmetic on shell variables
ln       Make links between files
local    Create variables
locate   Find files
logname  Print current login name
logout   Exit a login shell
look     Display lines beginning with a given string
lpc      Line printer control program
lpr      Off line print
lprint   Print a file
lprintd  Abort a print job
lprintq  List the print queue
lprm     Remove jobs from the print queue
ls       List information about file(s)
lsof     List open files
m
make     Recompile a group of programs
man      Help manual
mkdir    Create new folder(s)
mkfifo   Make FIFOs (named pipes)
mkisofs  Create an hybrid ISO9660/JOLIET/HFS filesystem
mknod    Make block or character special files
more     Display output one screen at a time
mount    Mount a file system
mtools   Manipulate MS-DOS files
mv       Move or rename files or directories
mmv      Mass Move and rename (files)
n
netstat  Networking information
nice     Set the priority of a command or job
nl       Number lines and write files
nohup    Run a command immune to hangups
nslookup Query Internet name servers interactively
o
open     Open a file in its default application
op       Operator access
p
passwd   Modify a user password
paste    Merge lines of files
pathchk  Check file name portability
ping     Test a network connection
popd     Restore the previous value of the current directory
pr       Prepare files for printing
printcap Printer capability database
printenv Print environment variables
printf   Format and print data
ps       Process status
pushd    Save and then change the current directory
pwd      Print Working Directory
q
quota    Display disk usage and limits
quotacheck Scan a file system for disk usage
quotactl Set disk quotas
r
ram      ram disk device
rcp      Copy files between two machines
read     read a line from standard input
readonly Mark variables/functions as readonly
reboot   Reboot the system
renice   Alter priority of running processes
remsync  Synchronize remote files via email
return   Exit a shell function
rev      Reverse lines of a file
rm       Remove files
rmdir    Remove folder(s)
rsync    Remote file copy (Synchronize file trees)
s
screen   Multiplex terminal, run remote shells via ssh
scp      Secure copy (remote file copy)
sdiff    Merge two files interactively
sed      Stream Editor
select   Accept keyboard input
seq      Print numeric sequences
set      Manipulate shell variables and functions
sftp     Secure File Transfer Program
shift    Shift positional parameters
shopt    Shell Options
shutdown Shutdown or restart linux
sleep    Delay for a specified time
slocate  Find files
sort     Sort text files
source   Run commands from a file `.'
split    Split a file into fixed-size pieces
ssh      Secure Shell client (remote login program)
strace   Trace system calls and signals
su       Substitute user identity
sudo     Execute a command as another user
sum      Print a checksum for a file
symlink  Make a new name for a file
sync     Synchronize data on disk with memory
t
tail     Output the last part of files
tar      Tape ARchiver
tee      Redirect output to multiple files
test     Evaluate a conditional expression
time     Measure Program running time
times    User and system times
touch    Change file timestamps
top      List processes running on the system
traceroute Trace Route to Host
trap     Run a command when a signal is set(bourne)
tr       Translate, squeeze, and/or delete characters
true     Do nothing, successfully
tsort    Topological sort
tty      Print filename of terminal on stdin
type     Describe a command
u
ulimit   Limit user resources
umask    Users file creation mask
umount   Unmount a device
unalias  Remove an alias
uname    Print system information
unexpand Convert spaces to tabs
uniq     Uniquify files
units    Convert units from one scale to another
unset    Remove variable or function names
unshar   Unpack shell archive scripts
until    Execute commands (until error)
useradd  Create new user account
usermod  Modify user account
users    List users currently logged in
uuencode Encode a binary file
uudecode Decode a file created by uuencode
v
v        Verbosely list directory contents (`ls -l -b')
vdir     Verbosely list directory contents (`ls -l -b')
vi       Text Editor
vmstat   Report virtual memory statistics
w
watch    Execute/display a program periodically
wc       Print byte, word, and line counts
whereis  Report all known instances of a command 
which    Locate a program file in the user's path.
while    Execute commands
who      Print all usernames currently logged in
whoami   Print the current user id and name (`id -un')
Wget     Retrieve web pages or files via HTTP, HTTPS or FTP
write    Send a message to another user
x
xargs    Execute utility, passing constructed argument list(s)
yes      Print a string until interrupted
.        Run a command script in the current shell
###      Comment / Remark

A Beginner's Guide to Pointers

noreply@blogger.com (Mubarak World) — Mon, 22 Dec 2008 11:00:00 +0000

What Are Pointers?

Pointers are basically the same as any other variable. However, what is different about them is that instead of containing actual data, they contain a pointer to the memory location where information can be found. This is a very important concept. Many programs and ideas rely on pointers as the basis of their design, linked lists for example.

Getting Started

How do I define a pointer? Well, the same as any other variable, except you add an asterisk before its name. So, for example, the following code creates two pointers, both of which point to an integer:

Collapse

int* pNumberOne;
int* pNumberTwo;

Notice the "p" prefix in front of the two variable names? This is a convention used to indicate that the variable is a pointer. Now, let's make these pointers actually point to something:

Collapse

pNumberOne = &some_number;
pNumberTwo = &some_other_number;

The & (ampersand) sign should be read as "the address of" and causes the address in memory of a variable to be returned, instead of the variable itself. So, in this example, pNumberOne is set to equal the address of some_number, so pNumberOne now points to some_number.

Now if we want to refer to the address of some_number, we can use pNumberOne. If we want to refer to the value of some_number from pNumberOne, we would have to say *pNumberOne. The * dereferences the pointer and should be read as "the memory location pointed to by," unless in a declaration, as in the line int *pNumber.

What We've Learned So Far: An Example

Phew! That's a lot to take in. I'd recommend that if you don't understand any of those concepts, to give it another read through. Pointers are a complex subject and it can take a while to master them. Here is an example that demonstrates the ideas discussed above. It is written in C, without the C++ extensions.

Collapse

#include <stdio.h>


void main()
{
   // declare the variables:

   int nNumber;
   int *pPointer;

   // now, give a value to them:

   nNumber = 15;
   pPointer = &nNumber;

   // print out the value of nNumber:

   printf("nNumber is equal to : %d\n", nNumber);

   // now, alter nNumber through pPointer:

   *pPointer = 25;

   // prove that nNumber has changed as a result of the above by

   // printing its value again:

   printf("nNumber is equal to : %d\n", nNumber);
}

Read through and compile the above code sample. Make sure you understand why it works. Then, when you are ready, read on!

A Trap!

See if you can spot the fault in the program below:

Collapse

#include <stdio.h>


int *pPointer;

void SomeFunction();
{
   int nNumber;
   nNumber = 25;   

   // make pPointer point to nNumber:

   pPointer = &nNumber;
}

void main()
{
   SomeFunction(); // make pPointer point to something


   // why does this fail?

   printf("Value of *pPointer: %d\n", *pPointer);
}

This program firstly calls the SomeFunction function, which creates a variable called nNumber and then makes the pPointer point to it. Then, however, is where the problem is. When the function leaves, nNumber is deleted because it is a local variable. Local variables are always deleted when execution leaves the block they were defined in. This means that when SomeFunction returns to main(), the variable is deleted. So pPointer is pointing at where the variable used to be, which no longer belongs to this program. If you do not understand this, it may be wise to read back over on local and global variables, and on scope. This concept is also important.

So, how can the problem be solved? The answer is by using a technique known as dynamic allocation. Please be aware that this is different between C and C++. Since most developers are now using C++, this is the dialect that the code below is using.

Dynamic Allocation

Dynamic allocation is perhaps the key to pointers. It is used to allocate memory without having to define variables and then make pointers point to them. Although the concept may appear confusing, it is really simple. The following code demonstrates how to allocate memory for an integer:

Collapse

int *pNumber;
pNumber = new int;

The first line declares the pointer, pNumber. The second line then allocates memory for an integer and then makes pNumber point to this new memory. Here is another example, this time using a double:

Collapse

double *pDouble;
pDouble = new double;

The formula is the same every time, so you can't really fail with this bit. What is different about dynamic allocation, however, is that the memory you allocate is not deleted when the function returns, or when execution leaves the current block. So, if we rewrite the above example using dynamic allocation, we can see that it works fine now:

Collapse

#include <stdio.h>


int *pPointer;

void SomeFunction()
{
   // make pPointer point to a new integer

   pPointer = new int;
   *pPointer = 25;
}

void main()
{
   SomeFunction(); // make pPointer point to something

   printf("Value of *pPointer: %d\n", *pPointer);
}

Read through and compile the above code sample. Make sure you understand why it works. When SomeFunction is called, it allocates some memory and makes pPointer point to it. This time, when the function returns, the new memory is left intact, so pPointer still points to something useful. That's it for dynamic allocation! Make sure you understand this, and then read on to learn about the fly in the ointment, and why there is still a serious error in the code above.

Run Windows applications on Linux

noreply@blogger.com (Mubarak World) — Thu, 18 Dec 2008 10:58:00 +0000

Most people who use Linux are familiar with the WINE program, which enables the use of Windows software on Linux without requiring Windows itself. WINE is still fairly immature. While it can run some applications, other applications can present a problem.

However, other programs exist that allow you to run more specialized applications. For example, CodeWeaver's CrossOver Office lets you run Windows business applications (such as Microsoft Office, Quicken, etc.) under Linux, and TransGaming's WineX allows you to play many popular Windows games under Linux.

CodeWeaver recently released CrossOver Office 2.1, which includes support for even more applications, most notably Macromedia's Dreamweaver MX and Flash MX. The ability to run these applications on Linux is a true benefit for professional Web developers, who often write Web applications on the Windows platform for deployment on Linux servers.

CrossOver Office is easy to install. You can download RPM packages or the Loki installer, which looks like a large bash script file. The Loki installer is the most portable option, enabling you to install CrossOver Office in a location of your choice and on any Linux distribution, including Debian and Slackware.

CrossOver Office is a commercial application, and it costs $59.95. However, you can download a 30-day trial version. When you download the Loki installer, start it by executing the following:

$ sh install-crossover-office-2.1.0.sh

This begins the installation program and allows you to choose the installation location or pick the existing location if you're upgrading.

Once the installation is complete, grab the installation CDs for the Windows applications you want to install, and use the easy-to-use configuration tool to launch the installation wizards for the respective programs.

Use Cygwin when you can't use Linux

noreply@blogger.com (Mubarak World) — Fri, 12 Dec 2008 10:57:00 +0000

Linux fans would love to use Linux all of the time, but sometimes it just isn't possible. Maybe a certain application requires that you use Windows, or perhaps you're forced to use Windows at work. Regardless of the reason, if you've become attached to your Linux and open source applications, rest assured that you can use Cygwin to run most of those applications on Windows.

Cygwin is an environment for Windows, similar to Linux, that provides a Linux API emulation layer and a collection of tools that are normally only available on systems that use open source tools, such as Linux, the *BSD's, and Mac OS X.

To begin using this environment, visit the Cygwin Web site and download the installer--the setup.exe file. Once this component is downloaded, double-click it and choose the Install From Internet option, which will download only the packages you want to install. You'll need to specify the root environment of the installation, where packages will be downloaded to, and a mirror site from which to download packages.

After you've picked a mirror, the installer will download some base files and allow you to select packages from various categories. Here you can choose what shells, text-processing tools, databases, desktop applications, and other programs that you'd like to install. Since Cygwin comes with an X server, you can even install GNOME and KDE programs. Better yet, you can compile your own programs to run under Cygwin by installing gcc and friends.

Cygwin will dutifully download and install all of the packages that you select. When the download process is complete, you can fire up Cygwin and an initial bash shell by clicking the Cygwin icon on your desktop.

LINUX NEWBIE ADMINISTRATOR GUIDE

noreply@blogger.com (Mubarak World) — Thu, 11 Dec 2008 12:24:00 +0000

Intro. We are relative Linux newbies (with Linux since Summer 1998). We run mostly RedHat and Mandrake -> the solutions might not be directly applicable to other Linux distributions (although most of them probably will be). Hope this helps; we try to be as practical as possible. Of course, we provide no warranty whatsoever. If you spotted a bad error or would like to contribute a part on a topic of your choice, we would like to hear from you.

General description of this Guide. A complete reference for new Linux users who wish to set up and administer their own Linux home computer, workstation and/or their home or small office network. The answers are meant to be simple, with just sufficient detail, and always supported with a readily usable example. The work is still in progress, but we hope the Guide can be helpful already. We welcome your corrections, advice, criticism, links, translations, and CONTRIBUTIONS. Pls note that there are no ad banners on our pages.

Conventions:
<> = single special or function key on the keyboard. For example indicates the "control" key.
italic = name of a file or variable you probably want to substitute with your own.
fixed width = commands and filenames.

Part 0: For the Undecided (Linux Benefits)
If you are wondering what the Linux pros and cons are, and whether Linux is for you.

Part 1: Before Linux Installation
What distribution should I use, how to obtain it, Linux hardware requirements, how to partition your hard drive, about dual boot, which packages to install, which graphical user interface (GUI) to install (gnome or kde?), and how to login for the very first time.

Part 2: Linux Resources, Help and Some Links
How to access the Linux documentation (from under MS Windows or Linux), what are Linux help commands, where to find the geek dictionary, + pointers to some Linux newsgroups and websites.

Part 3: Basic Operations FAQ
After you installed Linux, here are answers to some questions that Linux newbie users/administrators may have when trying to perform every-day tasks: what are the file name conventions, how to run a program, shut down my computer, set up the path, add users, remove users, make your passwords and system more secure, work with file permissions, schedule jobs with "at" and cron, change your shell prompt, print symbols in the text mode, use color in the text mode, redirect input/output, write a simple shell script, install a new program ...

Part 4.1: Boot-time issues
Some info on LILO and GRUB boot managers, how do I choose the operating system which boots on default, hints on configuration of the boot loaders, "uninstalling" Linux ...

Part 4.2: Drives
Where are my drives, how to access them, configure user access, get the zip drive recognized, set 32-bit hard drive IO, increase the limit on the number of opened files, add a new hardrive, manage the swap space ...

Part 4.3: X-windows
How to switch between text and graphical consoles, set up my video card, monitor and mouse for the X-server, setup a graphical login prompt, change a default desktop, have multiple sessions of Xwindows running at the same time, use Xwindow remotely, install TrueType fonts from my MS Windows partition to Linux, how to copy-paste under X and in the text mode, how to use VNC.

Part 4.4: Basic Configurations
Real basics on how to configure the printer and soundcard, bits about configuration files, daemons, and device files.

Part 4.5: Networking
Setting up a network, ppp (connection over the phone), remote access to your computer, ftp and html server, e-mail, how my computer can get hacked ...

Part 5: Linux Shortcuts and Commands
Maybe this should have come first. A practical selection of Linux shortcuts and commands in a concise form. Perhaps this is everything that a computer-literate newbie Linuxer really needs. Highly recommended.

Part 6: Linux applications (proprietary or not)
Essential and/or famous Linux applications with some hint/comments: word processing, spreadsheet, database, latex. Extensive info on how to set up and use a CD recorder to write data, audio, and mixed mode CDs.

Part 7: Learning with Linux (commands for more esoteric work or programming)
Review of some more advanced or less useful commands/tools to get you started with fancier text processing, encryption, digital signatures (gpg), simple programming plus some info on the Linux console tools that can help you learn about computers. Under development so perhaps not so good: grep, regular expressions, sed, gawk, sort, ascii codes, linux built-in c compiler and tools, perl, python, tcl/tk, "Reverse Polish Notation" (RPN) calculator, scilab, wine ... working on it.

Making waves with Linux: A few tips for trainers

noreply@blogger.com (Mubarak World) — Mon, 08 Dec 2008 10:54:00 +0000

Are you teaching Linux? Will you be teaching Linux soon? Are you thinking about catching the Linux wave in the future? If you can say “yes” to at least one of these questions, this article is for you. TechRepublic has published some excellent articles about Linux. We’d like to take this opportunity to highlight some of the Linux articles that trainers might find most useful.

Linux jargon
If you’re new to Linux, you might want to catch up on the terms by reading Jargon Watch: Open-source, kernel, and SMP , by Mary Ann Fitzharris.

Linux certification
Bruce Maples’ article The unsettled world of Linux certification uncovers a tsunami of information on the availability of Linux certification. If you are considering obtaining Linux certification, this article will serve as a quick reference guide to get you started.

Linux tips you can teach
Looking for some Linux tips or information on the Linux OS? We have several:

Jack Wallen, Jr.’s tip, titled Access remote Linux hosts with NFS discusses the benefits offered by NFS, including centralized data housing.

Linux systems are stable, but they aren't bombproof. In the article titled Do yourself a favor—create a Linux boot floppy , Wallen tells you how to save yourself from kernel panic by making a boot floppy for Linux.

Run Windows applications on Linux, BSD and Mac OS X

noreply@blogger.com (Mubarak World) — Tue, 02 Dec 2008 10:47:00 +0000

Wine 1.1.11 Released

December 20, 2008

The Wine development release 1.1.11 is now available.

What's new in this release:

Numerous fixes for IE7 support.
Support for 64-bit cross-compile using Mingw64.
User interface support for crypto certificates.
Better support for MSI installation patches.
Various Direct3D optimizations.
Various bug fixes.

The source is available now. Binary packages are in the process of being built, and will appear soon at their respective download locations.

OpenGL programming in Eclipse

noreply@blogger.com (Mubarak World) — Sun, 30 Nov 2008 10:40:00 +0000

Today I had written my first C++ Socket program with eclipse Ganymede and MinGW under Windows. It’s different to UNIX, for example the WSAStartup, the return types (SOCKET_ERROR, INVALID_SOCKET) and the socket datatype.

The first thing that costs me some minutes, was to configure the C++ Linker. You need to configure the ws2_32 library besides there will be a build error (undefined reference to `WSAStartup@8′).

The ws2_32 (Winsock Library) will required to perform TCP/IP network communication.