sqlmapproject/sqlmap
1
1
Fork 0
mirror of https://github.com/sqlmapproject/sqlmap.git synced 2024-11-25 02:53:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

Replacing CRLF with LF in rest of files

Browse Source
This commit is contained in:
Miroslav Stampar 2012-12-26 17:12:17 +01:00
parent eea249c991
commit 8b7cbe03b0
14 changed files with 12282 additions and 12282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
plugins/dbms/db2/__init__.py
View File

@ -1,34 +1,34 @@
#!/usr/bin/env python #!/usr/bin/env python
""" """
Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/) Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission See the file 'doc/COPYING' for copying permission
""" """
from lib.core.enums import DBMS from lib.core.enums import DBMS
from lib.core.settings import DB2_SYSTEM_DBS from lib.core.settings import DB2_SYSTEM_DBS
from lib.core.unescaper import unescaper from lib.core.unescaper import unescaper
from plugins.dbms.db2.enumeration import Enumeration from plugins.dbms.db2.enumeration import Enumeration
from plugins.dbms.db2.filesystem import Filesystem from plugins.dbms.db2.filesystem import Filesystem
from plugins.dbms.db2.fingerprint import Fingerprint from plugins.dbms.db2.fingerprint import Fingerprint
from plugins.dbms.db2.syntax import Syntax from plugins.dbms.db2.syntax import Syntax
from plugins.dbms.db2.takeover import Takeover from plugins.dbms.db2.takeover import Takeover
from plugins.generic.misc import Miscellaneous from plugins.generic.misc import Miscellaneous
class DB2Map(Syntax, Fingerprint, Enumeration, Filesystem, Miscellaneous, Takeover): class DB2Map(Syntax, Fingerprint, Enumeration, Filesystem, Miscellaneous, Takeover):
""" """
This class defines DB2 methods This class defines DB2 methods
""" """
def __init__(self): def __init__(self):
self.excludeDbsList = DB2_SYSTEM_DBS self.excludeDbsList = DB2_SYSTEM_DBS
Syntax.__init__(self) Syntax.__init__(self)
Fingerprint.__init__(self) Fingerprint.__init__(self)
Enumeration.__init__(self) Enumeration.__init__(self)
Filesystem.__init__(self) Filesystem.__init__(self)
Miscellaneous.__init__(self) Miscellaneous.__init__(self)
Takeover.__init__(self) Takeover.__init__(self)
unescaper[DBMS.DB2] = Syntax.unescape unescaper[DBMS.DB2] = Syntax.unescape

38
plugins/dbms/db2/enumeration.py
View File

@ -1,20 +1,20 @@
#!/usr/bin/env python #!/usr/bin/env python
""" """
Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/) Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission See the file 'doc/COPYING' for copying permission
""" """
from lib.core.data import logger from lib.core.data import logger
from plugins.generic.enumeration import Enumeration as GenericEnumeration from plugins.generic.enumeration import Enumeration as GenericEnumeration
class Enumeration(GenericEnumeration): class Enumeration(GenericEnumeration):
def __init__(self): def __init__(self):
GenericEnumeration.__init__(self) GenericEnumeration.__init__(self)
def getPasswordHashes(self): def getPasswordHashes(self):
warnMsg = "on DB2 it is not possible to list password hashes" warnMsg = "on DB2 it is not possible to list password hashes"
logger.warn(warnMsg) logger.warn(warnMsg)
return {} return {}

138
plugins/dbms/db2/syntax.py
View File

@ -1,69 +1,69 @@
#!/usr/bin/env python #!/usr/bin/env python
""" """
Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/) Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission See the file 'doc/COPYING' for copying permission
""" """
from lib.core.data import logger from lib.core.data import logger
from lib.core.exception import SqlmapSyntaxException from lib.core.exception import SqlmapSyntaxException
from plugins.generic.syntax import Syntax as GenericSyntax from plugins.generic.syntax import Syntax as GenericSyntax
class Syntax(GenericSyntax): class Syntax(GenericSyntax):
def __init__(self): def __init__(self):
GenericSyntax.__init__(self) GenericSyntax.__init__(self)
@staticmethod @staticmethod
def unescape(expression, quote=True): def unescape(expression, quote=True):
if quote: if quote:
while True: while True:
index = expression.find("'") index = expression.find("'")
if index == -1: if index == -1:
break break
firstIndex = index + 1 firstIndex = index + 1
index = expression[firstIndex:].find("'") index = expression[firstIndex:].find("'")
if index == -1: if index == -1:
raise SqlmapSyntaxException, "Unenclosed ' in '%s'" % expression raise SqlmapSyntaxException, "Unenclosed ' in '%s'" % expression
lastIndex = firstIndex + index lastIndex = firstIndex + index
old = "'%s'" % expression[firstIndex:lastIndex] old = "'%s'" % expression[firstIndex:lastIndex]
unescaped = "" unescaped = ""
for i in xrange(firstIndex, lastIndex): for i in xrange(firstIndex, lastIndex):
unescaped += "CHR(%d)" % (ord(expression[i])) unescaped += "CHR(%d)" % (ord(expression[i]))
if i < lastIndex - 1: if i < lastIndex - 1:
unescaped += "||" unescaped += "||"
expression = expression.replace(old, unescaped) expression = expression.replace(old, unescaped)
else: else:
expression = "||".join("CHR(%d)" % ord(c) for c in expression) expression = "||".join("CHR(%d)" % ord(c) for c in expression)
return expression return expression
@staticmethod @staticmethod
def escape(expression): def escape(expression):
logMsg = "escaping %s" % expression logMsg = "escaping %s" % expression
logger.info(logMsg) logger.info(logMsg)
while True: while True:
index = expression.find("CHR(") index = expression.find("CHR(")
if index == -1: if index == -1:
break break
firstIndex = index firstIndex = index
index = expression[firstIndex:].find(")") index = expression[firstIndex:].find(")")
if index == -1: if index == -1:
raise SqlmapSyntaxException, "Unenclosed ) in '%s'" % expression raise SqlmapSyntaxException, "Unenclosed ) in '%s'" % expression
lastIndex = firstIndex + index + 1 lastIndex = firstIndex + index + 1
old = expression[firstIndex:lastIndex] old = expression[firstIndex:lastIndex]
oldUpper = old.upper() oldUpper = old.upper()
oldUpper = oldUpper.lstrip("CHR(").rstrip(")") oldUpper = oldUpper.lstrip("CHR(").rstrip(")")
oldUpper = oldUpper.split("||") oldUpper = oldUpper.split("||")
escaped = "'%s'" % "".join(chr(int(char)) for char in oldUpper) escaped = "'%s'" % "".join(chr(int(char)) for char in oldUpper)
expression = expression.replace(old, escaped) expression = expression.replace(old, escaped)
return expression return expression

112
tamper/halfversionedmorekeywords.py
View File

@ -1,56 +1,56 @@
#!/usr/bin/env python #!/usr/bin/env python
""" """
Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/) Copyright (c) 2006-2012 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission See the file 'doc/COPYING' for copying permission
""" """
import os import os
import re import re
from lib.core.common import singleTimeWarnMessage from lib.core.common import singleTimeWarnMessage
from lib.core.data import kb from lib.core.data import kb
from lib.core.enums import DBMS from lib.core.enums import DBMS
from lib.core.enums import PRIORITY from lib.core.enums import PRIORITY
from lib.core.settings import IGNORE_SPACE_AFFECTED_KEYWORDS from lib.core.settings import IGNORE_SPACE_AFFECTED_KEYWORDS
__priority__ = PRIORITY.HIGHER __priority__ = PRIORITY.HIGHER
def dependencies(): def dependencies():
singleTimeWarnMessage("tamper script '%s' is only meant to be run against %s < 5.1" % (os.path.basename(__file__).split(".")[0], DBMS.MYSQL)) singleTimeWarnMessage("tamper script '%s' is only meant to be run against %s < 5.1" % (os.path.basename(__file__).split(".")[0], DBMS.MYSQL))
def tamper(payload, **kwargs): def tamper(payload, **kwargs):
""" """
Adds versioned MySQL comment before each keyword Adds versioned MySQL comment before each keyword
Example: Example:
* Input: value' UNION ALL SELECT CONCAT(CHAR(58,107,112,113,58),IFNULL(CAST(CURRENT_USER() AS CHAR),CHAR(32)),CHAR(58,97,110,121,58)), NULL, NULL# AND 'QDWa'='QDWa * Input: value' UNION ALL SELECT CONCAT(CHAR(58,107,112,113,58),IFNULL(CAST(CURRENT_USER() AS CHAR),CHAR(32)),CHAR(58,97,110,121,58)), NULL, NULL# AND 'QDWa'='QDWa
* Output: value'/*!0UNION/*!0ALL/*!0SELECT/*!0CONCAT(/*!0CHAR(58,107,112,113,58),/*!0IFNULL(CAST(/*!0CURRENT_USER()/*!0AS/*!0CHAR),/*!0CHAR(32)),/*!0CHAR(58,97,110,121,58)), NULL, NULL#/*!0AND 'QDWa'='QDWa * Output: value'/*!0UNION/*!0ALL/*!0SELECT/*!0CONCAT(/*!0CHAR(58,107,112,113,58),/*!0IFNULL(CAST(/*!0CURRENT_USER()/*!0AS/*!0CHAR),/*!0CHAR(32)),/*!0CHAR(58,97,110,121,58)), NULL, NULL#/*!0AND 'QDWa'='QDWa
Requirement: Requirement:
* MySQL < 5.1 * MySQL < 5.1
Tested against: Tested against:
* MySQL 4.0.18, 5.0.22 * MySQL 4.0.18, 5.0.22
Notes: Notes:
* Useful to bypass several web application firewalls when the * Useful to bypass several web application firewalls when the
back-end database management system is MySQL back-end database management system is MySQL
* Used during the ModSecurity SQL injection challenge, * Used during the ModSecurity SQL injection challenge,
http://modsecurity.org/demo/challenge.html http://modsecurity.org/demo/challenge.html
""" """
def process(match): def process(match):
word = match.group('word') word = match.group('word')
if word.upper() in kb.keywords and word.upper() not in IGNORE_SPACE_AFFECTED_KEYWORDS: if word.upper() in kb.keywords and word.upper() not in IGNORE_SPACE_AFFECTED_KEYWORDS:
return match.group().replace(word, "/*!0%s" % word) return match.group().replace(word, "/*!0%s" % word)
else: else:
return match.group() return match.group()
retVal = payload retVal = payload
if payload: if payload:
retVal = re.sub(r"(?<=\W)(?P<word>[A-Za-z_]+)(?=\W|\Z)", lambda match: process(match), retVal) retVal = re.sub(r"(?<=\W)(?P<word>[A-Za-z_]+)(?=\W|\Z)", lambda match: process(match), retVal)
retVal = retVal.replace(" /*!0", "/*!0") retVal = retVal.replace(" /*!0", "/*!0")
return retVal return retVal

98
thirdparty/colorama/ansi.py vendored
View File

@ -1,49 +1,49 @@
''' '''
This module generates ANSI character codes to printing colors to terminals. This module generates ANSI character codes to printing colors to terminals.
See: http://en.wikipedia.org/wiki/ANSI_escape_code See: http://en.wikipedia.org/wiki/ANSI_escape_code
''' '''
CSI = '\033[' CSI = '\033['
def code_to_chars(code): def code_to_chars(code):
return CSI + str(code) + 'm' return CSI + str(code) + 'm'
class AnsiCodes(object): class AnsiCodes(object):
def __init__(self, codes): def __init__(self, codes):
for name in dir(codes): for name in dir(codes):
if not name.startswith('_'): if not name.startswith('_'):
value = getattr(codes, name) value = getattr(codes, name)
setattr(self, name, code_to_chars(value)) setattr(self, name, code_to_chars(value))
class AnsiFore: class AnsiFore:
BLACK = 30 BLACK = 30
RED = 31 RED = 31
GREEN = 32 GREEN = 32
YELLOW = 33 YELLOW = 33
BLUE = 34 BLUE = 34
MAGENTA = 35 MAGENTA = 35
CYAN = 36 CYAN = 36
WHITE = 37 WHITE = 37
RESET = 39 RESET = 39
class AnsiBack: class AnsiBack:
BLACK = 40 BLACK = 40
RED = 41 RED = 41
GREEN = 42 GREEN = 42
YELLOW = 43 YELLOW = 43
BLUE = 44 BLUE = 44
MAGENTA = 45 MAGENTA = 45
CYAN = 46 CYAN = 46
WHITE = 47 WHITE = 47
RESET = 49 RESET = 49
class AnsiStyle: class AnsiStyle:
BRIGHT = 1 BRIGHT = 1
DIM = 2 DIM = 2
NORMAL = 22 NORMAL = 22
RESET_ALL = 0 RESET_ALL = 0
Fore = AnsiCodes( AnsiFore ) Fore = AnsiCodes( AnsiFore )
Back = AnsiCodes( AnsiBack ) Back = AnsiCodes( AnsiBack )
Style = AnsiCodes( AnsiStyle ) Style = AnsiCodes( AnsiStyle )

378
thirdparty/colorama/ansitowin32.py vendored
View File

@ -1,189 +1,189 @@
import re import re
import sys import sys
from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style
from .winterm import WinTerm, WinColor, WinStyle from .winterm import WinTerm, WinColor, WinStyle
from .win32 import windll from .win32 import windll
if windll is not None: if windll is not None:
winterm = WinTerm() winterm = WinTerm()
def is_a_tty(stream): def is_a_tty(stream):
return hasattr(stream, 'isatty') and stream.isatty() return hasattr(stream, 'isatty') and stream.isatty()
class StreamWrapper(object): class StreamWrapper(object):
''' '''
Wraps a stream (such as stdout), acting as a transparent proxy for all Wraps a stream (such as stdout), acting as a transparent proxy for all
attribute access apart from method 'write()', which is delegated to our attribute access apart from method 'write()', which is delegated to our
Converter instance. Converter instance.
''' '''
def __init__(self, wrapped, converter): def __init__(self, wrapped, converter):
# double-underscore everything to prevent clashes with names of # double-underscore everything to prevent clashes with names of
# attributes on the wrapped stream object. # attributes on the wrapped stream object.
self.__wrapped = wrapped self.__wrapped = wrapped
self.__convertor = converter self.__convertor = converter
def __getattr__(self, name): def __getattr__(self, name):
return getattr(self.__wrapped, name) return getattr(self.__wrapped, name)
def write(self, text): def write(self, text):
self.__convertor.write(text) self.__convertor.write(text)
class AnsiToWin32(object): class AnsiToWin32(object):
''' '''
Implements a 'write()' method which, on Windows, will strip ANSI character Implements a 'write()' method which, on Windows, will strip ANSI character
sequences from the text, and if outputting to a tty, will convert them into sequences from the text, and if outputting to a tty, will convert them into
win32 function calls. win32 function calls.
''' '''
ANSI_RE = re.compile('\033\[((?:\d|;)*)([a-zA-Z])') ANSI_RE = re.compile('\033\[((?:\d|;)*)([a-zA-Z])')
def __init__(self, wrapped, convert=None, strip=None, autoreset=False): def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
# The wrapped stream (normally sys.stdout or sys.stderr) # The wrapped stream (normally sys.stdout or sys.stderr)
self.wrapped = wrapped self.wrapped = wrapped
# should we reset colors to defaults after every .write() # should we reset colors to defaults after every .write()
self.autoreset = autoreset self.autoreset = autoreset
# create the proxy wrapping our output stream # create the proxy wrapping our output stream
self.stream = StreamWrapper(wrapped, self) self.stream = StreamWrapper(wrapped, self)
on_windows = sys.platform.startswith('win') on_windows = sys.platform.startswith('win')
# should we strip ANSI sequences from our output? # should we strip ANSI sequences from our output?
if strip is None: if strip is None:
strip = on_windows strip = on_windows
self.strip = strip self.strip = strip
# should we should convert ANSI sequences into win32 calls? # should we should convert ANSI sequences into win32 calls?
if convert is None: if convert is None:
convert = on_windows and is_a_tty(wrapped) convert = on_windows and is_a_tty(wrapped)
self.convert = convert self.convert = convert
# dict of ansi codes to win32 functions and parameters # dict of ansi codes to win32 functions and parameters
self.win32_calls = self.get_win32_calls() self.win32_calls = self.get_win32_calls()
# are we wrapping stderr? # are we wrapping stderr?
self.on_stderr = self.wrapped is sys.stderr self.on_stderr = self.wrapped is sys.stderr
def should_wrap(self): def should_wrap(self):
''' '''
True if this class is actually needed. If false, then the output True if this class is actually needed. If false, then the output
stream will not be affected, nor will win32 calls be issued, so stream will not be affected, nor will win32 calls be issued, so
wrapping stdout is not actually required. This will generally be wrapping stdout is not actually required. This will generally be
False on non-Windows platforms, unless optional functionality like False on non-Windows platforms, unless optional functionality like
autoreset has been requested using kwargs to init() autoreset has been requested using kwargs to init()
''' '''
return self.convert or self.strip or self.autoreset return self.convert or self.strip or self.autoreset
def get_win32_calls(self): def get_win32_calls(self):
if self.convert and winterm: if self.convert and winterm:
return { return {
AnsiStyle.RESET_ALL: (winterm.reset_all, ), AnsiStyle.RESET_ALL: (winterm.reset_all, ),
AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT), AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL), AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL), AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
AnsiFore.BLACK: (winterm.fore, WinColor.BLACK), AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
AnsiFore.RED: (winterm.fore, WinColor.RED), AnsiFore.RED: (winterm.fore, WinColor.RED),
AnsiFore.GREEN: (winterm.fore, WinColor.GREEN), AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW), AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
AnsiFore.BLUE: (winterm.fore, WinColor.BLUE), AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA), AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
AnsiFore.CYAN: (winterm.fore, WinColor.CYAN), AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
AnsiFore.WHITE: (winterm.fore, WinColor.GREY), AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
AnsiFore.RESET: (winterm.fore, ), AnsiFore.RESET: (winterm.fore, ),
AnsiBack.BLACK: (winterm.back, WinColor.BLACK), AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
AnsiBack.RED: (winterm.back, WinColor.RED), AnsiBack.RED: (winterm.back, WinColor.RED),
AnsiBack.GREEN: (winterm.back, WinColor.GREEN), AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW), AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
AnsiBack.BLUE: (winterm.back, WinColor.BLUE), AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA), AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
AnsiBack.CYAN: (winterm.back, WinColor.CYAN), AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
AnsiBack.WHITE: (winterm.back, WinColor.GREY), AnsiBack.WHITE: (winterm.back, WinColor.GREY),
AnsiBack.RESET: (winterm.back, ), AnsiBack.RESET: (winterm.back, ),
} }
def write(self, text): def write(self, text):
if self.strip or self.convert: if self.strip or self.convert:
self.write_and_convert(text) self.write_and_convert(text)
else: else:
self.wrapped.write(text) self.wrapped.write(text)
self.wrapped.flush() self.wrapped.flush()
if self.autoreset: if self.autoreset:
self.reset_all() self.reset_all()
def reset_all(self): def reset_all(self):
if self.convert: if self.convert:
self.call_win32('m', (0,)) self.call_win32('m', (0,))
elif is_a_tty(self.wrapped): elif is_a_tty(self.wrapped):
self.wrapped.write(Style.RESET_ALL) self.wrapped.write(Style.RESET_ALL)
def write_and_convert(self, text): def write_and_convert(self, text):
''' '''
Write the given text to our wrapped stream, stripping any ANSI Write the given text to our wrapped stream, stripping any ANSI
sequences from the text, and optionally converting them into win32 sequences from the text, and optionally converting them into win32
calls. calls.
''' '''
cursor = 0 cursor = 0
for match in self.ANSI_RE.finditer(text): for match in self.ANSI_RE.finditer(text):
start, end = match.span() start, end = match.span()
self.write_plain_text(text, cursor, start) self.write_plain_text(text, cursor, start)
self.convert_ansi(*match.groups()) self.convert_ansi(*match.groups())
cursor = end cursor = end
self.write_plain_text(text, cursor, len(text)) self.write_plain_text(text, cursor, len(text))
def write_plain_text(self, text, start, end): def write_plain_text(self, text, start, end):
if start < end: if start < end:
self.wrapped.write(text[start:end]) self.wrapped.write(text[start:end])
self.wrapped.flush() self.wrapped.flush()
def convert_ansi(self, paramstring, command): def convert_ansi(self, paramstring, command):
if self.convert: if self.convert:
params = self.extract_params(paramstring) params = self.extract_params(paramstring)
self.call_win32(command, params) self.call_win32(command, params)
def extract_params(self, paramstring): def extract_params(self, paramstring):
def split(paramstring): def split(paramstring):
for p in paramstring.split(';'): for p in paramstring.split(';'):
if p != '': if p != '':
yield int(p) yield int(p)
return tuple(split(paramstring)) return tuple(split(paramstring))
def call_win32(self, command, params): def call_win32(self, command, params):
if params == []: if params == []:
params = [0] params = [0]
if command == 'm': if command == 'm':
for param in params: for param in params:
if param in self.win32_calls: if param in self.win32_calls:
func_args = self.win32_calls[param] func_args = self.win32_calls[param]
func = func_args[0] func = func_args[0]
args = func_args[1:] args = func_args[1:]
kwargs = dict(on_stderr=self.on_stderr) kwargs = dict(on_stderr=self.on_stderr)
func(*args, **kwargs) func(*args, **kwargs)
elif command in ('H', 'f'): # set cursor position elif command in ('H', 'f'): # set cursor position
func = winterm.set_cursor_position func = winterm.set_cursor_position
func(params, on_stderr=self.on_stderr) func(params, on_stderr=self.on_stderr)
elif command in ('J'): elif command in ('J'):
func = winterm.erase_data func = winterm.erase_data
func(params, on_stderr=self.on_stderr) func(params, on_stderr=self.on_stderr)
elif command == 'A': elif command == 'A':
if params == () or params == None: if params == () or params == None:
num_rows = 1 num_rows = 1
else: else:
num_rows = params[0] num_rows = params[0]
func = winterm.cursor_up func = winterm.cursor_up
func(num_rows, on_stderr=self.on_stderr) func(num_rows, on_stderr=self.on_stderr)

110
thirdparty/colorama/initialise.py vendored
View File

@ -1,55 +1,55 @@
import atexit import atexit
import sys import sys
from .ansitowin32 import AnsiToWin32 from .ansitowin32 import AnsiToWin32
orig_stdout = sys.stdout orig_stdout = sys.stdout
orig_stderr = sys.stderr orig_stderr = sys.stderr
wrapped_stdout = sys.stdout wrapped_stdout = sys.stdout
wrapped_stderr = sys.stderr wrapped_stderr = sys.stderr
atexit_done = False atexit_done = False
def reset_all(): def reset_all():
AnsiToWin32(orig_stdout).reset_all() AnsiToWin32(orig_stdout).reset_all()
def init(autoreset=False, convert=None, strip=None, wrap=True): def init(autoreset=False, convert=None, strip=None, wrap=True):
if not wrap and any([autoreset, convert, strip]): if not wrap and any([autoreset, convert, strip]):
raise ValueError('wrap=False conflicts with any other arg=True') raise ValueError('wrap=False conflicts with any other arg=True')
global wrapped_stdout, wrapped_stderr global wrapped_stdout, wrapped_stderr
sys.stdout = wrapped_stdout = \ sys.stdout = wrapped_stdout = \
wrap_stream(orig_stdout, convert, strip, autoreset, wrap) wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
sys.stderr = wrapped_stderr = \ sys.stderr = wrapped_stderr = \
wrap_stream(orig_stderr, convert, strip, autoreset, wrap) wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
global atexit_done global atexit_done
if not atexit_done: if not atexit_done:
atexit.register(reset_all) atexit.register(reset_all)
atexit_done = True atexit_done = True
def deinit(): def deinit():
sys.stdout = orig_stdout sys.stdout = orig_stdout
sys.stderr = orig_stderr sys.stderr = orig_stderr
def reinit(): def reinit():
sys.stdout = wrapped_stdout sys.stdout = wrapped_stdout
sys.stderr = wrapped_stdout sys.stderr = wrapped_stdout
def wrap_stream(stream, convert, strip, autoreset, wrap): def wrap_stream(stream, convert, strip, autoreset, wrap):
if wrap: if wrap:
wrapper = AnsiToWin32(stream, wrapper = AnsiToWin32(stream,
convert=convert, strip=strip, autoreset=autoreset) convert=convert, strip=strip, autoreset=autoreset)
if wrapper.should_wrap(): if wrapper.should_wrap():
stream = wrapper.stream stream = wrapper.stream
return stream return stream

218
thirdparty/colorama/win32.py vendored
View File

@ -1,109 +1,109 @@
# from winbase.h # from winbase.h
STDOUT = -11 STDOUT = -11
STDERR = -12 STDERR = -12
try: try:
from ctypes import windll from ctypes import windll
except ImportError: except ImportError:
windll = None windll = None
SetConsoleTextAttribute = lambda *_: None SetConsoleTextAttribute = lambda *_: None
else: else:
from ctypes import ( from ctypes import (
byref, Structure, c_char, c_short, c_uint32, c_ushort byref, Structure, c_char, c_short, c_uint32, c_ushort
) )
handles = { handles = {
STDOUT: windll.kernel32.GetStdHandle(STDOUT), STDOUT: windll.kernel32.GetStdHandle(STDOUT),
STDERR: windll.kernel32.GetStdHandle(STDERR), STDERR: windll.kernel32.GetStdHandle(STDERR),
} }
SHORT = c_short SHORT = c_short
WORD = c_ushort WORD = c_ushort
DWORD = c_uint32 DWORD = c_uint32
TCHAR = c_char TCHAR = c_char
class COORD(Structure): class COORD(Structure):
"""struct in wincon.h""" """struct in wincon.h"""
_fields_ = [ _fields_ = [
('X', SHORT), ('X', SHORT),
('Y', SHORT), ('Y', SHORT),
] ]
class SMALL_RECT(Structure): class SMALL_RECT(Structure):
"""struct in wincon.h.""" """struct in wincon.h."""
_fields_ = [ _fields_ = [
("Left", SHORT), ("Left", SHORT),
("Top", SHORT), ("Top", SHORT),
("Right", SHORT), ("Right", SHORT),
("Bottom", SHORT), ("Bottom", SHORT),
] ]
class CONSOLE_SCREEN_BUFFER_INFO(Structure): class CONSOLE_SCREEN_BUFFER_INFO(Structure):
"""struct in wincon.h.""" """struct in wincon.h."""
_fields_ = [ _fields_ = [
("dwSize", COORD), ("dwSize", COORD),
("dwCursorPosition", COORD), ("dwCursorPosition", COORD),
("wAttributes", WORD), ("wAttributes", WORD),
("srWindow", SMALL_RECT), ("srWindow", SMALL_RECT),
("dwMaximumWindowSize", COORD), ("dwMaximumWindowSize", COORD),
] ]
def __str__(self): def __str__(self):
return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % ( return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
self.dwSize.Y, self.dwSize.X self.dwSize.Y, self.dwSize.X
, self.dwCursorPosition.Y, self.dwCursorPosition.X , self.dwCursorPosition.Y, self.dwCursorPosition.X
, self.wAttributes , self.wAttributes
, self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
, self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
) )
def GetConsoleScreenBufferInfo(stream_id=STDOUT): def GetConsoleScreenBufferInfo(stream_id=STDOUT):
handle = handles[stream_id] handle = handles[stream_id]
csbi = CONSOLE_SCREEN_BUFFER_INFO() csbi = CONSOLE_SCREEN_BUFFER_INFO()
success = windll.kernel32.GetConsoleScreenBufferInfo( success = windll.kernel32.GetConsoleScreenBufferInfo(
handle, byref(csbi)) handle, byref(csbi))
return csbi return csbi
def SetConsoleTextAttribute(stream_id, attrs): def SetConsoleTextAttribute(stream_id, attrs):
handle = handles[stream_id] handle = handles[stream_id]
return windll.kernel32.SetConsoleTextAttribute(handle, attrs) return windll.kernel32.SetConsoleTextAttribute(handle, attrs)
def SetConsoleCursorPosition(stream_id, position): def SetConsoleCursorPosition(stream_id, position):
position = COORD(*position) position = COORD(*position)
# If the position is out of range, do nothing. # If the position is out of range, do nothing.
if position.Y <= 0 or position.X <= 0: if position.Y <= 0 or position.X <= 0:
return return
# Adjust for Windows' SetConsoleCursorPosition: # Adjust for Windows' SetConsoleCursorPosition:
# 1. being 0-based, while ANSI is 1-based. # 1. being 0-based, while ANSI is 1-based.
# 2. expecting (x,y), while ANSI uses (y,x). # 2. expecting (x,y), while ANSI uses (y,x).
adjusted_position = COORD(position.Y - 1, position.X - 1) adjusted_position = COORD(position.Y - 1, position.X - 1)
# Adjust for viewport's scroll position # Adjust for viewport's scroll position
sr = GetConsoleScreenBufferInfo(STDOUT).srWindow sr = GetConsoleScreenBufferInfo(STDOUT).srWindow
adjusted_position.Y += sr.Top adjusted_position.Y += sr.Top
adjusted_position.X += sr.Left adjusted_position.X += sr.Left
# Resume normal processing # Resume normal processing
handle = handles[stream_id] handle = handles[stream_id]
return windll.kernel32.SetConsoleCursorPosition(handle, adjusted_position) return windll.kernel32.SetConsoleCursorPosition(handle, adjusted_position)
def FillConsoleOutputCharacter(stream_id, char, length, start): def FillConsoleOutputCharacter(stream_id, char, length, start):
handle = handles[stream_id] handle = handles[stream_id]
char = TCHAR(char) char = TCHAR(char)
length = DWORD(length) length = DWORD(length)
num_written = DWORD(0) num_written = DWORD(0)
# Note that this is hard-coded for ANSI (vs wide) bytes. # Note that this is hard-coded for ANSI (vs wide) bytes.
success = windll.kernel32.FillConsoleOutputCharacterA( success = windll.kernel32.FillConsoleOutputCharacterA(
handle, char, length, start, byref(num_written)) handle, char, length, start, byref(num_written))
return num_written.value return num_written.value
def FillConsoleOutputAttribute(stream_id, attr, length, start): def FillConsoleOutputAttribute(stream_id, attr, length, start):
''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )''' ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
handle = handles[stream_id] handle = handles[stream_id]
attribute = WORD(attr) attribute = WORD(attr)
length = DWORD(length) length = DWORD(length)
num_written = DWORD(0) num_written = DWORD(0)
# Note that this is hard-coded for ANSI (vs wide) bytes. # Note that this is hard-coded for ANSI (vs wide) bytes.
return windll.kernel32.FillConsoleOutputAttribute( return windll.kernel32.FillConsoleOutputAttribute(
handle, attribute, length, start, byref(num_written)) handle, attribute, length, start, byref(num_written))

240
thirdparty/colorama/winterm.py vendored
View File

@ -1,120 +1,120 @@
from . import win32 from . import win32
# from wincon.h # from wincon.h
class WinColor(object): class WinColor(object):
BLACK = 0 BLACK = 0
BLUE = 1 BLUE = 1
GREEN = 2 GREEN = 2
CYAN = 3 CYAN = 3
RED = 4 RED = 4
MAGENTA = 5 MAGENTA = 5
YELLOW = 6 YELLOW = 6
GREY = 7 GREY = 7
# from wincon.h # from wincon.h
class WinStyle(object): class WinStyle(object):
NORMAL = 0x00 # dim text, dim background NORMAL = 0x00 # dim text, dim background
BRIGHT = 0x08 # bright text, dim background BRIGHT = 0x08 # bright text, dim background
class WinTerm(object): class WinTerm(object):
def __init__(self): def __init__(self):
self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
self.set_attrs(self._default) self.set_attrs(self._default)
self._default_fore = self._fore self._default_fore = self._fore
self._default_back = self._back self._default_back = self._back
self._default_style = self._style self._default_style = self._style
def get_attrs(self): def get_attrs(self):
return self._fore + self._back * 16 + self._style return self._fore + self._back * 16 + self._style
def set_attrs(self, value): def set_attrs(self, value):
self._fore = value & 7 self._fore = value & 7
self._back = (value >> 4) & 7 self._back = (value >> 4) & 7
self._style = value & WinStyle.BRIGHT self._style = value & WinStyle.BRIGHT
def reset_all(self, on_stderr=None): def reset_all(self, on_stderr=None):
self.set_attrs(self._default) self.set_attrs(self._default)
self.set_console(attrs=self._default) self.set_console(attrs=self._default)
def fore(self, fore=None, on_stderr=False): def fore(self, fore=None, on_stderr=False):
if fore is None: if fore is None:
fore = self._default_fore fore = self._default_fore
self._fore = fore self._fore = fore
self.set_console(on_stderr=on_stderr) self.set_console(on_stderr=on_stderr)
def back(self, back=None, on_stderr=False): def back(self, back=None, on_stderr=False):
if back is None: if back is None:
back = self._default_back back = self._default_back
self._back = back self._back = back
self.set_console(on_stderr=on_stderr) self.set_console(on_stderr=on_stderr)
def style(self, style=None, on_stderr=False): def style(self, style=None, on_stderr=False):
if style is None: if style is None:
style = self._default_style style = self._default_style
self._style = style self._style = style
self.set_console(on_stderr=on_stderr) self.set_console(on_stderr=on_stderr)
def set_console(self, attrs=None, on_stderr=False): def set_console(self, attrs=None, on_stderr=False):
if attrs is None: if attrs is None:
attrs = self.get_attrs() attrs = self.get_attrs()
handle = win32.STDOUT handle = win32.STDOUT
if on_stderr: if on_stderr:
handle = win32.STDERR handle = win32.STDERR
win32.SetConsoleTextAttribute(handle, attrs) win32.SetConsoleTextAttribute(handle, attrs)
def get_position(self, handle): def get_position(self, handle):
position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition
# Because Windows coordinates are 0-based, # Because Windows coordinates are 0-based,
# and win32.SetConsoleCursorPosition expects 1-based. # and win32.SetConsoleCursorPosition expects 1-based.
position.X += 1 position.X += 1
position.Y += 1 position.Y += 1
return position return position
def set_cursor_position(self, position=None, on_stderr=False): def set_cursor_position(self, position=None, on_stderr=False):
if position is None: if position is None:
#I'm not currently tracking the position, so there is no default. #I'm not currently tracking the position, so there is no default.
#position = self.get_position() #position = self.get_position()
return return
handle = win32.STDOUT handle = win32.STDOUT
if on_stderr: if on_stderr:
handle = win32.STDERR handle = win32.STDERR
win32.SetConsoleCursorPosition(handle, position) win32.SetConsoleCursorPosition(handle, position)
def cursor_up(self, num_rows=0, on_stderr=False): def cursor_up(self, num_rows=0, on_stderr=False):
if num_rows == 0: if num_rows == 0:
return return
handle = win32.STDOUT handle = win32.STDOUT
if on_stderr: if on_stderr:
handle = win32.STDERR handle = win32.STDERR
position = self.get_position(handle) position = self.get_position(handle)
adjusted_position = (position.Y - num_rows, position.X) adjusted_position = (position.Y - num_rows, position.X)
self.set_cursor_position(adjusted_position, on_stderr) self.set_cursor_position(adjusted_position, on_stderr)
def erase_data(self, mode=0, on_stderr=False): def erase_data(self, mode=0, on_stderr=False):
# 0 (or None) should clear from the cursor to the end of the screen. # 0 (or None) should clear from the cursor to the end of the screen.
# 1 should clear from the cursor to the beginning of the screen. # 1 should clear from the cursor to the beginning of the screen.
# 2 should clear the entire screen. (And maybe move cursor to (1,1)?) # 2 should clear the entire screen. (And maybe move cursor to (1,1)?)
# #
# At the moment, I only support mode 2. From looking at the API, it # At the moment, I only support mode 2. From looking at the API, it
# should be possible to calculate a different number of bytes to clear, # should be possible to calculate a different number of bytes to clear,
# and to do so relative to the cursor position. # and to do so relative to the cursor position.
if mode[0] not in (2,): if mode[0] not in (2,):
return return
handle = win32.STDOUT handle = win32.STDOUT
if on_stderr: if on_stderr:
handle = win32.STDERR handle = win32.STDERR
# here's where we'll home the cursor # here's where we'll home the cursor
coord_screen = win32.COORD(0,0) coord_screen = win32.COORD(0,0)
csbi = win32.GetConsoleScreenBufferInfo(handle) csbi = win32.GetConsoleScreenBufferInfo(handle)
# get the number of character cells in the current buffer # get the number of character cells in the current buffer
dw_con_size = csbi.dwSize.X * csbi.dwSize.Y dw_con_size = csbi.dwSize.X * csbi.dwSize.Y
# fill the entire screen with blanks # fill the entire screen with blanks
win32.FillConsoleOutputCharacter(handle, ord(' '), dw_con_size, coord_screen) win32.FillConsoleOutputCharacter(handle, ord(' '), dw_con_size, coord_screen)
# now set the buffer's attributes accordingly # now set the buffer's attributes accordingly
win32.FillConsoleOutputAttribute(handle, self.get_attrs(), dw_con_size, coord_screen ); win32.FillConsoleOutputAttribute(handle, self.get_attrs(), dw_con_size, coord_screen );
# put the cursor at (0, 0) # put the cursor at (0, 0)
win32.SetConsoleCursorPosition(handle, (coord_screen.X, coord_screen.Y)) win32.SetConsoleCursorPosition(handle, (coord_screen.X, coord_screen.Y))

44
thirdparty/socks/LICENSE vendored
View File

@ -1,22 +1,22 @@
Copyright 2006 Dan-Haim. All rights reserved. Copyright 2006 Dan-Haim. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met: are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this 1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer. list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, 2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution. and/or other materials provided with the distribution.
3. Neither the name of Dan Haim nor the names of his contributors may be used 3. Neither the name of Dan Haim nor the names of his contributors may be used
to endorse or promote products derived from this software without specific to endorse or promote products derived from this software without specific
prior written permission. prior written permission.
THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL DAN HAIM OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, EVENT SHALL DAN HAIM OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE. OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE.

5094
txt/common-columns.txt
View File

File diff suppressed because it is too large Load Diff

6736
txt/common-tables.txt
View File

File diff suppressed because it is too large Load Diff

7134
txt/smalldict.txt
View File

File diff suppressed because it is too large Load Diff

4156
txt/user-agents.txt
View File

File diff suppressed because it is too large Load Diff