source: trollforge/dsp-trollforge/Library/Libflood.py @ 290 Tweet

from httplib import HTTP, HTTPConnection
from random import choice, randint
from re import compile, search
from string import lowercase
from urllib import urlencode

__version__ = '0.5'
defaultheaders = {
        'Accept': 'text/html',
        'User-Agent': 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; )'
}
_msglist = []
_proxylist = []

def gemail(domain = ''):
        """
        Generate a random email address.
        """

        if domain != '':
                return rndchars(2, 9) + '@' + domain

        else:
                email = rndchars(2, 9) + '@'
                if randint(1, 3) > 1:
                        email += 'www.'
                email += rndchars(2, 13) + choice(['.com', '.com', '.net', '.org'])
                return email

def get(url, returnptr = 0):
        """
        Make a single GET request to the given URL with the given parameters.

        If no second argument is given or if it evaluates to false then the
        content of the remote page is returned as a string.

        If the second argument evaluates to true then an HTTPConnection instance
        is returned from which the server's reply can be read (including HTTP
        headers). This HTTPConnection must be closed manually when finished with.
        """
        global defaultheaders

        # prepare HTTP vars
        proxy = choice(_proxylist)

        con = HTTPConnection(proxy[0], proxy[1])

        try:
                con.request('GET', url, '', defaultheaders)
        except:
                raise "GetError", "couldn't submit GET request"

        if returnptr:
                return con
        else:
                str = con.getresponse().read()
                con.close()
                return str

def getcookies(resp):
        """
        Given an HTTPResponse instance, returns a list of cookies.
        Each cookie is represented as a (name, value) tuple.

        If no cookies are set in the HTTPResponse, an empty list is returned.
        """

        cookies = { }

        headers = str(resp.msg)
        for header in headers.split('\n'):
                if header.find('Set-Cookie:') == 0:
                        cookie = header.split()[1][:-1].split('=')
                        cookies[cookie[0]] = cookie[1]

        return cookies

def getmsgs(msgfile):
        """
        Read a list of messages from a file; each message is separated by
        a '%' on its own line.

        (i.e., it's assumed the message file is in fortune(6) format.)
        """
        global _msglist

        i = 0

        try:
                f = open(msgfile, 'r')
        except:
                raise "OpenError", "couldn't open " + msgfile

        _msglist.append('')
        for s in f.readlines():
                if s == "%\n":
                        _msglist.append('')
                        i += 1
                else:
                        _msglist[i] += s
        f.close()

def gurl(scheme = 'http'):
        """
        Generate a random URL with the scheme 'http://'
        (or the given scheme, if applicable).
        """
        url = rndchars(5, 13) + choice(['.com', '.net', '.org'])
        if randint(1, 3) == 1:
                return scheme + '://' + url
        else:
                return scheme + '://www.' + url

def post(url, param, return_conn = 0):
        """
        Make a single POST request to the given URL with the given
        parameters.

        If requested, return an HTTPConnection instance from which the
        server's reply can be read (including HTTP headers). This
        HTTPConnection must be closed manually when finished with.
        """
        global defaultheaders
        global _proxylist

        param = urlencode(param)
        proxy = choice(_proxylist)

        # setup the POST headers and merge in defaults
        headers = {
                'Content-type': 'application/x-www-form-urlencoded',
        }
        headers.update(defaultheaders)

        con = HTTPConnection(proxy[0], proxy[1])

        try:
                con.request('POST', url, param, headers)
        except:
                raise "PostError", "couldn't submit POST request"

        # make sure we close the connection properly if we're aren't returning an
        # HTTP connection

        if return_conn:
                return con
        else:
                con.close()

def proxies(proxyfile):
        """
        Read a list of proxies from a file for libflood to use, one per
        line, attempting to ignore any extraneous data.
        """
        global _proxylist

        proxmatch = compile('(([0-9a-z]{1,14}\.){3,5}[0-9a-z]{1,14}):([0-9]{1,5})')

        try:
                f = open(proxyfile, 'r')
        except:
                raise "OpenError", "couldn't open " + proxyfile

        for s in f.readlines():
                r = search(proxmatch, s)
                if r == None:
                        continue
                else:
                        _proxylist.append((r.group(1), int(r.group(3))))

        f.close()

def randline(path, lines = 0):
        """
        Return a random line or a series of random lines from a file.

        If no second argument is specified,     returns a random line from
        the given file as a string.

        If an integer is given as a second argument is given then that
        many lines are returned in a list.
        """

        f = open(path)

        if lines:
                chosen = []
                s = f.readlines()
                for i in range(lines):
                        chosen.append(choice(s).strip())
        else:
                chosen = choice(f.readlines()).strip()

        f.close()
        return chosen

def rndchars(minlen, maxlen = 0):
        """
        Generate a string composed of random lowercase characters.
        """

        if maxlen == 0:
                len = range(minlen)
        else:
                len = range(randint(minlen, maxlen))

        return ''.join([choice(lowercase) for i in len])