ruby_clamdscan 0.1.0

data/docker/clamav/config/freshclam.conf

@@ -0,0 +1,204 @@
+##
+## Example config file for freshclam
+## Please read the freshclam.conf(5) manual before editing this file.
+##
+
+
+# Comment or remove the line below.
+# Example
+
+# Path to the database directory.
+# WARNING: It must match clamd.conf's directive!
+# Default: hardcoded (depends on installation options)
+#DatabaseDirectory /var/lib/clamav
+
+# Path to the log file (make sure it has proper permissions)
+# Default: disabled
+UpdateLogFile /var/log/clamav/freshclam.log
+
+# Maximum size of the log file.
+# Value of 0 disables the limit.
+# You may use 'M' or 'm' for megabytes (1M = 1m = 1048576 bytes)
+# and 'K' or 'k' for kilobytes (1K = 1k = 1024 bytes).
+# in bytes just don't use modifiers. If LogFileMaxSize is enabled,
+# log rotation (the LogRotate option) will always be enabled.
+# Default: 1M
+#LogFileMaxSize 2M
+
+# Log time with each message.
+# Default: no
+#LogTime yes
+
+# Enable verbose logging.
+# Default: no
+#LogVerbose yes
+
+# Use system logger (can work together with UpdateLogFile).
+# Default: no
+#LogSyslog yes
+
+# Specify the type of syslog messages - please refer to 'man syslog'
+# for facility names.
+# Default: LOG_LOCAL6
+#LogFacility LOG_MAIL
+
+# Enable log rotation. Always enabled when LogFileMaxSize is enabled.
+# Default: no
+#LogRotate yes
+
+# This option allows you to save the process identifier of the daemon
+# This file will be owned by root, as long as freshclam was started by root.
+# It is recommended that the directory where this file is stored is
+# also owned by root to keep other users from tampering with it.
+# Default: disabled
+PidFile /tmp/freshclam.pid
+
+# By default when started freshclam drops privileges and switches to the
+# "clamav" user. This directive allows you to change the database owner.
+# Default: clamav (may depend on installation options)
+DatabaseOwner clamav
+
+# Use DNS to verify virus database version. FreshClam uses DNS TXT records
+# to verify database and software versions. With this directive you can change
+# the database verification domain.
+# WARNING: Do not touch it unless you're configuring freshclam to use your
+# own database verification domain.
+# Default: current.cvd.clamav.net
+#DNSDatabaseInfo current.cvd.clamav.net
+
+# database.clamav.net is now the primary domain name to be used world-wide.
+# Now that CloudFlare is being used as our Content Delivery Network (CDN),
+# this one domain name works world-wide to direct freshclam to the closest
+# geographic endpoint.
+# If the old db.XY.clamav.net domains are set, freshclam will automatically
+# use database.clamav.net instead.
+DatabaseMirror database.clamav.net
+
+# How many attempts to make before giving up.
+# Default: 3 (per mirror)
+#MaxAttempts 5
+
+# With this option you can control scripted updates. It's highly recommended
+# to keep it enabled.
+# Default: yes
+ScriptedUpdates yes
+
+# By default freshclam will keep the local databases (.cld) uncompressed to
+# make their handling faster. With this option you can enable the compression;
+# the change will take effect with the next database update.
+# Default: no
+#CompressLocalDatabase no
+
+# With this option you can provide custom sources for database files.
+# This option can be used multiple times. Support for:
+#   http(s)://, ftp(s)://, or file://
+# Default: no custom URLs
+#DatabaseCustomURL http://myserver.example.com/mysigs.ndb
+#DatabaseCustomURL https://myserver.example.com/mysigs.ndb
+#DatabaseCustomURL https://myserver.example.com:4567/allow_list.wdb
+#DatabaseCustomURL ftp://myserver.example.com/example.ldb
+#DatabaseCustomURL ftps://myserver.example.com:4567/example.ndb
+#DatabaseCustomURL file:///mnt/nfs/local.hdb
+
+# This option allows you to easily point freshclam to private mirrors.
+# If PrivateMirror is set, freshclam does not attempt to use DNS
+# to determine whether its databases are out-of-date, instead it will
+# use the If-Modified-Since request or directly check the headers of the
+# remote database files. For each database, freshclam first attempts
+# to download the CLD file. If that fails, it tries to download the
+# CVD file. This option overrides DatabaseMirror, DNSDatabaseInfo
+# and ScriptedUpdates. It can be used multiple times to provide
+# fall-back mirrors.
+# Default: disabled
+#PrivateMirror mirror1.example.com
+#PrivateMirror mirror2.example.com
+
+# Number of database checks per day.
+# Default: 12 (every two hours)
+#Checks 24
+
+# Proxy settings
+# The HTTPProxyServer may be prefixed with [scheme]:// to specify which kind
+# of proxy is used.
+#   http://     HTTP Proxy. Default when no scheme or proxy type is specified.
+#   https://    HTTPS Proxy. (Added in 7.52.0 for OpenSSL, GnuTLS and NSS)
+#   socks4://   SOCKS4 Proxy.
+#   socks4a://  SOCKS4a Proxy. Proxy resolves URL hostname.
+#   socks5://   SOCKS5 Proxy.
+#   socks5h://  SOCKS5 Proxy. Proxy resolves URL hostname.
+# Default: disabled
+#HTTPProxyServer https://proxy.example.com
+#HTTPProxyPort 1234
+#HTTPProxyUsername myusername
+#HTTPProxyPassword mypass
+
+# If your servers are behind a firewall/proxy which applies User-Agent
+# filtering you can use this option to force the use of a different
+# User-Agent header.
+# As of ClamAV 0.103.3, this setting may not be used when updating from the
+# clamav.net CDN and can only be used when updating from a private mirror.
+# Default: clamav/version_number (OS: ..., ARCH: ..., CPU: ..., UUID: ...)
+#HTTPUserAgent SomeUserAgentIdString
+
+# Use aaa.bbb.ccc.ddd as client address for downloading databases. Useful for
+# multi-homed systems.
+# Default: Use OS'es default outgoing IP address.
+#LocalIPAddress aaa.bbb.ccc.ddd
+
+# Send the RELOAD command to clamd.
+# Default: no
+NotifyClamd /etc/clamav/clamd.conf
+
+# Run command after successful database update.
+# Use EXIT_1 to return 1 after successful database update.
+# Default: disabled
+#OnUpdateExecute command
+
+# Run command when database update process fails.
+# Default: disabled
+#OnErrorExecute command
+
+# Run command when freshclam reports outdated version.
+# In the command string %v will be replaced by the new version number.
+# Default: disabled
+#OnOutdatedExecute command
+
+# Don't fork into background.
+# Default: no
+#Foreground yes
+
+# Enable debug messages in libclamav.
+# Default: no
+#Debug yes
+
+# Timeout in seconds when connecting to database server.
+# Default: 30
+#ConnectTimeout 60
+
+# Timeout in seconds when reading from database server. 0 means no timeout.
+# Default: 60
+#ReceiveTimeout 300
+
+# With this option enabled, freshclam will attempt to load new databases into
+# memory to make sure they are properly handled by libclamav before replacing
+# the old ones.
+# Tip: This feature uses a lot of RAM. If your system has limited RAM and you
+# are actively running ClamD or ClamScan during the update, then you may need
+# to set `TestDatabases no`.
+# Default: yes
+#TestDatabases no
+
+# This option enables downloading of bytecode.cvd, which includes additional
+# detection mechanisms and improvements to the ClamAV engine.
+# Default: yes
+#Bytecode no
+
+# Include an optional signature databases (opt-in).
+# This option can be used multiple times.
+#ExtraDatabase dbname1
+#ExtraDatabase dbname2
+
+# Exclude a standard signature database (opt-out).
+# This option can be used multiple times.
+#ExcludeDatabase dbname1
+#ExcludeDatabase dbname2

data/docker-compose.yml

@@ -0,0 +1,18 @@
+version: "3.9"
+services:
+  clamav:
+    image: clamav/clamav:latest
+    ports:
+      - "3310:3310"
+    volumes:
+      - clamav-dev:/var/lib/clamav # Virus database
+      - ./docker/clamav/config/clamd.conf:/etc/clamav/clamd.conf
+      - ./docker/clamav/config/freshclam.conf:/etc/clamav/freshclam.conf
+
+volumes:
+  clamav-dev:
+
+networks:
+  ruby-clamdscan:
+    external: true
+    name: ruby-clamdscan

data/eicar.com

@@ -0,0 +1 @@
+X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*

data/lib/ruby_clamdscan/commands/manage.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "ruby_clamdscan/commands/utils"
+
+module RubyClamdscan
+  module Commands
+    # Management commands for
+    module Manage
+      # Force ClamAV to reload the virus databases
+      # @param configuration [RubyClamdscan::Configuration] configuration for building the ClamAV connection
+      def self.reload_server_database(configuration)
+        RubyClamdscan::Commands::Utils.send_single_command("RELOAD", configuration)
+      end
+
+      # Shutdown ClamAV server
+      # Note: this will completely close socket communication. Server cannot be restarted through this library
+      # @param configuration [RubyClamdscan::Configuration] configuration for building the ClamAV connection
+      def self.shutdown_server(configuration)
+        RubyClamdscan::Commands::Utils.send_single_command("SHUTDOWN", configuration)
+      end
+    end
+  end
+end

data/lib/ruby_clamdscan/commands/scan.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "socket"
+require "ruby_clamdscan/models/scan_result"
+require "ruby_clamdscan/errors/clamav_errors"
+
+module RubyClamdscan
+  module Commands
+    # Methods for scanning file contents
+    module Scan
+      SCAN_COMMAND = "zINSTREAM\0"
+
+      # Stream file contents to ClamAV
+      # @param file_input_stream [IO] Input file_input_stream to scan
+      # @param configuration [RubyClamdscan::Configuration] Configuration settings
+      # @return [RubyClamdscan::Models::ScanResult]
+      # @raise [RubyClamdscan::Errors::VirusDetectedError] if Configuration is set to raise exception and malware is detected
+      # @raise [RubyClamdscan::Errors::ClamAVCommunicationError] if communication with ClamAV server fails
+      def self.scan(file_input_stream, configuration)
+        response = ""
+        clam_av_stream = nil
+
+        begin
+          clam_av_stream = RubyClamdscan::Socket.open_clamav_socket(configuration)
+          send_contents(clam_av_stream, configuration, file_input_stream)
+          response = get_response(clam_av_stream)
+        rescue StandardError => e
+          raise RubyClamdscan::Errors::ClamAVCommunicationError.new(SCAN_COMMAND, e)
+        ensure
+          clam_av_stream&.close
+        end
+
+        result = build_result(response)
+
+        raise RubyClamdscan::Errors::VirusDetectedError, result if configuration.raise_error_on_virus_detected && result.contains_virus
+
+        result
+      end
+
+      # Stream file contents to ClamAV
+      # @param filepath [String] Path to file in local storage to scan
+      # @param configuration [RubyClamdscan::Configuration] Configuration settings
+      # @return [RubyClamdscan::Models::ScanResult]
+      # @raise IOError if there is no file found at filepath
+      def self.scan_file(filepath, configuration)
+        raise IOError, "Unable to find file #{filepath}" unless File.exist?(filepath)
+
+        begin
+          fd = IO.sysopen(filepath, "rb")
+          fin = IO.new(fd)
+          result = scan(fin, configuration)
+        ensure
+          fin.close
+        end
+        result
+      end
+
+      # Builds a result object after parsing the response from ClamAV
+      # @param response [String] Response from ClamAV stream
+      # @return [RubyClamdscan::Models::ScanResult] Constructed result object
+      def self.build_result(response)
+        # OK response: "stream: OK"
+        # Malware response: "stream: Win.Test.EICAR_HDB-1 FOUND"
+        # Error response "stream: <message> ERROR"
+
+        response = response.strip # Strip out any trailing empty chars from the buffer
+        tokens = response.split(" ")
+        puts("RESPONSE:'#{response}'")
+
+        case tokens
+        in ["stream:", "OK"]
+          RubyClamdscan::Models::ScanResult.new(is_successful: true, contains_virus: false)
+        in ["stream:", virus_info, "FOUND"]
+          RubyClamdscan::Models::ScanResult.new(is_successful: true, contains_virus: true, virus_info:)
+        in []
+          RubyClamdscan::Models::ScanResult.new(is_successful: false, contains_virus: nil,
+                                                error_message: "Empty response from ClamAV, is the server accepting connections?")
+        else
+          RubyClamdscan::Models::ScanResult.new(is_successful: false, contains_virus: nil, error_message: response)
+        end
+      end
+
+      private_class_method :build_result
+
+      # Gets the response from ClamAV off the stream
+      # @param clam_av_stream [IO] Read stream from ClamAV
+      # @return [String] Response
+      def self.get_response(clam_av_stream)
+        response = ""
+        while (data = clam_av_stream.gets)
+          response += data
+        end
+        response
+      end
+
+      private_class_method :get_response
+
+      # Sends file contents from stream to ClamAV
+      # @param clam_av_stream [IO] Stream to ClamAV
+      # @param configuration [RubyClamdscan::Configuration] Params defining how much data to send per chunk
+      # @param file_input_stream [IO] Stream to read file contents from
+      def self.send_contents(clam_av_stream, configuration, file_input_stream)
+        clam_av_stream.write(SCAN_COMMAND) # Write the command to tell ClamAV to start scanning
+        clam_av_stream.flush
+        while (chunk = file_input_stream.read(configuration.chunk_size))
+          chunk_len = [chunk.length].pack("N")
+          clam_av_stream.write(chunk_len + chunk)
+          clam_av_stream.flush
+        end
+        clam_av_stream.write([0x00, 0x00, 0x00, 0x00].pack("NNNN"))
+        clam_av_stream.flush
+      end
+
+      private_class_method :send_contents
+    end
+  end
+end

data/lib/ruby_clamdscan/commands/status.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "ruby_clamdscan/commands/utils"
+
+module RubyClamdscan
+  module Commands
+    # Status commands for ClamAV
+    module Status
+      # Attempts to ping the ClamAV server
+      # @param configuration [RubyClamdscan::Configuration] configuration for building the ClamAV connection
+      # @raise [RubyClamdscan::Exceptions::EmptyResponseError] If server response is empty
+      def self.ping_server(configuration)
+        RubyClamdscan::Commands::Utils.send_single_command("PING", configuration)
+      end
+
+      # Attempts to retrieve the ClamAV server's version information
+      # @param configuration [RubyClamdscan::Configuration] configuration for building the ClamAV connection
+      # @raise [RubyClamdscan::Exceptions::EmptyResponseError] If server response is empty
+      def self.server_version(configuration)
+        RubyClamdscan::Commands::Utils.send_single_command("VERSION", configuration)
+      end
+
+      # Replies with statistics about the scan queue, contents of scan queue, and memory usage
+      # Because the format of this response is subject to change, this method will only return the string
+      # Uses "nSTATS\n", blocks in the returned response will be separated by the \n character
+      # @param configuration [RubyClamdscan::Configuration] configuration for building the ClamAV connection
+      # @return [String] Format (currently):
+      # "POOLS: 1\n\nSTATE: VALID PRIMARY\nTHREADS: live 1  idle 0 max 10 idle-timeout 30\nQUEUE: 0 items\n\tSTATS 0.000375 \n\n
+      # MEMSTATS: heap N/A mmap N/A used N/A free N/A releasable N/A pools 1 pools_used 1281.773M pools_total 1281.827M\nEND"
+      # @raise [RubyClamdscan::Errors::EmptyResponseError] If server response is empty
+      def self.server_stats(configuration)
+        RubyClamdscan::Commands::Utils.send_single_command("nSTATS\n", configuration)
+      end
+    end
+  end
+end

data/lib/ruby_clamdscan/commands/utils.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "ruby_clamdscan/errors/clamav_errors"
+
+module RubyClamdscan
+  module Commands
+    # Utilities for running commands
+    module Utils
+      # Sends a single command to the ClamAV server and return its response
+      # @param command [String] Command to send
+      # @param configuration [RubyClamdscan::Configuration] Configuration used for building socket
+      # @return [String] Response from ClamAV server
+      # @raise [RubyClamdscan::Errors::EmptyResponseError] if configuration.raise_error_on_empty_response is true and server doesn't send response
+      # @raise
+      def self.send_single_command(command, configuration)
+        response = ""
+        begin
+          clam_av_stream = RubyClamdscan::Socket.open_clamav_socket(configuration)
+          clam_av_stream.write(command)
+          clam_av_stream.flush
+
+          while (data = clam_av_stream.gets)
+            response += data
+          end
+
+          response = response.strip
+        rescue StandardError => e
+          raise RubyClamdscan::Errors::ClamAVCommunicationError.new(command, e)
+        ensure
+          clam_av_stream&.close
+        end
+
+        raise RubyClamdscan::Errors::EmptyResponseError, command if configuration.raise_error_on_empty_response && response.empty?
+
+        response
+      end
+    end
+  end
+end

data/lib/ruby_clamdscan/configuration.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubyClamdscan
+  # Configuration for the gem
+  class Configuration
+    # TCP Port ClamAV is listening on if using TCP
+    # Default: 3310
+    # @return [Integer]
+    attr_accessor :tcp_port
+
+    # Host ClamAV is listening on if using TCP
+    # Default: localhost
+    # @return [String]
+    attr_accessor :tcp_host
+
+    # Unix Socket for ClamAV
+    # Default: /tmp/clamd.socket
+    # @return [String]
+    attr_accessor :unix_socket
+
+    # Chunk size in bytes for streaming files
+    # Default: 1024
+    # @return [Integer]
+    attr_accessor :chunk_size
+
+    # If TCP socket should be used. If false, the Unix socket will be used instead
+    # Note, if running ClamAV on the same host, it is recommended to use the Unix socket as it's much faster
+    # Default: false
+    # @return [Boolean]
+    attr_accessor :use_tcp_socket
+
+    # If the server responds with an empty string, raise an error instead of just returning the empty string
+    # Default: true
+    # @return [Boolean]
+    attr_accessor :raise_error_on_empty_response
+
+    # If a virus is detected in the scanned contents, raise an error
+    # RubyClamdscan::Commands::Scan methods will raise RubyClamdscan::Errors::VirusDetected
+    # Default: true
+    # @return [Boolean]
+    attr_accessor :raise_error_on_virus_detected
+
+    def initialize
+      @tcp_host = "localhost"
+      @tcp_port = 3310
+      @chunk_size = 1024
+      @unix_socket = "/tmp/clamd.socket"
+      @raise_error_on_empty_response = true
+      @raise_error_on_virus_detected = true
+    end
+  end
+end

data/lib/ruby_clamdscan/errors/clamav_errors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyClamdscan
+  module Errors
+    # Raised when ClamAV returns an empty response - usually means that the server has not finished starting or is shutdown
+    class EmptyResponseError < StandardError
+      # @param command [String] Command that failed
+      # @param msg [String, nil] Optional message
+      def initialize(command, msg: nil)
+        msg = "Got empty response when attempting to run command: #{command}. Are you sure the ClamAV server is running?" unless msg.nil?
+        super(msg)
+      end
+    end
+
+    # Raised when there is some error in communicating with the ClamAV server
+    # @param command [String] Command that failed
+    # @param cause [StandardError, nil] Underlying error if found
+    # @param msg [String, nil] Optional message
+    class ClamAVCommunicationError < StandardError
+      # @return [StandardError, nil] Underlying error if found
+      attr_reader :cause
+
+      def initialize(command, cause, msg: nil)
+        @cause = cause
+        msg = "Error while communicating with ClamAV - cause: #{cause&.msg} command: #{command}." unless msg.nil?
+        super(msg)
+      end
+    end
+
+    # Raised if ClamAV detects malware in the scanned contents
+    class VirusDetectedError < StandardError
+      # @return [RubyClamdscan::Models::ScanResult] Information about scan and virus
+      attr_reader :scan_result
+
+      # @param scan_result [RubyClamdscan::Models::ScanResult] Information about scan result
+      # @param msg [String, nil] Optional message
+      def initialize(scan_result, msg: nil)
+        @scan_result = scan_result
+        msg = "Detected malware in scanned contents: #{scan_result.virus_info}" unless msg.nil?
+        super(msg)
+      end
+    end
+  end
+end

data/lib/ruby_clamdscan/models/scan_result.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyClamdscan
+  module Models
+    # Represents the result from scanning a file with ClamAV
+    class ScanResult
+      # If the command successfully - does not indicate file was safe! Check contains_virus for that information
+      # @return [Boolean]
+      attr_reader :is_successful
+
+      # If ClamAV detected malware in the passed file, will be nil if there was an error running the command
+      # @return [Boolean, nil]
+      attr_reader :contains_virus
+
+      # Returns the error string if the command failed
+      # @return [Exception, nil]
+      attr_reader :exception
+
+      # Returns the error string if the command failed
+      # @return [String, nil]
+      attr_reader :error_message
+
+      # Returns virus information if a virus was detected
+      # Value is the response from ClamAV, the malware classification - should be in the form of "Win.Test.EICAR_HDB-1"
+      # @return [String, nil]
+      attr_reader :virus_info
+
+      def initialize(is_successful:, contains_virus:, virus_info: nil, exception: nil, error_message: nil)
+        @is_successful = is_successful
+        @contains_virus = contains_virus
+        @exception = exception
+        @error_message = error_message
+        @virus_info = virus_info
+      end
+    end
+
+    class StatsResult
+      attr_reader :total_pools, :state, :threads_live, :threads_idle, :threads_max
+    end
+  end
+end

data/lib/ruby_clamdscan/socket.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module RubyClamdscan
+  # Socket related methods to open communication
+  module Socket
+    # Open a socket to ClamAV based on RubyClamdscan.Configuration
+    # @param configuration [RubyClamdscan::Configuration] configuration used to determine socket
+    # @return [IO]
+    def self.open_clamav_socket(configuration)
+      if configuration.use_tcp_socket
+        open_tcp_socket(configuration)
+      else
+        open_unix_socket(configuration)
+      end
+    end
+
+    def self.open_tcp_socket(configuration)
+      TCPSocket.open(configuration.tcp_host, configuration.tcp_port)
+    end
+
+    private_class_method :open_tcp_socket
+
+    def self.open_unix_socket(configuration)
+      UNIXSocket.new(configuration.unix_socket)
+    end
+
+    private_class_method :open_unix_socket
+  end
+end

data/lib/ruby_clamdscan/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyClamdscan
+  VERSION = "0.1.0"
+end

data/lib/ruby_clamdscan.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "ruby_clamdscan/socket"
+require "ruby_clamdscan/commands/scan"
+require "ruby_clamdscan/commands/manage"
+require "ruby_clamdscan/commands/status"
+require "ruby_clamdscan/configuration"
+require "ruby_clamdscan/version"
+
+# Utility for interacting with ClamAV
+module RubyClamdscan
+  class << self
+    # Configuration to use interacting with the ClamAV server
+    def configuration
+      @configuration ||= Configuration.new
+      @configuration.use_tcp_socket = true
+      @configuration.tcp_host = "localhost"
+      @configuration.tcp_port = 3310
+
+      @configuration
+    end
+
+    # Configure RubyClamdscan
+    def configure
+      yield(configuration)
+    end
+
+    # Scans a file
+    # @param filepath [String] Path to file in local storage
+    # @return [RubyClamdscan::Models::ScanResult] Result from the scan attempt
+    def scan_file_from_path(filepath)
+      RubyClamdscan::Commands::Scan.scan_file(filepath, @configuration)
+    end
+
+    # Scans the contents of the stream passed in
+    # @param stream [IO] stream of file contents
+    # @return [RubyClamdscan::Models::ScanResult] Result from the scan attempt
+    def scan_contents(stream)
+      RubyClamdscan::Commands::Scan.scan(stream, @configuration)
+    end
+
+    def ping_server
+      RubyClamdscan::Commands::Status.ping_server(@configuration)
+    end
+
+    def server_version
+      RubyClamdscan::Commands::Status.server_version(@configuration)
+    end
+
+    def server_stats
+      RubyClamdscan::Commands::Status.server_stats(@configuration)
+    end
+
+    def reload_server_database
+      RubyClamdscan::Commands::Manage.reload_server_database(@configuration)
+    end
+
+    def shutdown_server
+      RubyClamdscan::Commands::Manage.shutdown_server(@configuration)
+    end
+  end
+end