# -*- coding: cp1252 -*-
# <PythonProxy.py>
#
# Copyright (c) <2009> <Fábio Domingues - fnds3000 in gmail.com>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without
# restriction, including without limitation the rights to use,
# copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following
# conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

"""\
Copyright (c) <2009> <Fábio Domingues - fnds3000 in gmail.com> <MIT Licence>

                  **************************************
                 *** Python Proxy - A Fast HTTP proxy ***
                  **************************************

Neste momento este proxy é um Elie Proxy.

Suporta os métodos HTTP:
 - OPTIONS;
 - GET;
 - HEAD;
 - POST;
 - PUT;
 - DELETE;
 - TRACE;
 - CONENCT.

Suporta:
 - Conexões dos cliente em IPv4 ou IPv6;
 - Conexões ao alvo em IPv4 e IPv6;
 - Conexões todo o tipo de transmissão de dados TCP (CONNECT tunneling),
     p.e. ligações SSL, como é o caso do HTTPS.

A fazer:
 - Verificar se o input vindo do cliente está correcto;
   - Enviar os devidos HTTP erros se não, ou simplesmente quebrar a ligação;
 - Criar um gestor de erros;
 - Criar ficheiro log de erros;
 - Colocar excepções nos sítios onde é previsível a ocorrência de erros,
     p.e.sockets e ficheiros;
 - Rever tudo e melhorar a estrutura do programar e colocar nomes adequados nas
     variáveis e métodos;
 - Comentar o programa decentemente;
 - Doc Strings.

Funcionalidades futuras:
 - Adiconar a funcionalidade de proxy anónimo e transparente;
 - Suportar FTP?.


(!) Atenção o que se segue só tem efeito em conexões não CONNECT, para estas o
 proxy é sempre Elite.

Qual a diferença entre um proxy Elite, Anónimo e Transparente?
 - Um proxy elite é totalmente anónimo, o servidor que o recebe não consegue ter
     conhecimento da existência do proxy e não recebe o endereço IP do cliente;
 - Quando é usado um proxy anónimo o servidor sabe que o cliente está a usar um
     proxy mas não sabe o endereço IP do cliente;
     É enviado o cabeçalho HTTP "Proxy-agent".
 - Um proxy transparente fornece ao servidor o IP do cliente e um informação que
     se está a usar um proxy.
     São enviados os cabeçalhos HTTP "Proxy-agent" e "HTTP_X_FORWARDED_FOR".

"""

import socket
import select
import sys
import base64
import time
import errno

# Python 3 renamed thread module to _thread
try:
    import _thread as thread
except BaseException:
    import thread

__version__ = '0.1.0 Draft 1'
BUFLEN = 8192
VERSION = 'Python Proxy/' + __version__
HTTPVER = 'HTTP/1.1'

username = None
password = None


class ConnectionHandler:
    def __init__(self, connection, address, timeout):
        self.client = connection
        self.client_buffer = ''
        self.timeout = timeout
        self.method, self.path, self.protocol = self.get_base_header()
        global username
        global password
        if username is not None:
            auth = base64.b64encode(username + ':' + password)
            if not 'Proxy-Authorization: Basic ' + auth in self.client_buffer:
                print('PROXY - failed authentication: %s' % self.client_buffer)
                self.client.send(HTTPVER + ' 401 Authentication Failed\n' +
                                 'Proxy-agent: %s\n\n' % VERSION)
                self.client.close()
                return
        try:
            if self.method == 'CONNECT':
                self.method_CONNECT()
            elif self.method in ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT',
                                 'DELETE', 'TRACE'):
                self.method_others()
        except BaseException:
            try:
                self.client.send(HTTPVER + ' 502 Connection failed\n' +
                                 'Proxy-agent: %s\n\n' % VERSION)
            except Exception as e:
                print('PROXY - ', e)
            self.client.close()
            return

        self.client.close()
        self.target.close()

    def get_base_header(self):
        retries = 0
        while True:
            try:
                self.client_buffer += self.client.recv(BUFLEN)
            except socket.error as e:
                err = e.args[0]
                if (err == errno.EAGAIN or err == errno.EWOULDBLOCK) and retries < 20:
                    time.sleep(0.5)
                    retries += 1
                    continue
                raise e
            end = self.client_buffer.find('\r\n\r\n')
            if end != -1:
                break
        line_end = self.client_buffer.find('\n')
        print('PROXY - %s' % self.client_buffer[:line_end])  # debug
        data = (self.client_buffer[:line_end + 1]).split()
        self.client_buffer = self.client_buffer[line_end + 1:]
        return data

    def method_CONNECT(self):
        self._connect_target(self.path)
        self.client.send(HTTPVER + ' 200 Connection established\n' +
                         'Proxy-agent: %s\n\n' % VERSION)
        self.client_buffer = ''
        self._read_write()

    def method_others(self):
        self.path = self.path[7:]
        i = self.path.find('/')
        host = self.path[:i]
        path = self.path[i:]
        self._connect_target(host)
        self.target.send('%s %s %s\n' % (self.method, path, self.protocol) +
                         self.client_buffer)
        self.client_buffer = ''
        self._read_write()

    def _connect_target(self, host):
        i = host.find(':')
        if i != -1:
            port = int(host[i + 1:])
            host = host[:i]
        else:
            port = 80
        (soc_family, _, _, _, address) = socket.getaddrinfo(host, port)[0]
        self.target = socket.socket(soc_family)
        self.target.connect(address)

    def _read_write(self):
        time_out_max = self.timeout / 3
        socs = [self.client, self.target]
        count = 0
        while True:
            count += 1
            (recv, _, error) = select.select(socs, [], socs, 3)
            if error:
                break
            if recv:
                for in_ in recv:
                    data = in_.recv(BUFLEN)
                    if in_ is self.client:
                        out = self.target
                    else:
                        out = self.client
                    if data:
                        out.send(data)
                        count = 0
            if count == time_out_max:
                break


def start_server(host='localhost', port=8080, IPv6=False, timeout=100,
                 handler=ConnectionHandler):
    if IPv6:
        soc_type = socket.AF_INET6
    else:
        soc_type = socket.AF_INET
    soc = socket.socket(soc_type)
    soc.settimeout(120)
    print("PROXY - Serving on %s:%d." % (host, port))  # debug
    soc.bind((host, port))
    soc.listen(0)
    while True:
        thread.start_new_thread(handler, soc.accept() + (timeout,))


if __name__ == '__main__':
    listen_port = 8080
    i = 1
    while i < len(sys.argv):
        if sys.argv[i] == '--port':
            listen_port = int(sys.argv[i + 1])
            i += 1
        elif sys.argv[i] == '--username':
            username = sys.argv[i + 1]
            i += 1
        elif sys.argv[i] == '--password':
            password = sys.argv[i + 1]
            i += 1
        else:
            if sys.argv[i] != '--help':
                print(('PROXY - unknown option "%s"' % sys.argv[i]))
            print('usage: http.py [--port <listen-port>]')
            sys.exit(1)
        i += 1
    start_server(port=listen_port)