panopticon 0.1.0

data/lib/panopticon.rb

@@ -0,0 +1,10 @@
+require "panopticon/version"
+require "panopticon/api"
+require "panopticon/log"
+require "panopticon/wlan_capture"
+require "panopticon/wlan_control"
+require "panopticon/wlan_utilization"
+require "panopticon/command/panopticond"
+
+module Panopticon
+end

data/lib/panopticon/api.rb

@@ -0,0 +1,59 @@
+module Panopticon
+  require "sinatra/base"
+  require "json"
+
+  require "panopticon/wlan_control"
+
+  class APIServer < Sinatra::Base
+    DEFAULT_PORT=8080
+
+    set :port, DEFAULT_PORT
+    set :public_folder, File.dirname(__FILE__) + "/../../extra/public"
+    enable :logging
+
+    def self.run! arg={}
+      @arg = arg
+
+      @port = arg[:port] || DEFAULT_PORT
+      set :port, @port
+
+      @@wlan_control = Panopticon::WlanControl.new(arg)
+      super
+    end
+
+    get "/" do
+      redirect to ("/index.html")
+    end
+
+    get "/api/v1/status" do
+      JSON.dump(@@wlan_control.get_status)
+    end
+
+    post "/api/v1/start" do
+      begin
+        data =  request.body.read
+        json = JSON.parse(data)
+
+        @@wlan_control.start_capture(json)
+        status 200
+        "success"
+      rescue => e
+        $log.err("/start failed => #{e}")
+        status 500
+        "failed (#{e})"
+      end
+    end
+
+    post "/api/v1/stop" do
+      begin
+        @@wlan_control.stop_capture
+        status 200
+        "success"
+      rescue => e
+        $log.err("/start failed => #{e}")
+        status 500
+        "failed (#{e})"
+      end
+    end
+  end
+end

data/lib/panopticon/command/panopticond.rb

@@ -0,0 +1,47 @@
+module Panopticon
+  require "panopticon/log"
+
+  class Daemon
+    DEFAULT_CONFIG_PATH="/etc/panopticon.conf"
+
+    DEFAULT_API_PORT=8080
+
+    DEFAULT_IFNAME="wlan0"
+    DEFAULT_CAPTURE_PATH="/cap"
+    DEFAULT_LOG_FILE="/var/log/panopticond.log"
+
+    def self.default_options
+      {
+        # config file (exclusive)
+        :config_file => DEFAULT_CONFIG_PATH,
+
+        # daemon parameters
+        :port => DEFAULT_API_PORT,
+
+        # capture parameters
+        :ifname => DEFAULT_IFNAME,
+        :capture_path => DEFAULT_CAPTURE_PATH,
+
+        # log
+        :log_file => DEFAULT_LOG_FILE,
+      }
+    end
+
+    def initialize arg={}
+      @arg = arg
+
+      @config_file = arg[:config_file]
+
+      @arg = read_config(@config_file)
+    end
+
+    def run
+      Panopticon::APIServer.run!(@arg)
+    end
+
+    def read_config path
+      # notimp
+      @arg
+    end
+  end
+end

data/lib/panopticon/log.rb

@@ -0,0 +1,36 @@
+class Log
+  require "logger"
+  def initialize opts={}
+    @debug_mode = opts[:debug_mode] || false
+    @output = opts[:output] || STDOUT
+
+    case @output
+    when "STDOUT"
+      @output = STDOUT
+    when "STDERR"
+      @output = STDERR
+    end
+    @logger = Logger.new(@output)
+
+    @logger.datetime_format = "%Y%m%d%H%m%S"
+    @logger.formatter = proc { |severity, datetime, progname, msg|
+      "[#{datetime}] #{progname}\t#{severity}: #{msg}\n"
+    }
+  end
+
+  def warn str
+    @logger.warn(str)
+  end
+
+  def err str
+    @logger.error(str)
+  end
+
+  def info str
+    @logger.info(str)
+  end
+
+  def debug str
+    @logger.debug(str)
+  end
+end

data/lib/panopticon/version.rb

@@ -0,0 +1,3 @@
+module Panopticon
+  VERSION = "0.1.0"
+end

data/lib/panopticon/wlan_capture.rb

@@ -0,0 +1,135 @@
+module Panopticon
+  require "open3"
+  require "panopticon/wlan_utilization"
+
+  class WlanCapture
+    attr_reader :duration, :current_channel, :filesize, :channel_walk, :utilization, :utilization_channel
+    CHAN = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+            34, 36, 38, 40, 42, 44, 46, 48,
+            52, 56, 60, 64,
+            100, 104, 108, 112, 116,
+            120, 124, 128, 132, 136, 140,
+            149, 153, 157, 161, 165]
+    LIMIT_IDX=CHAN.length
+
+    DEFAULT_IFNAME="wlan0"
+    DEFAULT_INTERVAL=1
+
+    def initialize ifname=DEFAULT_IFNAME, channels=CHAN, interval = DEFAULT_INTERVAL
+      @th_shark = nil
+      @th_capture = nil
+      @black_list = []
+
+      @ifname = ifname || DEFAULT_IFNAME
+      @channels = channels || CHAN
+      @interval = interval || DEFAULT_INTERVAL
+
+      init_status()
+
+      @wlan_utilization = Panopticon::WlanUtilization.new(@ifname)
+    end
+
+    def run_capture fpath
+      init_device()
+      init_status()
+      start_time = Time.now.to_i
+
+      stdin, stdout, stderr, @th_tshark = *Open3.popen3(
+        "tshark -i #{@ifname} -F pcapng -w #{fpath}")
+
+      while @th_tshark.alive?
+        sleep 1
+
+        # update status
+        @duration = Time.now.to_i - start_time
+        @filesize = File.size?(fpath) || 0
+
+        # do something here to run before channel transition
+        ary = @wlan_utilization.current_data()
+        @utilization_channel = ary[0]
+        @utilization = ary[3]
+
+        prev_channel = @current_channel
+        @current_chanenl = move_channel(@current_channel, @channels)
+        @channel_walk += 1
+        $log.debug("channel moved to #{@current_channel} from #{prev_channel} (dur=#{@duration}, size=#{@filesize}, walk=#{@channel_walk}, utilization=#{@utilization} uch=#{@utilization_channel})")
+      end
+    rescue => e
+      $log.warn("run_capture detected unknown error (#{e})")
+    end
+
+    def stop_capture
+      if @th_tshark == nil
+        $log.err("tried to kill tshark, but it's not executed? (or already dead?)")
+        return
+      end
+
+      Process.kill("INT", @th_tshark.pid)
+    end
+
+    def modify_channels channels
+      @channels = channels
+    end
+
+    private
+    def init_status
+      @duration = 0
+      @current_channel = @channels[0] || 1
+      @filesize = 0
+      @channel_walk = 0
+    end
+
+    def init_device
+      unless @ifname.match(/^wlan\d+$/)
+        $log.debug("non-wlan device skips device initialization")
+        return
+      end
+
+      unless system("ip link set #{@ifname} down")
+        raise "failed to turn down #{@ifname}"
+      end
+      unless system("iw #{@ifname} set monitor fcsfail otherbss control")
+        raise "failed to set #{@ifname} to monitor mode"
+      end
+      unless system("ip link set #{@ifname} up")
+        raise "failed to turn up #{@ifname}"
+      end
+      unless system("iw wlan0 set channel #{@current_channel}")
+        raise "failed to set channel #{@current_channel} on #{@ifname}"
+      end
+    end
+
+    def move_channel current, channels
+      unless @ifname.match(/^wlan\d+$/)
+        $log.debug("non-wlan device skips channel transition")
+        return
+      end
+
+      next_channel = pick_channel(current, channels)
+
+      while !system("iw #{@ifname} set channel #{next_channel}")
+        # what if we got unplugged ifname? => should we die?
+        $log.debug("channel transition failed, added to black list (channel=#{next_channel})")
+        @black_list << next_channel
+        sleep 1
+        next_channel = pick_channel(next_channel, channels)
+      end
+
+      @current_channel = next_channel
+    end
+
+    def pick_channel current, channels
+      idx = channels.index(current)
+      idx += 1
+      next_channel = channels[idx % channels.length] || 1
+
+      # we have black list
+      while @black_list.include?(next_channel)
+        idx += 1
+        next_channel = channels[idx % channels.length] || 1
+      end
+
+      return next_channel
+    end
+  end
+end

data/lib/panopticon/wlan_control.rb

@@ -0,0 +1,275 @@
+module Panopticon
+  require "json"
+  require "thread"
+
+  require "panopticon/log"
+  require "panopticon/wlan_capture"
+
+  class WlanControl
+    DEFAULT_IFNAME = "wlan0"
+    DEFAULT_CAPTURE_PATH = "/cap"
+
+    STATE_INIT = :INIT
+    STATE_RUNNING = :RUNNING
+    STATE_STOP = :STOP
+
+    def self.default_options
+      return  {
+        :ifname => DEFAULT_IFNAME,
+        :capture_path => DEFAULT_CAPTURE_PATH,
+      }
+    end
+
+    def initialize args={}
+      @th_capture = nil
+      @wlan_capture = nil
+      @state = STATE_INIT
+
+      @ifname = args[:ifname] || DEFAULT_IFNAME
+      $log.debug("hogeeee #{@ifname} #{args[:ifname]}")
+      @capture_path = args[:capture_path] || DEFAULT_CAPTURE_PATH
+
+      @hostname = `hostname`
+    end
+
+    def disk_info
+      line = `df`.split("\n")[1].split  # assumes first line to be "/"
+      size = line[1].to_i * 512
+      used = line[2].to_i * 512
+
+      return {:size => size, :used => used }
+    end
+
+    def memory_info
+      if File.exists?("/proc/meminfo")
+        # linux or bsd
+        return memory_info_from_proc
+      else
+        # mac os x ?
+        return memory_info_from_mac
+      end
+    end
+
+    def memory_info_from_proc
+      total = 0
+      free = 0
+      used = 0
+      File.open("/proc/meminfo") do |file|
+        total = file.gets.split[1].to_i
+        free = file.gets.split[1].to_i
+        used = total - free
+      end
+
+      return {:size => total, :used => used}
+    end
+
+    def memory_info_from_mac
+      _, total = `sysctl hw.memsize`.split.map{|n| n.to_i}
+
+      used = 0
+      app_mem = 0
+      comp_mem = 0
+      file_backed_mem = 0
+      `vm_stat`.split("\n").each do |line|
+        match = line.match(/^Anonymous pages: *(\d+)\.$/)
+        if match
+          app_mem = match[1].to_i * 4096
+        end
+
+        match = line.match(/^Pages occupied by compressor: *(\d+)\.$/)
+        if match
+          comp_mem = match[1].to_i * 4096
+        end
+
+        match = line.match(/^File-backed pages: *(\d+)\.$/)
+        if match
+          file_backed_mem = match[1].to_i * 4096
+        end
+      end
+
+      used = (app_mem + comp_mem + file_backed_mem)
+
+      return {:size => total, :used => used}
+    end
+
+    def cpu_info
+      if File.exists?("/proc/stat")
+        return cpu_info_from_proc
+      else
+        return cpu_info_from_mac
+      end
+    end
+
+    def cpu_info_from_proc
+      used = 0
+
+      current_cpu_info = []
+      File.open("/proc/stat") do |file|
+        current_cpu_info = file.gets.split[1..4].map{|elm| elm.to_i}
+      end
+
+      if @prev_cpu_info == nil
+        @prev_cpu_info = current_cpu_info
+        return 0
+      end
+
+      usage_sub = current_cpu_info[0..2].inject(0){|sum, elm| sum += elm} -
+        @prev_cpu_info[0..2].inject(0){|sum, elm| sum += elm}
+      total_sub = current_cpu_info.inject(0){|sum, elm| sum += elm} -
+        @prev_cpu_info.inject(0){|sum, elm| sum += elm}
+
+      @prev_cpu_info = current_cpu_info
+
+      used = ((usage_sub.to_f * 100) / total_sub)
+
+      return used
+    end
+
+    def cpu_info_from_mac
+      line = `top | head -4 | grep CPU`
+      match = line.match(/^CPU usage: *(\d+\.\d+)% user, *(\d+\.\d+)% sys, *(\d+\.\d+)% idle $/)
+      return 0.0 unless match
+
+      user = match[1].to_f
+      sys = match[2].to_f
+      idle = match[3].to_f
+      used = 100 - idle
+
+      return used
+    end
+
+    def capture_file_info
+      filesize = 0
+      duration = 0
+
+      if @wlan_capture
+        filesize = @wlan_capture.filesize
+        duration = @wlan_capture.duration
+      end
+
+      return {
+        :filename => @filename,
+        :filesize => filesize,
+        :duration => duration,
+      }
+    end
+
+    def wlan_info
+      info = {
+        :current_channel =>     0,
+        :channel_walk =>        0,
+        :utilization =>         0,
+        :utilization_channel => 0,
+      }
+
+      unless @state == STATE_RUNNING
+        return info
+      end
+
+      if @wlan_capture.nil?
+        $log.err("state mismatch (state = #{@state} <=> capture is running");
+        return
+      end
+
+      info[:current_channel] = @wlan_capture.current_channel
+      info[:channel_walk] = @wlan_capture.channel_walk
+      info[:utilization] = @wlan_capture.utilization
+      info[:utilization_channel] = @wlan_capture.utilization_channel
+
+      return info
+    end
+
+    def generate_filename
+      return "#{Time.now.strftime("%Y%m%d%H%m%S")}_#{@ifname}_#{$$}.pcapng"
+    end
+
+    # request handler for API
+    def start_capture arg
+      $log.info("starting new capture")
+
+      if @state == STATE_RUNNING
+        $log.warn("WlanCapture instance is already running")
+        return
+      end
+
+      if @th_capture
+        $log.warn("capture thread is already running, terminate it first")
+        return
+      end
+
+      if @wlan_capture
+        $log.warn("capture instance is running, teminate it first")
+        return
+      end
+
+      $log.info("starting new capture instance")
+      @wlan_capture = Panopticon::WlanCapture.new(@ifname)
+
+      # start capturing
+      filename = generate_filename()
+      @th_capture = Thread.new do
+        @wlan_capture.run_capture("#{@capture_path}/#{filename}")
+      end
+      $log.info("started new capture at #{filename}")
+
+      # move state
+      @state = STATE_RUNNING
+      @filename = filename
+    end
+
+    def stop_capture
+      if @state == STATE_INIT or @state == STATE_STOP
+        $log.err("stopping not runnning capture instance")
+        return
+      end
+
+      if @wlan_capture
+        @wlan_capture.stop_capture
+      end
+
+      if @th_capture and @th_capture.alive?
+        $log.info("stopping capture thread")
+        @th_capture.join
+      end
+
+      @wlan_capture = nil
+      @th_capture = nil
+
+      @state = STATE_STOP
+    end
+
+    def change_channels arg
+    end
+
+    def get_config
+    end
+
+    def get_status
+      @cached_disk_info = disk_info()
+      @cached_memory_info = memory_info()
+      @cached_cpu_info = cpu_info()
+      @cached_file_info = capture_file_info()
+      @cached_wlan_info = wlan_info()
+
+      return {
+        :date         => Time.now.to_i,
+        :hostname     => @hostname,
+        :disk_size    => @cached_disk_info[:size],
+        :disk_used    => @cached_disk_info[:used],
+        :memory_size  => @cached_memory_info[:size],
+        :memory_used  => @cached_memory_info[:used],
+        :cpu_usage    => @cached_cpu_info,
+
+        :state        => @state,
+        :filename     => @filename,
+        :filesize     => @cached_file_info[:filesize],
+        :duration     => @cached_file_info[:duration],
+
+        :current_channel => @cached_wlan_info[:current_channel],
+        :channel_walk => @cached_wlan_info[:channel_walk],
+        :utilization  => @cached_wlan_info[:utilization],
+        :utilization_channel => @cached_wlan_info[:utilization_channel],
+      }
+    end
+  end
+end