ClickSpotter 0.1.1

data/lib/DNSResolver.rb

@@ -0,0 +1,53 @@
+#
+# DNSResolver.rb - ClickSpotter
+#
+# Copyright (c) 2005, 2006 by Chris Schlaeger <cs@kde.org>
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# $Id: DNSResolver.rb 8 2006-01-22 15:19:51Z cs $
+#
+
+require 'socket'
+require 'thread'
+
+$dnsCache = "DNSResolverCache"
+
+class DNSRecord
+  attr_reader :host
+  attr_accessor :timeStamp
+
+  def initialize
+    @host = nil
+  end
+
+  def resolve(ip)
+    begin
+      a = Socket.gethostbyname(ip)
+      @host = Socket.gethostbyaddr(a[3], a[2])[0]
+    rescue
+      @host = ip
+    end
+    @timeStamp =  Time.now()
+  end
+
+end
+
+class DNSResolver < AsyncResolverWithCache
+
+  def initialize
+    super('DNSCache', $globals.getSetting('DNSTimeout') * 60 * 60 * 24, 5)
+    @enabled = $globals.getSetting('DNSResolver')
+  end
+
+  def newRecord
+    DNSRecord.new
+  end
+
+  def hostName(ip)
+    (rec = resolve(ip)) ? rec.host : ip
+  end
+
+end
+

data/lib/GSServerLogSettings.rb

@@ -0,0 +1,24 @@
+#
+# GSServerLogSettings.rb - ClickSpotter
+#
+# Copyright (c) 2005, 2006 by Chris Schlaeger <cs@kde.org>
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# $Id: GSServerLogSettings.rb 8 2006-01-22 15:19:51Z cs $
+#
+
+class GSServerLogSettings
+
+  attr_accessor :name, :logFile, :default, :hostNames
+
+  def initialize
+    @name = nil
+    @logFile = nil
+    @default = nil
+    @hostNames = []
+  end
+
+end
+

data/lib/GeoDistView.rb

@@ -0,0 +1,351 @@
+#
+# GeoDistView.rb - ClickSpotter
+#
+# Copyright (c) 2005, 2006 by Chris Schlaeger <cs@kde.org>
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# $Id: GeoDistView.rb 8 2006-01-22 15:19:51Z cs $
+#
+
+require 'GeoLocator'
+require 'BrowserLauncher'
+require 'Qt'
+require 'ClickableCanvasView'
+
+# This class shows the geographical distribution of visitors on a
+# world map and as numbers per country in a list.
+
+class GeoDistView < Qt::Object
+
+  include BrowserLauncher
+
+  slots 'routerListClicked(QListViewItem*)', 'popUpInfo()', 'mapClicked()'
+
+  attr_writer :showRouters, :showRoutes, :showIPs,
+              :showHostNames, :showCities, :showAll,
+              :showLast, :lastMinutes
+
+  # The mapFrame widget will hold the world map and the countryList will
+  # show the distribution by country.
+  def initialize(mapFrame, countryList = nil, routeList = nil, large = false)
+    super(nil)
+    @mapFrame = mapFrame
+    @countryList = countryList
+    @routeList = routeList
+
+    if @countryList
+      @countryListCSLV = CSListView.new(@countryList)
+      @countryList.setSorting(1, false)
+    end
+    if @routeList
+      @routeListCSLV = CSListView.new(@routeList)
+      @routeList.setSorting(0, true)
+
+      connect(@routeList, SIGNAL('clicked(QListViewItem*)'),
+          SLOT('routerListClicked(QListViewItem*)'))
+    end
+
+    # Canvas that shows the map and the location crosses
+    @canvas = Qt::Canvas.new
+    # The canvas view will be a child of the mapFrame widget
+    @mapFrame.setColumnLayout(0, Qt::Vertical)
+    @mapFrame.layout().setSpacing(6)
+    @mapFrame.layout().setMargin(11)
+    lm = Qt::GridLayout.new(mapFrame.layout)
+    # Create the CanvasView that shows the map canvas
+    @mapView = ClickableCanvasView.new(@canvas, @mapFrame)
+    lm.addWidget(@mapView, 0, 0)
+    # The world map is a background image of the canvas
+    pm = Qt::Pixmap.new(large ? AppConfig.dataFile('worldmap-large.jpg') :
+        AppConfig.dataFile('worldmap.png'))
+    if large
+      @mapView.setMaximumSize(pm.width + 2 * @mapView.frameWidth ,
+                              pm.height + 2 * @mapView.frameWidth)
+    else
+      @mapView.setFixedSize(pm.width + 2 * @mapView.frameWidth ,
+                            pm.height + 2 * @mapView.frameWidth)
+      @mapView.setVScrollBarMode(Qt::ScrollView.AlwaysOff)
+      @mapView.setHScrollBarMode(Qt::ScrollView.AlwaysOff)
+    end
+    connect(@mapView, SIGNAL('clicked()'), self, SLOT('mapClicked()'))
+
+    @canvas.resize(pm.width, pm.height)
+    @canvas.setBackgroundPixmap(pm)
+
+    @showAll = false
+    @showRoutes = false
+    @showRouters = false
+    @showIPs = false
+    @showHostNames = false
+    @showCities = false
+    @showLast = false
+    @lastMinutes = 1
+
+    @layer = 0
+
+    @highlightedVisitor = nil
+    @highlightedRouter = nil
+  end
+
+  # Update the map and the country distribution list.
+  def update(visitors)
+    # Remove all crosses from the map canvas
+    @canvas.allItems().each { |i| i.dispose }
+    @layer = 10
+
+    @highlightedVisitor = nil
+    @highlightedRouter = nil
+
+    # Determine a little square on the map the mouse cursor is over.
+    mouseRect = nil
+    pos = @mapView.mapFromGlobal(Qt::Cursor.new.pos);
+    if pos.x >= 0 && pos.y >= 0 &&
+       pos.x < @mapView.width && pos.y < @mapView.height
+       radius = 4
+       mouseRect = Qt::Rect.new(pos.x - radius, pos.y - radius,
+           2 * radius, 2 * radius)
+    end
+
+    # Count the number of visitors for each country.
+    countries = {}
+    showSurfers = $globals.getSetting('ShowSurfers') != 0
+    showRobots = $globals.getSetting('ShowRobots') != 0
+    deadline = Time.now - @lastMinutes * 60
+    visitors.each do |key, visitor|
+      if (!@showAll &&
+         ((visitor.robot != nil && !showRobots) ||
+          (visitor.robot == nil && !showSurfers))) ||
+         (@showLast && visitor.lastHit.timeStamp < deadline)
+        next
+      end
+      markRouteOnMap(visitor.ip, mouseRect)
+      updateRouterList(visitor.ip) if @routeList
+      geoloc = $geoLocator.resolve(visitor.ip)
+      if geoloc == nil || geoloc.country == nil
+        label = '* Unknown *'
+      else
+        label = geoloc.country
+        # Mark all visitors with known locations on the map
+        if markOnMap(geoloc, "red", 8, visitor.ip, mouseRect)
+          @highlightedVisitor = visitor
+        end
+      end
+      countries[label] = 0 if !countries.has_key?(label)
+      countries[label] += 1
+    end
+    @canvas.update
+    if @countryList
+      @countryListCSLV.startUpdate
+      countries.each do |country, count|
+        @countryListCSLV.insertItem(country, country, count,
+            count * 100.0 / visitors.size)
+      end
+      @countryListCSLV.finishUpdate
+    end
+
+  end
+
+  def markRouteOnMap(ip, mouseRect)
+    return unless @showRouters || @showRoutes
+
+    rec = $traceRouter.resolve(ip)
+    return unless rec
+
+    last = nil
+    rec.routers.each do |r|
+      loc = $geoLocator.resolve(r)
+      next unless loc && loc.latitude && loc.longitude
+      drawConnection(last, loc) if @showRoutes
+      last = loc
+      if @showRouters && markOnMap(loc, 'yellow', 6, ip, mouseRect)
+        @highlightedRouter = ip
+      end
+    end
+    # Make sure that we always connect to the destination if we have found
+    # at least one router along the way.
+    if last
+      loc = $geoLocator.resolve(ip)
+      drawConnection(last, loc) if @showRoutes
+    end
+  end
+
+  def updateRouterList(ip)
+    rec = $traceRouter.resolve(ip)
+    return unless rec
+
+    i = 1
+    @routeListCSLV.startUpdate
+    rec.routers.each do |r|
+      loc = $geoLocator.resolve(r)
+      if loc
+        @routeListCSLV.insertItem(r, i, r, $resolver.hostName(r),
+            loc.country ? loc.country : '',
+            loc.city ? loc.city : '',
+            loc.latitude ? loc.latitude : 0,
+            loc.longitude ? loc.longitude : 0)
+      else
+        @routeListCSLV.insertItem(r, i, '*', '*', '', '', 0, 0)
+      end
+      i += 1
+    end
+    @routeListCSLV.finishUpdate
+  end
+
+  def drawConnection(loc1, loc2)
+    x1, y1 = loc2xy(loc1)
+    return unless x1 > 0 && y1 > 0
+    x2, y2 = loc2xy(loc2)
+    return unless x2 > 0 && y2 > 0
+
+    horizRollover = (x1 - x2).abs > (@canvas.width / 2)
+    vertRollover = (y1 - y2).abs > (@canvas.height / 2)
+
+    if !horizRollover && !vertRollover
+      l = Qt::CanvasLine.new(@canvas)
+      l.setPen(Qt::Pen.new(Qt::Color.new('gray'), 1))
+      l.setPoints(x1, y1, x2, y2)
+      l.z = 2
+      l.show
+    elsif horizRollover
+      xl, yl = x1 < x2 ? [ x1, y1 ] : [ x2, y2 ]
+      xr, yr = x1 > x2 ? [ x1, y1 ] : [ x2, y2 ]
+      l1 = Qt::CanvasLine.new(@canvas)
+      l1.setPen(Qt::Pen.new(Qt::Color.new('gray'), 1))
+      l1.setPoints(xr - @canvas.width, yr, xl, yl)
+      l1.z = 2
+      l1.show
+
+      l2 = Qt::CanvasLine.new(@canvas)
+      l2.setPen(Qt::Pen.new(Qt::Color.new('gray'), 1))
+      l2.setPoints(xl + @canvas.width, yl, xr, yr)
+      l2.z = 2
+      l2.show
+    else
+      xt, yt = y1 < y2 ? [ x1, y1 ] : [ x2, y2 ]
+      xb, yb = y1 > y2 ? [ x1, y1 ] : [ x2, y2 ]
+      l1 = Qt::CanvasLine.new(@canvas)
+      l1.setPen(Qt::Pen.new(Qt::Color.new('gray'), 1))
+      l1.setPoints(xt, yt - @canvas.height, xb, yb)
+      l1.z = 2
+      l1.show
+
+      l2 = Qt::CanvasLine.new(@canvas)
+      l2.setPen(Qt::Pen.new(Qt::Color.new('gray'), 1))
+      l2.setPoints(xb, yb + @canvas.height, xt, yt)
+      l2.z = 2
+      l2.show
+    end
+  end
+
+  # Mark the specified location with a small red cross on the map
+  def markOnMap(geoloc, color, pLayer, ip, mouseRect)
+    return false unless geoloc
+    x , y = loc2xy(geoloc)
+    return false unless x > 0 && y > 0
+
+    # In case this IP is under the mouse cursor we will show full details
+    # no matter that the show flags say.
+    showFullInfo = mouseRect && mouseRect.contains(x, y)
+
+    # Horizontal line
+    l1 = Qt::CanvasLine.new(@canvas)
+    l1.setPen(Qt::Pen.new(Qt::Color.new(color), 1))
+    l1.setPoints(x - 1, y, x + 2, y)
+    l1.z = pLayer
+    l1.show
+    # Vertical line
+    l2 = Qt::CanvasLine.new(@canvas)
+    l2.setPen(Qt::Pen.new(Qt::Color.new(color), 1))
+    l2.setPoints(x, y - 1, x, y + 2)
+    l2.z = pLayer
+    l2.show
+
+    label = ''
+    label += ip + "\n" if @showIPs || showFullInfo
+    label += $resolver.hostName(ip) + "\n" if @showHostNames || showFullInfo
+    label += geoloc.city + "\n" if (@showCities || showFullInfo) && geoloc.city
+    label += geoloc.country + "\n" if showFullInfo
+    drawLabel(x, y, color, label, showFullInfo) unless label.empty?
+
+    return showFullInfo
+  end
+
+  def loc2xy(geoloc)
+    return [ -1, -1 ] unless geoloc
+    # Check that location is valid
+    latitude = geoloc.latitude
+    longitude = geoloc.longitude
+    return [ -1, -1 ] if latitude == nil || longitude == nil
+    mapW = @canvas.width
+    mapH = @canvas.height
+    # Compute the center of the cross
+    x = (mapW / 2) + longitude * mapW / 360
+    y = (mapH / 2) - latitude * mapH / 180
+    [ x, y ]
+  end
+
+  def drawLabel(px, py, frameColor, text, large)
+
+    x = px + 5
+    y = py - 5
+
+    tl = Qt::CanvasText.new(text, @canvas)
+    tl.setColor(Qt::Color.new('black'))
+    font = Qt::Font.new
+    font.setPixelSize(large ? 11 : 9)
+    tl.setFont(font)
+    tl.x = x
+    tl.y = y
+    tl.z = @layer + 1
+    tl.show
+
+    bg = Qt::CanvasRectangle.new(tl.boundingRect, @canvas)
+    bg.setPen(Qt::Pen.new(Qt::Color.new(frameColor)))
+    bg.setBrush(Qt::Brush.new(Qt::Color.new('white')))
+    bg.z = @layer
+    bg.show
+
+    l = Qt::CanvasLine.new(@canvas)
+    l.setPen(Qt::Pen.new(Qt::Color.new(frameColor), 1))
+    l.setPoints(px, py, x, y + bg.boundingRect.height / 3)
+    l.show
+    l.z = 8
+
+    @layer += 2
+  end
+
+  def selectedItems
+    return [] unless @countryList
+    @countryListCSLV.selectedItems
+  end
+
+  def mapClicked()
+    if @highlightedVisitor
+      correctIP(@highlightedVisitor.ip)
+    elsif @highlightedRouter
+      correctIP(@highlightedRouter)
+    end
+  end
+
+  def routerListClicked(item)
+    return unless item
+
+    ip = @routeListCSLV.item(item)
+    return unless ip
+
+    correctIP(ip)
+  end
+
+  def correctIP(ip)
+    browseURL("http://www.hostip.info/correct.html?spip=#{ip}")
+
+    # I don't know how long it takes for the hostip server to provide the
+    # changed information but there seems to be a noticable delay. We set the
+    # record to timeout in 60 minutes to that it will be fetched again then.
+    $geoLocator.expireInMinutes(ip, 60)
+  end
+
+end
+

data/lib/GeoLocator.rb

@@ -0,0 +1,91 @@
+#
+# GeoLocator.rb - ClickSpotter
+#
+# Copyright (c) 2005, 2006 by Chris Schlaeger <cs@kde.org>
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# $Id: GeoLocator.rb 8 2006-01-22 15:19:51Z cs $
+#
+
+require 'net/http'
+require 'time'
+require 'AsyncResolverWithCache'
+
+class GeoLocatorRecord
+  attr_reader :country, :countryCode, :city, :latitude, :longitude
+  attr_accessor :timeStamp
+
+  def initialize
+    @country = nil
+    @countryCode = nil
+    @city = nil
+    @latitude = nil
+    @longitude = nil
+    @timeStamp = nil
+  end
+
+  def resolve(ip)
+    begin
+      http = Net::HTTP.new($globals.getSetting('GeolocHost'),
+                           $globals.getSetting('GeolocPort'))
+      resp = http.get("/rough.php?ip=#{ip}&position=true", nil)
+      # This is how the data string should look like:
+      # data = <<EOS
+      # Country: GERMANY
+      # Country Code: DE
+      # City: Albstadt
+      # Latitude: 48.25
+      # Longitude: 9.0167
+      # Guessed: false
+      # EOS
+      resp.body.scan(/(.*):\s+(.*)\n/) do |tokens|
+        tokens[1].gsub!(/\|/, '')
+        case tokens[0]
+        when 'Country'
+          @country = tokens[1]
+        when 'Country Code'
+          @countryCode = tokens[1]
+        when 'City'
+          @city = tokens[1]
+        when 'Latitude'
+          val = tokens[1].to_f
+          @latitude = val if val != 0 && val > -90 && val < 90
+        when 'Longitude'
+          val = tokens[1].to_f
+          @longitude = val if val != 0 && val >= -180 && val <= 180
+        else
+        end
+      end
+      rescue
+      return false
+    end
+    @timeStamp = Time.now()
+    return true
+  end
+
+end
+
+class GeoLocator < AsyncResolverWithCache
+
+  def initialize
+    super('GeoLocatorCache',
+        $globals.getSetting('GeolocTimeout') * 60 * 60 * 24, 2)
+    @enabled = $globals.getSetting('Geolocator')
+  end
+
+  def newRecord
+    GeoLocatorRecord.new
+  end
+
+  def country(ip)
+    (rec = resolve(ip)) ? rec.country : nil
+  end
+
+  def city(ip)
+    (rec = resolve(ip)) ? rec.city : nil
+  end
+
+end
+