阿福的空虛世界

if [ "$BASH" ]; then
  if [ -f ~/.bashrc ]; then
    . ~/.bashrc
  fi
fi

mesg n
#if [ -d "$HOME/env/bin" ] ; then
#    PATH="$HOME/env/bin:$PATH"
#fi

# -*- coding: utf-8 -*-
import os, sys
import urllib, urllib2, cookielib
from datetime import *
import time

"""
    Get nico video's link.
    Save cookie in a file, for repeating request API server.
"""
class Nico:
    def __init__(self, settings={}, cookieFile='nico_cookies.lwp'):
        self.cj = cookielib.LWPCookieJar()   # cookie
        self.sm = 0                          # video ID
        self.ck_file = cookieFile            # cookie file
        self.header =  {'User-agent' : 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'} # header
        if settings:
            self.login_data = settings       # account / pw
        else:
            self.login_data = {
                'mail' : 'your_account',
                'password' : 'your_password',
            }

        self.flapi_info = {}
        self.post_url = 'https://secure.nicovideo.jp/secure/login?site=niconico'  # login page url
        self.api_url = 'http://flapi.nicovideo.jp/api/getflv?v={0}'               # api url
        self.thumb_url = 'http://ext.nicovideo.jp/api/getthumbinfo/{0}'           # thumb url
        self.page_url = ''                                                        # video page url
        self.video_url = ''                                                       # video real link
        self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cj))
        self.domain = '.autocookie.tt.vv'                                         # define a doamin
        self.cookie_expires = 60*60*24*30  # save cookie in a month

        urllib2.install_opener(self.opener)

        ## if cookie file exist, load it
        if os.path.isfile(self.ck_file):
            self.cj.load(self.ck_file)
            if self.validate()==False:  ## after load cookie file, validate it.
                self.get_cookie()       ## invalid, get a new cookie.
        else:
            ## try to get a new cookie
            self.get_cookie()

    """
        if cookie files exists, validate cookies first!

        @return  : bool
    """
    def validate(self):
        try:
            _user = self.get_value('user', self.domain)
            if len(_user)==1 and _user[0]==self.login_data['mail']:
                return True
            else:
                ## custom cookie value not found / account not match, maybe changed.
                return False

        except Exception, e:
            print e
            return False          

    """
        Dump cookie's data.
    """
    def pr_cookie(self):
        for index, cookie in enumerate(self.cj):
            print index, '  :  ', cookie
            print '%s --> %s' % (cookie.name, cookie.value)

        for d in self.cj._cookies:
            print d

    """
        Get a cookie from nico.
    """
    def get_cookie(self):
        self.cj.clear()
        post = urllib.urlencode(self.login_data)
        req = urllib2.Request(self.post_url, post, self.header)
        resp = urllib2.urlopen(req)
        if resp.headers['x-niconico-authflag']=='1':
            print '== get cookie from NICO success =='
            self.add_custom_cookie("user", self.login_data['mail'])   # add a custom cookie
            self.cj.save(self.ck_file)

        elif resp.headers['x-niconico-authflag']=='0':
            print '== Error: Failed getting cookie. Check ID/PW is correct =='
            self.cj.save(self.ck_file)
            sys.exit()
        else:
            print '== Error: cookie format error. =='
            sys.exit()

    """
        get value from cookies.

        @name   : index
        @domain : if domain not set, it will find all cookies without domain

        @return : a list
    """
    def get_value(self, name, domain=''):
        ret = []
        a = 0
        if domain=='':
            for c in self.cj:
                if c.name == name:
                    ret.append(c.value)
        else:
            if len(self.cj._cookies[domain]).__class__ == a.__class__:
                if self.cj._cookies[domain]["/"][name].name == name:
                    ret.append(self.cj._cookies[domain]["/"][name].value)
            else:
                pass

        return ret

    """
        add a custom datas into cookie, for validate user account

        @name  : 
        @value : 
    """
    def add_custom_cookie(self, name, value):
        _expires = int(time.time()) + self.cookie_expires

        self.cj.set_cookie(
            cookielib.Cookie(
                version=0,
                name=name,
                value=value,
                port=None,
                port_specified=False,
                domain=self.domain,
                domain_specified=True,
                domain_initial_dot=False,
                path="/",
                path_specified=True,
                secure=False,
                expires=_expires,
                discard=False,
                comment=None,
                comment_url=None,
                rest={}
            )
        )

    """
        Start request / find the nico video original link.

        @param : post data
        @url   : the nico video's URL
    """
    def req(self, url='', param={}):
        try:
            self.sm = url.rsplit('/', 1)[1]   # get ID
            return self.reqSM(self.sm, param)

        except Exception, e:
            print '== Error: cannot parse video ID in link =='
            sys.exit()

    """
        If already have video ID, than get video link by ID.

        @param : post data
        @sm    : video ID
        @retry : if failed, retry again.
    """
    def reqSM(self, sm='0', param={}, retry=True):
        try:
            self.sm = sm
            self.page_url = "http://www.nicovideo.jp/watch/{0}".format(self.sm)
            
            url = self.api_url.format(self.sm)
            post = urllib.urlencode(param)
            resp = self.opener.open(url, post)
            data = resp.read()
            for i in data.split('&'):
                x = i.split('=')
                self.flapi_info[x[0]] = x[1]

            if 'url' in self.flapi_info:
                self.video_url = self.flapi_info['url']
            else:
                if retry:
                    self.get_cookie()                                   # get a newer cookie
                    self.video_url = self.reqSM(self.sm, param, False)  # req once again
                else:
                    self.video_url = ''

            self.video_url = urllib2.unquote(self.video_url.encode("utf8"))
            return self.video_url

        except Exception, e:
            print '== Error: cannot reverse the video url =='

    """
        Download video. 
            Before doing download, make sure "req()" or "reqSM()" first! 
    """
    def DLVideo(self, url=''):
        if url=='':
            print "Video URL is empty!"
            return False
        
        if self.page_url=='':
            print "Video page link not set. Please run req()/reqSM() first."
            return False
        
        try:
            from BeautifulSoup import BeautifulSoup as Soup
        except:
            print "'BeautifulSoup' libary not found."
            return False
        
        # get thumb info
        resp = self.opener.open(self.thumb_url.format(self.sm))
        data = resp.read()
        soup = Soup(data)
        file_ext = soup.find('movie_type').text
        
        
        # open original page first
        self.opener.open(self.page_url)

        file_name = "{0}.{1}".format(self.sm, file_ext)
        u = urllib2.urlopen(url)
        f = open(file_name, 'wb')
        meta = u.info()
        file_size = int(meta.getheaders("Content-Length")[0])
        print("Downloading: {0} Bytes: {1}".format(url, file_size))

        file_size_dl = 0
        block_sz = 1024
        while True:
            buffer = u.read(block_sz)
            if not buffer:
                break

            file_size_dl += len(buffer)
            f.write(buffer)
            p = float(file_size_dl) / file_size
            status = r"{0}  [{1:.2%}]".format(file_size_dl, p)
            status = status + chr(8)*(len(status))
            sys.stdout.write(status)

        f.close()
        print "Complete!  -->  {0}".format(file_name)
        return True
        
"""
    usage:  
        python nicoDLM.py sm123456 sm345678    .....
"""
if __name__ == "__main__":
    cookie_path = 'nico_cookies.lwp'  # cookie's location
    myset = {
        'mail' : '',
        'password': ''
    }
    
    #nico = Nico(cookieFile=cookie_path, settings=myset)
    #print nico.req('http://www.nicovideo.jp/watch/sm19186604')
    #print nico.reqSM('sm19154040')
    #nico.DLVideo( nico.reqSM('sm18684948') )
    
    num = len(sys.argv)
    if num==1:
        print "no input for download"
    else:
        nico = Nico(cookieFile=cookie_path, settings=myset)
        for i in xrange(1, num):
            nico.DLVideo( nico.reqSM(sys.argv[i]) )
    
    

#/bin/bash
# ./backup.sh -p /var/www/sc/ -t /tmp

function usage ()
{
    echo -e "** param error. **"
    echo -e "usage:"
    echo -e "\tbackup --path /var/www/kilfu --to /var/www/"
    echo -e "\tbackup -p /var/www/kilfu -t /var/www/\n"
    echo -e "param:"
    echo -e "\t-p | --path\t\tfolder's path."
    echo -e "\t-t | --to\t\tthe path where compress into."
    exit
}

function check_folder_exist ()
{
    if [ -d "$1" ]; then
        return 1
    else
        echo -e "[$2] folder not found!"
        exit
    fi
}

if [ $# -le 0 ]; then
    usage
fi

while [ "$1" != "" ]; do
    case $1 in
        -p | --path )           shift
                                _path=$1
                                ;;
        -t | --to )             shift
                                _to=$1
                                ;;
        -h | --help )           usage
                                exit
                                ;;
        * )                     usage
                                exit 1
    esac
    shift
done

if [ $_path == "" ]; then
    $_path
fi


check_folder_exist $_path "path"
check_folder_exist $_to "to"

TODAY=`date +%Y%m%d`
IFS="/"
export IFS;
for word in $_path; do
    if [ "$word" != "" ]; then
        fname="$word"
    fi
done

cd "$_to"
echo -e "Start compressing..."
echo -e "  compress folder:\t$_path"
echo -e "  destination:\t\t$_to"

tar zcvfP "${fname}_${TODAY}.tar" "$_path"

/bin/bash backup.sh -p /var/www/sc/ -t /tmp

#分 時 日 月 週
# backup sc
30 3 * * * /bin/bash /var/www/sc/backup.sh --path /var/www/sc --to /home/backup/

wget http://download.osgeo.org/geos/geos-3.3.0.tar.bz2
tar xjf geos-3.3.0.tar.bz2

cd geos-3.3.0
./configure
make
sudo make install

sudo ldconfig

from django.conf import settings
from django.shortcuts import render_to_response
from django.contrib.gis.maps.google.gmap import GoogleMap
from django.contrib.gis.maps.google.overlays import GMarker, GEvent

def google_map(request):
    points = [
        {'lat':'35.42',     'lng': '139.42', 'href':'http://en.wikipedia.org/wiki/Tokyo'},
        {'lat':'51.30',     'lng':   '0.73', 'href':'http://en.wikipedia.org/wiki/London'},
        {'lat':'40.43',     'lng': '-74.0',  'href':'http://en.wikipedia.org/wiki/New_York_City'},
        {'lat':'34.03',     'lng':'-118.15', 'href':'http://en.wikipedia.org/wiki/Los_Angeles'},
        {'lat':'36.774402', 'lng':'-119.755405', 'href':'http://en.wikipedia.org/wiki/Fresno'},]
    markers = []
    for point in points:
        marker = GMarker('POINT(%s %s)' % (point['lng'], point['lat']))
        event = GEvent('click', 'function() { location.href = "%s"}' % point['href'])
        marker.add_event(event)
        markers.append(marker)
    google = GoogleMap(center=(0,0), zoom=1, markers=markers,
                       key=settings.GOOGLE_MAPS_API_PASSWORD)
    return render_to_response('google_map.html',
                              {'google': google,})

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
{{ google.xhtml }}
<head>
  {{ google.style }}
  {{ google.scripts }}
</head>
<body onload="{{ google.js_module }}.map_load()" onunload="GUnload()">
  <div id="{{ google.dom_id }}" style="width:600px; height:400px;"></div>
</body>
</html>

INSTALLED_APPS = (
    ...
    'django.contrib.gis',
    ...
)

GEOS_LIBRARY_PATH = '/usr/local/lib/libgeos_c.so'
GOOGLE_MAPS_API_PASSWORD = 'asdasdasdasdasd'

       ┌----> VPN Server <-----┐
       |                       |
       | port:5063             | port:5063
       | udp(out)              | udp(out)
       A                       B

# clean all setting
iptables -F
iptables -t nat -F
iptables -t mangle -F
iptables -X

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# DNF port pre-routing
iptables -t nat -A PREROUTING -p udp --dport 5063 -i eth0 -j DNAT -s 0/0 --to 192.168.10.234
iptables -t nat -A PREROUTING -p udp --dport 5063 -i eth0 -j DNAT -s 0/0 --to 192.168.10.235
iptables -t nat -A PREROUTING -p udp --dport 5063 -i eth0 -j DNAT -s 192.168.10.234 --to 0.0.0.0-255.255.255.255
iptables -t nat -A PREROUTING -p udp --dport 5063 -i eth0 -j DNAT -s 192.168.10.235 --to 0.0.0.0-255.255.255.255

iptables -I FORWARD -p tcp --syn -i ppp+ -j TCPMSS --set-mss 1356
iptables -o eth0 -A FORWARD -p tcp --tcp-flags SYN,RST SYN -m tcpmss --mss 800:1536 -j TCPMSS --clamp-mss-to-pmtu

A傳給B:
       ┌----> VPN Server ------┐
       |                       |
       | port:5063             | port:5063
       | udp(out)              ↓ udp(in)
       A                       B

B傳給A:
       ┌----- VPN Server <-----┐
       |                       |
       | port:5063             | port:5063
       ↓ udp(in)               | udp(out)
       A                       B

apt-get update
apt-get upgrade
apt-get install pptpd

vim /etc/pptpd.conf

localip 192.168.0.234-238,192.168.0.245
remoteip 192.168.1.234-238,192.168.1.245

vim /etc/ppp/chap-secrets

# Secrets for authentication using CHAP
# client        server  secret                  IP addresses
fu              pptpd   passwordhere            *

vim /etc/sysctl.conf

net.ipv4.ip_forward=1

sysctl -p

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -o eth0 -A FORWARD -p tcp --tcp-flags SYN,RST SYN \
-m tcpmss --mss 800:1536 -j TCPMSS --clamp-mss-to-pmtu

chmod +x /etc/init.d/pptpd
/usr/sbin/update-rc.d -f pptpd defaults

vim /etc/iptables.sh

#!/bin/sh
IPT="/sbin/iptables"
$IPT -t nat -A POSTROUTING -o eth0 -j MASQUERADE
$IPT -o eth0 -A FORWARD -p tcp --tcp-flags SYN,RST SYN \
-m tcpmss --mss 800:1536 -j TCPMSS --clamp-mss-to-pmtu

chown root /etc/iptables.sh
chmod 700 /etc/iptables.sh

vim /etc/network/interfaces

pre-up /etc/iptables.sh