rims 0.2.6 → 0.3.1

data/lib/rims/protocol/parser.rb

@@ -33,21 +33,7 @@ module RIMS
     end
 
     class RequestReader
-      def initialize(input, output, logger)
-        @input = input
-        @output = output
-        @logger = logger
-      end
-
-      def read_line
-        line = @input.gets or return
-        @logger.debug("read line: #{Protocol.io_data_log(line)}") if @logger.debug?
-        line.chomp!("\n")
-        line.chomp!("\r")
-        scan_line(line)
-      end
-
-      def scan_line(line)
+      def self.scan(line)
         atom_list = line.scan(/BODY(?:\.\S+)?\[.*?\](?:<\d+\.\d+>)?|[\[\]()]|".*?"|[^\[\]()\s]+/i).map{|s|
           case (s)
           when '(', ')', '[', ']', /\A NIL \z/ix
@@ -77,22 +63,14 @@ module RIMS
           end
         }
         if ((atom_list[-1].is_a? String) && (atom_list[-1] =~ /\A {\d+} \z/x)) then
-          next_size = $&[1..-2].to_i
-          @logger.debug("found literal: #{next_size} octets.") if @logger.debug?
-          @output.write("+ continue\r\n")
-          @output.flush
-          @logger.debug('continue literal.') if @logger.debug?
-          literal_string = @input.read(next_size) or raise 'unexpected client close.'
-          @logger.debug("read literal: #{Protocol.io_data_log(literal_string)}") if @logger.debug?
-          atom_list[-1] = literal_string
-          next_atom_list = read_line or raise 'unexpected client close.'
-          atom_list += next_atom_list
+          literal_size = $&[1..-2].to_i
+          atom_list[-1] = [ :literal, literal_size ]
         end
 
         atom_list
       end
 
-      def parse(atom_list, last_atom=nil)
+      def self.parse(atom_list, last_atom=nil)
         syntax_list = []
         while (atom = atom_list.shift)
           case (atom)
@@ -105,7 +83,7 @@ module RIMS
           else
             if ((atom.is_a? Array) && (atom[0] == :body)) then
               body = atom[1]
-              body.section_list = parse(scan_line(body.section))
+              body.section_list = parse(scan(body.section))
             end
             syntax_list.push(atom)
           end
@@ -118,18 +96,90 @@ module RIMS
         syntax_list
       end
 
+      def initialize(input, output, logger, line_length_limit: 1024*8, literal_size_limit: (1024**2)*10, command_size_limit: (1024**2)*10)
+        @input = input
+        @output = output
+        @logger = logger
+        @line_length_limit = line_length_limit
+        @literal_size_limit = literal_size_limit
+        @command_size_limit = command_size_limit
+        @command_tag = nil
+        @read_size = 0
+      end
+
+      attr_reader :command_tag
+
+      def gets
+        if (line = @input.gets($/, @line_length_limit)) then # arguments compatible with OpenSSL::Buffering#gets
+          if (line.bytesize < @line_length_limit) then
+            line
+          elsif (line.bytesize == @line_length_limit && (line.end_with? $/)) then
+            line
+          else
+            raise LineTooLongError.new('line too long.', line_fragment: line)
+          end
+        end
+      end
+
+      def read_literal(size)
+        @logger.debug("found literal: #{size} octets.") if @logger.debug?
+        if (size > @literal_size_limit) then
+          raise LiteralSizeTooLargeError.new('literal size too large', @command_tag)
+        end
+        if (@read_size + size > @command_size_limit) then
+          raise CommandSizeTooLargeError.new('command size too large', @command_tag)
+        end
+        @output.write("+ continue\r\n")
+        @output.flush
+        @logger.debug('continue literal.') if @logger.debug?
+        literal_string = @input.read(size) or raise 'unexpected client close.'
+        @read_size += size
+        @logger.debug("read literal: #{Protocol.io_data_log(literal_string)}") if @logger.debug?
+
+        literal_string
+      end
+      private :read_literal
+
+      def read_line
+        line = gets or return
+        @logger.debug("read line: #{Protocol.io_data_log(line)}") if @logger.debug?
+        line.chomp!("\n")
+        line.chomp!("\r")
+        @read_size += line.bytesize
+        if (@read_size > @command_size_limit) then
+          raise CommandSizeTooLargeError.new('command size too large', @command_tag)
+        end
+        atom_list = self.class.scan(line)
+
+        if (@command_tag.nil? && ! atom_list.empty?) then
+          unless ((atom_list[0].is_a? String) && ! (atom_list[0].start_with? '*', '+')) then
+            raise SyntaxError, "invalid command tag: #{atom_list[0]}"
+          end
+          @command_tag = atom_list[0]
+        end
+
+        if ((atom_list[-1].is_a? Array) && (atom_list[-1][0] == :literal)) then
+          atom_list[-1] = read_literal(atom_list[-1][1])
+          next_atom_list = read_line or raise 'unexpected client close.'
+          atom_list += next_atom_list
+        end
+
+        atom_list
+      end
+      private :read_line
+
       def read_command
+        @command_tag = nil
+        @read_size = 0
         while (atom_list = read_line)
           if (atom_list.empty?) then
+            @read_size = 0
             next
           end
           if (atom_list.length < 2) then
-            raise 'need for tag and command.'
-          end
-          if (atom_list[0] =~ /\A [*+]/x) then
-            raise "invalid command tag: #{atom_list[0]}"
+            raise SyntaxError, 'need for tag and command.'
           end
-          return parse(atom_list)
+          return self.class.parse(atom_list)
         end
 
         nil
@@ -228,13 +278,15 @@ module RIMS
     end
 
     class SearchParser
-      def initialize(mail_store, folder)
+      def initialize(mail_store, folder, charset_aliases: RFC822::DEFAULT_CHARSET_ALIASES, charset_convert_options: nil)
         @mail_store = mail_store
         @folder = folder
+        @charset_aliases = charset_aliases
+        @charset_convert_options = charset_convert_options || {}
         @charset = nil
         @mail_cache = Hash.new{|hash, uid|
           if (msg_txt = @mail_store.msg_text(@folder.mbox_id, uid)) then
-            hash[uid] = RFC822::Message.new(msg_txt)
+            hash[uid] = RFC822::Message.new(msg_txt, charset_aliases: @charset_aliases)
           end
         }
       end
@@ -247,47 +299,35 @@ module RIMS
       attr_reader :charset
 
       def charset=(new_charset)
-        @charset = Encoding.find(new_charset)
+        charset_encoding = @charset_aliases[new_charset] || Encoding.find(new_charset)
+        if (charset_encoding.dummy?) then
+          # same error type as `Encoding.find'
+          raise ArgumentError, "not a searchable charset: #{new_charset}"
+        end
+        @charset = charset_encoding
       end
 
-      def force_string_charset(string)
+      def force_charset(string)
         string = string.dup
         string.force_encoding(@charset)
         string.valid_encoding? or raise SyntaxError, "invalid #{@charset} string: #{string.inspect}"
         string
       end
-      private :force_string_charset
+      private :force_charset
 
-      # should set `search_string' encoding to `@charset'
-      def string_include?(search_string, text)
-        if (search_string.ascii_only?) then
-          unless (text.encoding.ascii_compatible?) then
-            text = text.encode('utf-8')
-          end
+      def encode_charset(string)
+        if (string.encoding == @charset) then
+          string
         else
-          if (@charset) then
-            text = text.encode(@charset)
-          end
+          string.encode(@charset, **@charset_convert_options)
         end
-
-        text.include? search_string
       end
-      private :string_include?
+      private :encode_charset
 
-      def mail_body_text(mail)
-        if (mail.text? || mail.message?) then
-          body_txt = mail.body.raw_source
-          if (charset = mail.charset) then
-            if (body_txt.encoding != charset) then
-              body_txt = body_txt.dup.force_encoding(charset)
-            end
-          end
-          body_txt
-        else
-          nil
-        end
+      def compile_search_regexp(search_string)
+        Regexp.new(Regexp.quote(search_string), true)
       end
-      private :mail_body_text
+      private :compile_search_regexp
 
       def end_of_cond
         proc{|msg| true }
@@ -322,14 +362,29 @@ module RIMS
       private :parse_msg_flag_enabled
 
       def parse_search_header(field_name, search_string)
-        search_string = force_string_charset(search_string) if @charset
+        if (@charset) then
+          search_string = force_charset(search_string)
+          search_regexp = compile_search_regexp(search_string)
+          search_header = proc{|mail|
+            mail.mime_decoded_header_field_value_list(field_name, @charset, charset_convert_options: @charset_convert_options).any?{|field_value|
+              search_regexp.match? field_value
+            }
+          }
+        else
+          search_string = search_string.b
+          search_regexp = compile_search_regexp(search_string)
+          search_header = proc{|mail|
+            mail.header.field_value_list(field_name).any?{|field_value|
+              search_regexp.match? field_value
+            }
+          }
+        end
+
         proc{|next_cond|
           proc{|msg|
             mail = get_mail(msg)
             if (mail.header.key? field_name) then
-              mail.header.field_value_list(field_name).any?{|field_value|
-                string_include?(search_string, field_value)
-              } && next_cond.call(msg)
+              search_header.call(mail) && next_cond.call(msg)
             else
               false
             end
@@ -372,11 +427,40 @@ module RIMS
       private :parse_mail_bytesize
 
       def parse_body(search_string)
-        search_string = force_string_charset(search_string) if @charset
+        if (@charset)
+          search_string = force_charset(search_string)
+          search_regexp = compile_search_regexp(search_string)
+          search_body = proc{|mail|
+            if (mail.text? || mail.messge?) then
+              search_regexp.match? encode_charset(mail.mime_charset_body_text)
+            elsif (mail.multipart?) then
+              mail.parts.any?{|next_mail|
+                search_body.call(next_mail)
+              }
+            else
+              false
+            end
+          }
+        else
+          search_string = search_string.b
+          search_regexp = compile_search_regexp(search_string)
+          search_body = proc{|mail|
+            if (mail.text? || mail.message?)then
+              search_regexp.match? mail.mime_binary_body_string
+            elsif (mail.multipart?) then
+              mail.parts.any?{|next_mail|
+                search_body.call(next_mail)
+              }
+            else
+              false
+            end
+          }
+        end
+
         proc{|next_cond|
           proc{|msg|
-            if (text = mail_body_text(get_mail(msg))) then
-              string_include?(search_string, text) && next_cond.call(msg)
+            if (mail = get_mail(msg)) then
+              search_body.call(mail) && next_cond.call(msg)
             else
               false
             end
@@ -435,20 +519,44 @@ module RIMS
       private :parse_or
 
       def parse_text(search_string)
-        search_string = force_string_charset(search_string) if @charset
-        search_text = proc{|message_text| string_include?(search_string, message_text) }
-        search_mail = proc{|mail|
-          if (mail.multipart?) then
-            search_text.call(mail.header.raw_source) || mail.parts.any?{|m| search_mail.call(m) }
-          else
-            body_text = mail_body_text(mail)
-            search_text.call(mail.header.raw_source) || (body_text && search_text.call(body_text))
-          end
-        }
+        if (@charset) then
+          search_string = force_charset(search_string)
+          search_regexp = compile_search_regexp(search_string)
+          search_text = proc{|mail|
+            if (search_regexp.match? mail.mime_decoded_header_text(@charset, charset_convert_options: @charset_convert_options)) then
+              true
+            elsif (mail.text? || mail.message?) then
+              search_regexp.match? encode_charset(mail.mime_charset_body_text)
+            elsif (mail.multipart?) then
+              mail.parts.any?{|next_mail|
+                search_text.call(next_mail)
+              }
+            else
+              false
+            end
+          }
+        else
+          search_string = search_string.b
+          search_regexp = compile_search_regexp(search_string)
+          search_text = proc{|mail|
+            if (search_regexp.match? mail.header.raw_source) then
+              true
+            elsif (mail.text? || mail.message?) then
+              search_regexp.match? mail.mime_binary_body_string
+            elsif (mail.multipart?) then
+              mail.parts.any?{|next_mail|
+                search_text.call(next_mail)
+              }
+            else
+              false
+            end
+          }
+        end
+
         proc{|next_cond|
           proc{|msg|
             mail = get_mail(msg)
-            search_mail.call(mail) && next_cond.call(msg)
+            search_text.call(mail) && next_cond.call(msg)
           }
         }
       end
@@ -768,12 +876,12 @@ module RIMS
       end
       include Utils
 
-      def initialize(mail_store, folder)
+      def initialize(mail_store, folder, charset_aliases: RFC822::DEFAULT_CHARSET_ALIASES)
         @mail_store = mail_store
         @folder = folder
         @mail_cache = Hash.new{|hash, uid|
           if (msg_txt = @mail_store.msg_text(@folder.mbox_id, uid)) then
-            hash[uid] = RFC822::Message.new(msg_txt)
+            hash[uid] = RFC822::Message.new(msg_txt, charset_aliases: charset_aliases)
           end
         }
       end

data/lib/rims/service.rb

@@ -118,6 +118,7 @@ module RIMS
       #   daemon:
       #     daemonize: true
       #     debug: false
+      #     umask: 0037
       #     status_file: rims.pid
       #     server_polling_interval_seconds: 3
       #     server_privileged_user: nobody
@@ -157,10 +158,29 @@ module RIMS
       #     send_buffer_limit_size: 16384
       #     read_polling_interval_seconds: 1
       #     command_wait_timeout_seconds: 1800
+      #   protocol:
+      #     line_length_limit: 8192
+      #     literal_size_limit: 10485760
+      #     command_size_limit: 10485760
+      #   charset:
+      #     use_default_aliases: true
+      #     aliases:
+      #       - name: euc-jp
+      #         encoding: eucJP-ms
+      #       - name: ios-2022-jp
+      #         encoding: CP50221
+      #       - name: Shift_JIS
+      #         encoding: Windows-31J
+      #     convert_options:
+      #       replace_invalid_byte_sequence: false
+      #       replace_undefined_character: true
+      #       replaced_mark: "\uFFFD"
       #   drb_services:
       #     process_num: 4
+      #     load_limit: 134217728
       #     engine:
       #       bulk_response_count: 100
+      #       bulk_response_size: 33554432
       #       read_lock_timeout_seconds: 30
       #       write_lock_timeout_seconds: 30
       #       cleanup_write_lock_timeout_seconds: 1
@@ -385,9 +405,8 @@ module RIMS
       end
 
       def daemonize?
-        daemon_config = @config['daemon'] || {}
-        if (daemon_config.key? 'daemonize') then
-          daemon_config['daemonize']
+        if (@config.dig('daemon')&.key? 'daemonize') then
+          @config.dig('daemon', 'daemonize')
         else
           true
         end
@@ -398,14 +417,17 @@ module RIMS
       end
 
       def daemon_debug?
-        daemon_config = @config['daemon'] || {}
-        if (daemon_config.key? 'debug') then
-          daemon_config['debug']
+        if (@config.dig('daemon')&.key? 'debug') then
+          @config.dig('daemon', 'debug')
         else
           false
         end
       end
 
+      def daemon_umask
+        @config.dig('daemon', 'umask') || 0037
+      end
+
       def status_file
         file_path = @config.dig('daemon', 'status_file') || 'rims.pid'
         file_path = Pathname(file_path)
@@ -521,22 +543,20 @@ module RIMS
       end
 
       def ssl_context
-        if (openssl_config = @config['openssl']) then
-          if (openssl_config.key? 'use_ssl') then
-            use_ssl = openssl_config['use_ssl']
-          else
-            use_ssl = openssl_config.key? 'ssl_context'
-          end
-
-          if (use_ssl) then
-            ssl_context = OpenSSL::SSL::SSLContext.new
-            if (ssl_config_expr = openssl_config['ssl_context']) then
-              anon_mod = SSLContextConfigAttribute.new_module(ssl_context, base_dir)
-              SSLContextConfigAttribute.eval_config(anon_mod, ssl_config_expr, 'ssl_context')
-            end
+        if (@config.dig('openssl')&.key? 'use_ssl') then
+          use_ssl = @config.dig('openssl', 'use_ssl')
+        else
+          use_ssl = (@config.dig('openssl')&.key? 'ssl_context') || false
+        end
 
-            ssl_context
+        if (use_ssl) then
+          ssl_context = OpenSSL::SSL::SSLContext.new
+          if (ssl_config_expr = @config.dig('openssl', 'ssl_context')) then
+            anon_mod = SSLContextConfigAttribute.new_module(ssl_context, base_dir)
+            SSLContextConfigAttribute.eval_config(anon_mod, ssl_config_expr, 'ssl_context')
           end
+
+          ssl_context
         end
       end
 
@@ -551,14 +571,102 @@ module RIMS
                                        @config.dig('connection', 'command_wait_timeout_seconds') || 60 * 30)
       end
 
+      def protocol_line_length_limit
+        @config.dig('protocol', 'line_length_limit') || 1024 * 8
+      end
+
+      def protocol_literal_size_limit
+        @config.dig('protocol', 'literal_size_limit') || 1024**2 * 10
+      end
+
+      def protocol_command_size_limit
+        @config.dig('protocol', 'command_size_limit') || 1024**2 * 10
+      end
+
+      def charset_aliases
+        charset_aliases = RFC822::CharsetAliases.new
+
+        if (@config.dig('charset')&.key? 'use_default_aliases') then
+          use_default_aliases = @config.dig('charset', 'use_default_aliases')
+        else
+          use_default_aliases = true
+        end
+
+        if (use_default_aliases) then
+          for name, encoding in RFC822::DEFAULT_CHARSET_ALIASES
+            charset_aliases.add_alias(name, encoding)
+          end
+        end
+
+        if (alias_list = @config.dig('charset', 'aliases')) then
+          for an_alias in alias_list
+            charset_aliases.add_alias(an_alias['name'], Encoding.find(an_alias['encoding']))
+          end
+        end
+
+        charset_aliases
+      end
+
+      def charset_convert_options
+        options = {}
+
+        if (@config.dig('charset', 'convert_options')&.key? 'replace_invalid_byte_sequence') then
+          replace_invalid_byte_sequence = @config.dig('charset', 'convert_options', 'replace_invalid_byte_sequence')
+        else
+          replace_invalid_byte_sequence = false
+        end
+
+        if (replace_invalid_byte_sequence) then
+          options[:invalid] = :replace
+        end
+
+        if (@config.dig('charset', 'convert_options')&.key? 'replace_undefined_character') then
+          replace_undefined_character = @config.dig('charset', 'convert_options', 'replace_undefined_character')
+        else
+          replace_undefined_character = true
+        end
+
+        if (replace_undefined_character) then
+          options[:undef] = :replace
+        end
+
+        if (replaced_mark = @config.dig('charset', 'convert_options', 'replaced_mark')) then
+          options[:replace] = replaced_mark
+        end
+
+        options
+      end
+
       def drb_process_num
         @config.dig('drb_services', 'process_num') || 0
       end
 
+      def drb_server_config
+        config = {}
+        if (load_limit = @config.dig('drb_services', 'load_limit')) then
+          config[:load_limit] = load_limit
+        end
+
+        config
+      end
+
+      def drb_client_config
+        config = {}
+        if (load_limit = @config.dig('drb_services', 'load_limit')) then
+          config[:load_limit] = load_limit
+        end
+
+        config
+      end
+
       def bulk_response_count
         @config.dig('drb_services', 'engine', 'bulk_response_count') || 100
       end
 
+      def bulk_response_size
+        @config.dig('drb_services', 'engine', 'bulk_response_size') || 1024**2 * 10
+      end
+
       def read_lock_timeout_seconds
         @config.dig('drb_services', 'engine', 'read_lock_timeout_seconds') ||
           @config.dig('read_lock_timeout_seconds') || # for backward compatibility
@@ -639,8 +747,8 @@ module RIMS
       end
 
       def make_authentication
-        if ((@config.key? 'authentication') && (@config['authentication'].is_a? Hash)) then
-          auth_conf = @config['authentication']
+        if (@config.dig('authentication')&.is_a? Hash) then
+          auth_conf = @config.dig('authentication')
         else
           auth_conf = {}
         end
@@ -679,8 +787,8 @@ module RIMS
         end
 
         # for backward compatibility
-        if ((@config.key? 'authentication') && (@config['authentication'].is_a? Array)) then
-          plug_in_list = @config['authentication']
+        if (@config.dig('authentication')&.is_a? Array) then
+          plug_in_list = @config.dig('authentication')
           for plug_in_conf in plug_in_list
             plug_in_name = plug_in_conf['plug_in'] or raise KeyError, 'not found an authentication plug_in.'
             plug_in_config = get_configuration(plug_in_conf)
@@ -717,16 +825,16 @@ module RIMS
     using Logger::JointPlus
 
     def setup(server, daemon: false)
-      file_logger_params = @config.make_file_logger_params
-      logger = Logger.new(*file_logger_params)
+      *file_logger_params, file_logger_opts = @config.make_file_logger_params
+      logger = Logger.new(*file_logger_params, **file_logger_opts)
 
-      stdout_logger_params = @config.make_stdout_logger_params
+      *stdout_logger_params, stdout_logger_opts = @config.make_stdout_logger_params
       unless (daemon && @config.daemonize?) then
-        logger += Logger.new(*stdout_logger_params)
+        logger += Logger.new(*stdout_logger_params, **stdout_logger_opts)
       end
 
-      protocol_logger_params = @config.make_protocol_logger_params
-      protocol_logger = Logger.new(*protocol_logger_params)
+      *protocol_logger_params, protocol_logger_opts = @config.make_protocol_logger_params
+      protocol_logger = Logger.new(*protocol_logger_params, **protocol_logger_opts)
 
       logger.info('preload libraries.')
       Riser.preload
@@ -780,16 +888,21 @@ module RIMS
         end
       end
 
-      drb_services = Riser::DRbServices.new(drb_process_num)
+      drb_services = Riser::DRbServices.new(drb_process_num,
+                                            server_config: @config.drb_server_config,
+                                            client_config: @config.drb_client_config)
       drb_services.add_sticky_process_service(:engine,
                                               Riser::ResourceSet.build{|builder|
                                                 builder.at_create{|unique_user_id|
                                                   mail_store = MailStore.build(unique_user_id, kvs_meta_open, kvs_text_open)
                                                   Protocol::Decoder::Engine.new(unique_user_id, mail_store, logger,
                                                                                 bulk_response_count: @config.bulk_response_count,
+                                                                                bulk_response_size: @config.bulk_response_size,
                                                                                 read_lock_timeout_seconds: @config.read_lock_timeout_seconds,
                                                                                 write_lock_timeout_seconds: @config.write_lock_timeout_seconds,
-                                                                                cleanup_write_lock_timeout_seconds: @config.cleanup_write_lock_timeout_seconds)
+                                                                                cleanup_write_lock_timeout_seconds: @config.cleanup_write_lock_timeout_seconds,
+                                                                                charset_aliases: @config.charset_aliases,
+                                                                                charset_convert_options: @config.charset_convert_options)
                                                 }
                                                 builder.at_destroy{|engine|
                                                   engine.destroy
@@ -806,17 +919,17 @@ module RIMS
         file_logger_params[1..-2].each_with_index do |value, i|
           logger.info("file logging parameter: shift_args[#{i}]=#{value}")
         end
-        for name, value in file_logger_params[-1]
+        for name, value in file_logger_opts
           logger.info("file logging parameter: #{name}=#{value}")
         end
-        for name, value in stdout_logger_params[-1]
+        for name, value in stdout_logger_opts
           logger.info("stdout logging parameter: #{name}=#{value}")
         end
         logger.info("protocol logging parameter: path=#{protocol_logger_params[0]}")
         protocol_logger_params[1..-2].each_with_index do |value, i|
           logger.info("protocol logging parameter: shift_args[#{i}]=#{value}")
         end
-        for name, value in protocol_logger_params[-1]
+        for name, value in protocol_logger_opts
           logger.info("protocol logging parameter: #{name}=#{value}")
         end
         logger.info("listen address: #{server_socket.local_address.inspect_sockaddr}")
@@ -895,11 +1008,27 @@ module RIMS
         logger.info("connection parameter: send_buffer_limit_size=#{@config.send_buffer_limit_size}")
         logger.info("connection parameter: read_polling_interval_seconds=#{conn_limits.read_polling_interval_seconds}")
         logger.info("connection parameter: command_wait_timeout_seconds=#{conn_limits.command_wait_timeout_seconds}")
+        logger.info("protocol parameter: line_length_limit=#{@config.protocol_line_length_limit}")
+        logger.info("protocol parameter: literal_size_limit=#{@config.protocol_literal_size_limit}")
+        logger.info("protocol parameter: command_size_limit=#{@config.protocol_command_size_limit}")
+        @config.charset_aliases.each_with_index do |(name, enc), i|
+          logger.info("charset aliases parameter: alias[#{i}]: #{name} -> #{enc.name}")
+        end
+        for name, value in @config.charset_convert_options
+          logger.info("charset convert_options parameter: #{name}=#{value}")
+        end
         logger.info("drb_services parameter: process_num=#{drb_process_num}")
+        for name, value in @config.drb_server_config
+          logger.info("drb_services server config parameter: #{name}=#{value}")
+        end
+        for name, value in @config.drb_client_config
+          logger.info("drb_services client config parameter: #{name}=#{value}")
+        end
         logger.info("drb_services engine parameter: bulk_response_count=#{@config.bulk_response_count}")
-        logger.info("lock parameter: read_lock_timeout_seconds=#{@config.read_lock_timeout_seconds}")
-        logger.info("lock parameter: write_lock_timeout_seconds=#{@config.write_lock_timeout_seconds}")
-        logger.info("lock parameter: cleanup_write_lock_timeout_seconds=#{@config.cleanup_write_lock_timeout_seconds}")
+        logger.info("drb_services engine parameter: bulk_response_size=#{@config.bulk_response_size}")
+        logger.info("drb_services engine parameter: read_lock_timeout_seconds=#{@config.read_lock_timeout_seconds}")
+        logger.info("drb_services engine parameter: write_lock_timeout_seconds=#{@config.write_lock_timeout_seconds}")
+        logger.info("drb_services engine parameter: cleanup_write_lock_timeout_seconds=#{@config.cleanup_write_lock_timeout_seconds}")
         kvs_meta_log.call
         kvs_text_log.call
         logger.info("authentication parameter: hostname=#{auth.hostname}")
@@ -947,7 +1076,11 @@ module RIMS
                   stream = Riser::WriteBufferStream.new(socket, @config.send_buffer_limit_size)
                 end
                 stream = Riser::LoggingStream.new(stream, protocol_logger)
-                decoder = Protocol::Decoder.new_decoder(drb_services, auth, logger, mail_delivery_user: @config.mail_delivery_user)
+                decoder = Protocol::Decoder.new_decoder(drb_services, auth, logger,
+                                                        mail_delivery_user: @config.mail_delivery_user,
+                                                        line_length_limit: @config.protocol_line_length_limit,
+                                                        literal_size_limit: @config.protocol_literal_size_limit,
+                                                        command_size_limit: @config.protocol_command_size_limit)
                 Protocol::Decoder.repl(decoder, conn_limits, stream, stream, logger)
               ensure
                 if (stream) then