Cameron Zemek - script

HTML Sanitizer

grom — Thu, 30 Oct 2008 08:27:06 +0000

#!/usr/bin/php
<?php
/**
 * Script for sanitizing HTML input to only allow what is in the whitelist.
 * Tested against majority of the hacks listed at http://ha.ckers.org/xss.html
 *
 * @author Cameron Zemek <grom@zeminvaders.net>
 * @license http://opensource.org/licenses/mit-license.php MIT License
 */
<!--break-->
/**
 * Callback handler for HtmlParser
 */
interface HtmlParserHandler {
    /**
     * Callback for open tag
     *
     * @param $tagName string Tag name
     * @param $attributes array Attributes as an associative array of name => value
     */
    public function openTag($tagName, $attributes);
 
    /**
     * Callback for close tag
     *
     * @param $tagName string Tag name
     */
    public function closeTag($tagName);
 
    /**
     * Callback for comment tags
     *
     * @param $comment string Comment
     */
    public function comment($comment);
 
    /**
     * Callback for text
     *
     * @param $text string Escaped text
     */
    public function text($text);
}
 
/**
 * Handles HTML special characters (ie. < & > ") thereby making it easier
 * for the filter to remove XSS attacks.
 */
class HtmlParser {
    /**
     * Parse HTML snippet
     *
     * @param $html string HTML snippet
     * @param $handler HtmlParserHandler Callback handler
     */
    public function parse($html, HtmlParserHandler $handler) {
        $this->input = $html;
        $this->pos = 0;
        $this->len = strlen($html);
        $this->handler = $handler;
 
        $text = '';
        while ($this->pos < $this->len) {
            $char = $this->look();
            if ($char === '<') {
                if ($this->lookMatches('<!')) {
                    // Handle HTML comment
                    $this->commentBlock();
                } else {
                    // Process tag
                    $this->fireText($text);
                    $text = '';
                    $this->tag();
                }
            } else {
                $text .= $this->char();
            }
        }
        if ($text !== '') {
            $this->fireText($text);
        }
    }
 
    protected function fireOpenTag($tagName, $attributes) {
        $this->handler->openTag($tagName, $attributes);
    }
 
    protected function fireCloseTag($tagName) {
        $this->handler->closeTag($tagName);
    }
 
    protected function fireComment($comment) {
        $this->handler->comment($comment);
    }
 
    protected function fireText($text) {
        if (strlen($text) == '') {
            return;
        }
        $this->handler->text($text);
    }
 
    /**
     * Parse HTML comment block
     */
    private function commentBlock() {
        $comment = '';
        $this->matches('<!');
        while ($this->look() !== '>' && $this->pos < $this->len) {
            if ($this->lookMatches('--')) {
                $comment .= $this->comment();
            } else {
                $this->matchAny(); // Ignore characters outside comment
            }
        }
        $this->match('>');
        $this->fireComment($comment);
    }
 
    /**
     * Parse HTML comment
     */
    private function comment() {
        $comment = '';
        $this->matches('--');
        while (!$this->lookMatches('--') && $this->pos < $this->len) {
            // Convert characters to stop comment hacks <!------><script>alert('xss')</script>-->
            $comment .= htmlspecialchars($this->matchAny());
        }
        $this->matches('--');
        return $comment;
    }
 
    /**
     * Parse HTML tag
     */
    private function tag() {
        $output = $this->match('<');
 
        // Check if close tag
        $closeTag = false;
        if ($this->look() === '/') {
            $closeTag = true;
            $output .= $this->match('/');
        }
 
        $tagName = strtolower($this->matchWord());
        if ($tagName === 'h' && $this->look() >= '1' && $this->look() <= '6') {
            $tagName .= $this->matchAny();
        }
        $output .= $tagName;
 
        // If not valid tag, escape output
        if (strlen($tagName) === 0) {
            $this->fireText(htmlspecialchars($output));
            return;
        }
 
        if ($closeTag) {
            if ($this->look() !== '>') {
                $this->fireText(htmlspecialchars($output));
                return;
            }
            $this->match('>');
            $this->fireCloseTag($tagName);
            return;
        }
 
        $ws = $this->matchWhitespace();
        if ($ws === '' && !($this->look() === '/' || $this->look() === '>')) {
            $this->fireText(htmlspecialchars($output));
            return;
        }
        $attributes = array();
        while (!$this->lookMatches('/>') && $this->look() !== '>' && $this->pos < $this->len) {
            $attribute = $this->attribute();
 
            // Invalid attribute, finish tag
            if ($attribute === null) {
                break;
            }
 
            list($attributeName, $attributeValue) = $attribute;
            $attributes[$attributeName] = $attributeValue;
            $this->matchWhitespace();
        }
        if ($this->look() === '/') {
            $closeTag = true;
            $this->match('/');
            $this->match('>');
        }
        if ($this->look() === '>') {
            $this->match('>');
        }
        $this->fireOpenTag($tagName, $attributes);
        if ($closeTag) {
            $this->fireCloseTag($tagName);
        }
    }
 
    /**
     * Parse attribute
     */
    private function attribute() {
        $attributeName = strtolower($this->matchHyphenWords());
        if (strlen($attributeName) === 0) {
            return null;
        }
        $this->matchWhitespace();
        if ($this->look() === '=') {
            $this->match('=');
            $this->matchWhitespace();
            $attributeValue = $this->attributeValue();
        } else {
            $attributeValue = null;
        }
        return array($attributeName, $attributeValue);
    }
 
    /**
     * Parse attribute value
     */
    private function attributeValue() {
        if ($this->look() === '"' || $this->look() === "'") {
            $quoteChar = $this->look();
            $this->match($quoteChar);
            $attributeValue = $this->matchUntil($quoteChar);
            $this->match($quoteChar);
        } else {
            $attributeValue = '';
            while (!ctype_space($this->look()) && $this->look() != '>' && $this->pos < $this->len) {
                $attributeValue .= $this->char();
            }
        }
        if (strlen($attributeValue) === 0) {
            return null;
        }
        return $attributeValue;
    }
 
    /**
     * Match character, handling special characters and character entities
     */
    private function char() {
        if ($this->look() === '&') {
            return $this->entity();
        } else {
            return htmlspecialchars($this->matchAny());
        }
    }
 
    /**
     * Parse HTML entity
     */
    private function entity() {
        if ($this->lookMatches('&#x')) {
            return $this->entityHex();
        } elseif ($this->lookMatches('&#')) {
            return $this->entityNumber();
        } else {
            return $this->entityName();
        }
    }
 
    /**
     * Parse HTML entity name
     */
    private function entityName() {
        $entity = $this->match('&') . $this->matchWord();
        if (strlen($entity) === 1) {
            // Invalid entity, escape &
            return htmlspecialchars($entity);
        }
        if ($this->look() === ';') {
            $entity .= $this->match(';');
        } else {
            $entity .= ';';
        }
        return $entity;
    }
 
    /**
     * Parse HTML entity in number format. Eg. &#169;
     */
    private function entityNumber() {
        $entity = $this->matches('&#');
        $entity .= $this->matchNumber();
        $len = strlen($entity);
        if ($len <= 2 || $len > 6) {
            // Invalid entity, escape &
            return htmlspecialchars($entity);
        }
        if ($this->look() === ';') {
            $entity .= $this->match(';');
        } else {
            $entity .= ';';
        }
        return $entity;
    }
 
    /**
     * Parse HTML entity in hex format. Eg. &#x6A;
     */
    private function entityHex() {
        $entity = $this->matches('&#x', true);
        $entity .= $this->matchHexNumber();
        $len = strlen($entity);
        if ($len <= 3 || $len > 7) {
            // Invalid entity, escape &
            return htmlspecialchars($entity);
        }
        if ($this->look() === ';') {
            $entity .= $this->match(';');
        } else {
            $entity .= ';';
        }
        return $entity;
    }
 
    private function look() {
        return $this->input[ $this->pos ];
    }
 
    private function lookMatches($str, $ignoreCase = true) {
        $input = substr($this->input, $this->pos, strlen($str));
        if ($ignoreCase) {
            $input = strtolower($input);
        }
        return $str === $input;
    }
 
    private function matchAny() {
        return $this->input[ $this->pos++ ];
    }
 
    private function match($char, $ignoreCase = false) {
        $input = $this->look();
        if ($ignoreCase) {
            $input = strtolower($input);
        }
        if ($input !== $char) {
            throw new Exception('Invalid match');
        }
        return $this->input[ $this->pos++ ];
    }
 
    private function matches($str, $ignoreCase = false) {
        $input = substr($this->input, $this->pos, strlen($str));
        if ($ignoreCase) {
            $input = strtolower($input);
        }
        if ($str !== $input) {
            throw new Exception('Invalid match');
        }
        $this->pos += strlen($str);
        return $str;
    }
 
    private function matchUntil($char) {
        $match = '';
        while ($this->look() !== $char && $this->pos < $this->len) {
            $match .= $this->char();
        }
        return $match;
    }
 
    private function matchHyphenWords() {
        $words = $this->matchWord();
        while ($this->look() === '-' && $this->pos < $this->len) {
            // Is there another character after the hypen?
            if ($this->pos + 1 >= $this->len) {
                break;
            }
            // Is next character after hypen part of a word?
            if (!ctype_alpha($this->input [ $this->pos + 1 ])) {
                break;
            }
            // There is another word, so match the hyphen and word
            $words .= $this->match('-') . $this->matchWord();
        }
        return $words;
    }
 
    private function matchWord() {
        $word = '';
        while (ctype_alpha($this->input[ $this->pos ]) && $this->pos < $this->len) {
            $word .= $this->input[ $this->pos++ ];
        }
        return $word;
    }
 
    private function matchNumber() {
        $num = '';
        while (ctype_digit($this->input[ $this->pos ]) && $this->pos < $this->len) {
            $num .= $this->input[ $this->pos++ ];
        }
        return $num;
    }
 
    private function matchHexNumber() {
        $num = '';
        while (ctype_xdigit($this->input[ $this->pos ]) && $this->pos < $this->len) {
            $num .= $this->input[ $this->pos++ ];
        }
        return $num;
    }
 
    private function matchWhitespace() {
        $ws = '';
        while (ctype_space($this->input[ $this->pos ]) && $this->pos < $this->len) {
            $ws .= $this->input[ $this->pos++ ];
        }
        return $ws;
    }
 
    private $pos; // Position in input
    private $len; // Length of input
    private $input;
    private $handler;
}
 
class HtmlFilter implements HtmlParserHandler {
    /**
     * Allowed tags
     */
    private $allowedTags = array('a', 'b', 'i', 'u', 'strong', 'em',
        'sub', 'sup', 'br', 'ul', 'ol', 'li', 'table', 'colgroup', 'col',
        'thead', 'tbody', 'tr', 'td', 'img');
 
    /**
     * Attributes that are allowed
     */
    private $allowedAttributes = array(
        'a' => array('href'),
        'col' => array('width'),
        'td' => array('rowspan', 'colspan', 'bgcolor', 'align'),
        'img' => array('src', 'width', 'height', 'alt')
    );
 
    /**
     * Tag stack is used to balance tags
     */
    private $tagStack = array();
 
    /**
     * Tags which should always be self-closing (eg. "<img />")
     */
    private $selfCloseTags = array('img', 'br', 'col');
 
    /**
     * Attributes which contain URLs
     */
    private $urlAttributes = array('src', 'href');
 
    /**
     * Protocols which are allowed
     */
    private $allowedProtocols = array('http');
 
    /**
     * Are URL paths allowed, that is no protocol scheme is specified. Eg. /images/photo.jpg
     */
    private $urlPathAllowed = true;
 
    /**
     * Should comments be removed?
     */
    private $stripComments = true;
 
    private $output = ''; // Safe HTML
 
    public function openTag($tagName, $attributes) {
        // Ignore tags that are not white listed
        if (!in_array($tagName, $this->allowedTags)) {
            return;
        }
        if (!in_array($tagName, $this->selfCloseTags)) {
            array_push($this->tagStack, $tagName);
        }
        $this->output .= '<' . $tagName;
        $allowedAttributes = $this->allowedAttributes[$tagName];
        if (isset($allowedAttributes) && is_array($allowedAttributes)) {
            foreach ($attributes as $name => $value) {
                if (in_array($name, $allowedAttributes)) {
                    // If its a protocol attribute, check if its an allowed protocol
                    if (in_array($name, $this->urlAttributes)) {
                        $urlComponents = parse_url($value);
                        if ((isset($urlComponents['scheme']) &&
                            in_array($urlComponents['scheme'], $this->allowedProtocols)) ||
                            (!isset($urlComponents['scheme']) && $this->urlPathAllowed)) {
                            $this->output .= ' ' . $name . '="' . $value . '"';
                        }
                    } else {
                        $this->output .= ' ' . $name . '="' . $value . '"';
                    }
                }
            }
        }
        if (in_array($tagName, $this->selfCloseTags)) {
            $this->output .= ' /';
        }
        $this->output .= '>';
    }
 
    public function closeTag($tagName) {
        if (!in_array($tagName, $this->tagStack)) {
            // Orphan close tag, ignore
            return;
        }
        while (true) {
            if (count($this->tagStack) === 0) {
                break;
            }
            $popTag = array_pop($this->tagStack);
            if ($popTag === $tagName) {
                break;
            }
            $this->output .= '</' . $popTag . '>';
        }
        $this->output .= '</' . $tagName . '>';
    }
 
    public function comment($comment) {
        if ($this->stripComments) {
            return;
        }
        $this->output .= '<!--' . $comment . '-->';
    }
 
    public function text($text) {
        $this->output .= $text;
    }
 
    private $parser;
 
    public function __construct() {
        $this->parser = new HtmlParser;
    }
 
    public function filter($html) {
        $this->parser->parse($html, $this);
        // Close any remaining tags on the stack
        while ($tagName = array_pop($this->tagStack)) {
            $this->output .= '</' . $tagName . '>';
        }
        return $this->output;
    }
}
 
$filename = $argv[1];
$contents = file_get_contents($filename);
 
$filter = new HtmlFilter;
$safeHTML = $filter->filter($contents);
 
// Compress html
//$safeHTML = preg_replace('/\s+/', ' ', $safeHTML);
 
echo $safeHTML . "\n";

Fix whitespace

grom — Thu, 17 Jul 2008 08:47:27 +0000

#!/bin/sh
EXTENSIONS="sh|txt|php|py|rb|css|js|html|xsl|xml|sql"
for file in `find -type f | grep -v "\.svn" | grep -E "($EXTENSIONS)$"`
do
    # Send the commands H and w to ed
    # ed will append newline if the file does not end in one
    printf "%s\n" H w | ed -s $file
 
    # Strip trailing whitespace
    sed -i 's/[ \t]*$//g' $file
 
    # Convert tabs to 4 spaces
    sed -i -r "s/\t/    /g" $file
done

Google Search Screen Scrapper

grom — Tue, 08 Apr 2008 23:21:55 +0000

#!/usr/bin/env python
import urllib2
from urllib import urlencode
from urlparse import urlparse
 
from BeautifulSoup import BeautifulSoup
 
def doGoogleSearch(query, limit=10):
    def _googleSearch(query, start, limit):
        urlParams = {'q' : query}
        if start > 0:
            urlParams['start'] = start
        url = "http://www.google.com.au/search?hl=en&" + urlencode(urlParams)
        request = urllib2.Request(url)
        # Google blocks queries based on User Agent. So pretend we are IE 7
        request.add_header('User-agent', 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT)')
        opener = urllib2.build_opener()
        htmlResults = opener.open(request).read()
        soup = BeautifulSoup(htmlResults)
        results = []
        howManyRemaining = limit - start
        for link in soup.findAll('a', {'class' : 'l'}):
            if len(results) == howManyRemaining:
                break
            results.append(link['href'])
        if soup.find('div', {'id' : 'nn'}):
            start = start + 10
            if start < limit:
                results.extend(_googleSearch(query, start, limit))
        return results    
    return _googleSearch(query, 0, limit)
 
def main():
	results = doGoogleSearch('a_search_term', 20)
	for rank, link in enumerate(results):
		host = urlparse(link)[1]
		if host.endswith('mydomain.com'):
			print str(rank) + ':' + link
 
if __name__ == '__main__':
	main()

HTML Tidy

grom — Tue, 08 Apr 2008 11:11:50 +0000

#!/usr/bin/env python
import sys
import getopt
 
def isHexDigit(c):
    return c.isdigit() or (c >= 'A' and c <= 'F') or (c >= 'a' and c <= 'f')
 
def isEntityStartCharacter(c):
    return c.isalpha() or c == '_' or c == ':'
 
def isEntityCharacter(c):
    return isEntityStartCharacter(c) or c.isdigit() or c == '.' or c == '-'
 
class ParseError(Exception):
    def __init__(self, msg):
        Exception.__init__(self, msg)
 
class TidyHtml:
    def init(self, html):
        self.input = html
        self.pos = 0
        self.tagStack = []
        self.beginText = False # Indicates at beginning of text node
        self.lineNo = 1
        self.columnNo = 1
        self.firstLine = True
 
    def output(self, str):
        """Write to the output."""
        sys.stdout.write(str)
 
    def getInputCharacter(self):
        """Get the next character from the input."""
        if self.pos >= len(self.input):
            return '\n'
        char = self.input[self.pos]
        self.pos += 1
        self.columnNo += 1
        if char == '\n':
            self.lineNo += 1
            self.columnNo = 1
        return char
 
    def previous(self):
        return self.input[self.pos - 1]
 
    def look(self):
        """Look ahead in the input."""
        if self.pos >= len(self.input):
            return False
        return self.input[self.pos]
 
    def lookMatches(self, match):
        if not self.look():
            return False
        return self.input[self.pos:self.pos + len(match)] == match
 
    def getEntity(self):
        html = []
        html += self.getCharacter('&')
        if self.lookMatches("#x"):
            html += self.getCharacter('#')
            html += self.getCharacter('x')
            i = 0
            while self.look() and self.look() != ';' and i < 4 and isHexDigit(self.look()):
                html += self.getInputCharacter()
                i += 1
            if self.look() != ';' and isHexDigit(self.previous()):
                html += ';';
                return ''.join(html)
        elif self.look() == '#':
            html += self.getCharacter('#');
            i = 0
            while self.look() and self.look() != ';' and i < 4 and self.look().isdigit():
                html += self.getInputCharacter()
                i += 1
            if self.look() != ';' and self.previous().isdigit():
                html += ';'
                return ''.join(html)
        elif isEntityStartCharacter(self.look()):
            while self.look() and self.look() != ';' and isEntityCharacter(self.look()):
                html += self.getInputCharacter()
 
        if self.look() == ';':
            html += self.getCharacter(';')
            return ''.join(html)
        else:
            return "&amp;" + ''.join(html[1:])
 
    def getCodeBlock(self):
        """Return code block."""
        code = []
        code += self.getCharacter('<') + self.getCharacter('?')
        while self.look() and not (self.previous() == '?' and self.look() == '>'):
            if self.look() == '"' or self.look() == "'":
                quoteChar = self.look()
                code += self.getCharacter(quoteChar)
                while self.look() and not (self.previous() != '\\' and self.look() == quoteChar):
                    code += self.getInputCharacter()
                code += self.getCharacter(quoteChar)
            else:
                code += self.getInputCharacter()
        code += self.getCharacter('>')
        return ''.join(code)
 
    def getScriptBlock(self):
        """Return script block."""
        code = []
        while self.look() and not self.lookMatches("</"):
            if self.look() == '"' or self.look() == "'":
                quoteChar = self.look()
                code += self.getCharacter(quoteChar)
                while self.look() and not (self.previous() != '\\' and self.look() == quoteChar):
                    code += self.getInputCharacter()
                code += self.getCharacter(quoteChar)
            else:
                code += self.getInputCharacter()
        return ''.join(code)
 
    def codeBlock(self):
        self.output(self.getCodeBlock())
 
    def scriptBlock(self):
        self.output(self.getScriptBlock())
 
    def getCharacter(self, match=None):
        if match:
            if self.look() == match:
                return self.getInputCharacter()
            else:
                self.notfound(match)
        elif self.lookMatches('<?'):
            return self.getCodeBlock()
        elif self.look() == '&':
            return self.getEntity()
        else:
            char = self.getInputCharacter()
            if char == '"':
                return '&quot;'
            else:
                return char
 
    def _location(self):
        return "on line " + str(self.lineNo) + " at column " + str(self.columnNo)
 
    def notfound(self, char):
        raise ParseError("Error " + self._location() + ": expecting " + char)
 
    def ignore(self, char):
        """Ignore a character."""
        if self.look() == char:
            self.getInputCharacter()
        else:
            self.notfound(char)
 
    def matchAny(self):
        """Match any character."""
        self.output(self.getCharacter())
 
    def match(self, char):
        """Match a character."""
        if self.look() == char:
            self.output(self.getInputCharacter())
        else:
            self.notfound(char)
 
    def skipWhitespace(self):
        """skip whitespace characters"""
        while self.look() and self.look().isspace():
            self.getInputCharacter()
 
    def indent(self):
        spacesPerIndent = 2
        indent = len(self.tagStack) * spacesPerIndent
        self.output(' ' * indent)
 
    def newline(self):
        if not self.firstLine:
            self.output('\n')
        else:
            self.firstLine = False
        self.indent()
 
    def attributeValue(self):
        attributeValue = []
        if self.look() == '"' or self.look() == "'":
            quoteChar = self.look()
            self.ignore(quoteChar)
            while self.look() and self.look() != quoteChar:
                attributeValue += self.getCharacter()
            self.ignore(quoteChar)
        else:
            while self.look() and not self.look().isspace() and self.look() != '>':
                attributeValue += self.getCharacter()
        return '"' + ''.join(attributeValue) + '"'
 
    def attribute(self):
        html = []
        attributeName = []
        while self.look() and not self.look().isspace() and self.look() != '=' and self.look() != '>':
            attributeName += self.getCharacter()
        attributeName = ''.join(attributeName)
        if attributeName[:2] != "<?": # Don't convert code blocks to lowercase
        	attributeName = attributeName.lower()
        if len(attributeName) == 0:
            return ''
        html += " " + attributeName
        self.skipWhitespace()
        if self.look() == '=':
            html += self.getCharacter('=')
            self.skipWhitespace()
            html += self.attributeValue()
        return ''.join(html)
 
    def tag(self):
        html = []
        html += self.getCharacter('<')
        self.skipWhitespace()
        tagName = []
        while self.look() and not self.look().isspace() and self.look() != '>':
            tagName += self.getCharacter()
        tagName = ''.join(tagName).lower()
        if len(tagName) == 0:
            raise ParseError('Expecting tag name ' + self._location())
        html += tagName
        self.skipWhitespace()
        while self.look() and self.look() != '>':
            html += self.attribute()
            self.skipWhitespace()
        html += self.getCharacter('>')
        isCloseTag = tagName[0] == '/'
        if isCloseTag:
            tagName = tagName[1:]
            if tagName in self.tagStack:
                while True:
                    if len(self.tagStack) == 0:
                        break
                    popTag = self.tagStack.pop()
                    if popTag == tagName:
                        break
                    # Insert missing closing tag
                    self.newline()
                    self.output("</" + popTag + ">")
                self.newline()
            else:
                return # Ignore closing tag
        else:
            self.newline()
            if tagName not in ['br', 'img', 'hr', 'col', 'link', 'input']:
                self.tagStack.append(tagName)
        self.output(''.join(html))
        if tagName == "script" and not isCloseTag:
            self.scriptBlock()
 
    def commentBlock(self):
        def comment():
            self.match('-')
            self.match('-')
            while self.look() and not self.lookMatches('--'):
                self.matchAny()
            self.match('-')
            self.match('-')
        self.match('<')
        self.match('!')
        while self.look() and self.look() != '>':
            if self.lookMatches('--'):
                comment()
            else:
                self.matchAny()
        self.match('>')
 
    def process(self, html):
        self.init(html)
        while self.look():
            if self.lookMatches('<?'):
                self.codeBlock()
            elif self.lookMatches('<!'):
                self.newline()
                self.commentBlock()
                self.beginText = True
            elif self.look() == '<':
                self.tag()
                self.beginText = True
            elif self.look().isspace():
                self.skipWhitespace()
            else:
                if self.beginText:
                    self.newline()
                    self.beginText = False
                elif self.previous().isspace():
                    self.output(' ')
                self.matchAny()
        # Close any remaining tags
        while True:
            if len(self.tagStack) == 0:
                break
            tagName = self.tagStack.pop()
            self.newline()
            self.output("</" + tagName + ">")
        self.output('\n')
 
    def processFile(self, fileName):
        f = open(fileName, 'r')
        html = f.read()
        f.close()
        self.process(html)
 
def usage():
    print "Usage: tidy.py [options] [file...]"
 
def version():
    print "Clean HTML v0.1\n" \
          "Copyright (c) 2008 by Cameron Zemek"
 
def main(argv):
    if len(argv) == 0:
        usage()
        sys.exit(1)
    try:
        opts, args = getopt.getopt(argv, "hv", ["help", "version"])
    except getopt.GetoptError:
        usage()
        sys.exit(1)
    for opt, optarg in opts:
        if opt in ("-h", "--help"):
            usage()
            sys.exit()
        elif opt in ("-v", "--version"):
            version()
            sys.exit()
    tidy = TidyHtml()
    try:
        for arg in args:
            tidy.processFile(arg)
    except ParseError, e:
        print '\n' + str(e)
        sys.exit(1)
 
if __name__ == '__main__':
    main(sys.argv[1:])