#!/usr/bin/env python
import binascii
import cgi
import hashlib
import hmac
import httplib
import os
import random
import sys
import time
import urllib
 
SERVER  = 'api.douban.com'
API_KEY = 'your api key'
SECRET  = 'your api secret'
 
OAUTH_SERVER            = 'www.douban.com'
REQUEST_TOKEN_URI       = '/service/auth/request_token'
AUTHORIZATION_URI       = '/service/auth/authorize'
ACCESS_TOKEN_URI        = '/service/auth/access_token'
SAYING_URI              = '/miniblog/saying'
 
SIG_METHOD              = 'HMAC-SHA1'
OAUTH_VER               = '1.0'
SCHEME                  = 'http'
 
ACCESS_TOKEN_FILE       = 'douban_access_token'
 
def escape(s):
        return urllib.quote(s, safe='~')
 
def generate_timestamp():
        return str(int(time.time()))
 
def generate_nonce(length=8):
        return ''.join([str(random.randint(0, 9)) for i in range(length)])
 
def normalize_params(params):
        key_values = [(escape(k), escape(v)) for k,v in params.items()]
        key_values.sort()
        return '&'.join(['%s=%s' % (k, v) for k, v in key_values])
 
def sign(method, url, params, secret, token_secret):
        sig = (
                        escape(method.upper()),
                        escape(SCHEME + '://' + url),
                        escape(normalize_params(params))
        )
        key = escape(secret) + '&'
        if url == OAUTH_SERVER + ACCESS_TOKEN_URI:
                #I have no idea why the fuck douban uses concatenated secrets as signature instead of the computed one
                return secret + '&' + token_secret
        if token_secret:
                key += escape(token_secret)
        base_string = '&'.join(sig)
        return binascii.b2a_base64(hmac.new(key, base_string, hashlib.sha1).digest())[:-1]
 
def generate_header(method, url, params, key, token):
        header = 'OAuth realm=""'
        params['oauth_version'] = OAUTH_VER
        signature = sign(method, url, params, key, token)
        params['oauth_signature'] = signature
        key_values = [(k, v) for k,v in params.items()]
        key_values.sort()
        for k, v in key_values:
                header += ', %s="%s"' % (k, escape(v))
        return {"Authorization": header}
 
def create_connection(server):
        return httplib.HTTPConnection(server)
 
def read_access_token_file():
        if os.access(ACCESS_TOKEN_FILE, os.F_OK):
                token_file = open(ACCESS_TOKEN_FILE, 'r')
                data = token_file.read()
                data = cgi.parse_qs(data, keep_blank_values=False)
                token = {}
                for k, v in data.iteritems():
                        token[k] = urllib.unquote(v[0])
                token_file.close()
                return token
        else:
                return {}
 
def write_access_token_file(data):
        if os.access('./', os.W_OK):
                token_file = open(ACCESS_TOKEN_FILE, 'w')
                token_file.write(data)
                token_file.close()
                print "Token file successfully updated"
        else:
                print "Cannot write to file, please confirm you have write permission"
 
class douban(object):
        def __init__(self):
                self.key = API_KEY
                self.secret = SECRET
                self.stored_token = read_access_token_file()
 
        def update_stored_token(self, data):
                data = cgi.parse_qs(data, keep_blank_values=False)
                for k, v in data.iteritems():
                        self.stored_token[k] = urllib.unquote(v[0])
 
        def get_request_token(self):
                conn = create_connection(OAUTH_SERVER)
                params = {
                                'oauth_consumer_key': self.key,
                                'oauth_signature_method': SIG_METHOD,
                                'oauth_timestamp': generate_timestamp(),
                                'oauth_nonce': generate_nonce()
                }
                header = generate_header('GET', OAUTH_SERVER + REQUEST_TOKEN_URI, params, self.secret, None)
                conn.request("GET", REQUEST_TOKEN_URI, headers=header)
                response = conn.getresponse()
                data = response.read()
                if response.status == 200:
                        self.update_stored_token(data)
                        self.authorize_token()
                else:
                        print "%s %s\n%s" % (response.status, response.reason, response.read())
                conn.close()
 
        def authorize_token(self):
                print "Open the link below to authorize the request token:"
                print "http://%s%s?oauth_token=%s" % (OAUTH_SERVER, AUTHORIZATION_URI, escape(self.stored_token['oauth_token']))
                raw_input("Press enter to continue")
                self.get_access_token()
 
        def get_access_token(self):
                conn = create_connection(OAUTH_SERVER)
                params = {
                                'oauth_consumer_key': self.key,
                                'oauth_token': self.stored_token['oauth_token'],
                                'oauth_sgnature_method': SIG_METHOD,
                                'oauth_timestamp': generate_timestamp(),
                                'oauth_nonce': generate_nonce()
                }
                header = generate_header("GET", OAUTH_SERVER + ACCESS_TOKEN_URI, params, self.secret, self.stored_token['oauth_token_secret'])
                conn.request("GET", ACCESS_TOKEN_URI, headers=header)
                response = conn.getresponse()
                if response.status == 200:
                        data = response.read()
                        write_access_token_file(data)
                else:
                        print "%s %s\n%s" % (response.status, response.reason, response.read())
 
        def first_run(self):
                if 'douban_user_id' in self.stored_token:
                        confirm = raw_input('token file exists arleady, overwrite? ([y]/n):')
                        if confirm.upper()[0] == 'N':
                                sys.exit(0)
                self.get_request_token()
 
        def add_saying(self, content):
                if 'douban_user_id' not in self.stored_token:
                        print 'Access token file does not exist'
                        return None
                entry = '<?xml version=\'1.0\' encoding=\'UTF-8\'?>'\
                        + '<entry xmlns:ns0="http://www.w3.org/2005/Atom" xmlns:db="http://www.douban.com/xmlns/">'\
                        + '<content>' + content + '</content>'\
                        + '</entry>'
                conn = create_connection(SERVER)
                params = {
                                'oauth_consumer_key': self.key,
                                'oauth_token': self.stored_token['oauth_token'],
                                'oauth_signature_method': SIG_METHOD,
                                'oauth_timestamp': generate_timestamp(),
                                'oauth_nonce': generate_nonce()
                }
                header = generate_header("POST", SERVER + SAYING_URI, params, self.secret, self.stored_token['oauth_token_secret'])
                header['Content-Type'] = 'application/atom+xml'
                conn.request("POST", SAYING_URI, entry, header)
                response = conn.getresponse()
                if response.status != 201:
                        print "%s %s\n%s" % (response.status, response.reason, response.read())

<?php
$link	=	trim($_POST['link']);
$to	=	$_POST['to'];
$from	=	null;
$out	=	'';
if($link != null) {
	$strAry	=	split('://', $link);
	$size	=	sizeof($strAry);
	if($size == 2) {
		$protocol = $strAry[0];
		if(strcasecmp($protocol, 'flashget') == 0) {
			$from = 'fg';
		} else if (strcasecmp($protocol, 'qqdl') == 0) {
			$from = 'qq';
		}  else if (strcasecmp($protocol, 'thunder') == 0) {
			$from = 'xl';
		}
		if ($from == null) {
			$out = 'this link is not in the correct format';
		} else if ($from == $to) {
			$out = 'no conversion needed you stupid fuck';
		} else {
			$real_link = '';
			$decoded_link = base64_decode($strAry[1]);
			if(!$decoded_link) {
				$out = 'this link is not in the correct format';
			} else {
				switch($from) {
					case 'fg':
						$real_link = str_replace('[FLASHGET]','',$decoded_link);
						break;
					case 'qq':
						$real_link = $decoded_link;
						break;
					case 'xl':
						$real_link = substr($decoded_link, 2, -2);
						break;
				}
				switch($to) {
					case 'fg':
						$out = 'flashget://'.base64_encode('[FLASHGET]'.$real_link.'[FLASHGET]');
						break;
					case 'qq':
						$out = 'qqdl://'.base64_encode($real_link);
						break;
					case 'xl':
						$out = 'thunder://'.base64_encode('AA'.$real_link.'ZZ');
						break;
					case 'no_encrypt':
						$out = iconv('GB18030','UTF-8',$real_link);
						break;
				}
			}
		}
	} else {
		$out = 'this link is not in the correct format';
	}
}
?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<html>
<head>
 
<meta http-equiv="Content-Type" content="text/html; charset="utf-8">
<link type="text/css" href="iframe.css" rel="stylesheet" />
<style type="text/css">
textarea {
  width: 100%;
  height: 4em;
}
</style>
 
</head>
<body>
<h2>Download Link Converter</h2>
<form action="" method="post">
	<label for="link">Paste the download link here (FlashGet, QQ Tornado, or Xunlei)</label>
	<textarea name="link"><?php echo $link; ?></textarea>
 
	<label for="to">
		Select the format you want to convert to:
	</label>
	&nbsp;
<select name="to">
		<option value="fg">FlashGet</option>
		<option value="qq">QQ Tornado</option>
		<option value="xl">Xunlei</option>
		<option value="no_encrypt">Unencrypted</option>
	</select>
 
	&nbsp;&nbsp;
	<button type="submit">Convert</button>
</form>
 
<textarea>
<?php echo $out; ?>
</textarea>
</body>
</html>

elif snode.nodeName == 'text':

elif (snode.nodeName == 'text') and (snode.childNodes[0].nodeValue[0] != '@'):