patronus_fati 0.8.0

data/lib/patronus_fati/data_observers/connection_observer.rb

@@ -0,0 +1,66 @@
+module PatronusFati::DataObservers
+  class ConnectionObserver
+    include DataMapper::Observer
+
+    observe PatronusFati::DataModels::Connection
+
+    before :save do
+      next unless self.valid?
+      @change_type = self.new? ? :new : :changed
+
+      if @change_type == :changed
+        dirty = self.dirty_attributes.map { |a| a.first.name }.map(&:to_s)
+        dirty.delete('last_seen_at')
+
+        # If there weren't any meaningful changes, don't print out anything
+        # after we save.
+        if dirty.empty?
+          @change_type = nil
+          next
+        end
+
+        changes = dirty.map do |attr|
+          clean = original_attributes[PatronusFati::DataModels::Connection.properties[attr]]
+          dirty = dirty_attributes[PatronusFati::DataModels::Connection.properties[attr]]
+
+          [attr, [clean, dirty]]
+        end
+
+        @change_list = Hash[changes]
+      end
+    end
+
+    after :save do
+      next unless @change_type
+
+      client.mac.update_cached_counts!
+      access_point.mac.update_cached_counts!
+
+      if @change_type == :new
+        if disconnected_at.nil?
+          PatronusFati.event_handler.event(
+            :connection,
+            :connect,
+            self.full_state
+          )
+        else
+          # Weird situation, new record that is already disconnected...
+          warn('Connection (%i) created that is already disconnected' % id)
+        end
+      else
+        if @change_list.keys.include?('disconnected_at') && @change_list['disconnected_at'][0] == nil && !disconnected_at.nil?
+          PatronusFati.event_handler.event(
+            :connection,
+            :disconnect,
+            self.full_state.merge(duration: duration)
+          )
+        else
+          warn('Connection (%i) updated in a weird way: %s' % [id, @change_list.inspect])
+        end
+      end
+
+      @change_type = nil
+      @change_list = nil
+    end
+  end
+end

data/lib/patronus_fati/data_observers/probe_observer.rb

@@ -0,0 +1,11 @@
+module PatronusFati::DataObservers
+  class ProbeObserver
+    include DataMapper::Observer
+
+    observe PatronusFati::DataModels::Probe
+
+    after :save do
+      PatronusFati.event_handler.event(:client, :changed, self.client.full_state)
+    end
+  end
+end

data/lib/patronus_fati/data_observers/ssid_observer.rb

@@ -0,0 +1,53 @@
+module PatronusFati::DataObservers
+  class SsidObserver
+    include DataMapper::Observer
+
+    observe PatronusFati::DataModels::Ssid
+
+    before :save do
+      next unless self.valid?
+
+      # We're about to report this, make sure the attribute gets saved
+      old_ro_val = reported_online
+      self.reported_online = true
+
+      @change_list = {
+        ssids: [
+          [],
+          [full_state]
+        ]
+      }
+
+      unless self.new?
+        dirty = self.dirty_attributes.map { |a| a.first.name }.map(&:to_s)
+        dirty.delete('last_seen_at')
+
+        # If there weren't any meaningful changes, don't print out anything
+        # after we save.
+        if dirty.empty?
+          @change_list = nil
+          self.reported_online = old_ro_val
+          next
+        end
+
+        tmp_obj = Hash[original_attributes.map { |k,v| [k.name, v] }]
+        @change_list[:ssids][0] = PatronusFati::DataModels::Ssid.new(tmp_obj).full_state
+      end
+    end
+
+    after :save do
+      next unless @change_list
+
+      access_point.mac.update_cached_counts!
+
+      PatronusFati.event_handler.event(
+        :access_point,
+        :changed,
+        self.access_point.full_state,
+        @change_list
+      )
+
+      @change_list = nil
+    end
+  end
+end

data/lib/patronus_fati/event_handler.rb

@@ -0,0 +1,27 @@
+module PatronusFati
+  class EventHandler
+    def handlers
+      @handlers ||= {}
+    end
+
+    def handlers_for(asset_type, event_type)
+      handlers[asset_type] ||= (asset_type == :any ? [] : {})
+      Array(handlers[:any]) | Array(handlers[asset_type][:any]) | Array(handlers[asset_type][event_type])
+    end
+
+    def on(asset_type, event_type = :any, &handler)
+      if asset_type == :any
+        handlers[:any] ||= []
+        handlers[:any].push(handler)
+      else
+        handlers[asset_type] ||= {}
+        handlers[asset_type][event_type] ||= []
+        handlers[asset_type][event_type].push(handler)
+      end
+    end
+
+    def event(asset_type, event_type, msg, optional = {})
+      handlers_for(asset_type, event_type).each { |h| h.call(asset_type, event_type, msg, optional) }
+    end
+  end
+end

data/lib/patronus_fati/factory_base.rb

@@ -0,0 +1,56 @@
+module PatronusFati
+  # This module provides the basis for an automatic Factory registration and
+  # generation system. Other modules that wish to make use of this
+  # functionality should extend this module. Those modules should then in turn
+  # be included by their respective generators.
+  module FactoryBase
+    # Turns the name of a class into it's snake cased equivalent.
+    #
+    # @param [Object] klass
+    # @return [Symbol]
+    def class_to_name(klass)
+      klass.to_s.split('::').last.scan(/[A-Z][a-z]*/).map(&:downcase)
+        .join('_').to_sym
+    end
+
+    # Factory method for triggering the lookup and return of the specific
+    # requested type of factory.
+    #
+    # @param [Symbol] type Type of generator to create
+    # @param [Hash<Symbol=>String>] options
+    def factory(type, opts = {})
+      return if ignored_types.include?(type)
+      if registered_factories[type].nil?
+        warn("Unknown factory #{type} (Available: #{registered_factories.keys})")
+        #puts opts.inspect
+        return
+      end
+      registered_factories[type].process(opts)
+    end
+
+    # Placeholder mechanism to allow sub-generators to not generate any
+    # warnings for specific types.
+    #
+    # @return [Array<Symbol>]
+    def ignored_types
+      []
+    end
+
+    # Trigger for when this module gets included to register it with the
+    # factory.
+    #
+    # @param [Object#create] klass
+    # @return [Object]
+    def included(klass)
+      registered_factories[class_to_name(klass)] = klass
+    end
+
+    # Returns the hash containing the set of registered factories or
+    # initializes it if one doesn't exist.
+    #
+    # @return [Hash<Symbol=>Object>]
+    def registered_factories
+      @registered_factories ||= {}
+    end
+  end
+end

data/lib/patronus_fati/message_models/ack.rb

@@ -0,0 +1,5 @@
+module PatronusFati
+  module MessageModels
+    Ack = CapStruct.new(:cmdid, :text)
+  end
+end

data/lib/patronus_fati/message_models/alert.rb

@@ -0,0 +1,10 @@
+module PatronusFati
+  module MessageModels
+    Alert = CapStruct.new(
+      :sec, :usec, :header, :bssid, :source, :dest, :other, :channel, :text
+    )
+
+    Alert.set_data_filter(:bssid, :source, :dest, :other) { |val| val.downcase }
+    Alert.set_data_filter(:sec, :usec, :channel) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/battery.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Battery = CapStruct.new(:percentage, :charging, :ac, :remaining)
+    Battery.set_data_filter(:percentage, :charging, :ac, :remaining) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/bssid.rb

@@ -0,0 +1,43 @@
+module PatronusFati
+  module MessageModels
+    Bssid = CapStruct.new(
+      :bssid, :type, :llcpackets, :datapackets, :cryptpackets, :manuf, :channel,
+      :firsttime, :lasttime, :atype, :rangeip, :netmaskip, :gatewayip, :gpsfixed,
+      :minlat, :minlon, :minalt, :minspd, :maxlat, :maxlon, :maxalt, :maxspd,
+      :signal_dbm, :noise_dbm, :minsignal_dbm, :minnoise_dbm, :maxsignal_dbm,
+      :maxnoise_dbm, :signal_rssi, :noise_rssi, :minsignal_rssi, :minnoise_rssi,
+      :maxsignal_rssi, :maxnoise_rssi, :bestlat, :bestlon, :bestalt, :agglat,
+      :agglon, :aggalt, :aggpoints, :datasize, :turbocellnid, :turbocellmode,
+      :turbocellsat, :carrierset, :maxseenrate, :encodingset, :decrypted,
+      :dupeivpackets, :bsstimestamp, :cdpdevice, :cdpport, :fragments, :retries,
+      :newpackets, :freqmhz, :datacryptset
+    )
+    Bssid.set_data_filter(:bssid) { |val| val.downcase }
+    Bssid.set_data_filter(:llcpackets, :datapackets, :cryptpackets,
+                          :firsttime, :lasttime, :atype, :gpsfixed, :minlat,
+                          :minlon, :minalt, :minspd, :maxlat, :maxlon, :maxalt,
+                          :maxspd, :signal_dbm, :noise_dbm, :minsignal_dbm,
+                          :minnoise_dbm, :maxsignal_dbm, :maxnoise_dbm,
+                          :signal_rssi, :noise_rssi, :minsignal_rssi,
+                          :minnoise_rssi, :maxsignal_rssi, :maxnoise_rssi,
+                          :bestlat, :bestlon, :bestalt, :agglat, :agglon,
+                          :aggalt, :aggpoints, :datasize, :turbocellnid,
+                          :turbocellmode, :turbocellsat, :carrierset, :channel,
+                          :maxseenrate, :encodingset, :decrypted, :dupeivpackets,
+                          :bsstimestamp, :fragments, :retries, :newpackets) { |val| val.to_i }
+
+    # Attempt to map the returned BSSID type to one we know about it and
+    # convert it to a string. In the event we don't know it will leave this as
+    # an integer field.
+    #
+    # @param [String] bssid_type The string is actually an integer value in
+    #   numeric form (this is how it's received from the network).
+    Bssid.set_data_filter(:type) { |val| BSSID_TYPE_MAP[val.to_i] || val.to_i }
+    Bssid.set_data_filter(:rangeip, :netmaskip, :gatewayip) { |val| (val == "0.0.0.0") ? nil : val }
+
+    Bssid.set_data_filter(:freqmhz) do |val|
+      raw = val.split('*').reject { |i| i.strip.empty? }.map { |v| v.split(':').map(&:to_i) }
+      Hash[raw]
+    end
+  end
+end

data/lib/patronus_fati/message_models/bssidsrc.rb

@@ -0,0 +1,15 @@
+module PatronusFati
+  module MessageModels
+    Bssidsrc = CapStruct.new(
+      :bssid, :uuid, :lasttime, :numpackets, :signal_dbm, :noise_dbm,
+      :minsignal_dbm, :minnoise_dbm, :maxsignal_dbm, :maxnoise_dbm, :signal_rssi,
+      :noise_rssi, :minsignal_rssi, :minnoise_rssi, :maxsignal_rssi,
+      :maxnoise_rssi
+    )
+    Bssidsrc.set_data_filter(:bssid) { |val| val.downcase }
+    Bssidsrc.set_data_filter(:numpackets, :signal_dbm, :noise_dbm, :firsttime,
+      :lasttime, :minsignal_dbm, :minnoise_dbm, :maxsignal_dbm, :maxnoise_dbm,
+      :signal_rssi, :noise_rssi, :minsignal_rssi, :minnoise_rssi,
+      :maxsignal_rssi, :maxnoise_rssi) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/btscandev.rb

@@ -0,0 +1,11 @@
+module PatronusFati
+  module MessageModels
+    Btscandev = CapStruct.new(
+      :bdaddr, :name, :class, :firsttime, :lasttime, :packets, :gpsfixed,
+      :minlat, :minlon, :minalt, :minspd, :maxlat, :maxlon, :maxalt, :maxspd,
+      :agglat, :agglon, :aggalt, :aggpoints
+    )
+    Btscandev.set_data_filter(:bdaddr) { |val| val.downcase }
+    Bssid.set_data_filter(:firsttime, :lasttime) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/capability.rb

@@ -0,0 +1,5 @@
+module PatronusFati
+  module MessageModels
+    Capability = CapStruct.new(:name, :capabilities)
+  end
+end

data/lib/patronus_fati/message_models/channel.rb

@@ -0,0 +1,13 @@
+module PatronusFati
+  module MessageModels
+    Channel = CapStruct.new(
+      :channel, :time_on, :packets, :packetsdelta, :usecused, :bytes,
+      :bytesdelta, :networks, :maxsignal_dbm, :maxsignal_rssi, :maxnoise_dbm,
+      :maxnoise_rssi, :activenetworks
+    )
+    Channel.set_data_filter(:channel, :time_on, :packets, :packetsdelta,
+      :usecused, :bytes, :bytesdelta, :networks, :maxsignal_dbm,
+      :maxsignal_dbm, :maxsignal_rssi, :maxnoise_dbm, :maxnoise_rssi,
+      :activenetworks) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/client.rb

@@ -0,0 +1,45 @@
+module PatronusFati
+  module MessageModels
+    Client = CapStruct.new(
+      :bssid, :mac, :type, :firsttime, :lasttime, :manuf, :llcpackets,
+      :datapackets, :cryptpackets, :gpsfixed, :minlat, :minlon, :minalt,
+      :minspd, :maxlat, :maxlon, :maxalt, :maxspd, :agglat, :agglon, :aggalt,
+      :aggpoints, :signal_dbm, :noise_dbm, :minsignal_dbm, :minnoise_dbm,
+      :maxsignal_dbm, :maxnoise_dbm, :signal_rssi, :noise_rssi,
+      :minsignal_rssi, :minnoise_rssi, :maxsignal_rssi, :maxnoise_rssi,
+      :bestlat, :bestlon, :bestalt, :atype, :ip, :gatewayip, :datasize,
+      :maxseenrate, :encodingset, :carrierset, :decrypted, :channel,
+      :fragments, :retries, :newpackets, :freqmhz, :cdpdevice, :cdpport,
+      :dot11d, :dhcphost, :dhcpvendor, :datacryptset
+    )
+    Client.set_data_filter(:bssid, :mac) { |val| val.downcase }
+
+    # Attempt to map the returned client type to one we know about it and
+    # convert it to a string. In the event we don't know it will leave this as
+    # an integer field.
+    #
+    # @param [String] client_type The string is actually an integer value in
+    #   numeric form (this is how it's received from the network).
+    Client.set_data_filter(:type) { |val| CLIENT_TYPE_MAP[val.to_i] || val.to_i }
+    Client.set_data_filter(:firsttime, :lasttime, :llcpackets, :datapackets,
+                           :cryptpackets, :minlat, :minlon, :minalt, :minspd,
+                           :maxlat, :maxlon, :maxalt, :maxspd, :agglat,
+                           :agglon, :aggalt, :aggpoints, :signal_dbm,
+                           :noise_dbm, :minsignal_dbm, :minnoise_dbm,
+                           :maxsignal_dbm, :maxnoise_dbm, :signal_rssi,
+                           :noise_rssi, :minsignal_rssi, :minnoise_rssi,
+                           :maxsignal_rssi, :maxnoise_rssi, :bestlat, :bestlon,
+                           :bestalt, :atype, :datasize, :maxseenrate,
+                           :encodingset, :carrierset, :decrypted, :channel,
+                           :fragments, :retries, :newpackets) { |val| val.to_i }
+    Client.set_data_filter(:gpsfixed) { |val| val.to_i == 1 }
+
+    Client.set_data_filter(:ip, :gatewayip) { |val| (val == "0.0.0.0") ? nil : val }
+    Client.set_data_filter(:dhcphost) { |val| val.strip.empty? ? nil : val }
+
+    Client.set_data_filter(:freqmhz) do |val|
+      raw = val.split('*').reject { |i| i.strip.empty? }.map { |v| v.split(':').map(&:to_i) }
+      Hash[raw]
+    end
+  end
+end

data/lib/patronus_fati/message_models/clisrc.rb

@@ -0,0 +1,17 @@
+module PatronusFati
+  module MessageModels
+    Clisrc = CapStruct.new(
+      :bssid, :mac, :uuid, :lasttime, :numpackets, :signal_dbm, :noise_dbm,
+      :minsignal_dbm, :minnoise_dbm, :maxsignal_dbm, :maxnoise_dbm,
+      :signal_rssi, :noise_rssi, :minsignal_rssi, :minnoise_rssi,
+      :maxsignal_rssi, :maxnoise_rssi
+    )
+
+    Clisrc.set_data_filter(:bssid, :mac) { |val| val.downcase }
+    Clisrc.set_data_filter(:lasttime, :numpackets, :signal_dbm, :noise_dbm,
+                           :minsignal_dbm, :minnoise_dbm, :maxsignal_dbm,
+                           :maxnoise_dbm, :signal_rssi, :noise_rssi,
+                           :minsignal_rssi, :minnoise_rssi, :maxsignal_rssi,
+                           :maxnoise_rssi) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/clitag.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Clitag = CapStruct.new(:bssid, :mac, :tag, :value)
+    Clitag.set_data_filter(:bssid, :mac) { |val| val.downcase }
+  end
+end

data/lib/patronus_fati/message_models/common.rb

@@ -0,0 +1,15 @@
+module PatronusFati
+  module MessageModels
+    Common = CapStruct.new(
+      :phytype, :macaddr, :firsttime, :lasttime, :packets, :llcpackets,
+      :errorpackets, :datapackets, :cryptpackets, :datasize, :newpackets,
+      :channel, :frequency, :freqmhz, :gpsfixed, :minlat, :minlon, :minalt,
+      :minspd, :maxlat, :maxlon, :maxalt, :maxspd, :signaldbm, :noisedbm,
+      :minsignaldbm, :minnoisedbm, :signalrssi, :noiserssi, :minsignalrssi,
+      :minnoiserssi, :maxsignalrssi, :maxnoiserssi, :bestlat, :bestlon,
+      :bestalt, :agglat, :agglon, :aggalt, :aggpoints
+    )
+    Common.set_data_filter(:macaddr) { |val| val.downcase }
+    Common.set_data_filter(:firsttime, :lasttime) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/critfail.rb

@@ -0,0 +1,5 @@
+module PatronusFati
+  module MessageModels
+    Critfail = CapStruct.new(:id, :time, :message)
+  end
+end

data/lib/patronus_fati/message_models/error.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Error = CapStruct.new(:cmdid, :text)
+    Error.set_data_filter(:cmdid) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/gps.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Gps = CapStruct.new(:lat, :lon, :alt, :spd, :heading, :fix, :satinfo, :hdop, :vdop, :connected)
+    Gps.set_data_filter(:lat, :lon, :alt, :spd, :heading, :fix, :hdop, :vdop) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/info.rb

@@ -0,0 +1,11 @@
+module PatronusFati
+  module MessageModels
+    Info = CapStruct.new(
+      :networks, :packets, :crypt, :noise, :dropped, :rate, :filtered, :clients,
+      :llcpackets, :datapackets, :numsources, :numerrorsources
+    )
+    Info.set_data_filter(:networks, :packets, :crypt, :noise, :dropped, :rate,
+                         :filtered, :clients, :llcpackets, :datapackets,
+                         :numsources, :numerrorsources) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/kismet.rb

@@ -0,0 +1,8 @@
+module PatronusFati
+  module MessageModels
+    Kismet = CapStruct.new(
+      :version, :starttime, :servername, :dumpfiles, :uid
+    )
+    Kismet.set_data_filter(:starttime) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/nettag.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Nettag = CapStruct.new(:bssid, :tag, :value)
+    Nettag.set_data_filter(:bssid) { |val| val.downcase }
+  end
+end

data/lib/patronus_fati/message_models/packet.rb

@@ -0,0 +1,10 @@
+module PatronusFati
+  module MessageModels
+    Packet = CapStruct.new(
+      :type, :subtype, :timesec, :encrypted, :weak, :beaconrate, :sourcemac,
+      :destmac, :bssid, :ssid, :prototype, :sourceip, :destip, :sourceport,
+      :destport, :nbtype, :nbsource, :sourcename
+    )
+    Packet.set_data_filter(:bssid, :destmac, :sourcemac) { |val| val.downcase }
+  end
+end

data/lib/patronus_fati/message_models/plugin.rb

@@ -0,0 +1,8 @@
+module PatronusFati
+  module MessageModels
+    Plugin = CapStruct.new(
+      :filename, :name, :version, :description, :unloadable, :root
+    )
+    Plugin.set_data_filter(:unloadable, :root) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/protocols.rb

@@ -0,0 +1,5 @@
+module PatronusFati
+  module MessageModels
+    Protocols = CapStruct.new(:protocols)
+  end
+end

data/lib/patronus_fati/message_models/remove.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Remove = CapStruct.new(:bssid)
+    Remove.set_data_filter(:bssid) { |val| val.downcase }
+  end
+end

data/lib/patronus_fati/message_models/source.rb

@@ -0,0 +1,10 @@
+module PatronusFati
+  module MessageModels
+    Source = CapStruct.new(
+      :interface, :type, :username, :channel, :uuid, :packets, :hop, :velocity,
+      :dwell, :hop_time_sec, :hop_time_usec
+    )
+    Source.set_data_filter(:channel, :dwell, :hop_time_sec, :hop_time_usec,
+                           :hop, :packets, :velocity) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/spectrum.rb

@@ -0,0 +1,8 @@
+module PatronusFati
+  module MessageModels
+    Spectrum = CapStruct.new(
+      :devname, :amp_offset_mdbm, :amp_res_mdbm, :rssi_max, :start_khz,
+      :res_hz, :num_samples, :samples
+    )
+  end
+end

data/lib/patronus_fati/message_models/ssid.rb

@@ -0,0 +1,25 @@
+module PatronusFati
+  module MessageModels
+    Ssid = CapStruct.new(
+      :mac, :checksum, :type, :ssid, :beaconinfo, :cryptset, :cloaked,
+      :firsttime, :lasttime, :maxrate, :beaconrate
+    )
+    Ssid.set_data_filter(:mac) { |val| val.downcase }
+    Ssid.set_data_filter(:checksum, :firsttime, :lasttime, :maxrate,
+                         :beaconrate) { |val| val.to_i }
+    Ssid.set_data_filter(:cloaked) { |val| val.to_i == 1 }
+    Ssid.set_data_filter(:cryptset) do |val|
+      val = val.to_i
+      next [SSID_CRYPT_MAP[0]] if val == 0
+      SSID_CRYPT_MAP.select { |k, _| (k & val) != 0 }.map { |_, v| v }
+    end
+
+    # Attempt to map the returned SSID type to one we know about it and convert
+    # it to a string. In the event we don't know it will leave this as an
+    # integer field.
+    #
+    # @param [String] ssid_type The string is actually an integer value in
+    #   numeric form (this is how it's received from the network).
+    Ssid.set_data_filter(:type) { |val| SSID_TYPE_MAP[val.to_i] || val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/status.rb

@@ -0,0 +1,5 @@
+module PatronusFati
+  module MessageModels
+    Status = CapStruct.new(:text, :flags)
+  end
+end

data/lib/patronus_fati/message_models/string.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    String = CapStruct.new(:bssid, :source, :dest, :string)
+    String.set_data_filter(:bssid) { |val| val.downcase }
+  end
+end

data/lib/patronus_fati/message_models/terminate.rb

@@ -0,0 +1,5 @@
+module PatronusFati
+  module MessageModels
+    Terminate = CapStruct.new(:text)
+  end
+end

data/lib/patronus_fati/message_models/time.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Time = CapStruct.new(:timesec)
+    Time.set_data_filter(:timesec) { |val| val.to_i }
+  end
+end

data/lib/patronus_fati/message_models/trackinfo.rb

@@ -0,0 +1,8 @@
+module PatronusFati
+  module MessageModels
+    Trackinfo = CapStruct.new(
+      :devices, :packets, :datapackets, :cryptpackets, :errorpackets,
+      :filterpackets, :packetrate
+    )
+  end
+end

data/lib/patronus_fati/message_models/wepkey.rb

@@ -0,0 +1,6 @@
+module PatronusFati
+  module MessageModels
+    Wepkey = CapStruct.new(:origin, :bssid, :key, :encrypted, :failed)
+    Wepkey.set_data_filter(:bssid) { |val| val.downcase }
+  end
+end

data/lib/patronus_fati/message_models.rb

@@ -0,0 +1,39 @@
+require 'patronus_fati/message_models/ack'
+require 'patronus_fati/message_models/alert'
+require 'patronus_fati/message_models/battery'
+require 'patronus_fati/message_models/bssid'
+require 'patronus_fati/message_models/bssidsrc'
+require 'patronus_fati/message_models/btscandev'
+require 'patronus_fati/message_models/capability'
+require 'patronus_fati/message_models/channel'
+require 'patronus_fati/message_models/client'
+require 'patronus_fati/message_models/clisrc'
+require 'patronus_fati/message_models/clitag'
+require 'patronus_fati/message_models/common'
+require 'patronus_fati/message_models/critfail'
+require 'patronus_fati/message_models/error'
+require 'patronus_fati/message_models/gps'
+require 'patronus_fati/message_models/info'
+require 'patronus_fati/message_models/kismet'
+require 'patronus_fati/message_models/nettag'
+require 'patronus_fati/message_models/packet'
+require 'patronus_fati/message_models/plugin'
+require 'patronus_fati/message_models/protocols'
+require 'patronus_fati/message_models/remove'
+require 'patronus_fati/message_models/source'
+require 'patronus_fati/message_models/spectrum'
+require 'patronus_fati/message_models/ssid'
+require 'patronus_fati/message_models/status'
+require 'patronus_fati/message_models/string'
+require 'patronus_fati/message_models/terminate'
+require 'patronus_fati/message_models/time'
+require 'patronus_fati/message_models/trackinfo'
+require 'patronus_fati/message_models/wepkey'
+
+module MessageModels
+  # @note In all of the message models the ordering of the attributes is
+  #   actually important, as these are the default orderings provided by the
+  #   server I was developing against.  The casing of the name is also important
+  #   as the best we can automatically do from the header information is a
+  #   downcase and capitalize.
+end