Open-Source-Access-Control-Web-Interface/app/controllers/macs_controller.rb

class MacsController < ApplicationController
load_and_authorize_resource :mac, :except => [:index, :create, :history]
#load_and_authorize_resource :user, :through => :mac, :except => [:index, :show, :scan, :import]

before_filter :arp_lookup, :only => :new

#require "active_record"
require "optparse"
#require "rubygems"

def index
  recent_mac_logs_ungrouped = MacLog.last(1000)
  if recent_mac_logs_ungrouped.present?
    @mac_time_start_date = recent_mac_logs_ungrouped.first.created_at
    recent_mac_logs = recent_mac_logs_ungrouped.group_by(&:mac)
    @mac_times = {}
    # Go thru each mac
    recent_mac_logs.each do |mac_log|
      last_active = nil
      # And the entries for each mac (mac_log.first is the string, mac_log.last is the array)
      mac_log.last.each do |entry|
        # Find an activate followed immediately by a deactivate
        if entry.action == "activate"
          last_active = entry 
        else
          if last_active && entry.action == "deactivate"
            # Calculate the time difference between the two and append to this mac's total time
            this_entry = @mac_times[entry.mac]
            if this_entry
              this_time = this_entry[:time]
            else
              this_time = 0
            end
            @mac_times[entry.mac] = {:mac => entry, :time => (entry.created_at - last_active.created_at) + this_time}
          else
            # No pair found; discard.
            last_active = nil
          end
        end
      end
    end
    @mac_times_sorted = @mac_times.sort{|a,b| b.last[:time] <=> a.last[:time] }
    @most_active_mac = nil
    @runner_up_mac = nil
    @mac_times_sorted.each do |mac_time|
      unless @most_active_mac
        this_mac = Mac.find_by_mac(mac_time.first)
        unless this_mac.hidden
          @most_active_mac = this_mac
          @most_active = mac_time
        end
      else
        unless @runner_up_mac
          this_mac = Mac.find_by_mac(mac_time.first)
          unless this_mac.hidden
            @runner_up_mac = this_mac
            @runner_up = mac_time
          end
        end
      end
    end
  end
  
  #@active_macs = Mac.where(:active => true, :hidden => false)
  #@active_macs += Mac.where(:active => true, :hidden => nil)
  
  # De-dupe users for the public
  if can? :update, Mac then
    @active_macs = Mac.where("macs.active = ? AND (macs.hidden IS NULL OR macs.hidden = ?)", true, false).includes(:user).order("users.name ASC")
  elsif user_signed_in? then
    @active_macs = Mac.where("macs.active = ? AND (macs.hidden IS NULL OR macs.hidden = ?)", true, false).includes(:user).order("users.name ASC").group("users.name")
  else
    @active_macs = Mac.select("mac, note, user_id").where("macs.active = ? AND (macs.hidden IS NULL OR macs.hidden = ?)", true, false).joins(:user).order("users.name ASC").group("users.name, mac, note, user_id")
  end

  @hidden_macs = Mac.where("macs.active = ? AND macs.hidden = ?", true, true).order("note ASC")

  @all_macs = Mac.find(:all, :order => "LOWER(mac)")

  respond_to do |format|
    format.html
    format.json {
      @filtered_macs = Mac.select("macs.mac, users.name, macs.note").where("macs.active = ? AND (macs.hidden IS NULL OR macs.hidden = ?)", true, false).joins(:user)
      render :json => @filtered_macs 
    }
  end
end

  def history
    authorize! :read_details, Mac
    begin
      @start_date = DateTime.parse(params[:start])
      @end_date = DateTime.parse(params[:end])
    rescue
      @start_date = DateTime.now - 2.weeks
      @end_date = DateTime.now
    end

    @mac_logs_by_hour = MacLog.where("created_at > ? AND created_at < ?", @start_date, @end_date).group_by{|m| m.created_at.beginning_of_hour}
    @mac_log_graph = []
    mac_running_balance = 0
    lowest_balance = 0
    @mac_logs_by_hour.each do |time, mac_log|
      mac_log.each do |entry|
        # Add one computer for activate, subtract one for deactivate
        if entry.action == "activate"
          mac_running_balance += 1
        elsif entry.action == "deactivate"
          mac_running_balance -= 1
        end
        # Keep track of the lowest number in the graph
        if mac_running_balance < lowest_balance
          lowest_balance = mac_running_balance
        end
      end
      @mac_log_graph << [time.to_time.to_i*1000,mac_running_balance]
    end

    if lowest_balance != 0
      # Subtract a negative balance to raise everything
      @mac_log_graph = @mac_log_graph.map{ |time,balance| [time, balance - lowest_balance] }
    end

    respond_to do |format|
      format.html
      format.json { render :json => @mac_log_graph }
    end
  end

  # GET /macs/1
  # GET /macs/1.json
  def show
    @mac = Mac.find(params[:id])
    @mac_logs = MacLog.where(:mac => @mac.mac)

    respond_to do |format|
      format.html # show.html.erb
      format.json { render :json => @macs }
    end
  end

  # GET /macs/new
  # GET /macs/new.json
  def new
    @mac = Mac.new
    if can? :manage, Mac then
      @users = User.accessible_by(current_ability).sort_by(&:name)
    else 
      @users = [current_user]
    end

    respond_to do |format|
      format.html # new.html.erb
      format.json { render :json => @mac }
    end
  end

  # GET /macs/1/edit
  def edit
    @mac = Mac.find(params[:id])
    if can? :manage, Mac then
      @users = User.accessible_by(current_ability).sort_by(&:name)
    else 
      @users = [current_user]
    end
  end

  # POST /macs
  def create
    @mac = Mac.new(params[:mac])
    @existing_mac = Mac.find_by_mac(@mac.mac)
        if can? :manage, Mac then
          @users = User.accessible_by(current_ability).sort_by(&:name)
        else 
          @users = [current_user]
        end
 
      if @existing_mac.present?
        if @existing_mac.user_id.nil?
          redirect_to edit_mac_path(@existing_mac), :notice => 'This MAC already exists, edit it here:'
        else
@mac.errors.add(:user,"for this MAC is already set to #{@existing_mac.user.name} -- please contact them or an admin if this is incorrect.")
          render :action => "new"
        end
      else
 
        respond_to do |format|
          if @mac.save
            format.html { redirect_to macs_path, :notice => 'MAC was successfully created.' }
            format.json { render :json => @mac, :status => :created, :location => @mac }
          else
            format.html { render :action => "new" }
            format.json { render :json => @mac.errors, :status => :unprocessable_entity }
          end
        end
      end
  end

  # PUT /macs/1
  # PUT /macs/1.json
  def update
    #Log who updated this
    @mac = Mac.find(params[:id])
    @mac.assign_attributes(params[:mac])
    #@mac.user_id = params[:mac][:user_id]
    authorize! :update, @mac

    if can? :manage, Mac then
      @users = User.accessible_by(current_ability).sort_by(&:name)
    else 
      @users = [current_user]
    end

    respond_to do |format|
      if @mac.save
        format.html { redirect_to macs_path, :notice => 'MAC was successfully updated.' }
        format.json { head :no_content }
      else
        format.html { render :action => "edit" }
        format.json { render :json => @mac.errors, :status => :unprocessable_entity }
      end
    end
  end

def arp_lookup
  @ip = request.env['REMOTE_ADDR']
  @arp = /([0-9A-F]{2}[:-]){5}([0-9A-F]{2})/i.match(%x(arp -a | grep #{@ip}))
end

def scan
Rails.logger.info "starting scan..."
  # Command line arguments
  options = {};
  OptionParser.new { |opts|
    opts.banner = "Usage: pamela-scanner.rb --interface=en0"

    options[:verbose] = true
    opts.on("v", "--verbose", "Run verbosely") { |verbose|
      options[:verbose] = verbose
    }

    options[:interface] = "eth0"
    opts.on("i", "--interface=interface", "Network Interface") { |interface|
      options[:interface] = interface
    }

    options[:max_age] = 20
    opts.on("a", "--max-age=minutes", "Minutes to keep expired macs active") { |max_age|
      options[:max_age] = max_age.to_i
    }

    options[:db_host] = "configure_me"
    opts.on("r", "--db-host=host", "Database Host") { |host|
      options[:db_host] = host
    }

    options[:db_name] = "configure_me"
    opts.on("n", "--db-name=name", "Database Name") { |name|
      options[:db_name] = name
    }

    options[:db_user] = "configure_me"
    opts.on("u", "--db-user=user", "Database User") { |user|
      options[:db_user] = user
    }

    options[:db_password] = "configure_me"
    opts.on("p", "--db-password=password", "Database Password") { |password|
      options[:db_password] = password
    }

  }.parse!

  # Open the database
  #ActiveRecord::Base::establish_connection(
  #  :adapter  => "mysql2",
  #  :host     => options[:db_host],
  #  :database => options[:db_name],
  #  :username => options[:db_user],
  #  :password => options[:db_password])

  #class Mac < ActiveRecord::Base
  #end

  #class MacLog < ActiveRecord::Base
  #end

  # Scan the network for mac addresses
  macs = {};
  command = sprintf("arp-scan -R --interface=%s --localnet", options[:interface])
  if options[:verbose]
    Rails.logger.info "Running [#{command}]"
  end
  IO.popen(command) { |stdin|
    result = stdin.read()
    result.lines.each { |line| 
      Rails.logger.info "Reading stdin: "+line.inspect
      next if line !~ /^([\d\.]+)\s+([[:xdigit:]:]+)\s/;
      macs[($2).downcase] = ($1).downcase;
    }
    Rails.logger.info "STDIN:"+result.lines.count.inspect
    @macs = macs.dup # make a copy for output in the view
    Rails.logger.info "MACS:"+@macs.inspect
  }

  # Scan the existing macs and update each record as necessary
  Mac.find(:all).each { |entry|
    mac = entry.mac.downcase
    ip = entry.ip
    if macs.has_key?(mac) # if our scan shows this mac
      if ! entry.active || ! entry.since
        Rails.logger.info "Activating #{mac} at #{ip}" if options[:verbose]
        entry.since = Time.now
        MacLog.new(:mac => mac, :ip => ip, :action => "activate").save
      end
      entry.active = 1
      entry.ip = ip
      entry.refreshed = Time.now
      entry.save
      macs.delete(mac)
      next
    end

    # Entry is no longer current
    if entry.active
      ageMinutes = ((Time.now - entry.refreshed)/60).to_i
      next if ageMinutes < options[:max_age]
      Rails.logger.info "Deactivating #{mac}, #{ageMinutes} minutes old" if options[:verbose]
      entry.active = 0
      entry.save
      MacLog.new(:mac => mac, :ip => ip, :action => "deactivate").save
    end
  }

  # Add entries for any macs not already in the db
  macs.each { |mac, ip|
    Rails.logger.info "Activating new entry #{mac} at #{ip}" if options[:verbose]
    Mac.new(:mac => mac, :ip => ip, :active => 1, :since => Time.now, :refreshed => Time.now).save
    Rails.logger.info MacLog.new(:mac => mac, :ip => ip, :action => "activate").save
  }

@log = MacLog.all

end #def scan


def import

require 'csv'    

csv_text = File.read('mac_log.csv')
csv = CSV.parse(csv_text)

@output = []

csv.each do |row|
  @output += [row[1], Mac.create({:mac => row[0], :note => row[1], :hidden => row[2]}) ]
end

end

end