#!/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())

# this example is based on the assumption that 
# eth0 is WAN interface and eth1 is LAN interface,
# 192.168.0.2 is the ip address of a computer in LAN,
# 4262 is the tcp port for ed2k network,
# 4272 is the udp port for kad network.
 
-A PREROUTING -i eth0 -p tcp -m tcp --dport 4262 -j DNAT --to-destination 192.168.0.2:4262
-A PREROUTING -i eth0 -p udp -m udp --dport 4272 -j DNAT --to-destination 192.168.0.2:4272
 
-A FORWARD -d 192.168.0.2/32 -i eth0 -o eth1 -p tcp --dport 4262 -j ACCEPT
-A FORWARD -d 192.168.0.2/32 -i eth0 -o eth1 -p udp --dport 4272 -j ACCEPT

# Configuration
$eth = "eth0";
 
# Script
Xchat::register("Sysinfo", "0.1", "System Information Displayer");
Xchat::print("Sysinfo 0.1 Loaded.");
Xchat::hook_command("uptime", "uptime");
Xchat::hook_command("os", "os");
Xchat::hook_command("bw", "bw");
Xchat::hook_command("cpu", "cpu");
Xchat::hook_command("mem", "mem");
 
sub uptime {
	$uptime = `cat /proc/uptime | awk '{printf \$1}'`;
	$_day = 60 * 60 * 24;
	$_hour = 60 * 60;
	$_minute = 60;
	$day = int($uptime/$_day);
	$uptime %= $_day;
	$hour = int($uptime/$_hour);
	$uptime %= $_hour;
	$minute = int($uptime/$_minute);
	$uptime %= $_minute;
	$second = int($uptime);
	$uptime = "";
	if($day != 0) {
		$uptime .= $day;
		if($day == 1) {
			$uptime .= " day ";
		} else {
			$uptime .= " days ";
		}
	}
	if($hour != 0) {
		$uptime .= $hour;
		if($hour == 1) {
			$uptime .= " hour ";
		} else {
			$uptime .= " hours ";
		}
	}
	if($minute != 0) {
		$uptime .= $minute;
		if($minute == 1) {
			$uptime .= " minute ";
		} else {
			$uptime .= " minutes ";
		}
	}
	$uptime .= $second;
	if($second == 1) {
		$uptime .= " second";
	} else {
		$uptime .= " seconds";
	}
	Xchat::command("SAY \002[UPTIME]\002 $uptime");
	Xchat::EAT_ALL;
}
 
sub os {
	$_kernel_release = `uname -r`;
	$_operating_system = `uname -o`;
	chomp($_kernel_release);
	chomp($_operating_system);
	$os = $_operating_system . " " . $_kernel_release;
	Xchat::command("SAY \002[OS]\002 $os");
	Xchat::EAT_ALL;
}
 
sub bw {
	$old = `cat /proc/net/dev | grep $eth | cut -d ":" -f 2 | tr -s " "| cut -d " " -f 1,9`;
	sleep(1);
	$new = `cat /proc/net/dev | grep $eth | cut -d ":" -f 2 | tr -s " "| cut -d " " -f 1,9`;
	@ary_old = split(/\s/, $old);
	@ary_new = split(/\s/, $new);
	$down = $ary_new[0] - $ary_old[0];
	$up = $ary_new[1] - $ary_old[1];
	$bw = "";
	if($down < 1000) {
		$bw .= $down . " B/s Down ";
	} else {
		$bw .= sprintf("%.02f", $down / 1000) . " KB/s Down ";
	}	
	if($up < 1000) {
		$bw .= $up . " B/s Up";
	} else {
		$bw .= sprintf("%.02f", $up / 1000) . " KB/s Up";
	}
	Xchat::command("SAY \002[BW]\002 $bw");
	Xchat::EAT_ALL;
}
 
sub cpu {
	$model_name = `cat /proc/cpuinfo | grep "model name" | tail -1 | cut -d ":" -f 2 | tr -s " "`;
	$number_cores = `cat /proc/cpuinfo | grep "model name" -c`;
	$freq = `cat /proc/cpuinfo | grep "cpu MHz" | tail -1 | cut -d ":" -f 2 | tr -s " "`;
	$idle = `vmstat | tail -1 | awk '{printf \$15}'`;
	$load = 100 - $idle;
	chomp($model_name);
	chomp($number_cores);
	chomp($freq);
	$cpuinfo = $number_cores . " CPU";
	if($number_cores > 1) {
		$cpuinfo .= "'s";
	}
	$cpuinfo .= " -" . $model_name;
	$cpuinfo .= " @ " . int($freq) . " MHz" . " (" . $load . "% Load)";
	Xchat::command("SAY \002[CPU]\002 $cpuinfo");
	Xchat:EAT_ALL;
}
 
sub mem {
	$mem_total = `free -m | grep Mem | awk '{printf \$2}'`;
	$mem_used = `free -m | grep - | awk '{printf \$3}'`;
	$swap_total = `free -m| grep Swap | awk '{printf \$2}'`;
	$swap_used = `free -m| grep Swap | awk '{printf \$3}'`;
	$meminfo = "\002[MEM]\002 " . $mem_used . "/" . $mem_total . " MB \002[SWAP]\002 " . $swap_used . "/" . $swap_total . " MB";
	Xchat::command("SAY $meminfo");
	Xchat::EAT_ALL;
}