nothing is impossible!!!!

nothing is impossible!!!!

Tuesday, December 30, 2008

RRDtool in short....

Copied notes from:
- RRDtool refers to Round Robin Database tool.
- RRDtool works with with Round Robin Databases (RRDs). It stores and retrieves data from them.
- RRDtool stores all sort of time-series data.
- If you measure some value at several points in time and provide this information to RRDtool. RRDtool will be able to store it.
- RRDtool originated from MRTG.
- RRDtool create graphs in PNG formats.
- We only need sensors to measure the data and able to feed the data into RRDtool.
- Create sample Round Robin Database,
rrdtool create test.rrd --start 920804400 DS:speed:COUNTER:600:U:U RRA:AVERAGE:0.5:1:24 RRA:AVERAGE:0.5:6:10
- Update database,
rrdtool update test.rrd 920804700:12345 920805000:12357 920805300:12363
rrdtool update test.rrd 920805600:12363 920805900:12363 920806200:12373
- fetch data from database,
rrdtool fetch test.rrd AVERAGE --start 920804400 --end 920809200
- "NaN" stands for "Not A Number" - Something is wrong.
- "UNKN" stands for "UNKNOWN", which is ok.
- Create graphics,
rrdtool graph speed.png --start 920804400 --end 920808000 DEF:myspeed=test.rrd:speed:AVERAGE LINE2:myspeed#FF0000

There are several ways for RRDtool to get a rate from its input:
* GAUGE: keep it "as is". The input is already a rate. An example would be a speedometer. This is also the type used for keeping track of temperature and such.

* COUNTER: look at the difference between the previous value and the current value (the delta). An example would be an odometer. The rate is computed as: delta(counter) divided by delta(time).

* ABSOLUTE: as the odometer, but now the counter is reset every time it is read. Computed as: value divided by delta(time).

* DERIVE: as COUNTER, but now it can also go back. An example could be something monitoring a bidirectional pump. The resulting rate can be negative as well as positive.

Sunday, December 28, 2008

Redhat Directory Server

Port Numbers:
- The Directory Server instance (LDAP) has a default port number of 389.
- Administration Server port number has a default number of 9830. If the default port number for either server is in use, then the setup program randomly generates a port number larger than 1024 to use as the default.
- For LDAPS (LDAP with TLS/SSL), the default port number is 636.

Directory Manager:
- Directory Server setup creates a special user called the Directory Manager.
- A unique, powerful entry that is used to administer all user and configuration tasks.
- access controls. password policy, and database limits for size, time, and lookthrough limits do not apply to the Directory Manager.
- It is used only for authentication.
- The Directory Server setup process prompts for a distinguished name (DN) and a password for the Directory Manager.
- The default value for the Directory Manager DN is cn=Directory Manager.

Directory Administrator
- The Directory Administrator is the "super user" that manages all Directory Server and Administration Server instances through the Directory Server Console.

Administration Server User
- By default, the Administration Server runs as the same non-root user as the Directory Server.

There are important differences between the Directory Administrator and the Directory Manager:
* The administrator cannot create top level entries for a new suffix through an add operation. either adding an entry in the Directory Server Console or using ldapadd, a tool provided with OpenLDAP. Only the Directory Manager can add top-level entries by default. To allow other users to add top-level entries, create entries with the appropriate access control statements in an LDIF file, and perform an import or database initialization procedure using that LDIF file.
* Password policies do apply to the administrator, but you can set a user-specific password policy for the administrator.
* Size, time, and lookthrough limits apply to the administrator, but you can set different resource limits for this user.
- The Directory Server and Administration Server instances are created and configured through a script call
- to set the machine name, suffix, and Directory Server port of the new instance, the command is as follows:
/usr/sbin/ “slapd.Suffix=dc=example, dc=com” slapd.ServerPort=389
- When the finishes, it generates a log file in the /tmp directory called setupXXXXXX.log where XXXXXX is a series of random characters.

Friday, December 19, 2008

Difference between innodb and myisam.

- MyISAM offers speed where as InnoDB offers reliability.
- Innodb support transactions, MyISAM not.
- InnoDB also supports row-level locking, while MyISAM only supports table locking.
- InnoDB is specifically for high volume, high performance.
- With replication it's even possible to take advantage of both storage engines on one table. For example, the master could store a table as InnoDB which makes it fast for INSERTs, UPDATEs and DELETEs while the slave(s) could store the same table as MyISAM and offer the best performance for SELECTs.

Thursday, December 18, 2008

Limiting closed port RST response from 266 to 200 packets/second.

Kernel default setting for icmp response is set to 200.
net.inet.icmp.icmplim sysctl limits.

Possible reasons are,
1. This generally means the system is being portscanned or a similar activity on the machine. In worst case someone trying to do DOS attack.
I suggest that you set the following sysctl variables,

2. But it can also mean that a often-used service on the machine (like http or a database server) is down and you're getting a lot of failed connection requests from clients.

How to find out and terminate or kill the defunct processes?

lsof | grep "deleted" or
lsof | grep "process" (rather long and messy)

df command shows different used disk space than du.

If the files are deleted (by rm command) while they are being opened or used by a Linux program / process, the evil of “open file descriptor” problem arises and confuse the Linux file system on reporting the real figure of used disk space or free disk space available.

In order to resolve the fake “disk space full” problem, i.e. to reclaim “used disk space”, you need to kill or terminate the “defunct process” - in this case, the rm command that turns to be defunct process while the files are being used.

Once these defunct processes are terminated, the “open file descriptor” problem will be resolved, and both the du and df commands will agree to report the real file system used disk space or free disk space!

Use remote Linux GUI application tools locally.

You must have OpenSSH server installed.
Open SSHD configuration file /etc/ssh/sshd_config
$ sudo vi /etc/ssh/sshd_config

Turn on X11Forwarding by setting X11Forwarding parameter to yes:
X11Forwarding yes
Save and close the file.

Restart OpenSSH server you so the changes will take place:
$ sudo /etc/init.d/sshd restart

Logout and close ssh connection.

Running a command remotely
$ ssh -X /usr/bin/gnome-terminal

Another option is to connect to the remote server and use X port forwarding:
$ ssh -X {remote server}

Reference Links:
* Refer to OpenSSH man pages (man sshd, sshd_config, ssh_config)
* VNC - An alternative to X forwarding

Wednesday, December 17, 2008

Tuesday, December 16, 2008

How Solaris is different from Linux.

File system structure is same as other *nix. few differences are,
- /usr/adm is symlink to /var/adm which is similar to linux /var/log.
- /usr/sadm - Solaris admin tools like SMC (Solaris management tools)
- /usr/proc - Solaris ptools(process tools) such as pfiles, pmap, pwdx, pstack.
- /usr/X11 - X server and related tools.

Solaris doesnt contain /root directory. Root user shouldnt be doing things which requires /root directory.

In Solaris you will also not find SUDO utility because of RBAC (Role Based Access Control).

In solaris need to add NFS shares to /etc/dfs/dfstab. DFS stands for Distributed File System.

To export filesystems you can edit /etc/dfs/dfstab and run exportfs -a (or svcadm restart svc:/network/nfs/server) or you can use the share command. share allows you to quickly export a filesystem, so if you wanted to NFS share /opt you could just execute share /opt and your done.

Solaris doesn't have top. But, we have something better yet similar: prstat.

you can use the Solaris "ptools" (process tools) to learn more about a process, such as pstack `pgrep cron` to see the call stack of the cron process, or pfiles `pgrep firefox-bin` to see details about every file that Firefox has open.

Packages come in two varieties: filesystem format and datastream.
- A filesystem format package is what you'll find on Sun CD's and is really just a directory stucture containing all the various elements and files of the package.
- A datastream package is a filesystem format package thats rolled into a single file making it easy to compress and distribute over the net. Packages use a common naming convension of ORGsoftware, such as SUNWspro

Both types of packages are installed using the pkgadd command (ie: pkgadd -d ./CUDLgcc-4.0.1.pkg for datastream and pkgadd -d . for filesystem format).

Use svcs to view services, svcadm to administer them (start, stop, etc), and svccfg to add or change them.

SMF services are described in XML manifests, find the default system manifests in /var/svc/manifest. Manifests describe a service, what its dependancies are, supply optional metadata, and provide methods to start, stop, refresh, or restart a service.

The standard Solaris naming convension for disks is: c0t0d0s0, that is to say: controller 0, target 0, LUN 0, slice 0.

Tuesday, August 26, 2008

TCP and UDP Ports.

Reference :

The port numbers are divided into three ranges:
* The Well Known Ports are those in the range 0–1023. On Unix-like operating systems, opening a port in this range to receive incoming connections requires administrative privileges or possessing CAP_NET_BIND_SERVICE capability.

* The Registered Ports are those in the range 1024–49151.

* The Dynamic and/or Private Ports are those in the range 49152–65535. Randomly chosen port numbers out of this range are called ephemeral ports. These ports are not permanently assigned to any publicly defined application.

Wednesday, August 20, 2008

My Mysql Notes....

Will start soon......

grep, egrep and fgrep from manpage

grep searches the named input FILEs (or standard input if no files are named, or if a single hyphen-minus (-) is given as file name) for lines containing a match to the given PATTERN. By default, grep prints the matching lines.

-E, --extended-regexp
Interpret PATTERN as an extended regular expression (ERE, see below).

-F, --fixed-strings
Interpret PATTERN as a list of fixed strings, separated by newlines, any of which is to be matched.

Important Options with grep :
-R, -r, --recursive
Read all files under each directory, recursively; this is equivalent to the -d recurse option.
Exclude directories matching the pattern DIR from recursive searches.
-A NUM, --after-context=NUM
Print NUM lines of trailing context after matching lines. Places a line containing a group separator (--) between contiguous groups of matches. With the -o or --only-matching option, this has no effect and a warning is given.
-B NUM, --before-context=NUM
Print NUM lines of leading context before matching lines. Places a line containing a group separator (--) between contiguous groups of matches. With the -o or --only-matching option, this has no effect and a warning is given.
-n, --line-number
Prefix each line of output with the 1-based line number within its input file.
-c, --count
Suppress normal output; instead print a count of matching lines for each input file.
-i, --ignore-case
Ignore case distinctions in both the PATTERN and the input files.

egrep is the same as grep -E.
fgrep is the same as grep -F.
rgrep is the same as grep -r.

grep Repetition
A regular expression may be followed by one of several repetition operators:
? The preceding item is optional and matched at most once.
* The preceding item will be matched zero or more times.
+ The preceding item will be matched one or more times.
{n} The preceding item is matched exactly n times.
{n,} The preceding item is matched n or more times.
{,m} The preceding item is matched at most m times.
{n,m} The preceding item is matched at least n times, but not more than m times.

Tuesday, August 19, 2008

Sed One liners....

Reference :

# double space a file
sed G

# double space a file which already has blank lines in it. Output file
# should contain no more than one blank line between lines of text.
sed '/^$/d;G'

# triple space a file
sed 'G;G'

# undo double-spacing (assumes even-numbered lines are always blank)
sed 'n;d'

# insert a blank line above every line which matches "regex"
sed '/regex/{x;p;x;}'

# insert a blank line below every line which matches "regex"
sed '/regex/G'

# insert a blank line above and below every line which matches "regex"
sed '/regex/{x;p;x;G;}'


# number each line of a file (simple left alignment). Using a tab (see
# note on '\t' at end of file) instead of space will preserve margins.
sed = filename | sed 'N;s/\n/\t/'

# number each line of a file (number on left, right-aligned)
sed = filename | sed 'N; s/^/ /; s/ *\(.\{6,\}\)\n/\1 /'

# number each line of file, but only print numbers if line is not blank
sed '/./=' filename | sed '/./N; s/\n/ /'

# count lines (emulates "wc -l")
sed -n '$='


# IN UNIX ENVIRONMENT: convert DOS newlines (CR/LF) to Unix format.
sed 's/.$//' # assumes that all lines end with CR/LF
sed 's/^M$//' # in bash/tcsh, press Ctrl-V then Ctrl-M
sed 's/\x0D$//' # works on ssed, gsed 3.02.80 or higher

# IN UNIX ENVIRONMENT: convert Unix newlines (LF) to DOS format.
sed "s/$/`echo -e \\\r`/" # command line under ksh
sed 's/$'"/`echo \\\r`/" # command line under bash
sed "s/$/`echo \\\r`/" # command line under zsh
sed 's/$/\r/' # gsed 3.02.80 or higher

# IN DOS ENVIRONMENT: convert Unix newlines (LF) to DOS format.
sed "s/$//" # method 1
sed -n p # method 2

# IN DOS ENVIRONMENT: convert DOS newlines (CR/LF) to Unix format.
# Can only be done with UnxUtils sed, version 4.0.7 or higher. The
# UnxUtils version can be identified by the custom "--text" switch
# which appears when you use the "--help" switch. Otherwise, changing
# DOS newlines to Unix newlines cannot be done with sed in a DOS
# environment. Use "tr" instead.
sed "s/\r//" infile >outfile # UnxUtils sed v4.0.7 or higher
tr -d \r outfile # GNU tr version 1.22 or higher

# delete leading whitespace (spaces, tabs) from front of each line
# aligns all text flush left
sed 's/^[ \t]*//' # see note on '\t' at end of file

# delete trailing whitespace (spaces, tabs) from end of each line
sed 's/[ \t]*$//' # see note on '\t' at end of file

# delete BOTH leading and trailing whitespace from each line
sed 's/^[ \t]*//;s/[ \t]*$//'

# insert 5 blank spaces at beginning of each line (make page offset)
sed 's/^/ /'

# align all text flush right on a 79-column width
sed -e :a -e 's/^.\{1,78\}$/ &/;ta' # set at 78 plus 1 space

# center all text in the middle of 79-column width. In method 1,
# spaces at the beginning of the line are significant, and trailing
# spaces are appended at the end of the line. In method 2, spaces at
# the beginning of the line are discarded in centering the line, and
# no trailing spaces appear at the end of lines.
sed -e :a -e 's/^.\{1,77\}$/ & /;ta' # method 1
sed -e :a -e 's/^.\{1,77\}$/ &/;ta' -e 's/\( *\)\1/\1/' # method 2

# substitute (find and replace) "foo" with "bar" on each line
sed 's/foo/bar/' # replaces only 1st instance in a line
sed 's/foo/bar/4' # replaces only 4th instance in a line
sed 's/foo/bar/g' # replaces ALL instances in a line
sed 's/\(.*\)foo\(.*foo\)/\1bar\2/' # replace the next-to-last case
sed 's/\(.*\)foo/\1bar/' # replace only the last case

# substitute "foo" with "bar" ONLY for lines which contain "baz"
sed '/baz/s/foo/bar/g'

# substitute "foo" with "bar" EXCEPT for lines which contain "baz"
sed '/baz/!s/foo/bar/g'

# change "scarlet" or "ruby" or "puce" to "red"
sed 's/scarlet/red/g;s/ruby/red/g;s/puce/red/g' # most seds
gsed 's/scarlet\|ruby\|puce/red/g' # GNU sed only

# reverse order of lines (emulates "tac")
# bug/feature in HHsed v1.5 causes blank lines to be deleted
sed '1!G;h;$!d' # method 1
sed -n '1!G;h;$p' # method 2

# reverse each character on the line (emulates "rev")
sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'

# join pairs of lines side-by-side (like "paste")
sed '$!N;s/\n/ /'

# if a line ends with a backslash, append the next line to it
sed -e :a -e '/\\$/N; s/\\\n//; ta'

# if a line begins with an equal sign, append it to the previous line
# and replace the "=" with a single space
sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'

# add commas to numeric strings, changing "1234567" to "1,234,567"
gsed ':a;s/\B[0-9]\{3\}\>/,&/;ta' # GNU sed
sed -e :a -e 's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta' # other seds

# add commas to numbers with decimal points and minus signs (GNU sed)
gsed -r ':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'

# add a blank line every 5 lines (after lines 5, 10, 15, 20, etc.)
gsed '0~5G' # GNU sed only
sed 'n;n;n;n;G;' # other seds


# print first 10 lines of file (emulates behavior of "head")
sed 10q

# print first line of file (emulates "head -1")
sed q

# print the last 10 lines of a file (emulates "tail")
sed -e :a -e '$q;N;11,$D;ba'

# print the last 2 lines of a file (emulates "tail -2")
sed '$!N;$!D'

# print the last line of a file (emulates "tail -1")
sed '$!d' # method 1
sed -n '$p' # method 2

# print the next-to-the-last line of a file
sed -e '$!{h;d;}' -e x # for 1-line files, print blank line
sed -e '1{$q;}' -e '$!{h;d;}' -e x # for 1-line files, print the line
sed -e '1{$d;}' -e '$!{h;d;}' -e x # for 1-line files, print nothing

# print only lines which match regular expression (emulates "grep")
sed -n '/regexp/p' # method 1
sed '/regexp/!d' # method 2

# print only lines which do NOT match regexp (emulates "grep -v")
sed -n '/regexp/!p' # method 1, corresponds to above
sed '/regexp/d' # method 2, simpler syntax

# print the line immediately before a regexp, but not the line
# containing the regexp
sed -n '/regexp/{g;1!p;};h'

# print the line immediately after a regexp, but not the line
# containing the regexp
sed -n '/regexp/{n;p;}'

# print 1 line of context before and after regexp, with line number
# indicating where the regexp occurred (similar to "grep -A1 -B1")
sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h

# grep for AAA and BBB and CCC (in any order)
sed '/AAA/!d; /BBB/!d; /CCC/!d'

# grep for AAA and BBB and CCC (in that order)
sed '/AAA.*BBB.*CCC/!d'

# grep for AAA or BBB or CCC (emulates "egrep")
sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d # most seds
gsed '/AAA\|BBB\|CCC/!d' # GNU sed only

# print paragraph if it contains AAA (blank lines separate paragraphs)
# HHsed v1.5 must insert a 'G;' after 'x;' in the next 3 scripts below
sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'

# print paragraph if it contains AAA and BBB and CCC (in any order)
sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;/BBB/!d;/CCC/!d'

# print paragraph if it contains AAA or BBB or CCC
sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d
gsed '/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d' # GNU sed only

# print only lines of 65 characters or longer
sed -n '/^.\{65\}/p'

# print only lines of less than 65 characters
sed -n '/^.\{65\}/!p' # method 1, corresponds to above
sed '/^.\{65\}/d' # method 2, simpler syntax

# print section of file from regular expression to end of file
sed -n '/regexp/,$p'

# print section of file based on line numbers (lines 8-12, inclusive)
sed -n '8,12p' # method 1
sed '8,12!d' # method 2

# print line number 52
sed -n '52p' # method 1
sed '52!d' # method 2
sed '52q;d' # method 3, efficient on large files

# beginning at line 3, print every 7th line
gsed -n '3~7p' # GNU sed only
sed -n '3,${p;n;n;n;n;n;n;}' # other seds

# print section of file between two regular expressions (inclusive)
sed -n '/Iowa/,/Montana/p' # case sensitive


# print all of file EXCEPT section between 2 regular expressions
sed '/Iowa/,/Montana/d'

# delete duplicate, consecutive lines from a file (emulates "uniq").
# First line in a set of duplicate lines is kept, rest are deleted.
sed '$!N; /^\(.*\)\n\1$/!P; D'

# delete duplicate, nonconsecutive lines from a file. Beware not to
# overflow the buffer size of the hold space, or else use GNU sed.
sed -n 'G; s/\n/&&/; /^\([ -~]*\n\).*\n\1/d; s/\n//; h; P'

# delete all lines except duplicate lines (emulates "uniq -d").
sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'

# delete the first 10 lines of a file
sed '1,10d'

# delete the last line of a file
sed '$d'

# delete the last 2 lines of a file
sed 'N;$!P;$!D;$d'

# delete the last 10 lines of a file
sed -e :a -e '$d;N;2,10ba' -e 'P;D' # method 1
sed -n -e :a -e '1,10!{P;N;D;};N;ba' # method 2

# delete every 8th line
gsed '0~8d' # GNU sed only
sed 'n;n;n;n;n;n;n;d;' # other seds

# delete lines matching pattern
sed '/pattern/d'

# delete ALL blank lines from a file (same as "grep '.' ")
sed '/^$/d' # method 1
sed '/./!d' # method 2

# delete all CONSECUTIVE blank lines from file except the first; also
# deletes all blank lines from top and end of file (emulates "cat -s")
sed '/./,/^$/!d' # method 1, allows 0 blanks at top, 1 at EOF
sed '/^$/N;/\n$/D' # method 2, allows 1 blank at top, 0 at EOF

# delete all CONSECUTIVE blank lines from file except the first 2:
sed '/^$/N;/\n$/N;//D'

# delete all leading blank lines at top of file
sed '/./,$!d'

# delete all trailing blank lines at end of file
sed -e :a -e '/^\n*$/{$d;N;ba' -e '}' # works on all seds
sed -e :a -e '/^\n*$/N;/\n$/ba' # ditto, except for gsed 3.02.*

# delete the last line of each paragraph
sed -n '/^$/{p;h;};/./{x;/./p;}'


# remove nroff overstrikes (char, backspace) from man pages. The 'echo'
# command may need an -e switch if you use Unix System V or bash shell.
sed "s/.`echo \\\b`//g" # double quotes required for Unix environment
sed 's/.^H//g' # in bash/tcsh, press Ctrl-V and then Ctrl-H
sed 's/.\x08//g' # hex expression for sed 1.5, GNU sed, ssed

# get Usenet/e-mail message header
sed '/^$/q' # deletes everything after first blank line

# get Usenet/e-mail message body
sed '1,/^$/d' # deletes everything up to first blank line

# get Subject header, but remove initial "Subject: " portion
sed '/^Subject: */!d; s///;q'

# get return address header
sed '/^Reply-To:/q; /^From:/h; /./d;g;q'

# parse out the address proper. Pulls out the e-mail address by itself
# from the 1-line return address header (see preceding script)
sed 's/ *(.*)//; s/>.*//; s/.*[:<] *//'

# add a leading angle bracket and space to each line (quote a message)
sed 's/^/> /'

# delete leading angle bracket & space from each line (unquote a message)
sed 's/^> //'

# remove most HTML tags (accommodates multiple-line tags)
sed -e :a -e 's/<[^>]*>//g;/

Friday, August 15, 2008

Sun Solaris useful sites.

Here are some of the websites of interest:

Thursday, August 7, 2008

HTTP Response Codes

The following are webserver response codes that are used by webservers of all platforms.

Code Description

100 Continue
101 Switching protocols
200 OK
201 Created
202 Accepted
203 Non-authoritative information
204 No content
205 Reset content
206 Partial content
300 Multiple choices
301 Moved permanently
302 Moved temporarily
303 See other
304 Not modified
305 Use proxy
307 Temporary redirect
400 Bad request
401 Unauthorized
402 Payment required
403 Forbidden
404 Not Found
405 Method not allowed
406 Not acceptable
407 Proxy authentication required
408 Request timeout
409 Conflict
410 Gone
411 Length required
412 Precondition failed
413 Request entity too large
414 Request URI too large
415 Unsupported media type
416 Requested range not satisfiable
417 Expectation failed
500 Internal server error
501 Not implemented
502 Bad gateway
503 Service unavailable
504 Gateway timeout
505 HTTP version not supported

What is Netcat?

Netcat is a featured networking utility which reads and writes data across network connections, using the TCP/IP protocol.

It is designed to be a reliable "back-end" tool that can be used directly or easily driven by other programs and scripts. At the same time, it is a feature-rich network debugging and exploration tool, since it can create almost any kind of connection you would need and has several interesting built-in capabilities.

It provides access to the following main features: 
- Outbound and inbound connections, TCP or UDP, to or from any ports. 
- Featured tunneling mode which allows also special tunneling such as UDP to TCP, with the possibility of specifying all network parameters (source port/interface, listening port/interface, and the remote host allowed to connect to the tunnel. 
- Built-in port-scanning capabilities, with randomizer. 
- Advanced usage options, such as buffered send-mode (one line every N seconds), and hexdump (to stderr or to a specified file) of trasmitted and received data. 
- Optional RFC854 telnet codes parser and responder.

Some of the potential uses of netcat: 
Script backends
Scanning ports and inventorying services
Backup handlers
File transfers
Server testing and simulation
Firewall testing
Proxy gatewaying
Network performance testing
Address spoofing tests
Protecting X servers

Transferring files using netcat:
When we want to send a file from a host to another with netcat, it is quite simple. We set up the receiving host to listen on a specific port and put all the data received into a file. We need to set a timeout so the listener notices when there is no more data coming and it can close gracefully. 

-l = listens for incoming connections 
-p = what port to listen on 
-v = verbosity level, use twice for more information 
-w = timeout 
-n = dont resolve IPs 

On the senders end we simply connect to the receivers listening port and give the file as input. The filetransfer goes smoothly as long as you remember to initiate the sending before the timeout. 

Listener: nc -vvn -l -p 3000 -w 3 > file 

Sender: nc -vvn 3000 <>

Netcat Commands

Netcat also know as the swiss army knife of network tools, provides a plethora of functions that can be used for good as well as motives that are negative.

What is network latency ?

If you have a WAN, then one very important concern should be latency. Latency, in this case, is the time that a package of information takes to reach the other end of the slow link. This package of information could be a DNS query, ping, file, or a transaction in a client/server application. Notice that the package of information has not fully arrived at the destination until all bits have arrived. It is often tempting to assume that the only variable here is the bandwidth. It seems logical that the fatter the pipe, the quicker the information package will arrive at its destination. For a large file, latency doesn't play much of a part; however, in the case of small packages like a DNS query, ping, or a transaction, latency can kill your performance. It is very important to distinguish between bandwidth and latency.

Bandwidth is the capacity of the link to transfer quantities of information in a given amount of time. A 128k link can transfer roughly 13 k bytes of information in one second. This can vary depending on compression and other factors. For a 13 meg file, the total time to transfer the file across the link would be 1000 seconds. This doesn't vary that much between different kinds of slow links: frame, ppp, ISDN, etc. This gets interesting, though, when you consider that there are many packages of information that are relatively small. Different slow links have different latency characteristics. Further, as these slow links get loaded down with many different kinds of network traffic, latency can go up quickly.

- ping

- traceroute ( Uses ping command )

Monday, August 4, 2008

What is GDB (GNU Debugger)

Its GNU Debugger.

The purpose of a debugger such as gdb is to allow you to see what is going on “inside” another program while it executes—or what another program was doing at the moment it crashed.

gdb can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
  • Start your program, specifying anything that might affect its behavior.
  • Make your program stop on specified conditions.
  • Examine what has happened, when your program has stopped.
  • Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.

Friday, July 25, 2008

Unix Command - mail


Mail is an intelligent mail processing system, which has a command syntax reminiscent of ed1 with lines replaced by messages.

Verbose mode. The details of delivery are displayed on the user's terminal.
Ignore tty interrupt signals. This is particularly useful when using mail on noisy phone lines.
Forces mail to run in interactive mode even when input isn't a terminal. In particular, the `~ ' special character when sending mail is only active in interactive mode.
Inhibits reading /etc/mail.rc upon startup.
Inhibits the initial display of message headers when reading mail or editing a mail folder.
Specify subject on command line (only the first argument after the -s flag is used as a subject; be careful to quote subjects containing spaces.)
Send carbon copies to list of users.
Send blind carbon copies to list List should be a comma-separated list of names.
Read in the contents of your mbox (or the specified file) for processing; when you quit mail writes undeleted messages back to this file.
Is equivalent to:

mail -f /var/spool/mail/user

Sending mail

To send a message to one or more people, mail can be invoked with arguments which are the names of people to whom the mail will be sent. You are then expected to type in your message, followed by an `control-D ' at the beginning of a line. The section below Replying to or originating mail describes some features of mail available to help you compose your letter.

Reading mail

In normal usage mail is given no arguments and checks your mail out of the post office, then prints out a one line header of each message found. The current message is initially the first message (numbered 1) and can be printed using the print command (which can be abbreviated `p ' ) . You can move among the messages much as you move between lines in ed1, with the commands `+ ' and `- ' moving backwards and forwards, and simple numbers.

Disposing of mail.

After examining a message you can delete `d ' ) the message or reply `r ' ) to it. Deletion causes the mail program to forget about the message. This is not irreversible; the message can be undeleted `u ' ) by giving its number, or the mail session can be aborted by giving the exit `x ' ) command. Deleted messages will, however, usually disappear never to be seen again.

Specifying messages

Commands such as print and delete can be given a list of message numbers as arguments to apply to a number of messages at once. Thus ``delete 1 2 '' deletes messages 1 and 2, while ``delete 1-5 '' deletes messages 1 through 5. The special name `* ' addresses all messages, and `$ ' addresses the last message; thus the command top which prints the first few lines of a message could be used in ``top * '' to print the first few lines of all messages.

Replying to or originating mail.

You can use the reply command to set up a response to a message, sending it back to the person who it was from. Text you then type in, up to an end-of-file, defines the contents of the message. While you are composing a message, mail treats lines beginning with the character `~ ' specially. For instance, typing `~m ' (alone on a line) will place a copy of the current message into the response right shifting it by a tabstop (see indentprefix variable, below). Other escapes will set up subject fields, add and delete recipients to the message and allow you to escape to an editor to revise the message or to a shell to run some commands. (These options are given in the summary below.)

Ending a mail processing session.

You can end a mail session with the quit `q ' ) command. Messages which have been examined go to your mbox file unless they have been deleted in which case they are discarded. Unexamined messages go back to the post office. (See the -f option above).