#define _ -F<00||--F-OO--;
 int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
 {
             _-_-_-_
        _-_-_-_-_-_-_-_-_
     _-_-_-_-_-_-_-_-_-_-_-_
   _-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
   _-_-_-_-_-_-_-_-_-_-_-_-_-_
     _-_-_-_-_-_-_-_-_-_-_-_
         _-_-_-_-_-_-_-_
             _-_-_-_
 }

#!/usr/bin/perl
#-------------------------------------------------------------------------
#--     proxy.pl    -  A simple http proxy server.                      --
#
#	The original program was from:
#		http://www.cis.upenn.edu/sdt/proxy.pl
#
#	The original program employs the basic socket library, which
#		seems hard to understand for some beginners.
#	That is why I modify it  by employing the 
#		IO::Socket::INET
#
#	jay.s.liu@gmail.com
#	Apr. 17, 2006
#--                                                                     --
#--     To run, type   proxy.pl [port-number]   at the shell prompt.    --
#--     Default port number is 5364.                                    --
#--                                                                     --
#-------------------------------------------------------------------------
use IO::Socket::INET;
srand (time||$$);
 
#---  Define a friendly exit handler
$SIG{'KILL'} = $SIG{QUIT} = $SIG{INT} = 'exit_handler';
sub exit_handler {
    print "\n\n --- Proxy server is dying ...\n\n";
    close($SOCKET);
    exit;
}
 
$| = 1;	#Disable buffering
 
##--- Step 1 : Create Socket ---##	
 
#--- Get the port number form commemd line	
$proxy_port = shift(@ARGV);								
$proxy_port = 5364 unless $proxy_port =~ /\d+/;		
 
#--- Create a socket that listens to a specific port
&listen_to_port($SOCKET,$proxy_port);			
 
$local_host = `hostname`;	
chop($local_host);
$local_host_ip = $SOCKET->sockhost();
print " --- Proxy server running on $local_host( $local_host_ip ) port: $proxy_port \n\n";
 
#---  Loop forever taking requests as they come
while (1) {
 
##--- Step 2 : Wait for request ---##
    print " --- Waiting to be of service ...\n";
    $CHILD = $SOCKET->accept() || die "accept $!";
 
#--- Get the ip address of clinet
    $inetaddr = $CHILD->peerhost();					 
    $port = $CHILD->peerport();
	print "Connection from ", $inetaddr, "  port: $port \n";
 
#---  Fork a subprocess to handle request.
#---  Parent proces continues listening.
    if (fork) {
        wait;           # For now we wait for the child to finish
        next;           # We wait so that printouts don't mix
    }
 
 
##---  Step 3 : Read first line of request and analyze it. ---##
#---  Return and edited version of the first line and the request method.
  ($first,$method,$URL) = &analyze_request;
 
##---  Step 4 : Send request to remote host ---##
    print $URL $first;
    print $first;
 
#-- Read HTTP header and Send it to remote host
    $contentLength = 0;
    while (<$CHILD>) {
        print $_;
        next if (/Proxy-Connection:/);	#discard the line which begins with the string "/Proxy-Connection:/"
	if (/Content-length:(.*)/i) {
	    $contentLength = $1;
	}
        print $URL $_;
        last if ($_ =~ /^[\s\x00]*$/);	#exit loop if the line only contains space and null character
    }
 
#Read HTTP content and Send it to remote host
    if ($method eq "POST") {			
		if ($contentLength != 0) {
		    read $CHILD, $data, $contentLength;
		} 
		else {
		    $data = <$CHILD>;
		}
        print "POST body: $data";
        print $URL $data;
    }
    print $URL "\n";
 
##---  Step 5 : Wait for response and transfer it to requestor. ---##	
    print " --- Done sending. Response: \n\n";
    $header = 1;
    $text = 0;
    while (<$URL>) {
        print $CHILD $_;
        if ($header || $text) {      # Only print header & text lines to STDOUT
            print $_;
            if ($header && $_ =~ /^[\s\x00]*$/) {
                $header = 0;
            }
#           if ($header && $_ =~ /^Content-type: text/) {
#               $text = 1;
#           }
        }
    }
    close($URL);
    close($CHILD);
    exit;                       # Exit from child process
}
#-------------------------------------------------------------------------
#--     analyze_request                                                 --
#--                                                                     --
#--     Analyze a new request.  First read in first line of request.    --
#--     Read URL from it, process URL and open connection.              --
#--     Return an edited version of the first line and the request      --
#--     method.                                                         --
#-------------------------------------------------------------------------
sub analyze_request {
#---  Read first line of HTTP request
    my $first = <$CHILD>;
    my $url = ($first =~ m|(http://\S+)|)[0];
    print "Request for URL:  $url \n";
 
#---  Check if first line is of the form GET http://host-name ...
    my ($method, $remote_host, $remote_port) = 
        ($first =~ m!(GET|POST|HEAD) http://([^/:]+):?(\d*)! );
 
#---  If not, bad request.
    if (!$remote_host) {
        print $first;
        while (<$CHILD>) {
            print $_;
            last if ($_ =~ /^[\s\x00]*$/);
        }
        print "Invalid HTTP request from ",$inetaddr, "\n";
        print $CHILD "I don't understand your request.\n";
        close($CHILD);
        exit;
    }
 
#---  If requested URL is the proxy server then ignore request
	my $local_host = `hostname`;	
	chop($local_host);
	my $local_ip = (gethostbyname($local_host))[4];		#Get localhost ip (packed imformation)
    my $remote_ip = (gethostbyname($remote_host))[4];		#Get remote ip (packed imformation)
    if (($remote_ip eq $local_ip) && ($remote_port eq $proxy_port)) {
        print $first;
        while (<$CHILD>) {
            print $_;
            last if ($_ =~ /^[\s\x00]*$/);
        }
        print " --- Connection to proxy server ignored.\n";
        print $CHILD "It's not nice to make me loop on myself!.\n";
        close($CHILD);
        exit;
    }
 
 
#---  Setup connection to target host and send request
    $remote_port = "http" unless ($remote_port);
    &open_connection($URL, $remote_host, $remote_port);
 
#---  Remove remote hostname from URL
        $first =~ s/http:\/\/[^\/]+//;
    ($first, $method, $URL);
}
 
#-------------------------------------------------------------------------
#--     listen_to_port($SOCKET, $port)                                   --
#--                                                                     --
#--     Create a socket that listens to a specific port                 --
#-------------------------------------------------------------------------
sub listen_to_port {
    local ($port) = $_[1];
    local ($max_requests);
    local ($return_value);
 
    $max_requests = 30;          # Max number of outstanding requests
 
	#--- Get localhost name
	$local_hostname = `hostname`;	
	chop($local_hostname);
 
    $_[0] = new IO::Socket::INET (
    						LocalHost => $local_hostname,
							LocalPort => $port,
							Proto => 'tcp',
							Listen => $max_request,
							ReuseAddr => 1
                                                       )  || die "socket: $!";
    local ($cur) = select($_[0]); 
    $| = 1;                             # Disable buffering on socket.
    select($cur);
}
 
#-------------------------------------------------------------------------
#--     open_connection($SOCKET, $remote_hostname, $port)                --
#--                                                                     --
#--     Create a socket that connects to a certain host                 --
#-------------------------------------------------------------------------
sub open_connection {
    local ($remote_hostname, $port) = @_[1,2];
    local ($return_value);
 
#-- Get the port number by service name
    if ($port !~ /^\d+$/) {
        $port = (getservbyname($port, "tcp"))[2];
        $port = 80 unless ($port);				#If the service name is not valid, give it a default number(80)
    }
 
 
    my $remote_addr = (gethostbyname($remote_hostname))[4];
    if (!$remote_addr) {
        die "Unknown host: $remote_hostname";
    }
 
 
    #print "Connecting to $remote_hostname port $port.\n\n";
    $_[0] = new IO::Socket::INET (
    						PeerAddr => $remote_hostname,
							PeerPort => $port,
							Proto => 'tcp'
                            ) || die "socket: $!";   
 
	local ($remote_ip) = $_[0]->peerhost();									   
    print "Connecting to $remote_ip port $port.\n\n";								
 
    local ($cur) = select($_[0]);  
    $| = 1;                             # Disable buffering on socket.
    select($cur);
}

"""This is a simple HTTP proxy written in Python that imitate the Perl one:
 
http://liuj.fcu.edu.tw/net_pg/proxy-stu.pl.html
 
I wrote this in Python for classmates to compare to the one in Perl, because the 
readability of Perl is awful. You can see the readaibility is much better than 
the Perl one. You can also read this article:
 
http://www.garshol.priv.no/download/text/perl.html
 
to see what's wrong with Perl, and why Python.
 
To read this program, you might need the documents of python:
http://docs.python.org/index.html
 
You can also find older version here:
http://www.python.org/doc/versions/
 
To learn Python, you can browse my tutorials:
http://ez2learn.com/
 
If you got any problem about this program, feel free to ask.
 
Author: Victor Lin (bornstub@gmail.com)
        http://blog.ez2learn.com
 
2009/4/27 - Create first version
2009/4/30 - Fix the problem of keep-alive (fore the connection closed)
 
"""
 
import sys
import socket
import urlparse
import signal
import datetime
 
def listenToPort(port):
    """Listen to specific port and return socket
 
    @param port: port to listen
    @return: socket
    """
    # get name of host
    host = socket.gethostbyname(socket.gethostname())
    # create socket and bind, listen
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((host, port))
    s.listen(5)
    return s
 
def openConnection(host, port):
    """Open a connection to remote host
 
    @param host: host to connect
    @param port: port to connect
    @return: connection socket
    """
    # create socket for connecting remote host
    remote = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    ip = socket.gethostbyname(host)
    remote.connect((ip, port))
    return remote
 
def analyzeRequest(client):
    """Parse http request
 
    @param child: file of client socket to read request and parse
    @return: (first line of request for http server, http method, socket to url)
    """
    first = client.readline().strip()
 
    # parse first line
    method, url, version = first.split()
 
    # parse url
    result = urlparse.urlparse(url)
    host = result[1]
    if result[1].find(':') != -1:
        host, port = host.split(':')
        port = int(port)
    else:
        port = 80
    url = urlparse.urlunparse(('', '') + result[2:])
 
    # check is there a loop
    if host == socket.gethostname() or host == '127.0.0.1' or \
        host.lower() == 'localhost':
        print " --- Connection to proxy server ignored."
        print >> file, "It's not nice to make me loop on myself!."
        client.close()
        sys.exit()
 
    remote = openConnection(host, port)
    # the first line for remote socket
    first = "%s %s %s" % (method, url, version)
    return first, method, remote
 
def main():
    if len(sys.argv) > 1:
        proxyPort = int(sys.argv[1]) 
    else:
        proxyPort = 5364
 
    ##--- Step 1 : Create Socket ---##
    s = listenToPort(proxyPort)
    ip, port = s.getsockname()
    print " --- Proxy server running on %s ( %s ) port: %d" % (
        socket.gethostname(), ip, port)
 
    ##--- Step 2 : Wait for request ---##
    while 1:
        print " --- Waiting to be of service ..."
        client, address = s.accept()
        clientFile = client.makefile()
        ip, port = address
        print "Connection from %s port: %d" % (ip, port)
        ##---  Step 3 : Read first line of request and analyze it. ---##
        first, method, remote = analyzeRequest(clientFile)
        ##---  Step 4 : Send request to remote host ---##
        remoteFile = remote.makefile(bufsize=0)
        # write first line to remote server
        print >> remoteFile, first
        print first
        # force the remote connection closed as finish this request
        print >> remoteFile, 'Connection: close'
        # read headers from client
        contentLength = 0
        for line in clientFile:
            line = line.strip()
            print line
            # filter headers that we don't want they passed to server
            match = False
            for header in ['connection:', 'proxy-connection:', 'keep-alive:']:
                if line.lower().startswith(header):
                    match = True
            if match:
                continue
            # get content length
            if line.lower().startswith('content-length:'):
                _, length = line.split(':')
                contentLength = int(length)
            print >> remoteFile, line
            if not line:
                break
 
        if method == "POST":            
            if contentLength != 0:
                data = clientFile.read(contentLength)
            else:
                data = clientFile.readline()
 
            print "POST body:", data
            print >> remoteFile, data
 
        ##---  Step 5 : Wait for response and transfer it to requestor. ---##    
        print " --- Done sending. Response: "
        print
 
        contentLength = None
        for line in remoteFile:
            line = line.strip()
            print >> clientFile, line
            if not line:
                break
            print line
            if line.lower().startswith('content-length:'):
                _, length = line.split(':')
                contentLength = int(length)
 
        if contentLength is not None:
            body = remoteFile.read(contentLength)
        else:
            body = remoteFile.read()
 
        clientFile.write(body)
 
        remoteFile.close()
        clientFile.close()
 
if __name__ == '__main__':
    main()