xscreen_usb_unlocker 0.90.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xscreen_usb_unlocker.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ernie Brodeur
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# XscreenUsb
+
+This gem provides a command line application that will control xscreensaver's lock/unlock features via connecting/disconnecting a given USB device.
+
+This will work best with a device that presents a unique serial number, and you have with you all the time . . . like your smart phone.  In fact I designed this to be used with an android phone in usb debugging mode (so it will register with the system).  I don't have to mount the disk, simply plugging it in is enough.
+
+## Installation
+
+    $ gem install xscreen_usb_unlocker
+
+## Usage
+
+To make sure it's not any device plugged or unpluged, you have to supply either a serial or a device id to scan for.
+
+For now, the serial can be found with:
+
+		$ lsusb -v |grep Serial
+
+Once you find the device (if it has a serial, most phone's do.)
+
+		$ xscreen_usb_unlocker -s SERIAL
+
+If it doesn't provide a serial, you can also use a device id.  Either the vendor, device or both can be supplied in a `vendor:device` format.
+
+To find these just run `lsusb` and look for the `1234:ABCD` piece, that is your device id.
+
+		$ xscreen_usb_unlocker -d 1234:ABCD
+
+You can also save these so you don't have to retype them, or have them in your history:
+
+		$ xscreen_usb_unlocker -s SERIAL -d 1234:ABCD --save-config
+
+Last, it can be daemonized, if this happens it will write a log to your homedirectory in: `~/.logs/xscreen_usb_unlocker.log`.  After you've saved your config, this is the simplest way to enable/disable it.
+
+		$ xscreen_usb_unlocker -D
+
+You can control logging and the logfile as well, likely I will disable the log for the 1.0 release.
+
+If you unlock xscreensaver by hand, you are not disabling this, the next time you plug/unplug your usb device, it will lock again.  This is useful if for some reason your usb device isn't available, you can still use your system as normal.
+
+## SECURITY
+
+This is incredibly important to understand, their isn't any.  This isn't a tool designed to secure your workstation, I can think of half a dozen ways to get past this easily.
+
+Instead, this tool is for convience, to help facilitate simple locking/unlocking in a casual business/home environment.
+
+All it does is start/kill (safely) xscreensaver based on scanning for usb devices.
+
+## TODO:
+
+* Add a --kill option to remove the other daemonizes.
+* Add a --name to trap for the device name (regex? substring?)
+* Add basic device detection to print out a pretty table to help configure it (offer options and save automatically?)
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/xscreen_usb_unlocker

@@ -0,0 +1,106 @@
+#!/usr/bin/ruby
+require 'xscreen_usb_unlocker'
+include XscreenUsbUnlocker
+Options.banner = "Usage: Used to lock/unlock xscreensaver based on usb device id and serial."
+Options.on("-s", "--serial SERIAL", "make sure the device matches this serial.") { |s| Options[:serial] = s}
+Options.on("-d", "--device DEVICE", "make sure it is this specific device.") { |d| Options[:device] = d}
+Options.on("-D", "--daemonize", "Daemonize this process in the background.") { |d| Options[:daemonize] = true}
+Options.on("--save-config", "Save the device and serial to a config file and exit.") { |d| Options[:save_config] = true}
+Options.parse!
+
+if !Options[:device] && !Options[:serial]
+  puts 'Must supply a device or serial to look for.'
+  exit
+end
+
+def lock_screen
+  Log.info 'locking'
+  p = spawn "xscreensaver -no-splash"
+  Process.detach p
+  %x[xscreensaver-command -lock]
+end
+
+def unlock_screen
+  Log.info 'unlocking'
+
+  if xscreensaver_pids
+    xscreensaver_pids.each do |p|
+      Log.info "Appears to be pid: #{p.pid}"
+      Process.kill "QUIT", p.pid
+    end
+  end
+end
+
+def xscreensaver_running?
+  xscreensaver_pids.any?
+end
+
+def xscreensaver_pids
+  Sys::ProcTable.ps.select{|x| x.cmdline.include?("xscreensaver") && !x.cmdline.include?("ruby")}
+end
+
+def plugged_in?
+  usb = LIBUSB::Context.new
+  options_hash = {}
+
+  if Options[:device]
+    v, p = Options[:device].split(":")
+    options_hash[:idVendor] = v.hex if v && !v.empty?
+    options_hash[:idProduct] = p.hex if p && !p.empty?
+  end
+
+  devices = usb.devices(options_hash)
+  return true if devices.select { |d| d.serial_number == Options[:serial]}.any?
+  false
+end
+
+def toggle_lock
+  if plugged_in?
+    Log.info 'unlock requested'
+    unlock_screen
+  else
+    Log.info 'lock request'
+    lock_screen
+  end
+end
+
+if __FILE__ == $0
+  # did we pry?
+  Options.on_pry
+
+  # should we save our config and bail?
+  if Options[:save_config]
+    Config["serial"] = Options[:serial] if Options[:serial]
+    Config["device"] = Options[:device] if Options[:device]
+    Config.save!
+    puts "Saved configuration to #{Config.file}"
+    exit
+  end
+
+  # kill a running copy of xscreensaver
+  if xscreensaver_running?
+    Log.info "xscreensaver appears to be running, killing so we can trap it."
+    %x[killall -QUIT xscreensaver]
+  end
+
+  # grab our notifications
+  Notifier = INotify::Notifier.new
+  Dir.glob("/dev/bus/usb/*").each do |d|
+    Notifier.watch(d, :delete, :create) do
+      toggle_lock
+    end
+  end
+
+  # fire off the lock cycle once.
+  toggle_lock
+
+  # start the notifier, which will fire off callbacks as needed.
+  if Options[:daemonize] || File.file?(Config.file)
+    Log.debug "Opening logfile."
+    Log.filename "/home/ebrodeur/.logs/xscreensaver_unlocker.log"
+    Log.debug "Daemonizing."
+    App.daemonize(:mulitple_pids => false) { Notifier.run }
+  else
+    Notifier.run
+  end
+end

data/lib/xscreen_usb_unlocker/app.rb

@@ -0,0 +1,75 @@
+# Some requires, they don't fit elsewhere.
+module XscreenUsbUnlocker
+
+  class Application
+    attr_accessor :version
+    attr_accessor :banner
+    attr_accessor :long_description
+    attr_accessor :plugins
+
+    # return the name of the app, for now this is just the cmd ran, later it will be
+    # something generated but more unique.
+    def name
+      $0.split("/").last
+    end
+
+    def cache_dir
+      "#{Dir.home}/.cache/erniebrodeur/#{App.name}/"
+    end
+
+    def config_dir
+      "#{Dir.home}/.config/erniebrodeur/#{App.name}/"
+    end
+
+    def pids
+      a = Sys::ProcTable.ps.select{|x| x.cmdline =~ /.*#{App.name}.*-[dD].*/}.map {|x| x.pid}
+      a.delete $$
+      return a if a.any?
+      nil
+    end
+
+    def initialize
+      @version = '0.0.0'
+      @banner  = 'A bin snippet by Ernie Brodeur that does . . . something.'
+      @long_description = ''
+      @plugins = []
+    end
+
+    def daemonize(*params, &block)
+      if params[0] && !params[0][:multiple_pids] && pids
+        puts_or_log :info, "#{App.name} appears to be running (#{pids}), only one allowed, exiting."
+        exit
+      end
+      puts_or_log :info, "Forking to background."
+
+      Process.daemon
+      block.call
+    end
+
+    def kill_daemon
+      if !pids
+        puts_or_log :fatal, "No pids found, exiting."
+      end
+
+      pids.each do |p|
+        puts_or_log :info, "Killing #{p}"
+        `kill -TERM #{p}`
+      end
+    end
+    private
+    def puts_or_log(l, s)
+      if App.plugins.include? 'logging'
+        Log.send l, s
+      else
+        puts s
+        exit if l.to_sym == :fatal
+      end
+    end
+  end
+
+  App = Application.new
+
+  # This will load a helper, if it exists.
+  f = "#{$:.last}/helpers/#{App.name}.rb"
+  require f if File.exist? f
+end

data/lib/xscreen_usb_unlocker/config.rb

@@ -0,0 +1,40 @@
+require 'fileutils'
+
+module XscreenUsbUnlocker
+  class ConfigBlob < Hash
+    BaseDir = "/home/ebrodeur/.config/erniebrodeur"
+
+    def initialize
+      FileUtils.mkdir_p BaseDir if !Dir.exist? BaseDir
+      load
+    end
+
+    def file
+      "#{BaseDir}/#{App.name}.json"
+    end
+
+    def save
+      if any?
+        # I do this the long way because I want an immediate sync.
+        f = open(file, 'w')
+        f.write Yajl.dump self
+        f.sync
+        f.close
+      end
+    end
+
+    def save!
+      FileUtils.rm file if File.file? file
+      save
+    end
+
+    def load
+      if File.exist? self.file
+        h = Yajl.load open(file, 'r').read
+        h.each { |k,v| self[k.to_sym] = v}
+      end
+    end
+  end
+  App.plugins.push 'config'
+  Config = ConfigBlob.new
+end

data/lib/xscreen_usb_unlocker/log.rb

@@ -0,0 +1,96 @@
+# it should override puts and print to 'capture' output as debug output.
+# It should have a semi easy to read standard format
+# it will have multiple formats available.
+# it should produce colorized output (either parsed or part of the file format)
+require 'logger'
+
+module XscreenUsbUnlocker
+  class Logger
+    def initialize
+      @options = {}
+
+      @options[:utc] = true
+      @options[:level] = ::Logger::DEBUG
+      @options[:override_puts] = false
+      @options[:filename] = STDOUT
+
+      create_logger
+    end
+
+    def method_missing(sym, *args, &block)
+      @l.send sym, *args, &block
+      exit if sym == :fatal
+    end
+
+    def enable(sym)
+      raise 'NoSuchOption' if @options[sym] == nil
+      @options[sym] = true
+
+      if sym == :override_puts
+        level ::Logger::DEBUG
+      end
+    end
+
+    def disable(sym)
+      raise 'NoSuchOption' if @options[sym] == nil
+      @options[sym] = false
+    end
+
+    def level(s)
+      level = case s.to_sym
+      when :fatal then ::Logger::FATAL
+      when :error then ::Logger::ERROR
+      when :warn then ::Logger::WARN
+      when :info then ::Logger::INFO
+      when :debug then ::Logger::DEBUG
+      else ::Logger::UNKNOWN
+      end
+
+      @options[:level] = level
+      @l.level = level
+    end
+
+    def override_puts?
+      return true if @options[:override_puts]
+      false
+    end
+
+    def filename(file)
+      @options[:filename] = file
+      create_logger
+    end
+    private
+    def fmt_time
+      if @options[:utc]
+        Time.now.getutc
+      else
+        Time.now
+      end
+    end
+
+    def create_logger
+      FileUtils.mkdir_p File.dirname @options[:filename] if File.file? @options[:filename]
+      @l = ::Logger.new(@options[:filename])
+      @l.level = @options[:level]
+
+      @l.formatter = proc do |severity, datetime, progname, msg|
+        "[#{fmt_time.asctime}] [#{severity}]: #{msg}\n"
+      end
+
+    end
+  end
+
+  App.plugins.push 'logging'
+  Log = Logger.new
+end
+
+# better way to do this with: Kernel.module_eval def puts ...
+module Kernel
+  def puts (s)
+    if Log.override_puts?
+      Log.info s
+    else
+      Kernel::puts s
+    end
+  end
+end

data/lib/xscreen_usb_unlocker/optparser.rb

@@ -0,0 +1,59 @@
+require 'optparse'
+
+module XscreenUsbUnlocker
+  class OptionParser < ::OptionParser
+    def initialize
+      super
+      @options = {}
+      on("-V", "--version", "Print version") { |version| @options[:version] = true}
+      on("-p", "--pry", "open a pry shell.") { |pry| @options[:pry] = true}
+      if App.plugins.include? 'logging'
+        on("-l", "--log-level LEVEL", "Change the log level, default is debug.") { |level| Log.level level }
+        on("--log-file FILE", "What file to output to, default is STDOUT") { |file| Log.filename file }
+      end
+    end
+
+    # This will build an on/off option with a default value set to false.
+    def bool_on(word, description = "")
+      Options[word.to_sym] = false
+      on "-#{word.chars.first}", "--[no]#{word}", description  do |o|
+        Options[word.to_sym] == o
+      end
+    end
+
+    def parse!
+      super
+
+      if @options[:version]
+        puts XscreenUsbUnlocker::Version
+        exit 0
+      end
+
+      # we need to mash in our config array.  To do this we want to make config
+      # options that don't overwrite cli options.
+      if App.plugins.include? 'config'
+        Config.each do |k,v|
+          @options[k] = v if !@options[k]
+        end
+      end
+    end
+
+    def on_pry
+      if @options[:pry]
+        require 'pry'
+        binding.pry
+      end
+    end
+
+    def [](k)
+      @options[k]
+    end
+
+    def []=(k,v)
+      @options[k] = v
+    end
+  end
+
+  App.plugins.push "optparser"
+  Options = OptionParser.new
+end

data/lib/xscreen_usb_unlocker/version.rb

@@ -0,0 +1,3 @@
+module XscreenUsbUnlocker
+  VERSION = "0.90.1"
+end

data/lib/xscreen_usb_unlocker.rb

@@ -0,0 +1,14 @@
+require 'rb-inotify'
+require 'libusb'
+require 'yajl'
+require 'sys/proctable'
+
+require 'xscreen_usb_unlocker/app'
+require 'xscreen_usb_unlocker/log'
+require 'xscreen_usb_unlocker/config'
+require 'xscreen_usb_unlocker/optparser'
+require "xscreen_usb_unlocker/version"
+
+module XscreenUsbUnlocker
+  # Your code goes here...
+end

data/xscreen_usb_unlocker.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/xscreen_usb_unlocker/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ernie Brodeur"]
+  gem.email         = ["ebrodeur@ujami.net"]
+  gem.description   = "A CLI tool that scans your usb ports for a device, then locks/unlocks xscreensaver."
+  gem.summary       = "This tool is used to control xscreensaver via a USB device being plugged in and removed.  It provides minor methods to scan for unique device, like serial and device id.  This is rather useful with a smart phone."
+  gem.homepage      = "https://github.com/erniebrodeur/xscreen_usb_unlocker"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "xscreen_usb_unlocker"
+  gem.require_paths = ["lib"]
+  gem.add_runtime_dependency "rb-inotify"
+  gem.add_runtime_dependency "libusb"
+  gem.add_runtime_dependency "yajl-ruby"
+  gem.add_runtime_dependency "sys-proctable"
+  gem.add_development_dependency "pry"
+  gem.version       = XscreenUsbUnlocker::VERSION
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: xscreen_usb_unlocker
+version: !ruby/object:Gem::Version
+  version: 0.90.1
+  prerelease: 
+platform: ruby
+authors:
+- Ernie Brodeur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: libusb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A CLI tool that scans your usb ports for a device, then locks/unlocks
+  xscreensaver.
+email:
+- ebrodeur@ujami.net
+executables:
+- xscreen_usb_unlocker
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/xscreen_usb_unlocker
+- lib/xscreen_usb_unlocker.rb
+- lib/xscreen_usb_unlocker/app.rb
+- lib/xscreen_usb_unlocker/config.rb
+- lib/xscreen_usb_unlocker/log.rb
+- lib/xscreen_usb_unlocker/optparser.rb
+- lib/xscreen_usb_unlocker/version.rb
+- xscreen_usb_unlocker.gemspec
+homepage: https://github.com/erniebrodeur/xscreen_usb_unlocker
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: This tool is used to control xscreensaver via a USB device being plugged
+  in and removed.  It provides minor methods to scan for unique device, like serial
+  and device id.  This is rather useful with a smart phone.
+test_files: []
+has_rdoc: