cmdserver 0.10.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fae792cda07478c097e01d974c9753ad2a79e1db
-  data.tar.gz: d881017e9579698f4d014df4f553f85146aa8df6
+  metadata.gz: 2dfb54b6f9772f32e6e92b953e278ff455fcabc5
+  data.tar.gz: f40b0e2b2372a0f9fd39740fcc9463d2c3bf70cc
 SHA512:
-  metadata.gz: 67f8c992d4be5fddcf46fea9649b967fc389f99f5635332d764ecf4223920309deff0335ac53a952c511753be12bbb706f4cfa119eb575a2b1b54fee21e8a7bf
-  data.tar.gz: fa8335ab0c42b8f3fe8c9c5ac83c76824dcafe1a7f5044859ded9305913d5ab1e0a8cd01c3a9f5fe07763f5c74d7a9af83c5b439a41733533c46f5dc05a88a5f
+  metadata.gz: 76583b63b095b3a146823e9245ebdceb525c7ae84c7a4fc0d3f0b0660522013b59b9c7d56dff3f0de41cf69e71e2237b44cec3f7f5d5e8db1b279d0bdaf4af1b
+  data.tar.gz: 3ea121d0fad232fbcd0e0185495fe4f0a7bf38fd0b51f53c36151df3b9fcde6c5aaa0ee7088fadaddb6c1ab5912806d8a3993e2a31d23a48ea17fbc5ed499953

data/.gitignore

@@ -8,3 +8,4 @@
 /spec/reports/
 /tmp/
 *.swp
+tags

data/README.md

@@ -1,8 +1,15 @@
 # Cmdserver
 
 Cmdserver gives you the ability to design a very simple command server.
-Simply create a .rb module under `~/.cmdserver/modules/` and override the module `Cmdserver::CmdProtocol`.   
-Fire up your server and you are done! It is ready to respond to the commands you have defined.
+Simply create a .rb module under `~/.cmdserver/modules/` and override the module `Cmdserver::Cmdprotocol`.   
+Fire up your server and you are done! It is ready to respond to the commands you have defined.  
+
+From version 1.0.0 the `cmdserver` executable is provided for even faster development startup. Please read the __Using 'cmdserver'__ section to learn more.
+
+## Future plans
+
+Currently, the server requests and responses are being sent in plaintext, which isn't exaclty the best idea. However, The server isn't ment as a substitute for SSH or other RCE tools. That is the reason why I haven't included support for SSL. It should be possible to hack this into your server through the modules, but it might be a bit painfull to do so (I haven't tried honestly). So, if there is enough requests to add this in, I might start working on it.  
+Besides that, there aren't any more future plans besides necessary bugfixes, documentation and examples.
 
 ## Installation
 
@@ -20,15 +27,56 @@ Or install it yourself as:
 
     $ gem install cmdserver
 
-## Usage
+## Using the 'cmdserver' executable
+
+With version 1.0.0, you can now easily create a module by issuing `cmdserver --skel > ~/.cmdserver/modules/test.rb`. This will generate  
+a skeleton file which will be loaded by the server during startup. Within the skeleton file there is a quick and dirty manual of  
+what you should do in order to get started. If the `~/.cmdserver/modules` path doesn't exits, create it. Otherwise it will be created the first time the executable is started.  
+To start the server, just type `cmdserver -p PORTNUMBER` where PORTNUMBER is the port you wish your server to listen at.  
+The skeleton file already has the `extension` command defined. To test if everything is working as it should, connect to your server via `telnet` or `netcat` through the specified port, and send it the command string `extension`.  
+The server should respond with `Command recieved`.  
+
+To daemonize the process supply the -d switch.  
+Here is an example session:  
+
+```
+$> cmdserver -dp 2121
+Loading module: /home/user/.cmdserver/modules/test.rb
+Forking server to the background...
+$> nc localhost 2121
+extension
+Command recieved
+^C
+$> 
+```  
+
+You can also force the server to reload all modules by sending it the SIGHUP signal.
+
+Other switches that are available:
+```
+$> cmdserver --help
+Usage: cmdserver [options]
+    -d, --daemon                     Daemonize process
+    -p, --port PORTNUM               Specify arbitrary port
+    -w, --workdir WORKDIR            Active working directory. '~/.cmdserver/' by default.
+					Without -m specified, module directory is set to 'WORKDIR/modules'.
+					This directory is also where 'cmdserver.log' gets created.
+    -m, --module-dir MODULE_DIR      Load modules from MODULE_DIR instead of '~/.cmdserver/modules'
+        --skel                       Dumps a simple module template to standard output.
+        --debug                      Turn on debugging information.
+    -h, --help                       Display this help message
+    -v, --version                    Display version information and exit
+```
+
+## Using the programming API
 
 By default, Cmdserver looks into `~/.cmdserver/modules` for any .rb files present. It then `require`-s them into the program.   
-In these .rb files, you override the module `Cmdserver::CmdProtocol` as demonstrated bellow   
+In these .rb files, you override the module `Cmdserver::Cmdprotocol` as demonstrated bellow   
 
 ```ruby
-module Cmdserver::CmdProtocol
+module Cmdserver::Cmdprotocol
     def self.extend_protocol
-        @protocol_hash["CustomCommand"] = -> client_socket, arguments { client_socket.puts "You sent: #{arguments}" }
+        @protocol["CustomCommand"] = -> client_socket, arguments { client_socket.puts "You sent: #{arguments}" }
     end
 
     def self.default_action(client_socket, arguments)
@@ -44,7 +92,7 @@ For now, argument parsing is left up to the individual functions.
 
 Also note that overriding the default behaviour can be done only once. The last loaded module that redefines `self.default_action` is what is going to happen, when the command is not recognized. By default, it echoes back whatever it recieves.   
 
-The `@protocol_hash` can be destroid in any module. The hash gets copied into the core on a per-module basis. Note that this can introduce
+The `@protocol` can be destroyed in any module. The hash gets copied into the core on a per-module basis. Note that this can introduce
 conflicts when many modules define the same keys for commands.
     
 

data/cmdserver.gemspec

@@ -10,8 +10,17 @@ Gem::Specification.new do |spec|
   spec.email         = ["gordon.zar@gmail.com"]
 
   spec.summary       = %q{Simple, module based command execution server over tcp.}
-  #spec.description   = %q{TODO: Write a longer description or delete this line.}
-  spec.homepage      = "https://github.com/majorendian/Modular-Tcp-Command-Server"
+  spec.description   = %q{
+    Note: Version 1.0.0 introduces some breaking changes. Make sure to read the documentation in case something is breaking
+    at your end.
+
+    'cmdserver' is a simple, multi-threaded, module based and extensible command server with a straight forward API.
+    Much of the functionality relies on ruby's ability to override module definitions at runtime. This, in turn
+    becomes the servers protocol. Read the documentation further details.
+
+    Gem includes an executable launching the server with a simple template file for getting started with writting protocol extension modules.
+  }
+  spec.homepage      = "https://github.com/majorendian/cmdserver"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
@@ -24,10 +33,10 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "release"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{^release/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", ">= 1.7"
+  spec.add_development_dependency "rake", ">= 10.0"
   spec.add_development_dependency "rspec"
 end

data/lib/cmdserver.rb

@@ -1,70 +1,53 @@
 require "socket"
 require "pathname"
 require "cmdserver/version"
+require "cmdserver/cmdprotocol"
+require "cmdserver/templates"
+require "cmdserver/cli"
 
 module Cmdserver
 
-    module CmdProtocol
-        # Protocol stuff goes here.
-        # Should be loaded from ~/.cmdserver/modules/*.rb
-        @protocol_hash = {}
-        @protocol = @protocol_hash
-        def self.extend_protocol()
-            @protocol = {
-                "dummy" => -> cs, args { cs.puts "Dummy reply"}
-            }
-            @protocol_hash = @protocol
-        end
-
-        def self.default_action(cs, args)
-            cs.puts args
-        end
-
-        module_function
-        def get_protocol_hash()
-            self.extend_protocol()
-            @protocol = @protocol_hash
-            return @protocol
-        end
-
-        # Default behaviour when querry was not found
-        module_function
-        def default(cs, args)
-            # NOTE: args is a String
-            self.default_action(cs, args)
-        end
-    end
+    class Settings# {{{
 
-    class Settings
+        attr_reader :module_dir
+        attr_reader :workdir
 
-        def initialize(config_dir="~/.cmdserver/")
-            @workdir = Pathname.new(File.expand_path(config_dir))
-            @config_rc = @workdir + "config" # Configuration file currently unused
+        def initialize(work_dir="~/.cmdserver/")
+            @workdir = Pathname.new(File.expand_path(work_dir))
             @module_dir = @workdir + "modules"
             if not @workdir.exist?
                 Dir.mkdir @workdir
-                if not @config_rc.exist?
-                    File.new @config_rc, "w"
-                end
             end
             if not @module_dir.exist?
                 Dir.mkdir @module_dir
             end
-            # Load modules contained within the module
-            # directories
-            load_modules()
+            # load_modules is now being called by the
+            # TCPCommandServer class
         end
 
         def load_modules
-            Dir.glob("#{@module_dir}/*.rb").each do |mod|
-                CmdProtocol.extend_protocol()
+            Dir.glob("#{@module_dir}/**/*.rb").each do |mod|
+                Cmdserver::Cmdprotocol.extend_protocol()
                 puts "Loading module: #{mod}"
                 require mod
             end
         end
-    end
+    end# }}}
+
+    class CustomSettings < Settings# {{{
 
-    class Command # Class provided for the possibilty of future extensibility
+        def initialize(options)
+            @workdir = options[:workdir]
+            if not @workdir.nil?
+                super(work_dir=@workdir)
+            else
+                super()
+            end
+            @module_dir = options[:module_dir] if options[:module_dir]
+        end
+    end# }}}
+
+    class Command # Class provided for the possibilty of future extensibility# {{{
         def initialize
         end
 
@@ -72,46 +55,87 @@ module Cmdserver
             client_socket.puts "Dummy command call"
         end
 
-    end
+    end# }}}
 
-    class TCPCommandServer
+    class TCPCommandServer# {{{
 
         attr_accessor :socket
+        attr_reader :settings
+        attr_writer :reload_settings
 
         def initialize(port, hash={}, settings=nil, debug=false)
             @socket = TCPServer.new(port)
+            @reload_settings = false # Used from Signal.trap to allow module reloading
             @cmd_hash = hash # hash of commands
-            load_cmd_proto()
+            @settings = settings
             @debug = debug
-            if settings.nil?
+            if @settings.nil?
                 @settings = Settings.new()
             end
+            @settings.load_modules()
+            load_cmd_proto()
         end
 
         def load_cmd_proto()
-            phash = CmdProtocol.get_protocol_hash()
+            phash = Cmdserver::Cmdprotocol.get_protocol_hash()
             phash.each_key do |key|
                 @cmd_hash[key] = phash[key]
             end
+            puts phash if @debug
         end
 
         def registerCallback(string, aproc)
             @cmd_hash[string] = aproc
         end
 
+
+        # "Private" schelued updater.
+        # Allows for loading of modules
+        # without having to restart the server
+        def _update_loop_
+            loop do
+                sleep 2
+                _update_()
+            end
+        end
+
+        def _update_
+            if @reload_settings
+                @settings.load_modules()
+                @reload_settings = false
+            end
+        end
+
+        # Start the local updater,
+        # and the socket => thread loop
         def start()
+            # Start the local updater
+            Thread.new{ _update_loop_() }
             loop do
-                client = @socket.accept
+                begin
+                    client = @socket.accept
+                    # update so that clients get the updated module
+                    # prevents race condition between connection
+                    # and the updater loop
+                    # Thanks to the variable, the modules will not get
+                    # loaded twice in a single update
+                    _update_() 
+                rescue SystemCallError
+                    exit -1
+                end
+
                 Thread.new{ process_client(client) }
             end
         end
 
-        def process_client(client)
+        def process_client(client)# {{{
             #NOTE: This should remain as an isolated thread process
             loop do
                 request = client.gets
+                # TODO:
+                # request = Cmdserver::Connection.client_to_server(request)
                 if not request.nil?
-                    request.chomp! 
+                    request.chomp!
                     puts "Got '#{request}'" if @debug
                     real_key = nil
                     @cmd_hash.each_key do |key|
@@ -120,7 +144,7 @@ module Cmdserver
                         end
                     end
                     puts "real_key:#{real_key}" if @debug
-                    if not real_key.nil?
+                    if not real_key.nil? and request.start_with? real_key
                         begin
                             request.sub! real_key, ""
                             request.lstrip!
@@ -134,17 +158,13 @@ module Cmdserver
                             raise $!
                         end
                     else
-                        Cmdserver::CmdProtocol.default(client, request)
+                        Cmdserver::Cmdprotocol.default(client, request)
                     end
                 else
                     client.close()
                     break
                 end
             end
-        end
-    end
+        end# }}}
+    end# }}}
 end
-
-
-#server = TCPCommandServer.new(2121, {}, false)
-#server.start()

data/lib/cmdserver/cli.rb

@@ -0,0 +1,71 @@
+module Cmdserver::CLI
+
+    DAEMON_NAME = "cmdserver"
+    DAEMON_LOGFILE = "cmdserver.log"
+
+    class Daemonizer
+        def initialize()
+            @dprocess = nil
+            @daemon_pid_file = nil
+            @daemon_pid = nil
+            @daemon_running = false
+        end
+
+        def daemonize()
+            puts "Forking server to the background..."
+
+            if @dprocess.nil?
+                puts "FATAL ERROR: No daemon process specified!"
+                exit -1
+            end
+
+            pid = fork
+            if not pid
+                #child
+                daemon_preparation()
+                @dprocess.call()
+                puts "Server started."
+            end
+            return pid
+        end
+
+        def daemon_preparation
+            $0 = DAEMON_NAME
+            Process.setsid
+            Signal.trap("HUP", proc { _handle_sighup } ) 
+            Signal.trap("TERM", proc { _handle_sigterm } )
+        end
+
+        def _handle_sighup()
+            # Placeholder
+        end
+
+        def _handle_sigterm()
+            # Placeholder
+        end
+    end
+
+    class ServerDaemonizer < Daemonizer
+        def initialize(server)
+            super()
+            @server = server
+            @dprocess = -> { server.start() }
+        end
+
+        def daemon_preparation
+            super()
+            logpath = Pathname.new(@server.settings.workdir) + Pathname.new(DAEMON_LOGFILE)
+            $stdout.reopen(logpath, "a")
+            $stderr = $stdout
+        end
+
+        # NOTE: Could use some logging mechanism...
+        def _handle_sighup()
+            @server.reload_settings = true
+        end
+
+        def _handle_sigterm()
+            @server.socket.close()
+        end
+    end
+end

data/lib/cmdserver/cmdprotocol.rb

@@ -0,0 +1,28 @@
+module Cmdserver::Cmdprotocol
+    # Protocol stuff goes here.
+    # Should be loaded from ~/.cmdserver/modules/*.rb
+    @protocol = {}
+
+    module_function
+    def extend_protocol()
+        @protocol = {
+            "dummy" => -> cs, args { cs.puts "Dummy reply"}
+        }
+    end
+
+    def default_action(cs, args)
+        cs.puts args
+    end
+
+    def get_protocol_hash()
+        extend_protocol()
+        return @protocol
+    end
+
+    # Default behaviour when querry was not found
+    def default(cs, args)
+        # NOTE: args is a String
+        default_action(cs, args)
+    end
+
+end

data/lib/cmdserver/templates.rb

@@ -0,0 +1,25 @@
+module Cmdserver::Templates
+    class BasicTemplate
+
+        attr_reader :body
+
+        def initialize
+            @body = <<TEMPLATE
+module Cmdserver::Cmdprotocol
+    def self.extend_protocol()
+        # Replace the bellow with your own commands.
+        # Each key is a command your server will accept and
+        # call the Proc or Command associated with it.
+        # 'Command' can also be a class as long as it has a 'call' method
+        @protocol["extension"] = -> client_socket, argument { client_socket.puts "Command recieved" }
+    end
+
+    # Replace the bellow with your own default 'command not found' action
+    def self.default_action(client_socket, argument)
+        client_socket.puts "No such command: '\#{argument}'"
+    end
+end
+TEMPLATE
+        end
+    end
+end

data/lib/cmdserver/version.rb

@@ -1,3 +1,3 @@
 module Cmdserver
-    VERSION = "0.10.0"
+    VERSION = "1.0.0"
 end

data/release/cmdserver

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "bundler/setup"
+require "cmdserver"
+
+options = {
+    :debug => false,
+}
+optparse = OptionParser.new do |opts|
+    opts.banner = <<"HELP"
+Usage: cmdserver [options]
+HELP
+
+    opts.on("-d", "--daemon", "Daemonize process") do
+        options[:daemon] = true
+    end
+
+    opts.on("-p", "--port PORTNUM", "Specify arbitrary port") do |portarg|
+        options[:port] = portarg
+    end
+
+    opts.on("-w", "--workdir WORKDIR", "Active working directory. '~/.cmdserver/' by default.\n\t\t\t\t\tWithout -m specified, module directory is set to 'WORKDIR/modules'.\n\t\t\t\t\tThis directory is also where 'cmdserver.log' gets created.") do |workdir| 
+        options[:workdir] = workdir
+    end
+
+    opts.on("-m", "--module-dir MODULE_DIR", "Load modules from MODULE_DIR instead of '~/.cmdserver/modules'" ) do |module_dir|
+        options[:module_dir] = module_dir
+    end
+
+    opts.on("--skel", "Dumps a simple module template to standard output.") do
+        puts Cmdserver::Templates::BasicTemplate.new().body
+        exit
+    end
+
+    opts.on("--debug", "Turn on debugging information.") do
+        options[:debug] = true
+    end
+
+    opts.on("-h", "--help", "Display this help message") do
+        puts opts
+        exit
+    end
+
+    opts.on("-v", "--version", "Display version information and exit") do
+        puts Cmdserver::VERSION
+        exit
+    end
+end
+
+optparse.parse!
+
+
+custom_settings = Cmdserver::CustomSettings.new(options)
+port = options[:port] 
+if port.nil?
+    puts "Port required.\nSee --help"
+    exit(1)
+end
+server = Cmdserver::TCPCommandServer.new(port, {}, settings=custom_settings, debug=options[:debug])
+
+begin
+    if options[:daemon]
+        daem = Cmdserver::CLI::ServerDaemonizer.new(server)
+        daem.daemonize()
+    else
+        server.start()
+    end
+rescue Interrupt => ie
+    puts
+    puts "Terminating..."
+    server.socket.close()
+    exit
+end

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: cmdserver
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ernest Deák
 autorequire: 
 bindir: release
 cert_chain: []
-date: 2015-11-01 00:00:00.000000000 Z
+date: 2015-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
@@ -52,10 +52,18 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description: "\n    Note: Version 1.0.0 introduces some breaking changes. Make sure
+  to read the documentation in case something is breaking\n    at your end.\n\n    'cmdserver'
+  is a simple, multi-threaded, module based and extensible command server with a straight
+  forward API.\n    Much of the functionality relies on ruby's ability to override
+  module definitions at runtime. This, in turn\n    becomes the servers protocol.
+  Read the documentation further details.\n\n    Gem includes an executable launching
+  the server with a simple template file for getting started with writting protocol
+  extension modules.\n  "
 email:
 - gordon.zar@gmail.com
-executables: []
+executables:
+- cmdserver
 extensions: []
 extra_rdoc_files: []
 files:
@@ -71,8 +79,12 @@ files:
 - bin/testserver
 - cmdserver.gemspec
 - lib/cmdserver.rb
+- lib/cmdserver/cli.rb
+- lib/cmdserver/cmdprotocol.rb
+- lib/cmdserver/templates.rb
 - lib/cmdserver/version.rb
-homepage: https://github.com/majorendian/Modular-Tcp-Command-Server
+- release/cmdserver
+homepage: https://github.com/majorendian/cmdserver
 licenses:
 - MIT
 metadata: