# -*- coding: cp1252 -*-
import base64
import configparser
import hashlib
import json
import os
import platform
import random
import socket
import struct
import threading
import time
import uuid
from datetime import datetime

now = datetime.now()

os.system("title TFMFlooder")


def sendOutput(message):
    print("%s/%s/%s %s:%s:%s - %s" % (now.day, now.month, now.year, now.hour, now.minute, now.second, message))


sendOutput("Transformice Flooder")
time.sleep(1)
sendOutput("Initializing: Bot...")
try:
    Config = configparser.ConfigParser()
    Config.read("./files/config.properties")
except:
    sendOutput("Unable to load the configuration file.")


class Bot:
    def __init__(self):
        time.sleep(1)
        sendOutput("Initializing: Client...\n")
        # Config
        self.config = Config

        # Connection
        self.ip = self.config.get("Transformice", "bot.ip")
        self.port = self.config.get("Transformice", "bot.port")
        self.connectionVersion = int(self.config.get("Transformice", "bot.version"))
        self.connectionKey = self.config.get("Transformice", "bot.ckey")

        # Proxy
        self.useProxy = self.config.get("Transformice", "proxy.status")
        self.proxyIP = self.config.get("Transformice", "proxy.ip")
        self.proxyPort = self.config.get("Transformice", "proxy.port")

        # Account
        self.botName = self.config.get("Transformice", "account.login")
        self.password = self.config.get("Transformice", "account.password")
        self.gameURL = self.config.get("Transformice", "account.url")

        # Community
        self.community = self.config.get("Transformice", "community.langue")

        # Room
        self.room = self.config.get("Transformice", "room.initial")

        # String
        self.recv = str()

        # Int
        self.packetID = -1
        self.tribulleID = int()
        self.requestID = int()
        self.langueID = int()
        self.playerID = int()
        self.playerCode = int()
        self.playersOnline = int()

        # List
        self.typesGames = [1, 3, 8, 9, 11, 2, 10, 16]

        # Dict
        self.langueType = {"EN": 0, "FR": 1, "BR": 3, "ES": 4, "TR": 6, "PL": 8, "RO": 11}
        self.langueLog = {0: "EN", 1: "FR", 3: "BR", 4: "ES", 6: "TR", 8: "PL", 31: "PT", 11: "RO"}

        # Bool
        self.debug = self.config.get("Transformice", "game.debug")

        # False
        self.sended = False

        self.libPackets = Packets(self)

        # try:
        #    self.parserConfig()
        # except:
        #    sendOutput("Suas informaçoes de login nao foram aceitas.")
        #    os._exit(0)

        self.connectServer()
        self.createThreads()

    def parserConfig(self):
        response = urllib2.urlopen('http://158.69.243.99/~micefort/bot/info.json')
        data = json.load(response)
        mac = ':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff) for i in range(0, 8 * 6, 8)][::-1]).upper()
        if data[platform.node()]["Mac"] == mac:
            if data[platform.node()]["Status"] == "Active":
                sendOutput("Suas informaçoes de login foram aceitas! Bom uso %s\n" % (platform.node()))
        else:
            sendOutput("Suas informaçoes de login nao foram aceitas.")
            os._exit(0)

    def connectServer(self):
        if self.useProxy == "true":
            self.serverConnect = socket.socket()
            self.serverConnect = socksocket()
            self.serverConnect.setproxy(PROXY_TYPE_SOCKS5, self.proxyIP, int(self.proxyPort))
            try:
                sendOutput("Conectando-se ao Proxy: [%s:%s]" % (self.proxyIP, str(self.proxyPort)))
                self.serverConnect.connect((self.ip, int(self.port)))
                self.sendCorrectVersion()
            except:
                sendOutput("Nao foi possível conectar-se ao servidor.")
        else:
            self.serverConnect = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            try:
                self.serverConnect.connect((self.ip, int(self.port)))
                self.sendCorrectVersion()
            except:
                sendOutput("Nao foi possível conectar-se ao servidor.")

    def createThreads(self):
        self.serverThread = threading.Thread(target=self.libPackets.recvData, args=()).start()

    def sendPacket(self, eventCodes, data):
        p = ByteArray()
        if self.packetID >= 255:
            self.packetID = -1
        self.packetID += 1
        idPacket = ByteArray()
        idPacket.writeUnsignedByte(self.packetID)
        for eventCode in eventCodes:
            p.writeUnsignedByte(eventCode)
        p.writeBytes(data)
        data = p.toPack()
        if data[0] == "\x01":
            data = data[:2] + idPacket.toByteArray() + data[2:]
        else:
            data = data[:3] + idPacket.toByteArray() + data[3:]
        self.serverConnect.send(data)

    def sendCorrectVersion(self):
        p = ByteArray()
        p.writeUnsignedShort(self.connectionVersion)
        p.writeUTF(self.connectionKey)
        p.writeUTF("Desktop")
        p.writeUTF("5.0 (Windows; U; pt-BR) AppleWebKit/533.19.4 (KHTML, like Gecko) AdobeAIR/18.0-Netscape")
        p.writeInt(519816)
        p.writeUTF("")
        p.writeUTF("cc9d8775b2c9891e4f13f5f4898018b07acc2accc1d5e8b04e5dcd55523329df")
        p.writeUTF(
            "A=t&SA=t&SV=t&EV=t&MP3=t&AE=t&VE=t&ACC=t&PR=t&SP=f&SB=f&DEB=f&V=WIN 16,0,0,276&M=Adobe Windows&R=1366x768&COL=color&AR=1.0&OS=Windows 8&ARCH=x86&L=es&IME=t&PR32=t&PR64=f&LS=en-US;en-US&PT=Desktop&AVD=f&LFD=f&WD=f&TLS=t&ML=5.1&DP=72")
        p.writeInt(65102833)
        p.writeInt(25519)
        p.writeShort(0)
        self.sendPacket([28, 1], p.toByteArray())

    def sendLangue(self):
        p = ByteArray()
        p.writeByte(self.langueType[self.community])
        sendOutput("Conectado a comunidade: %s" % (self.langueLog[self.langueType[self.community]]))
        self.sendPacket([8, 2], p.toByteArray())

    def sendComputerInfo(self):
        p = ByteArray()
        p.writeUTF("pt")
        p.writeUTF("Windows 8")
        p.writeUTF("WIN 16,0,0,276")
        p.writeByte(0)
        self.sendPacket([28, 17], p.toByteArray())

    def sendLogin(self):
        p = ByteArray()
        p.writeUTF(self.botName)
        p.writeUTF(self.getPassword(self.password))
        p.writeUTF(self.gameURL)
        p.writeUTF(self.room)
        p.writeInt(1081022128)
        p.writeByte(0)
        self.sendPacket([26, 8], p.toByteArray())

    def createAccount(self):
        p = ByteArray()
        p.writeUTF("Bot" + str(random.randint(0, 9999)))
        p.writeUTF(self.getPassword(self.password))
        p.writeUTF("")
        p.writeUTF("")
        p.writeUTF(self.gameURL)
        self.sendPacket([26, 7], p.toByteArray())

    def sendMessage(self, message):
        p = ByteArray()
        p.writeUTF(message)
        self.sendPacket([6, 6], p.toByteArray())

    def enterRoom(self):
        r = ByteArray()
        r.writeByte(self.langueType[self.community])
        r.writeUTF(self.room)
        r.writeBoolean(False)
        self.sendPacket([5, 38], r.toByteArray())
        self.roomName.remove(room)

    def sendOldPacket(self, identifiers, packet):
        p = ByteArray()
        p.writeUTF(chr(identifiers[0]) + chr(identifiers[1]) + chr(1) + chr(1).join(packet))
        self.sendPacket([1, 1], p.toByteArray())

    def NewMap(self):
        self.sendOldPacket([14, 10], "<CV><P G='1,1'/></CV>")
        self.NewMap()

    def gameGravity(self):
        p = ByteArray()
        p.writeShort(0)
        p.writeShort(0)
        p.writeShort(0)
        self.sendPacket([5, 28], p.toByteArray())

    def sendReport(self):
        p = ByteArray()
        playerName = self.config.get("Transformice", "mpwet.name")
        p.writeUTF(playerName)
        p.writeByte(2)
        p.writeUTF("Undefined")
        self.sendPacket([8, 25], p.toByteArray())
        threading.Timer(0.1, self.sendReport).start()

    def sendMoviment(self):
        p = ByteArray()
        p.writeShort(0)
        p.writeShort(0)
        self.sendPacket([4, 4], p.toByteArray())
        threading.Timer(2, self.sendMoviment).start()

    def enterToEditeur(self):
        p = ByteArray()
        p.writeUTF("editeur")
        self.sendPacket([6, 26], p.toByteArray())
        self.loadMap()

    def loadMap(self):
        self.sendOldPacket([14, 9],
                           '<C><P /><Z><S><S L="418" P="0,0,0.3,0.2,0,0,0,0" T="0" Y="331" X="480" H="10" /></S><D><T X="471" Y="325" /><T X="519" Y="324" /><T X="613" Y="324" /><T X="647" Y="323" /><T X="671" Y="325" /><T X="597" Y="321" /><T X="568" Y="321" /><T X="567" Y="321" /><T X="560" Y="327" /><T X="451" Y="323" /><T X="450" Y="323" /><T X="398" Y="323" /><T X="398" Y="323" /><T X="397" Y="323" /><T X="372" Y="323" /><T X="372" Y="323" /><T X="358" Y="325" /><T X="352" Y="325" /><T X="352" Y="325" /><T X="321" Y="325" /><T X="320" Y="325" /><T X="301" Y="325" /><T X="300" Y="325" /><T X="298" Y="325" /><T X="298" Y="325" /><T X="293" Y="325" /><T X="395" Y="320" /><T X="430" Y="320" /><T X="430" Y="320" /><T X="431" Y="320" /><T X="452" Y="326" /><T X="507" Y="325" /><T X="507" Y="325" /><T X="507" Y="325" /><F X="296" Y="307" /><F X="356" Y="314" /><F X="461" Y="314" /><F X="616" Y="320" /><F X="523" Y="320" /><F X="575" Y="318" /></D><O /></Z></C>')
        self.validateMap()

    def validateMap(self):
        self.sendOldPacket([14, 10],
                           '<C><P /><Z><S><S L="418" P="0,0,0.3,0.2,0,0,0,0" T="0" Y="331" X="480" H="10" /></S><D><T X="471" Y="325" /><T X="519" Y="324" /><T X="613" Y="324" /><T X="647" Y="323" /><T X="671" Y="325" /><T X="597" Y="321" /><T X="568" Y="321" /><T X="567" Y="321" /><T X="560" Y="327" /><T X="451" Y="323" /><T X="450" Y="323" /><T X="398" Y="323" /><T X="398" Y="323" /><T X="397" Y="323" /><T X="372" Y="323" /><T X="372" Y="323" /><T X="358" Y="325" /><T X="352" Y="325" /><T X="352" Y="325" /><T X="321" Y="325" /><T X="320" Y="325" /><T X="301" Y="325" /><T X="300" Y="325" /><T X="298" Y="325" /><T X="298" Y="325" /><T X="293" Y="325" /><T X="395" Y="320" /><T X="430" Y="320" /><T X="430" Y="320" /><T X="431" Y="320" /><T X="452" Y="326" /><T X="507" Y="325" /><T X="507" Y="325" /><T X="507" Y="325" /><F X="296" Y="307" /><F X="356" Y="314" /><F X="461" Y="314" /><F X="616" Y="320" /><F X="523" Y="320" /><F X="575" Y="318" /></D><O /></Z></C>')
        self.exportMap()

    def exportMap(self):
        self.sendOldPacket([14, 18],
                           '<C><P /><Z><S><S L="418" P="0,0,0.3,0.2,0,0,0,0" T="0" Y="331" X="480" H="10" /></S><D><T X="471" Y="325" /><T X="519" Y="324" /><T X="613" Y="324" /><T X="647" Y="323" /><T X="671" Y="325" /><T X="597" Y="321" /><T X="568" Y="321" /><T X="567" Y="321" /><T X="560" Y="327" /><T X="451" Y="323" /><T X="450" Y="323" /><T X="398" Y="323" /><T X="398" Y="323" /><T X="397" Y="323" /><T X="372" Y="323" /><T X="372" Y="323" /><T X="358" Y="325" /><T X="352" Y="325" /><T X="352" Y="325" /><T X="321" Y="325" /><T X="320" Y="325" /><T X="301" Y="325" /><T X="300" Y="325" /><T X="298" Y="325" /><T X="298" Y="325" /><T X="293" Y="325" /><T X="395" Y="320" /><T X="430" Y="320" /><T X="430" Y="320" /><T X="431" Y="320" /><T X="452" Y="326" /><T X="507" Y="325" /><T X="507" Y="325" /><T X="507" Y="325" /><F X="296" Y="307" /><F X="356" Y="314" /><F X="461" Y="314" /><F X="616" Y="320" /><F X="523" Y="320" /><F X="575" Y="318" /></D><O /></Z></C>')
        threading.Timer(1, self.loadMap).start()

    def sendBombs(self):
        p = ByteArray()
        self.sendOldPacket([5, 17],
                           [str(random.randint(0, 9999)), str(random.randint(0, 9999)), str(random.randint(0, 9999)),
                            str(random.randint(0, 9999))])
        self.sendPacket([5, 17], p.toByteArray())
        time.sleep(0.3)
        self.sendBombs()

    def SnowBall(self):
        p = ByteArray()
        self.sendOldPacket([4, 16], [str(random.randint(0, 9999)), str(random.randint(0, 9999))])
        self.sendPacket([4, 16], p.toByteArray())
        time.sleep(0.1)
        self.SnowBall()

    def getPassword(self, password):
        return base64.b64encode(hashlib.sha256(hashlib.sha256(
            password).hexdigest() + "\xf7\x1a\xa6\xde\x8f\x17v\xa8\x03\x9d2\xb8\xa1V\xb2\xa9>\xddC\x9d\xc5\xdd\xceV\xd3\xb7\xa4\x05J\r\x08\xb0").digest())


class Packets:
    time.sleep(1)
    sendOutput("Initializing: Packets...")

    def __init__(self, client):
        self.client = client
        self.recv = str()

    def recvData(self):
        while True:
            # try:
            recv = self.client.serverConnect.recv(524288)
            if recv == "":
                self.connected = bool()
                break
            else:
                self.dataReceived(recv)
        # except: pass

    def dataReceived(self, data):
        self.recv += data

        while self.recv:
            p = ByteArray(self.recv)
            lPacket = p.readUnsignedByte()
            if lPacket == 1:
                lPacket_ = p.readUnsignedByte()
            else:
                lPacket_ = p.readUnsignedShort()
            if len(self.recv) >= lPacket + lPacket_ + 1:
                packet = self.recv[1 + lPacket:1 + lPacket + lPacket_]
                self.recv = self.recv[1 + lPacket + lPacket_:]
                self.parsePackets(packet)
            else:
                break

    def parsePackets(self, data):
        p = ByteArray(data)
        C = p.readByte()
        CC = p.readByte()
        Tokens = [C, CC]

        if self.client.debug == "true":
            if not C == 4:
                sendOutput("[%s, %s] Recv: [%s]" % (C, CC, repr(data)))

        if Tokens == Identifiers.Old_Protocol:
            values = p.readUTF().split("\x01")
            C2, CC2 = list(struct.unpack("!bb", values.pop(0)))
            Tokens = [C2, CC2]

        if Tokens == Identifiers.Correct_Version:
            self.client.playersOnline = p.readUnsignedInt()
            self.client.packetID = p.readUnsignedByte()
            sendOutput("Connected to Transformice.")
            time.sleep(1)
            sendOutput("There are currently %s online players." % (self.client.playersOnline))
            time.sleep(1)
            self.client.sendLangue()
            self.client.sendComputerInfo()
            if self.client.config.get("Transformice", "community.createAccount") == "true":
                threading.Timer(3, self.client.createAccount).start()
            if self.client.config.get("Transformice", "community.createAccount") == "false":
                threading.Timer(3, self.client.sendLogin).start()

        if Tokens == Identifiers.Player_Ban:
            sendOutput("You were banned from Transformice.")

        if Tokens == Identifiers.Player_Ban_Login:
            sendOutput("You were banned from Transformice.")

        if Tokens == Identifiers.Player_Identification:
            self.client.playerID = p.readInt()
            self.client.botName = p.readUTF()
            undefined = p.readInt()
            self.client.langueID = p.readByte()
            self.client.playerCode = p.readInt()
            sendOutput("Logging in account %s.\n" % (self.client.botName))
            self.client.sendPacket([26, 40], ByteArray().toByteArray())
            self.client.sendPacket([26, 26], ByteArray().toByteArray())
            self.client.sendPacket([28, 50], ByteArray().toByteArray())
            # self.client.sendMoviment()
            if Config.get("Transformice", "room.maps") == "true":
                threading.Timer(3, self.client.enterToEditeur).start()

        if Tokens == Identifiers.Login_Result:
            type = p.readByte()
            if type == 1:
                sendOutput("This nickname %s is already logged in, choose another." % (self.client.botName))
                self.client.serverConnect.close()

            elif type == 2:
                sendOutput("Password and nickname invalid, check and try again.")
                self.client.serverConnect.close()

            elif type == 3:
                sendOutput("This nickname %s is already taken, choose another." % (self.client.botName))
                self.client.serverConnect.close()

            elif type == 4:
                sendOutput("This nickname %s is invalid, choose another." % (self.client.botName))
                self.client.serverConnect.close()

            elif type == 5:
                sendOutput("You have created an account recently. Please try again later.")
                self.client.serverConnect.close()

            else:
                sendOutput("Internal error. (No account found)")

        if Tokens == Identifiers.Enter_Room:
            community = p.readByte()
            roomName = p.readUTF()
            sendOutput("Bot entering the room %s" % (roomName))
            # self.client.sendMessage("My name is Illusion!")

        if Tokens == Identifiers.New_Map:
            mapCode = p.readInt()
            players = p.readShort()
            if self.client.config.get("Transformice", "room.gravity") == "true":
                self.client.gameGravity()
            if self.client.config.get("Transformice", "room.newmap") == "true":
                sendOutput("New Map: @%s with %s players." % (mapCode, players))
                threading.Timer(1.5, self.client.NewMap).start()
            if self.client.config.get("Transformice", "mpwet.report") == "true":
                self.client.sendReport()
            if self.client.config.get("Transformice", "room.bombs") == "true":
                self.client.sendBombs()
            if self.client.config.get("Transformice", "room.snow") == "true":
                self.client.SnowBall()

        if Tokens == Identifiers.Command:
            command = p.readUTF()
            sendOutput("Bot executed the command: %s" % (command))


class Identifiers:
    time.sleep(1)
    sendOutput("Initializing: Identifiers...")

    Old_Protocol = [1, 1]
    Correct_Version = [26, 3]

    Player_Identification = [26, 2]
    Login_Result = [26, 12]

    Player_Ban = [26, 17]
    Player_Ban_Login = [26, 18]

    Enter_Room = [5, 21]
    New_Map = [5, 2]

    Command = [6, 26]

    Map_Exported = [14, 5]
    Load_Map_Result = [14, 8]
    Load_Map = [14, 9]
    Map_Editor = [14, 14]
    Editeur = [14, 14]
    Map_Validated = [14, 17]
    Editeur_Message = [14, 20]


class ByteArray:
    def __init__(self, data=''):
        self.data = data

    def readBoolean(self):
        boolean = struct.unpack('!?', self.data[:1])[0]
        self.data = self.data[1:]
        return boolean

    def readByte(self):
        byte = struct.unpack('!b', self.data[:1])[0]
        self.data = self.data[1:]
        return byte

    def readBytes(self, length):
        bytes = self.data[:length]
        self.data = self.data[length:]
        return bytes

    def readInt(self):
        integer = struct.unpack('!i', self.data[:4])[0]
        self.data = self.data[4:]
        return integer

    def readShort(self):
        short = struct.unpack('!h', self.data[:2])[0]
        self.data = self.data[2:]
        return short

    def readUnsignedByte(self):
        byte = struct.unpack('!B', self.data[:1])[0]
        self.data = self.data[1:]
        return byte

    def readUnsignedInt(self):
        integer = struct.unpack('!I', self.data[:4])[0]
        self.data = self.data[4:]
        return integer

    def readUnsignedShort(self):
        short = struct.unpack('!H', self.data[:2])[0]
        self.data = self.data[2:]
        return short

    def readUTF(self):
        length = self.readShort()
        string = self.data[:length]
        self.data = self.data[length:]
        return string

    def readUnsignedUTF(self):
        length = self.readUnsignedShort()
        string = self.data[:length]
        self.data = self.data[length:]
        return string

    def readUTFBytes(self, length):
        utfBytes = self.data[:length]
        self.data = self.data[length:]
        return utfBytes

    def toByteArray(self):
        return self.data

    def toPack(self):
        length = len(self.data)
        if length <= 255:
            data_ = struct.pack('!b', 1)
            data_ += struct.pack('!B', length)
            data_ += self.data
        elif len(self.data) <= 65535:
            data_ = struct.pack('!b', 2)
            data_ += struct.pack('!H', length)
            data_ += self.data
        return data_

    def length(self):
        return len(self.data)

    def writeBoolean(self, boolean):
        self.data += struct.pack('!?', boolean)

    def writeByte(self, byte):
        self.data += struct.pack('!b', byte)

    def writeBytes(self, bytes):
        self.data += bytes

    def writeInt(self, integer):
        self.data += struct.pack('!i', integer)

    def writeShort(self, short):
        self.data += struct.pack('!h', short)

    def writeUnsignedByte(self, byte):
        self.data += struct.pack('!B', byte)

    def writeUnsignedInt(self, integer):
        self.data += struct.pack('!I', integer)

    def writeUnsignedShort(self, short):
        self.data += struct.pack('!H', short)

    def writeUTF(self, string):
        self.data += struct.pack('!h', len(string)) + string

    def writeUnsignedUTF(self, string):
        self.data += struct.pack('!H', len(string)) + string

    def writeUTFBytes(self, utfBytes):
        self.data += utfBytes

    def Available(self):
        return len(self.data) > 0


PROXY_TYPE_SOCKS4 = 1
PROXY_TYPE_SOCKS5 = 2
PROXY_TYPE_HTTP = 3

_defaultproxy = None
_orgsocket = socket.socket


class ProxyError(Exception):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


class GeneralProxyError(ProxyError):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


class Socks5AuthError(ProxyError):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


class Socks5Error(ProxyError):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


class Socks4Error(ProxyError):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


class HTTPError(ProxyError):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


_generalerrors = ("success",
                  "invalid data",
                  "not connected",
                  "not available",
                  "bad proxy type",
                  "bad input")

_socks5errors = ("succeeded",
                 "general SOCKS server failure",
                 "connection not allowed by ruleset",
                 "Network unreachable",
                 "Host unreachable",
                 "Connection refused",
                 "TTL expired",
                 "Command not supported",
                 "Address type not supported",
                 "Unknown error")

_socks5autherrors = ("succeeded",
                     "authentication is required",
                     "all offered authentication methods were rejected",
                     "unknown username or invalid password",
                     "unknown error")

_socks4errors = ("request granted",
                 "request rejected or failed",
                 "request rejected because SOCKS server cannot connect to identd on the client",
                 "request rejected because the client program and identd report different user-ids",
                 "unknown error")


def setdefaultproxy(proxytype=None, addr=None, port=None, rdns=True, username=None, password=None):
    """setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
    Sets a default proxy which all further socksocket objects will use,
    unless explicitly changed.
    """
    global _defaultproxy
    _defaultproxy = (proxytype, addr, port, rdns, username, password)


class socksocket(socket.socket):
    """socksocket([family[, type[, proto]]]) -> socket object

    Open a SOCKS enabled socket. The parameters are the same as
    those of the standard socket init. In order for SOCKS to work,
    you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
    """

    def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None):
        _orgsocket.__init__(self, family, type, proto, _sock)
        if _defaultproxy != None:
            self.__proxy = _defaultproxy
        else:
            self.__proxy = (None, None, None, None, None, None)
        self.__proxysockname = None
        self.__proxypeername = None

    def __recvall(self, bytes):
        """__recvall(bytes) -> data
        Receive EXACTLY the number of bytes requested from the socket.
        Blocks until the required number of bytes have been received.
        """
        data = ""
        while len(data) < bytes:
            data = data + self.recv(bytes - len(data))
        return data

    def setproxy(self, proxytype=None, addr=None, port=None, rdns=True, username=None, password=None):
        """setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
        Sets the proxy to be used.
        proxytype -	The type of the proxy to be used. Three types
                are supported: PROXY_TYPE_SOCKS4 (including socks4a),
                PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
        addr -		The address of the server (IP or DNS).
        port -		The port of the server. Defaults to 1080 for SOCKS
                servers and 8080 for HTTP proxy servers.
        rdns -		Should DNS queries be preformed on the remote side
                (rather than the local side). The default is True.
                Note: This has no effect with SOCKS4 servers.
        username -	Username to authenticate with to the server.
                The default is no authentication.
        password -	Password to authenticate with to the server.
                Only relevant when username is also provided.
        """
        self.__proxy = (proxytype, addr, port, rdns, username, password)

    def __negotiatesocks5(self, destaddr, destport):
        """__negotiatesocks5(self,destaddr,destport)
        Negotiates a connection through a SOCKS5 server.
        """
        # First we'll send the authentication packages we support.
        if (self.__proxy[4] != None) and (self.__proxy[5] != None):
            # The username/password details were supplied to the
            # setproxy method so we support the USERNAME/PASSWORD
            # authentication (in addition to the standard none).
            self.sendall("\x05\x02\x00\x02")
        else:
            # No username/password were entered, therefore we
            # only support connections with no authentication.
            self.sendall("\x05\x01\x00")
        # We'll receive the server's response to determine which
        # method was selected
        chosenauth = self.__recvall(2)
        if chosenauth[0] != "\x05":
            self.close()
            raise GeneralProxyError((1, _generalerrors[1]))
        # Check the chosen authentication method
        if chosenauth[1] == "\x00":
            # No authentication is required
            pass
        elif chosenauth[1] == "\x02":
            # Okay, we need to perform a basic username/password
            # authentication.
            self.sendall(
                "\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.proxy[5])) + self.__proxy[5])
            authstat = self.__recvall(2)
            if authstat[0] != "\x01":
                # Bad response
                self.close()
                raise GeneralProxyError((1, _generalerrors[1]))
            if authstat[1] != "\x00":
                # Authentication failed
                self.close()
                raise Socks5AuthError(((3, _socks5autherrors[3])))
        # Authentication succeeded
        else:
            # Reaching here is always bad
            self.close()
            if chosenauth[1] == "\xFF":
                raise Socks5AuthError((2, _socks5autherrors[2]))
            else:
                raise GeneralProxyError((1, _generalerrors[1]))
        # Now we can request the actual connection
        req = "\x05\x01\x00"
        # If the given destination address is an IP address, we'll
        # use the IPv4 address request even if remote resolving was specified.
        try:
            ipaddr = socket.inet_aton(destaddr)
            req = req + "\x01" + ipaddr
        except socket.error:
            # Well it's not an IP number,  so it's probably a DNS name.
            if self.__proxy[3] == True:
                # Resolve remotely
                ipaddr = None
                req = req + "\x03" + chr(len(destaddr)) + destaddr
            else:
                # Resolve locally
                ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
                req = req + "\x01" + ipaddr
        req = req + struct.pack(">H", destport)
        self.sendall(req)
        # Get the response
        resp = self.__recvall(4)
        if resp[0] != "\x05":
            self.close()
            raise GeneralProxyError((1, _generalerrors[1]))
        elif resp[1] != "\x00":
            # Connection failed
            self.close()
            if ord(resp[1]) <= 8:
                raise Socks5Error(ord(resp[1]), _generalerrors[ord(resp[1])])
            else:
                raise Socks5Error(9, _generalerrors[9])
        # Get the bound address/port
        elif resp[3] == "\x01":
            boundaddr = self.__recvall(4)
        elif resp[3] == "\x03":
            resp = resp + self.recv(1)
            boundaddr = self.__recvall(resp[4])
        else:
            self.close()
            raise GeneralProxyError((1, _generalerrors[1]))
        boundport = struct.unpack(">H", self.__recvall(2))[0]
        self.__proxysockname = (boundaddr, boundport)
        if ipaddr != None:
            self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
        else:
            self.__proxypeername = (destaddr, destport)

    def getproxysockname(self):
        """getsockname() -> address info
        Returns the bound IP address and port number at the proxy.
        """
        return self.__proxysockname

    def getproxypeername(self):
        """getproxypeername() -> address info
        Returns the IP and port number of the proxy.
        """
        return _orgsocket.getpeername(self)

    def getpeername(self):
        """getpeername() -> address info
        Returns the IP address and port number of the destination
        machine (note: getproxypeername returns the proxy)
        """
        return self.__proxypeername

    def __negotiatesocks4(self, destaddr, destport):
        """__negotiatesocks4(self,destaddr,destport)
        Negotiates a connection through a SOCKS4 server.
        """
        # Check if the destination address provided is an IP address
        rmtrslv = False
        try:
            ipaddr = socket.inet_aton(destaddr)
        except socket.error:
            # It's a DNS name. Check where it should be resolved.
            if self.__proxy[3] == True:
                ipaddr = "\x00\x00\x00\x01"
                rmtrslv = True
            else:
                ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
        # Construct the request packet
        req = "\x04\x01" + struct.pack(">H", destport) + ipaddr
        # The username parameter is considered userid for SOCKS4
        if self.__proxy[4] != None:
            req = req + self.__proxy[4]
        req = req + "\x00"
        # DNS name if remote resolving is required
        # NOTE: This is actually an extension to the SOCKS4 protocol
        # called SOCKS4A and may not be supported in all cases.
        if rmtrslv == True:
            req = req + destaddr + "\x00"
        self.sendall(req)
        # Get the response from the server
        resp = self.__recvall(8)
        if resp[0] != "\x00":
            # Bad data
            self.close()
            raise GeneralProxyError((1, _generalerrors[1]))
        if resp[1] != "\x5A":
            # Server returned an error
            self.close()
            if ord(resp[1]) in (91, 92, 93):
                self.close()
                raise Socks4Error((ord(resp[1]), _socks4errors[ord(resp[1]) - 90]))
            else:
                raise Socks4Error((94, _socks4errors[4]))
        # Get the bound address/port
        self.__proxysockname = (socket.inet_ntoa(resp[4:]), struct.unpack(">H", resp[2:4])[0])
        if rmtrslv != None:
            self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
        else:
            self.__proxypeername = (destaddr, destport)

    def __negotiatehttp(self, destaddr, destport):
        """__negotiatehttp(self,destaddr,destport)
        Negotiates a connection through an HTTP server.
        """
        # If we need to resolve locally, we do this now
        if self.__proxy[3] == False:
            addr = socket.gethostbyname(destaddr)
        else:
            addr = destaddr
        self.sendall("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n")
        # We read the response until we get the string "\r\n\r\n"
        resp = self.recv(1)
        while resp.find("\r\n\r\n") == -1:
            resp = resp + self.recv(1)
        # We just need the first line to check if the connection
        # was successful
        statusline = resp.splitlines()[0].split(" ", 2)
        if statusline[0] not in ("HTTP/1.0", "HTTP/1.1"):
            self.close()
            raise GeneralProxyError((1, _generalerrors[1]))
        try:
            statuscode = int(statusline[1])
        except ValueError:
            self.close()
            raise GeneralProxyError((1, _generalerrors[1]))
        if statuscode != 200:
            self.close()
            raise HTTPError((statuscode, statusline[2]))
        self.__proxysockname = ("0.0.0.0", 0)
        self.__proxypeername = (addr, destport)

    def connect(self, destpair):
        """connect(self,despair)
        Connects to the specified destination through a proxy.
        destpar - A tuple of the IP/DNS address and the port number.
        (identical to socket's connect).
        To select the proxy server use setproxy().
        """
        # Do a minimal input check first
        if (type(destpair) in (list, tuple) == False) or (len(destpair) < 2) or (type(destpair[0]) != str) or (
                type(destpair[1]) != int):
            raise GeneralProxyError((5, _generalerrors[5]))
        if self.__proxy[0] == PROXY_TYPE_SOCKS5:
            if self.__proxy[2] != None:
                portnum = self.__proxy[2]
            else:
                portnum = 1080
            _orgsocket.connect(self, (self.__proxy[1], portnum))
            self.__negotiatesocks5(destpair[0], destpair[1])
        elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
            if self.__proxy[2] != None:
                portnum = self.__proxy[2]
            else:
                portnum = 1080
            _orgsocket.connect(self, (self.__proxy[1], portnum))
            self.__negotiatesocks4(destpair[0], destpair[1])
        elif self.__proxy[0] == PROXY_TYPE_HTTP:
            if self.__proxy[2] != None:
                portnum = self.__proxy[2]
            else:
                portnum = 8080
            _orgsocket.connect(self, (self.__proxy[1], portnum))
            self.__negotiatehttp(destpair[0], destpair[1])
        elif self.__proxy[0] == None:
            _orgsocket.connect(self, (destpair[0], destpair[1]))
        else:
            raise GeneralProxyError((4, _generalerrors[4]))


if __name__ == "__main__":
    Bot()