root/lang/ruby/chokan/trunk/plugins/uri_information.rb @ 283

require 'chokan/plugin_base'
require 'net/https'
require 'net/ftp'
require "cgi"
require "image_size"
require "digest/md5"

class UriInformation < Chokan::PluginBase
        MAX_REDIRECT = 10
        HEADER       = {
                "User-Agent" => "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.5) Gecko/20041107 Firefox/1.0",
                "Accept"     => "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",
        }

        def initialize(config, chokan)
                super
                @uri = /(#{URI.regexp(@config['accept_scheme']).to_s})/
        end

        def on_privmsg(prefix, channel, message)
                @channel = channel
                message.scan(@uri) do |uri|
                        begin
                                uri = uri[0]
                                uri = URI(uri)
                                mes = chaining_try(uri)
                                log mes
                                notice(channel, mes) if mes
                        rescue Exception => e
                                notice(channel, e.inspect)
                        end
                end
        end


        def chaining_try(uri)
                ret = nil
                @config['modules'].each do |mod|
                        begin
                                if mod.kind_of? Hash
                                        name = mod.keys[0]
                                        config = mod[name]
                                else
                                        name = mod
                                        config = {}
                                end
                                ret = send("handler_#{name}", config, uri)
                                break if ret
                        rescue Exception => e
                                log e
                                log name
                                log e.message
                                log *e.backtrace
                        end
                end
                ret
        end


        def handler_gigazine(config, uri)
                return unless uri.scheme =~ /^https?/
                require "bdb"
                c  = config.find {|h| h["channel"] == @channel }
                log c.inspect
                return unless c

                db = BDB::Hash.open(c["db"], nil, 0, 0644)
                db.each do |k,v|
                        _, url, datetime, = */^(.+?):(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d)$/.match(k)
                        if url == uri.to_s
                                notice(@channel, "GIGAZINE にものってるわ")
                                break
                        end
                end
                db.close
                nil # continue chain
        end


        def handler_mixi(config, uri)
                return unless uri.host == 'mixi.jp'
                cookie = {}
                login_uri = URI("http://mixi.jp/login.pl")
                Net::HTTP.start(login_uri.host, login_uri.port) do |http|
                        data = {
                                "next_url" => "/home.pl",
                                "email"    => config['user'],
                                "password" => config['pass'],
                                "sticky"   => ""
                        }
                        data = data.collect {|k,v| "#{k}=#{URI.escape(v)}" }.join("&")
                        res = http.post(login_uri.request_uri, data, HEADER)
                        if res.key?("set-cookie")
                                res["set-cookie"].split(/\s*,\s*/).each do |c|
                                        k, v =c.sub(/;.*/, "").split(/=/)
                                        cookie[k] = v
                                end
                                #http.get("/check.pl?n=/home.pl", {"User-Agent" => UA} )
                        else
                                raise LoginError, "Invalid e-mail or password"
                        end
                end

                http(uri, {
                        "Cookie" => cookie.collect {|c| c.join("=") }.join(";")
                })
        end
        
        def handler_http(config, uri)
                return unless uri.scheme =~ /^https?/
                http(uri)
        end

        def handler_urn(config, uri)
                return unless uri.scheme == 'urn'
                nid, *nss = uri.opaque.split(/:/)
                case nid
                when 'ietf'
                        subclass, *rest = nss
                        case subclass
                        when "rfc"
                                "http://www.ietf.org/rfc/rfc#{rest[0]}.txt"
                        end
                when 'isbn'
                        "http://www.amazon.co.jp/gp/product/#{nss[0]}/"
                end
        end

        def handler_ftp(config, uri)
                return unless uri.scheme == 'ftp'
                ftp = Net::FTP.open(uri.host, uri.user || "anonymous", uri.password || "foobar@example.com")
                begin
                        size = ftp.size(uri.path)
                        time = ftp.mtime(uri.path)
                        "[size: #{size} mtime:#{time}]"
                rescue Net::FTPPermError => e
                        e.message
                ensure
                        ftp.close
                end
        end

        def http(uri, header=HEADER, limit=MAX_REDIRECT)
                return "Redirect loop?: last:#{uri}" if limit <= 0

                log uri
                ret = ''
                http = Net::HTTP.new(uri.host, uri.port) 
                http.use_ssl = (uri.scheme == "https")
                http.start do |http|
                        r = http.head(uri.request_uri, header)
                        log r.code.inspect
                        case r.code
                        when '200'
                                case r["Content-Type"]
                                when /html/
                                        ret = html(http.get(uri.request_uri, header))
                                when /image/
                                        ret = image(http.get(uri.request_uri, header))
                                else
                                        if r["Content-Length"]
                                                size = r["Content-Length"].to_i / 1024
                                                ret = "[#{r["Content-Type"]}] #{size}KB"
                                        else
                                                ret = "[#{r["Content-Type"]}]"
                                        end
                                end
                        when '401'
                                realm = r["WWW-Authenticate"][/Basic realm="([^"]+)"/, 1]
                                auth  =  @config["http_auth"].find {|e| e["host"] == uri.host and e["realm"] == realm }
                                if auth
                                        auth = "Basic " + ["#{auth["user"]}:#{auth["pass"]}"].pack("m")
                                        ret = http(uri, header.update({'Authorization' => auth}), limit-1)
                                else
                                        ret = realm
                                end
                        when /^3/
                                loc = URI(r["Location"])
                                loc = uri + loc if loc.relative?
                                ret = http(loc, header, limit-1)
                        else
                                ret = "[#{r.code} #{r.message}]"
                        end
                end

        rescue Exception => e
                log e.message
                log *e.backtrace
                e.inspect
        end

        def image(res)
                size = res.body.length / 1024
                img = ImageSize.new(res.body)
                ret =  "#{img.get_type} Image, "
                ret << "#{img.get_width || "?"}x#{img.get_height || "?"} "
                ret << "#{size.to_i}KB"
        end

        def html(res)
                title = res.body[/<title.*?>(.*?)<\/title>/imn, 1]
                title = "タイトル無し " if !title || title.empty?
                title = title.gsub(/\s+/, " ").gsub(/<.*?>/, "").to_u8
                title.gsub!(/&#(x)?([0-9a-f]+);/i) do |m|
                        [$1 ? $2.hex : $2.to_i].pack("U")
                end
                if title.size > 70
                        title = title[/.{0,60}/] + "..."
                end
                
                title = title.gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")

                "#{title} [#{res["Content-Type"]}]"
        end
end