midi-smtp-server 2.3.3 → 3.0.3

data/lib/midi-smtp-server.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'socket'
 require 'resolv'
 require 'base64'
@@ -10,6 +11,7 @@ module MidiSmtpServer
   # import sources
   require 'midi-smtp-server/version'
   require 'midi-smtp-server/exceptions'
+  require 'midi-smtp-server/logger'
   require 'midi-smtp-server/tls-transport'
 
   # default values
@@ -47,7 +49,7 @@ module MidiSmtpServer
     end
 
     # Stop the server
-    def stop(wait_seconds_before_close = 2, gracefully = true)
+    def stop(wait_seconds_before_close: 2, gracefully: true)
       # always signal shutdown
       shutdown if gracefully
       # wait if some connection(s) need(s) more time to handle shutdown
@@ -101,7 +103,7 @@ module MidiSmtpServer
     # Join with the server thread(s)
     # before joining the server threads, check and wait optionally a few seconds
     # to let the service(s) come up
-    def join(sleep_seconds_before_join = 1)
+    def join(sleep_seconds_before_join: 1)
       # check already existing TCPServers
       return if @tcp_servers.empty?
       # wait some seconds before joininig the upcoming threads
@@ -125,30 +127,23 @@ module MidiSmtpServer
       @ports.dup
     end
 
-    # New but deprecated method to access the old port attr for compatibility reasons
-    def port
-      logger.debug('Deprecated method port is used. Please update to ports.join() etc.')
-      ports.join(', ')
-    end
-
     # Array of hosts / ip_addresses on which to bind, set as string seperated by commata like 'name.domain.com, 127.0.0.1, ::1'
     def hosts
       # prevent original array from being changed
       @hosts.dup
     end
 
-    # New but deprecated method to access the old host attr for compatibility reasons
-    def host
-      logger.debug('Deprecated method host is used. Please update to hosts.join() etc.')
-      hosts.join(', ')
-    end
-
     # Array of ip_address:port which get bound and build up from given hosts and ports
     def addresses
       # prevent original array from being changed
       @addresses.dup
     end
 
+    # Current TLS OpenSSL::SSL::SSLContext when initalized by :TLS_OPTIONAL, :TLS_REQUIRED
+    def ssl_context
+      @tls&.ssl_context
+    end
+
     # Maximum number of simultaneous processed connections, this does not limit the TCP connections itself, as a FixNum
     attr_reader :max_processings
     # Maximum number of allowed connections, this does limit the TCP connections, as a FixNum
@@ -177,38 +172,63 @@ module MidiSmtpServer
 
     # Initialize SMTP Server class
     #
-    # +ports+:: ports to listen on. Allows multiple ports like "2525, 3535" or "2525:3535, 2525"
-    # +hosts+:: interface ip or hostname to listen on or "*" to listen on all interfaces, wildcard ("") is deprecated, allows multiple hostnames and ip_addresses like "name.domain.com, 127.0.0.1, ::1"
-    # +max_processings+:: maximum number of simultaneous processed connections, this does not limit the number of concurrent TCP connections
-    # +opts+:: hash with optional settings
-    # +opts.max_connections+:: maximum number of connections, this does limit the number of concurrent TCP connections (not set or nil => unlimited)
-    # +opts.crlf_mode+:: CRLF handling support (:CRLF_ENSURE [default], :CRLF_LEAVE, :CRLF_STRICT)
-    # +opts.do_dns_reverse_lookup+:: flag if this smtp server should do reverse DNS lookups on incoming connections
-    # +opts.io_cmd_timeout+:: time in seconds to wait until complete line of data is expected (DEFAULT_IO_CMD_TIMEOUT, nil => disabled test)
-    # +opts.io_buffer_chunk_size+:: size of chunks (bytes) to read non-blocking from socket (DEFAULT_IO_BUFFER_CHUNK_SIZE)
-    # +opts.io_buffer_max_size+:: max size of buffer (max line length) until \lf ist expected (DEFAULT_IO_BUFFER_MAX_SIZE, nil => disabled test)
-    # +opts.pipelining_extension+:: set to true for support of SMTP PIPELINING extension (DEFAULT_PIPELINING_EXTENSION_ENABLED)
-    # +opts.internationalization_extensions+:: set to true for support of SMTP 8BITMIME and SMTPUTF8 extensions (DEFAULT_INTERNATIONALIZATION_EXTENSIONS_ENABLED)
-    # +opts.auth_mode+:: enable builtin authentication support (:AUTH_FORBIDDEN [default], :AUTH_OPTIONAL, :AUTH_REQUIRED)
-    # +opts.tls_mode+:: enable builtin TLS support (:TLS_FORBIDDEN [default], :TLS_OPTIONAL, :TLS_REQUIRED)
-    # +opts.tls_cert_path+:: path to tls cerificate chain file
-    # +opts.tls_key_path+:: path to tls key file
-    # +opts.tls_ciphers+:: allowed ciphers for connection
-    # +opts.tls_methods+:: allowed methods for protocol
-    # +opts.tls_cert_cn+:: set subject (CN) for self signed certificate "cn.domain.com"
-    # +opts.tls_cert_san+:: set subject alternative (SAN) for self signed certificate, allows multiple names like "alt1.domain.com, alt2.domain.com"
-    # +opts.logger+:: own logger class, otherwise default logger is created
-    # +opts.logger_severity+:: logger level when default logger is used
-    def initialize(ports = DEFAULT_SMTPD_PORT, hosts = DEFAULT_SMTPD_HOST, max_processings = DEFAULT_SMTPD_MAX_PROCESSINGS, opts = {})
-      # logging
-      if opts.include?(:logger)
-        @logger = opts[:logger]
+    # +ports+:: ports to listen on. Allows multiple ports like "2525, 3535" or "2525:3535, 2525". Default value = DEFAULT_SMTPD_PORT
+    # +hosts+:: interface ip or hostname to listen on or "*" to listen on all interfaces, allows multiple hostnames and ip_addresses like "name.domain.com, 127.0.0.1, ::1". Default value = DEFAULT_SMTPD_HOST
+    # +max_processings+:: maximum number of simultaneous processed connections, this does not limit the number of concurrent TCP connections. Default value = DEFAULT_SMTPD_MAX_PROCESSINGS
+    # +max_connections+:: maximum number of connections, this does limit the number of concurrent TCP connections (not set or nil => unlimited)
+    # +crlf_mode+:: CRLF handling support (:CRLF_ENSURE [default], :CRLF_LEAVE, :CRLF_STRICT)
+    # +do_dns_reverse_lookup+:: flag if this smtp server should do reverse DNS lookups on incoming connections
+    # +io_cmd_timeout+:: time in seconds to wait until complete line of data is expected (DEFAULT_IO_CMD_TIMEOUT, nil => disabled test)
+    # +io_buffer_chunk_size+:: size of chunks (bytes) to read non-blocking from socket (DEFAULT_IO_BUFFER_CHUNK_SIZE)
+    # +io_buffer_max_size+:: max size of buffer (max line length) until \lf ist expected (DEFAULT_IO_BUFFER_MAX_SIZE, nil => disabled test)
+    # +pipelining_extension+:: set to true for support of SMTP PIPELINING extension (DEFAULT_PIPELINING_EXTENSION_ENABLED)
+    # +internationalization_extensions+:: set to true for support of SMTP 8BITMIME and SMTPUTF8 extensions (DEFAULT_INTERNATIONALIZATION_EXTENSIONS_ENABLED)
+    # +auth_mode+:: enable builtin authentication support (:AUTH_FORBIDDEN [default], :AUTH_OPTIONAL, :AUTH_REQUIRED)
+    # +tls_mode+:: enable builtin TLS support (:TLS_FORBIDDEN [default], :TLS_OPTIONAL, :TLS_REQUIRED)
+    # +tls_cert_path+:: path to tls cerificate chain file
+    # +tls_key_path+:: path to tls key file
+    # +tls_ciphers+:: allowed ciphers for connection
+    # +tls_methods+:: allowed methods for protocol
+    # +tls_cert_cn+:: set subject (CN) for self signed certificate "cn.domain.com"
+    # +tls_cert_san+:: set subject alternative (SAN) for self signed certificate, allows multiple names like "alt1.domain.com, alt2.domain.com"
+    # +logger+:: own logger class, otherwise default logger is created (DEPRECATED: use on_logging_event for special needs on logging)
+    # +logger_severity+:: set or override the logger level if given
+    def initialize(
+      ports: DEFAULT_SMTPD_PORT,
+      hosts: DEFAULT_SMTPD_HOST,
+      max_processings: DEFAULT_SMTPD_MAX_PROCESSINGS,
+      max_connections: nil,
+      crlf_mode: nil,
+      do_dns_reverse_lookup: nil,
+      io_cmd_timeout: nil,
+      io_buffer_chunk_size: nil,
+      io_buffer_max_size: nil,
+      pipelining_extension: nil,
+      internationalization_extensions: nil,
+      auth_mode: nil,
+      tls_mode: nil,
+      tls_cert_path: nil,
+      tls_key_path: nil,
+      tls_ciphers: nil,
+      tls_methods: nil,
+      tls_cert_cn: nil,
+      tls_cert_san: nil,
+      logger: nil,
+      logger_severity: nil
+    )
+      # create an exposed logger to forward loggings to the on_logging_event
+      @logger = MidiSmtpServer::ForwardingLogger.new(method(:on_logging_event))
+
+      # external logging
+      if logger.nil?
+        @logger_protected = Logger.new($stdout)
+        @logger_protected.datetime_format = '%Y-%m-%d %H:%M:%S'
+        @logger_protected.formatter = proc { |severity, datetime, _progname, msg| "#{datetime}: [#{severity}] #{msg.chomp}\n" }
+        @logger_protected.level = logger_severity.nil? ? Logger::DEBUG : logger_severity
       else
-        require 'logger'
-        @logger = Logger.new(STDOUT)
-        @logger.datetime_format = '%Y-%m-%d %H:%M:%S'
-        @logger.formatter = proc { |severity, datetime, _progname, msg| "#{datetime}: [#{severity}] #{msg.chomp}\n" }
-        @logger.level = opts.include?(:logger_severity) ? opts[:logger_severity] : Logger::DEBUG
+        @logger_protected = logger
+        @logger_protected.level = logger_severity unless logger_severity.nil?
+        logger.warn('Deprecated: "logger" was set on new! Please use "on_logging_event" instead.')
       end
 
       # list of TCPServers
@@ -235,8 +255,6 @@ module MidiSmtpServer
       # build array of hosts
       # split string into array to instantiate multiple servers
       @hosts = hosts.to_s.delete(' ').split(',')
-      # Deprecated default if empty bind to (first found) local host ip_address
-      # Check that not also the '' wildcard for hosts is added somewhere to the list
       #
       # Check source of TCPServer.c at https://github.com/ruby/ruby/blob/trunk/ext/socket/tcpserver.c#L25-L31
       # * Internally, TCPServer.new calls getaddrinfo() function to obtain ip_addresses.
@@ -247,14 +265,9 @@ module MidiSmtpServer
       # We won't support that magic anymore. If wish to bind on all local ip_addresses
       # and interfaces, use new "*" wildcard, otherwise specify ip_addresses and / or hostnames
       #
-      if @hosts.empty?
-        # info and change to "*" wildcard if only "" was given as hosts
-        logger.debug('Deprecated empty hosts wildcard "" is used. Please use specific hostnames and / or ip_addresses or "*" for wildcard!')
-        @hosts << '*'
-      elsif @hosts.include?('')
-        # raise exception when founding inner wildcard like "a.b.c.d,,e.f.g.h", guess miss-coding
-        raise 'Deprecated empty hosts wildcard "" is used. Please use specific hostnames and / or ip_addresses or "*" for wildcard!'
-      end
+      # raise exception when found empty or inner empty hosts specification like "" or "a.b.c.d,,e.f.g.h", guess miss-coding
+      raise 'No hosts defined! Please use specific hostnames and / or ip_addresses or "*" for wildcard!' if @hosts.empty?
+      raise 'Detected an empty identifier in given hosts! Please use specific hostnames and / or ip_addresses or "*" for wildcard!' if @hosts.include?('')
 
       # build array of addresses for ip_addresses and ports to use
       @addresses = []
@@ -300,51 +313,55 @@ module MidiSmtpServer
 
       # read max_processings
       @max_processings = max_processings
+      raise 'Number of simultaneous processings (max_processings) must be a positive integer!' unless @max_processings.is_a?(Integer) && @max_processings.positive?
       # check max_connections
-      @max_connections = opts.include?(:max_connections) ? opts[:max_connections] : nil
+      @max_connections = max_connections
       raise 'Number of concurrent connections is lower than number of simultaneous processings!' if @max_connections && @max_connections < @max_processings
 
       # check for crlf mode
-      @crlf_mode = opts.include?(:crlf_mode) ? opts[:crlf_mode] : DEFAULT_CRLF_MODE
-      raise "Unknown CRLF mode #{@crlf_mode} was given by opts!" unless CRLF_MODES.include?(@crlf_mode)
+      @crlf_mode = crlf_mode.nil? ? DEFAULT_CRLF_MODE : crlf_mode
+      raise "Unknown CRLF mode #{@crlf_mode} was given!" unless CRLF_MODES.include?(@crlf_mode)
 
       # always prevent auto resolving hostnames to prevent a delay on socket connect
       BasicSocket.do_not_reverse_lookup = true
       # do reverse lookups manually if enabled by io.addr and io.peeraddr
-      @do_dns_reverse_lookup = opts.include?(:do_dns_reverse_lookup) ? opts[:do_dns_reverse_lookup] : true
+      @do_dns_reverse_lookup = do_dns_reverse_lookup.nil? ? true : do_dns_reverse_lookup
 
       # io and buffer settings
-      @io_cmd_timeout = opts.include?(:io_cmd_timeout) ? opts[:io_cmd_timeout] : DEFAULT_IO_CMD_TIMEOUT
-      @io_buffer_chunk_size = opts.include?(:io_buffer_chunk_size) ? opts[:io_buffer_chunk_size] : DEFAULT_IO_BUFFER_CHUNK_SIZE
-      @io_buffer_max_size = opts.include?(:io_buffer_max_size) ? opts[:io_buffer_max_size] : DEFAULT_IO_BUFFER_MAX_SIZE
+      @io_cmd_timeout = io_cmd_timeout.nil? ? DEFAULT_IO_CMD_TIMEOUT : io_cmd_timeout
+      @io_buffer_chunk_size = io_buffer_chunk_size.nil? ? DEFAULT_IO_BUFFER_CHUNK_SIZE : io_buffer_chunk_size
+      @io_buffer_max_size = io_buffer_max_size.nil? ? DEFAULT_IO_BUFFER_MAX_SIZE : io_buffer_max_size
 
       # smtp extensions
-      @pipelining_extension = opts.include?(:pipelining_extension) ? opts[:pipelining_extension] : DEFAULT_PIPELINING_EXTENSION_ENABLED
-      @internationalization_extensions = opts.include?(:internationalization_extensions) ? opts[:internationalization_extensions] : DEFAULT_INTERNATIONALIZATION_EXTENSIONS_ENABLED
+      @pipelining_extension = pipelining_extension.nil? ? DEFAULT_PIPELINING_EXTENSION_ENABLED : pipelining_extension
+      @internationalization_extensions = internationalization_extensions.nil? ? DEFAULT_INTERNATIONALIZATION_EXTENSIONS_ENABLED : internationalization_extensions
 
       # check for authentification
-      @auth_mode = opts.include?(:auth_mode) ? opts[:auth_mode] : DEFAULT_AUTH_MODE
-      raise "Unknown authentification mode #{@auth_mode} was given by opts!" unless AUTH_MODES.include?(@auth_mode)
+      @auth_mode = auth_mode.nil? ? DEFAULT_AUTH_MODE : auth_mode
+      raise "Unknown authentification mode #{@auth_mode} was given!" unless AUTH_MODES.include?(@auth_mode)
 
       # check for encryption
-      @encrypt_mode = opts.include?(:tls_mode) ? opts[:tls_mode] : DEFAULT_ENCRYPT_MODE
-      raise "Unknown encryption mode #{@encrypt_mode} was given by opts!" unless ENCRYPT_MODES.include?(@encrypt_mode)
+      @encrypt_mode = tls_mode.nil? ? DEFAULT_ENCRYPT_MODE : tls_mode
+      raise "Unknown encryption mode #{@encrypt_mode} was given!" unless ENCRYPT_MODES.include?(@encrypt_mode)
       # SSL transport layer for STARTTLS
       if @encrypt_mode == :TLS_FORBIDDEN
         @tls = nil
       else
-        require 'openssl'
+        # try to load openssl gem now
+        begin
+          require 'openssl'
+        rescue LoadError
+        end
+        # check for openssl gem when enabling  TLS / SSL
+        raise 'The openssl library gem is not installed!' unless defined?(OpenSSL)
         # check for given CN and SAN
-        if opts.include?(:tls_cert_cn)
-          tls_cert_cn = opts[:tls_cert_cn].to_s.strip
-          tls_cert_san = opts[:tls_cert_san].to_s.delete(' ').split(',')
-        else
+        if tls_cert_cn.nil?
           # build generic set of "valid" self signed certificate CN and SAN
           # using all given hosts and detected ip_addresses but not "*" wildcard
           tls_cert_san = ([] + @hosts + @addresses.map { |address| address.rpartition(':').first }).uniq
           tls_cert_san.delete('*')
           # build generic CN based on first SAN
-          if tls_cert_san.first =~ /^(127\.0?0?0\.0?0?0\.0?0?1|::1|localhost)$/i
+          if tls_cert_san.first.match?(/^(127\.0?0?0\.0?0?0\.0?0?1|::1|localhost)$/i)
             # used generic localhost.local
             tls_cert_cn = 'localhost.local'
           else
@@ -353,9 +370,33 @@ module MidiSmtpServer
             tls_cert_cn = tls_cert_san.first
             tls_cert_san.slice!(0)
           end
+        else
+          tls_cert_cn = tls_cert_cn.to_s.strip
+          tls_cert_san = tls_cert_san.to_s.delete(' ').split(',')
         end
         # create ssl transport service
-        @tls = TlsTransport.new(opts[:tls_cert_path], opts[:tls_key_path], opts[:tls_ciphers], opts[:tls_methods], tls_cert_cn, tls_cert_san, @logger)
+        @tls = TlsTransport.new(tls_cert_path, tls_key_path, tls_ciphers, tls_methods, tls_cert_cn, tls_cert_san, @logger)
+      end
+    end
+
+    # event on LOGGING
+    # the exposed logger property is from class MidiSmtpServer::ForwardingLogger
+    # and pushes any logging message to this on_logging_event.
+    # if logging occurs from inside session, the _ctx should be not nil
+    # if logging occurs from an error, the err object should be filled
+    def on_logging_event(_ctx, severity, msg, err: nil)
+      case severity
+        when Logger::INFO
+          @logger_protected.info(msg)
+        when Logger::WARN
+          @logger_protected.warn(msg)
+        when Logger::ERROR
+          @logger_protected.error(msg)
+        when Logger::FATAL
+          @logger_protected.fatal(msg)
+          err.backtrace.each { |log| @logger_protected.fatal("#{log}") }
+        else
+          @logger_protected.debug(msg)
       end
     end
 
@@ -365,12 +406,12 @@ module MidiSmtpServer
     # that these will be used as local welcome and greeting strings
     # the values are not allowed to return CR nor LF chars and will be stripped
     def on_connect_event(ctx)
-      logger.debug("Client connect from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} to #{ctx[:server][:local_ip]}:#{ctx[:server][:local_port]}")
+      on_logging_event(ctx, Logger::DEBUG, "Client connect from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} to #{ctx[:server][:local_ip]}:#{ctx[:server][:local_port]}")
     end
 
     # event before DISONNECT
     def on_disconnect_event(ctx)
-      logger.debug("Client disconnect from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} on #{ctx[:server][:local_ip]}:#{ctx[:server][:local_port]}")
+      on_logging_event(ctx, Logger::DEBUG, "Client disconnect from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} on #{ctx[:server][:local_ip]}:#{ctx[:server][:local_port]}")
     end
 
     # event on HELO/EHLO
@@ -386,7 +427,7 @@ module MidiSmtpServer
       # if authentification is used, override this event
       # and implement your own user management.
       # otherwise all authentifications are blocked per default
-      logger.debug("Deny access from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} for #{authentication_id}" + (authorization_id == '' ? '' : "/#{authorization_id}") + " with #{authentication}")
+      on_logging_event(ctx, Logger::DEBUG, "Deny access from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} for #{authentication_id}" + (authorization_id == '' ? '' : "/#{authorization_id}") + " with #{authentication}")
       raise Smtpd535Exception
     end
 
@@ -453,7 +494,7 @@ module MidiSmtpServer
       # log information
       logger.info("Starting service on #{ip_address}:#{port}")
       # check that there is a specific ip_address defined
-      raise 'Deprecated wildcard "" ist not allowed anymore to start a listener on!' if ip_address.empty?
+      raise 'Unable to start TCP listener on missing or empty ip_address!' if ip_address.empty?
       # instantiate the service for ip_address and port
       tcp_server = TCPServer.new(ip_address, port)
       # append this server to the list of TCPServers
@@ -482,7 +523,7 @@ module MidiSmtpServer
                 # ignore this exception due to service shutdown
               rescue StandardError => e
                 # log fatal error while handling connection
-                logger.fatal(e.backtrace.join("\n"))
+                on_logging_event(nil, Logger::FATAL, "#{e} (#{e.class})".strip, err: e.clone)
               ensure
                 begin
                   # always gracefully shutdown connection.
@@ -509,7 +550,7 @@ module MidiSmtpServer
           # ignore this exception due to service shutdown
         rescue StandardError => e
           # log fatal error while starting new thread
-          logger.fatal(e.backtrace.join("\n"))
+          on_logging_event(nil, Logger::FATAL, "#{e} (#{e.class})".strip, err: e.clone)
         ensure
           begin
             # drop the service
@@ -545,7 +586,7 @@ module MidiSmtpServer
           # 220 <domain> Service ready
           # 421 <domain> Service not available, closing transmission channel
           # Reset and initialize message
-          process_reset_session(session, true)
+          process_reset_session(session, connection_initialize: true)
 
           # get local address info
           _, session[:ctx][:server][:local_port], session[:ctx][:server][:local_host], session[:ctx][:server][:local_ip] = @do_dns_reverse_lookup ? io.addr(:hostname) : io.addr(:numeric)
@@ -578,7 +619,7 @@ module MidiSmtpServer
           output = +"220 #{session[:ctx][:server][:local_response].to_s.strip}\r\n"
 
           # log and show to client
-          logger.debug(+'>>> ' << output)
+          on_logging_event(session[:ctx], Logger::DEBUG, +'>>> ' << output)
           io.print output unless io.closed?
 
           # initialize \r\n for line_break, this is used for CRLF_ENSURE and CRLF_STRICT and mark as mutable
@@ -646,27 +687,27 @@ module MidiSmtpServer
                     # remove any \r or \n occurence from line
                     line.delete!("\r\n")
                     # log line, verbosity based on log severity and command sequence
-                    logger.debug(+'<<< ' << line << "\n") if session[:cmd_sequence] != :CMD_DATA
+                    on_logging_event(session[:ctx], Logger::DEBUG, +'<<< ' << line << "\n") if session[:cmd_sequence] != :CMD_DATA
 
                   when :CRLF_LEAVE
                     # use input line_break for line_break
-                    line_break = line[-2..-1] == "\r\n" ? "\r\n" : "\n"
+                    line_break = line[-2..] == "\r\n" ? "\r\n" : "\n"
                     # check to override session crlf info, only when CRLF_LEAVE is used and in DATA mode
                     session[:ctx][:message][:crlf] = line_break if session[:cmd_sequence] == :CMD_DATA
                     # remove any line_break from line
                     line.chomp!
                     # log line, verbosity based on log severity and command sequence
-                    logger.debug(+'<<< ' << line.gsub("\r", '[\r]') << "\n") if session[:cmd_sequence] != :CMD_DATA
+                    on_logging_event(session[:ctx], Logger::DEBUG, +'<<< ' << line.gsub("\r", '[\r]') << "\n") if session[:cmd_sequence] != :CMD_DATA
 
                   when :CRLF_STRICT
                     # check line ends up by \r\n
-                    raise Smtpd500CrLfSequenceException unless line[-2..-1] == "\r\n"
+                    raise Smtpd500CrLfSequenceException unless line[-2..] == "\r\n"
                     # remove any line_break from line
                     line.chomp!
                     # check line for additional \r
                     raise Smtpd500Exception, 'Line contains additional CR chars!' if line.index("\r")
                     # log line, verbosity based on log severity and command sequence
-                    logger.debug(+'<<< ' << line << "\n") if session[:cmd_sequence] != :CMD_DATA
+                    on_logging_event(session[:ctx], Logger::DEBUG, +'<<< ' << line << "\n") if session[:cmd_sequence] != :CMD_DATA
                 end
 
                 # process line and mark output as mutable
@@ -681,8 +722,10 @@ module MidiSmtpServer
               rescue SmtpdException => e
                 # inc number of detected exceptions during this session
                 session[:ctx][:server][:exceptions] += 1
+                # save clone of error object to context
+                session[:ctx][:server][:errors].push(e.clone)
                 # log error info if logging
-                logger.error("#{e}")
+                on_logging_event(session[:ctx], Logger::ERROR, "#{e} (#{e.class})".strip, err: e)
                 # get the given smtp dialog result
                 output = +"#{e.smtpd_result}"
 
@@ -690,8 +733,10 @@ module MidiSmtpServer
               rescue StandardError => e
                 # inc number of detected exceptions during this session
                 session[:ctx][:server][:exceptions] += 1
+                # save clone of error object to context
+                session[:ctx][:server][:errors].push(e.clone)
                 # log error info if logging
-                logger.error("#{e}")
+                on_logging_event(session[:ctx], Logger::ERROR, "#{e} (#{e.class})".strip, err: e)
                 # set default smtp server dialog error
                 output = +"#{Smtpd500Exception.new.smtpd_result}"
               end
@@ -699,7 +744,7 @@ module MidiSmtpServer
               # check result
               unless output.empty?
                 # log smtp dialog // message data is stored separate
-                logger.debug(+'>>> ' << output)
+                on_logging_event(session[:ctx], Logger::DEBUG, +'>>> ' << output)
                 # append line feed
                 output << "\r\n"
                 # smtp dialog response
@@ -719,21 +764,25 @@ module MidiSmtpServer
           io.print(output) unless io.closed?
 
         # connection was simply closed / aborted by remote closing socket
-        rescue EOFError
+        rescue EOFError => e
           # log info but only while debugging otherwise ignore message
-          logger.debug('EOFError - Connection lost due abort by client!')
+          on_logging_event(session[:ctx], Logger::DEBUG, 'Connection lost due abort by client! (EOFError)', err: e)
 
         rescue StandardError => e
+          # inc number of detected exceptions during this session
+          session[:ctx][:server][:exceptions] += 1
+          # save clone of error object to context
+          session[:ctx][:server][:errors].push(e.clone)
           # log error info if logging
-          logger.error("#{e}")
+          on_logging_event(session[:ctx], Logger::ERROR, "#{e} (#{e.class})".strip, err: e)
           # power down connection
           # ignore IOErrors when sending final smtp abort return code 421
           begin
             output = +"#{Smtpd421Exception.new.smtpd_result}\r\n"
             # smtp dialog response
             io.print(output) unless io.closed?
-          rescue StandardError
-            logger.debug('IOError - Can\'t send 421 abort code!')
+          rescue StandardError => e
+            on_logging_event(session[:ctx], Logger::DEBUG, 'Can\'t send 421 abort code! (IOError)', err: e)
           end
         end
 
@@ -790,6 +839,7 @@ module MidiSmtpServer
             # check whether to answer as HELO or EHLO
             case line
               when (/^EHLO/i)
+                # rubocop:disable Style/StringConcatenation
                 # reply supported extensions
                 return "250-#{session[:ctx][:server][:helo_response].to_s.strip}\r\n" +
                        # respond with 8BITMIME extension
@@ -803,6 +853,7 @@ module MidiSmtpServer
                        # respond with STARTTLS if available and not already enabled
                        (@encrypt_mode == :TLS_FORBIDDEN || encrypted?(session[:ctx]) ? '' : "250-STARTTLS\r\n") +
                        '250 OK'
+                # rubocop:enable all
               else
                 # reply ok only
                 return "250 OK #{session[:ctx][:server][:helo_response].to_s.strip}".strip
@@ -847,7 +898,7 @@ module MidiSmtpServer
             # check that not already authenticated
             raise Smtpd503Exception if authenticated?(session[:ctx])
             # handle command line
-            auth_data = line.gsub(/^AUTH\ /i, '').strip.gsub(/\s+/, ' ').split(' ')
+            auth_data = line.gsub(/^AUTH\ /i, '').strip.gsub(/\s+/, ' ').split
             # handle auth command
             case auth_data[0]
 
@@ -865,26 +916,31 @@ module MidiSmtpServer
 
               when (/LOGIN/i)
                 # check if auth_id was sent too
-                if auth_data.length == 1
-                  # reset auth_challenge
-                  session[:auth_challenge] = {}
-                  # set sequence for next command input
-                  session[:cmd_sequence] = :CMD_AUTH_LOGIN_USER
-                  # response code with request for Username
-                  return '334 ' + Base64.strict_encode64('Username:')
-                elsif auth_data.length == 2
-                  # handle next sequence
-                  process_auth_login_user(session, auth_data[1])
-                else
-                  raise Smtpd500Exception
+                case auth_data.length
+
+                  when 1
+                    # reset auth_challenge
+                    session[:auth_challenge] = {}
+                    # set sequence for next command input
+                    session[:cmd_sequence] = :CMD_AUTH_LOGIN_USER
+                    # response code with request for Username
+                    return +'' << '334 ' << Base64.strict_encode64('Username:')
+
+                  when 2
+                    # handle next sequence
+                    process_auth_login_user(session, auth_data[1])
+
+                  else
+                    raise Smtpd500Exception
                 end
 
-              when (/CRAM-MD5/i)
-                # not supported in case of also unencrypted data delivery
-                # instead of supporting password encryption only, we will
-                # provide optional SMTPS service instead
-                # read discussion on https://github.com/4commerce-technologies-AG/midi-smtp-server/issues/3#issuecomment-126898711
-                raise Smtpd500Exception
+              # not supported in case of also unencrypted data delivery
+              # instead of supporting password encryption only, we will
+              # provide optional SMTPS service instead
+              # read discussion on https://github.com/4commerce-technologies-AG/midi-smtp-server/issues/3#issuecomment-126898711
+              #
+              # when (/CRAM-MD5/i)
+              #   raise Smtpd500Exception
 
               else
                 # unknown auth method
@@ -921,7 +977,7 @@ module MidiSmtpServer
             session[:cmd_sequence] = :CMD_QUIT
             return ''
 
-          when (/^MAIL FROM\:/i)
+          when (/^MAIL FROM:/i)
             # MAIL
             # 250 Requested mail action okay, completed
             # 421 <domain> Service not available, closing transmission channel
@@ -938,7 +994,7 @@ module MidiSmtpServer
             # check that authentication is enabled if necessary
             raise Smtpd530Exception if @auth_mode == :AUTH_REQUIRED && !authenticated?(session[:ctx])
             # handle command
-            cmd_data = line.gsub(/^MAIL FROM\:/i, '').strip
+            cmd_data = line.gsub(/^MAIL FROM:/i, '').strip
             # check for BODY= parameter
             case cmd_data
               # test for explicit 7bit
@@ -982,7 +1038,7 @@ module MidiSmtpServer
             # reply ok
             return '250 OK'
 
-          when (/^RCPT TO\:/i)
+          when (/^RCPT TO:/i)
             # RCPT
             # 250 Requested mail action okay, completed
             # 251 User not local; will forward to <forward-path>
@@ -1006,7 +1062,7 @@ module MidiSmtpServer
             # check that authentication is enabled if necessary
             raise Smtpd530Exception if @auth_mode == :AUTH_REQUIRED && !authenticated?(session[:ctx])
             # handle command
-            cmd_data = line.gsub(/^RCPT TO\:/i, '').strip
+            cmd_data = line.gsub(/^RCPT TO:/i, '').strip
             # call event to handle data
             return_value = on_rcpt_to_event(session[:ctx], cmd_data)
             if return_value
@@ -1125,7 +1181,7 @@ module MidiSmtpServer
     end
 
     # reset the context of current smtpd dialog
-    def process_reset_session(session, connection_initialize = false)
+    def process_reset_session(session, connection_initialize: false)
       # set active command sequence info
       session[:cmd_sequence] = connection_initialize ? :CMD_HELO : :CMD_RSET
       # drop any auth challenge
@@ -1149,6 +1205,7 @@ module MidiSmtpServer
             helo_response: +'',
             connected: +'',
             exceptions: 0,
+            errors: [],
             authorization_id: +'',
             authentication_id: +'',
             authenticated: +'',
@@ -1211,7 +1268,7 @@ module MidiSmtpServer
       # set sequence for next command input
       session[:cmd_sequence] = :CMD_AUTH_LOGIN_PASS
       # response code with request for Password
-      return '334 ' + Base64.strict_encode64('Password:')
+      return +'' << '334 ' << Base64.strict_encode64('Password:')
     end
 
     def process_auth_login_pass(session, encoded_auth_response)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: midi-smtp-server
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 3.0.3
 platform: ruby
 authors:
 - Tom Freudenberg
@@ -17,10 +17,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - MIT-LICENSE.txt
 - README.md
 - lib/midi-smtp-server.rb
 - lib/midi-smtp-server/exceptions.rb
+- lib/midi-smtp-server/logger.rb
 - lib/midi-smtp-server/tls-transport.rb
 - lib/midi-smtp-server/version.rb
 homepage:
@@ -31,7 +33,7 @@ metadata:
   source_code_uri: https://github.com/4commerce-technologies-AG/midi-smtp-server
   changelog_uri: https://github.com/4commerce-technologies-AG/midi-smtp-server#changes-and-updates
   bug_tracker_uri: https://github.com/4commerce-technologies-AG/midi-smtp-server/issues
-  documentation_uri: https://www.rubydoc.info/gems/midi-smtp-server/2.3.3
+  documentation_uri: https://www.rubydoc.info/gems/midi-smtp-server/3.0.3
   wiki_uri: https://midi-smtp-server.readthedocs.io/
 post_install_message:
 rdoc_options: []
@@ -41,7 +43,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="