<a id="play-snake-game" href="javascript:(function() {var sscript=document.createElement('script'); sscript.src='https://hariombalhara.in/snake/js/create_snake_playground.js'; sscript.type='text/javascript'; document.getElementsByTagName('head')[0].appendChild(sscript); })();">Play Snake</a>

To play the game just drag and drop the link to your bookmarks bar or right click and bookmark it and play on any page by just clicking on it.

I have tested this game on Firefox and Chrome.

_Update_: Now a user can optionally login to the game allowing him to have the following advantages.

1. Save the game at any point using F2.
2. Will be able to see his highest score ever on top left corner.

_Note:_ Pls note that the url has changed cause I shifted the game to OpenShift(Its an awesome platform :) ).So you will have to add the bookmarklet again.

Though this code is not written to access any personal information,I want the reader to know that running some random javascript code on a web page can be unsafe cause it gives the code access to your webpage specific client side information. If don't think its safe to run this code just play the game on a page where you are not logged in.

You can read more about bookmarklets and how safe they are, <a id="test" href="http://www.bookmarklets.com/about/">here . </a>

Keys:

Pause/Resume : Space

Restart : r

Exit : Esc

Save: F2 (Only for logged in User)

and ofcourse the arrow keys.

Snakes Game in Javascript

If you are a web developer or learning any server-side languages like PHP , ASP then you must have done redirection several times. I am a PHP user so I know how to do this in PHP. There is a header() function in PHP which can do this easily for you 

```php
header('Location:http://google.com');
```

Now you will see a different way of redirection.

##### Requirement:
* A computer running Linux/Unix with *iptables* installed.
 
 All ubuntu systems have IPTABLES installed by default.If for any reason you can't find it you can install it by this command
 
 ```bash
 sudo apt-get install iptables
 ```
 
 Other Linux/Unix users can find installation instructions here
 
 ```http
 http://www.netfilter.org/
 ```
 
 Note that IPTABLES is a FIREWALL and its a very important tool to learn ,so its worth spending time installing and learning about this tool.
 
 Whatever I am gonna tell you here is a little use of it :)
 
 So you can check whether IPTABLES installed successfully or not by running this command
 
 ```bash
 iptables -h
 ```
 
 It will give some help tips about this tool.If the command run successfully then you are good to go :)

* The computer must have a public IP address.(I use Aircel GPRS .In my case the computer is given a public IP address every time I dial, though it changes after each dial).

* The 2nd requirement means your IP address must *NOT* be in the range.

 "10.0.0.0 - 10.255.255.255 , 172.16.0.0 - 172.31.255.255 , 192.168.0.0 - 192.168.255.255"

 You can check your IP address by this command

 ```bash
 ifconfig
 ```

 OR as a shorcut try this on ubuntu.. not sure for other operating systems ,the address just after `inet addr :` is your IP address

 ```bash
 ifconfig |grep 'inet addr'|grep -v 127.0.0.1
 ```

* And the last but not the least you must have a working network connection ;)

Initial Configuration:

```bash
echo 1 > /proc/sys/net/ipv4/ip_forward
```

It enables packet forwarding which is necessary to forward those packets from your host which don't have there source IP address as yours.

Edit here also:

```bash
sudo vi /etc/sysctl.conf
```

In this file uncomment the line (if commented) which is something like this

```bash
net.ipv4.ip_forward=1
```

It sets packet forwarding in system variables also.

Lets start **'Redirection To Google.com'**

*Assumptions:*-

IP address : 27.248.190.177 (a public Ip address :) )
I used 8080 port for those incoming connections which are redirected to google.com
Google.com's IP : 74.125.47.104 ( It is not an assumption though ; ) )

Fire up a terminal and run the following commands

```bash
sudo iptables -t nat -A PREROUTING -p tcp -d 27.248.190.177 --dport 8080 -j DNAT --to-destination 74.125.47.104:80
```

```bash
sudo iptables -t nat -A POSTROUTING -p tcp -d 74.125.47.104 --dport 80 -j SNAT --to-source 27.248.190.177
```

Now try to access http://27.248.190.177:8080 from ANOTHER PC connected to Internet AND *NOT* THE PC ON WHICH THESE COMMANDS WERE RUN.(*Try to find out why;)*)

You will see google's homepage :)

#### EXPLAINATION:
*First command* : appends a rule(-A) to PREROUTING chain for those tcp (-p ->p for protocol) packets in the nat table (-t) whose destination (-d ) IP address is your IP address(27.248.190.177) and destination port (--dport ) 8080 and says that when such a packet comes jump (-j) to DNAT (Destination Network Address Translation ) Target and change that packet's destination IP address(-- to-destination) from *27.248.190.177 to 74.125.47.104:80 . ':80 ' specifies the destination port cause google.com opens on this port only which is default HTTP port.*

*Second command* : appends a rule(-A) to *POSTROUTING chain* for those tcp (-p ->p for protocol) packets in the nat table (-t) whose destination (-d ) IP address is 74.125.47.104 (which applies for the packet whose destination address is changed by the first command) and destination port (--dport ) 80 (which is also changed to this by the first command) and says that when such a packet comes jump (-j) to SNAT (Source Network Address Translation ) Target and change that packet's source IP address(-- to-source) from earlier(whatever it may be) to 27.248.190.177.
How it works:
Any packet that comes to your host(PC) is first handled by nat table's prerouting chain(to modify incoming packet's destination IP addresse and port) and after that by the same table's postrouting chain(to modify outgoing packet's source IP address and port)

Reference: <a href="http://www.faqs.org/docs/iptables/traversingoftables.html">http://www.faqs.org/docs/iptables/traversingoftables.html</a>
The whole situation can be understood by this sample image.The image explains what is the need for modification of source IP address before releasing the packet .If source address modification is not done then the source host(the one which http://27.248.190.177:8080 accessed this in his browser ) which actually requested to your PC (host with DNAT rule) will finally get reply from google.com(destination host) (see the diagram) and the obvious reaction to this by the source host will be "Who the hell are you.I did not requested you ;) " or may be "What the hell do you want ? ;)".

<table align="center" cellpadding="0" cellspacing="0" class="tr-caption-container" style="margin-left: auto; margin-right: auto; text-align: center;">
 <tbody>
 <tr>
 <td style="text-align: center;"><a href="https://3.bp.blogspot.com/_lNQnTvuzXNg/TOKBlaLnB8I/AAAAAAAAAEo/wVZMEcBru8w/s1600/dnat-mistake.png" imageanchor="1" style="margin-left: auto; margin-right: auto;"><img border="0" height="226" src="https://3.bp.blogspot.com/_lNQnTvuzXNg/TOKBlaLnB8I/AAAAAAAAAEo/wVZMEcBru8w/s320/dnat-mistake.png" width="320" /></a></td>
 </tr>
 <tr>
 <td class="tr-caption" style="text-align: center;">What's happening</td>
 </tr>
 </tbody>
</table>

Thats why the source address is modified by the second command so that the source feels that it get reply from the host with (DNAT ,SNAT rule) which was actually requested.

So this is how this redirection works :)

Hope you understood it well ,this is somewhat difficult for those who don't have much knowledge of IPTABLES.

Thanks to rvsjoen on #Netfilter :)The whole situation can be understood by this sample image

A little bit Technical Redirection

Those who use Gmail must know that Gmail's Standard View is quite slow though it provide a lot of features that Basic Html View doesn't provide.So you always prefer the earlier to the later if you have a broadband connection.But what if you aren't a broadband user? If you use Basic HTML View then this topic is surely going to help you.In this view of Gmail you can not select all the spams or drafts or messages at once.This is a big problem if you get a lot of spams daily and you can't even select all the spams shown on one page at once to delete. Use the following javascript code to select all the spams or drafts or messages at once.

```javascript
javascript:var nameArray=document.getElementsByName('t');for(i=0;nameArray[i];i++) {if(nameArray[i].checked) nameArray[i].checked=false; else nameArray[i].checked=true;} void(null);
```

Go to the inbox or drafts or spams folder and paste the above code in the URL field followed by enter .All the checkboxes will be selected :)

A simple javascript code to make Gmail more simple

I am an Ubuntu user and it occurs to me several times that I need to execute a command in shell.This is what I do.

1. Alt+F2
2. Type *gnome-terminal* followed by enter.

The terminal popped open.I start typing the command and suddenly I realise that I do not remember what the exact command is.I just have a slight idea about the command.I am just sure of a particular word/substring in the command.It happened to me yesterday too when I was trying to modify some configuration of Gnome-Desktop.The actual command for the configuration editor is *gconf-editor*.But I remembered only a part of it(editor :( ),thats when I tried to write a simple script(findscript) for finding a command when you have a slight idea of a substring or word in it.

#### THE SHELL SCRIPT

*findcommand*

```bash
#!/bin/bash
paths=${PATH//:/ };
find `echo $paths` -name $1;
```

Make this script executable by the following command

```bash
chmod +x findcommand;
```

Now move this file to */usr/local/bin* or any other directory in your PATH environment variable.

```bash
mv findcommand /usr/local/bin
```

Code to check the PATH variable.

```bash
echo $PATH;
```

So this is the full command I ran after making this script for finding the configuration editor command.

```bash
findcommand *editor
```

OUTPUT:
```bash
/usr/bin/gconf-editor
/usr/bin/nm-connection-editor
/usr/bin/sensible-editor
/usr/bin/gnome-text-editor
/usr/bin/select-editor
/usr/bin/gmenu-simple-editor
/usr/bin/editor
```

This script will accept a regex as argument.Other possible arguments for the job can be 1. *edit* 2. *ed* 3. *gconf* The script basically uses the linux file finding utility find to find all the executables in your path having a specific word.Feel free to experiment with it :) Though it can also be done using <a href="http://en.wikipedia.org/wiki/Apropos_%28Unix%29">apropos</a> command or 'man -k editor' (editor is the search term), but its always fun doing in a different way ;)

How to find a linux command having a specific substring

If you are on facebook then you must have used <a href="http://apps.facebook.com/moodweather/%20" target="_self" title="Mood weather Report">this</a> mood sharing application.Its's being used a lot these days.Its a very good application providing a lot of moods to share.But it restricts the access to a very few moods.Each day only one new mood is unlocked on sharing an already unlocked mood on facebook.

It seems quite frustrating when you have to choose from a very few moods and when you have a mood to share you find it locked.

Its very easy to share the locked mood and it takes a few seconds.I have tried it with firefox and google-chrome ,though I am sure it will work with any browser which supports javascript.

Follow the following steps:

- Be sure to enable javascript if disabled.It is enabled by default in every browser if you have not disabled it.
- Login to your facebook account and go to the Mood Weather Report application.
- Click on any locked mood that you want to share(if the mood is already unlocked then you should not be here :) )
- In the URL field of the browser copy & paste this code

 ```javascript
 javascript: document.getElementById(
 "app44898431470_PublishArea"
 ).style.display = "";
 void null;
 ```

- You will find a "Publish on your wall" button which wasn't there earlier .Go and publish your mood :)

Mood Weather Report on Facebook -share locked moods

I am going to show how to send information manually using GET and POST methods to a PHP page on my local apache server. Prerequsites: 1. Locally Running apache server.(Though you can test with any website also say google.com) 2.A PHP script(say test.php) for testing. test.php 

```php
 <?php echo "name=".$_REQUEST['name'].",age=".$_REQUEST['age']; ?>
```

 GET METHOD 

```php
 telnet 127.0.0.1 80
```
 Now Type the Request Manually 

```http
GET /test.php?name=test&age=20 HTTP/1.0
```

Press enter twice. You will see something similar to the following:

```http
HTTP/1.1 200 OK 
Date: Sun, 13 Mar 2011 08:37:25 GMT
Server: Apache/2.2.11 (Unix) DAV/2 mod_ssl/2.2.11 OpenSSL/0.9.8k PHP/5.2.9 mod_apreq2-20051231/2.6.0 mod_perl/2.0.4 Perl/v5.10.0 
X-Powered-By: PHP/5.2.9 
Content-Length: 21
Connection: close
Content-Type: text/html
name=test,age=20
```

The lines 1-7 respresent Response Header &amp; the text on line 9 is the response message that you would have seen on the browser if used.

POST Method 
```bash
telnet 127.0.0.1 80
```

Now Type the Request Manually 

```http
POST /test.php HTTP/1.0
content-type:application/x-www-form-urlencoded
content-length:17
```

Now press enter and type the message part. 

```http
name=test&age=132
```

Press enter again. 
You will see something similar to the following: 
 
```http
HTTP/1.1 200 OK
Date: Sun, 13 Mar 2011 08:43:02GMT
X-Powered-By: PHP/5.2.9
Content-Length: 22
Connection: close
Content-Type: text/html

name=test,age=132
```

Again,the text on lines 1-7 is Response Header &amp; the text on line 9 is the response message that you would have seen on the browser if used.

Sending request to the server  Manually

**Netcat** , also referred to as Swiss-army knife for TCP/IP , is a computer networking service for reading from and writing network connections using TCP and UDP.

Download it [here](http://www.downloadnetcat.com/) for Windows/Linux.

Repositories also provide this package

For ubuntu just type in terminal:

```javascript
sudo apt-get install netcat
```

This tool can be invoked by typing 'nc' or 'netcat' .The arguments and various options to it differ according to its use.

Without going into further definitions these are some of the gr8 uses of this tool.

### **A simple Chat**

In one Terminal , type:

```javascript
netcat -vvl 127.0.0.1 -p 1400</pre>
```

It creates a Listener (-l) which listens at port (-p) 1400 with IP 127.0.0.1 in extra verbose mode (-vv) i.e printing whats happening.

-v will also do ,but will be less verbose.

Fire up another terminal and type:

```javascript
netcat -vv 127.0.0.1 1400
```

It creates a connection to IP 127.0.0.1 i.e. localhost which listens at port 1400 in extra verbose mode (-vv).

Now type something and see whatever you type is seen on another terminal.A very simple chat.

### **A simple small webserver**

Make a script:
_webserver_

```bash
#!/bin/sh
while :
do
{ echo -ne "HTTP/1.1 200 OK\r\n\r\n";
 cat htmlfile.txt;
} | nc -vvl -w 2 -p 8080
done
```

The script basically runs netcat infinite times..each time sending an HTTP Response "HTTP/1.1 200 OK" along with the data.

-w option to netcat or nc sets the timeout . -w 2 asks to disconnect after 2 seconds if there is no connection request

_htmlfile.txt_

```html
<html>
<head>
<title>A simple Webserver</title>
</head>
<body>
yeah its working
</body>
</html>
</pre>
```

Make this script executable

```bash
chmod +x webserver
```

Run the script

```bash
./webserver
```

Open a webbrowser and go to

```http
http://127.0.0.1:8080
```

A very simple webserver is ready :)

Experiment with it yourself ..

**PORT SCANNING**

Lets Scan google.com for open ports b/w 1-100

```bash
netcat -vvz -w 1 google.com 1-100
```

-z options make sure no data is transferred during connection.It is specifically used for port scanning.
One thing is for sure that 80 port is open ,otherwise you can not google which you do everytime :P
So check it out yourself ..May be you can find any other port open :)

**Making any process a server**
Terminal 1:

```bash
nc -l -p 1400 -e /bin/bash
```

-e option makes sure a file is executed (int this case /bin/bash) when connection is made
Terminal 2:

```bash
nc 127.0.0.1 1400
```

This makes a connection at port 1400 to above started listener
After successful connection type this command in teminal 2

```bash
pwd
```

You know very well what this command does ..prints the current directory
Below is the output in my case on terminal 2:

```bash
/home/hariom/Desktop
```

when pwd is typed.. this text is forwarded to /bin/bash/ for which it is a valid command and the output i.e. the current directory is printed on the terminal 2.

## IP SPOOFING

<a href="https://4.bp.blogspot.com/_lNQnTvuzXNg/TOKAgUrkR9I/AAAAAAAAAEg/K1TEaQnvMBw/s1600/screenshot1.png" target="_blank">
 <img src="https://4.bp.blogspot.com/_lNQnTvuzXNg/TOKAgUrkR9I/AAAAAAAAAEg/K1TEaQnvMBw/s1600/screenshot1.png" />
</a>

On Terminal 1 netcat listens on port 1400

```bash
netcat -vvl -p 1400
```

<a href="https://4.bp.blogspot.com/_lNQnTvuzXNg/TOKApiCC0FI/AAAAAAAAAEk/UwlyC3CViFY/s1600/screenshot2.png" target="_blank">
 <img src="https://4.bp.blogspot.com/_lNQnTvuzXNg/TOKApiCC0FI/AAAAAAAAAEk/UwlyC3CViFY/s1600/screenshot2.png" />
</a>

On terminal 2 netcat specifies source IP address also by using -s and connects to port 1400 on localhost

But first this IP address must be bound with one of your network interfaces

```bash
sudo ifconfig eth0:0 98.137.149.56
```

Now it can be specified as source IP

```bash
netcat -vvs 98.137.149.56 127.0.0.1 1400
```

It can be seen in snapshot of terminal1 that there is a connection from yahoo.com as 98.137.149.56 is its IP. You made a connection from localhost but it shows connection from yahoo.com . gr8:)

What's its use??
It can be used to test an IP firewall created using iptables

These are some of the uses of Netcat there are many more that I leave on the reader to explore :)
Happy experimenting with netcat :) :)

Swiss-Army Knife for TCP/IP

node.attributes can give attributes that can't be set back on the element. Infact setAttribute will throw error when it encounters such an attribute.

Consider following html. Note, and extra " at the end of src attribute value.

```html
<img id="img" src="img.png" />
```

Now, lets try getting the attributes of this node.
```javascript
document.getElementById('img').attributes
```

It will give three attributes, the last one being '"'.
Lets try prefixing every attribute value with '_';

```javascript
 var img = document.getElementById('img'),
 attributes = img.attributes;
 for (var i = 0; i < attributes.length; i++) {
 img.setAttribute(attributes[i].name, '_' + attributes[i].value)
 }
```

Hariom's Blog