logstash-input-tcp 4.2.2-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9c6d50fef2efef38a82073875b776b27440e7af2
+  data.tar.gz: e4770a4a7f75dcf1ea81b15835a3f803755e5426
+SHA512:
+  metadata.gz: 50874dd44e9a968eb27ca855f7960e77e16d21d137432c262cc2d6c8c0c845aef41366b72ec81cb1d711c2fe8b231f863234945dfdffede13299a42263f93dc2
+  data.tar.gz: 7f257c7bc838ddc5f95e4510005e1797ad5aff903eb354966606cfe150a0fc352fa26b9c9c050c5f60fc8a5079d292ba412fe4ba1da55d09915b189be84832ef

data/CHANGELOG.md

@@ -0,0 +1,64 @@
+## 4.2.2
+  - Fixed regression causing incoming connection host ips being accidentally resolved to hostnames
+  - Implemented plain socket server in a non-blocking way improving performance and fixing issues for use cases with a large number of concurrent connections
+  
+## 4.2.1
+  - Version yanked from RubyGems for accidental behaviour change causing unwanted reverse lookups on connections
+
+## 4.2.0
+  - Version yanked from RubyGems for packaging issues
+
+## 4.1.2
+  - Add documentation for how to use tcp input to accept log4j2 data.
+
+## 4.1.0
+  - Add support for proxy protocol
+
+## 4.0.3
+  - Relax constraint on logstash-core-plugin-api to >= 1.60 <= 2.99
+
+## 4.0.2
+ - Change the log level of the SSLError for the handshake from **error** to **debug** https://github.com/logstash-plugins/logstash-input-tcp/pull/53
+## 4.0.1
+ - Republish all the gems under jruby.
+## 4.0.0
+ - Update the plugin to the version 2.0 of the plugin api, this change is required for Logstash 5.0 compatibility. See https://github.com/elastic/logstash/issues/5141
+# 3.0.5
+ - Fixed a bug where using a certificate with a passphrase wouldn't work.
+# 3.0.4
+ - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
+# 3.0.3
+ - New dependency requirements for logstash-core for the 5.0 release
+## 3.0.2
+ - Fixed a bug where previous connection would accidentally be closed when accepting new socket connection
+ - Fixed an issue with log message which used a closed socket's peer address 
+
+## 3.0.1
+ - properly convert sslsubject to string before assigning to event field, added specs, see https://github.com/logstash-plugins/logstash-input-tcp/pull/38
+
+## 3.0.0
+ - Deprecate ssl_cacert as it's confusing, does it job but when willing to add a chain of certificated the name and behaviour is a bit confusing.
+ - Add ssl_extra_chain_certs that allows you to specify a list of certificates path that will be added to the CAStore.
+ - Make ssl_verify=true as a default value, if using ssl and performing validation is not reasonable as security might be compromised.
+ - Add tests to verify behaviour under different SSL connection circumstances.
+ - Fixes #3 and #9.
+
+## 2.1.0
+ - Added the receiving port in the event payload, fixes #4
+
+## 2.0.5
+ - Fixed malformed SSL crashing Logstash, see https://github.com/logstash-plugins/logstash-input-tcp/pull/25
+
+## 2.0.4
+ - Dependency on logstash-core update to >= 2.0.0.beta2 < 3.0.0
+
+## 2.0.3
+ - removed usage of RSpec.configure, see https://github.com/logstash-plugins/logstash-input-tcp/pull/21
+
+## 2.0.2
+ - refactored & cleaned up plugin structure, see https://github.com/logstash-plugins/logstash-input-tcp/pull/18
+
+## 2.0.0
+ - Plugins were updated to follow the new shutdown semantic, this mainly allows Logstash to instruct input plugins to terminate gracefully,
+   instead of using Thread.raise on the plugins' threads. Ref: https://github.com/elastic/logstash/pull/3895
+ - Dependency on logstash-core update to 2.0

data/CONTRIBUTORS

@@ -0,0 +1,25 @@
+The following is a list of people who have contributed ideas, code, bug
+reports, or in general have helped logstash along its way.
+
+Contributors:
+* Avishai Ish-Shalom (avishai-ish-shalom)
+* Bernd Ahlers (bernd)
+* Colin Surprenant (colinsurprenant)
+* Dan Peterson (dpiddy)
+* John E. Vincent (lusis)
+* Jordan Sissel (jordansissel)
+* Kurt Hurtado (kurtado)
+* Ludovicus Maior (Ludovicus)
+* Matthew Richardson (mrichar1)
+* Nick Ethier (nickethier)
+* Pete Fritchman (fetep)
+* Philippe Weber (wiibaa)
+* Pier-Hugues Pellerin (ph)
+* Richard Pijnenburg (electrical)
+* Scott Wilkerson (scottwilkerson)
+* Alex Baker (AlexBaker-)
+
+Note: If you've sent us patches, bug reports, or otherwise contributed to
+Logstash, and you aren't on the list above and want to be, please let us know
+and we'll make sure you're here. Contributions from folks like you are what make
+open source awesome.

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+logstash_path = ENV["LOGSTASH_PATH"] || "../../logstash"
+use_logstash_source = ENV["LOGSTASH_SOURCE"] && ENV["LOGSTASH_SOURCE"].to_s == "1"
+
+if Dir.exist?(logstash_path) && use_logstash_source
+  gem 'logstash-core', :path => "#{logstash_path}/logstash-core"
+  gem 'logstash-core-plugin-api', :path => "#{logstash_path}/logstash-core-plugin-api"
+end

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012–2016 Elasticsearch <http://www.elastic.co>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/NOTICE.TXT

@@ -0,0 +1,5 @@
+Elasticsearch
+Copyright 2012-2015 Elasticsearch
+
+This product includes software developed by The Apache Software
+Foundation (http://www.apache.org/).

data/README.md

@@ -0,0 +1,98 @@
+# Logstash Plugin
+
+[![Travis Build Status](https://travis-ci.org/logstash-plugins/logstash-input-tcp.svg)](https://travis-ci.org/logstash-plugins/logstash-input-tcp)
+
+This is a plugin for [Logstash](https://github.com/elastic/logstash).
+
+It is fully free and fully open source. The license is Apache 2.0, meaning you are pretty much free to use it however you want in whatever way.
+
+## Documentation
+
+Logstash provides infrastructure to automatically generate documentation for this plugin. We use the asciidoc format to write documentation so any comments in the source code will be first converted into asciidoc and then into html. All plugin documentation are placed under one [central location](http://www.elastic.co/guide/en/logstash/current/).
+
+- For formatting code or config example, you can use the asciidoc `[source,ruby]` directive
+- For more asciidoc formatting tips, see the excellent reference here https://github.com/elastic/docs#asciidoc-guide
+
+## Need Help?
+
+Need help? Try #logstash on freenode IRC or the https://discuss.elastic.co/c/logstash discussion forum.
+
+## Developing
+
+### 1. Plugin Developement and Testing
+
+#### Code
+- To get started, you'll need JRuby with the Bundler gem installed.
+
+- Create a new plugin or clone and existing from the GitHub [logstash-plugins](https://github.com/logstash-plugins) organization. We also provide [example plugins](https://github.com/logstash-plugins?query=example).
+
+- Install dependencies
+```sh
+bundle install
+```
+
+#### Test
+
+- Update your dependencies
+
+```sh
+bundle install
+```
+
+- Run tests
+
+```sh
+bundle exec rspec
+```
+
+### 2. Running your unpublished Plugin in Logstash
+
+#### 2.1 Run in a local Logstash clone
+
+- Edit Logstash `Gemfile` and add the local plugin path, for example:
+```ruby
+gem "logstash-filter-awesome", :path => "/your/local/logstash-filter-awesome"
+```
+- Install plugin
+```sh
+# Logstash 2.3 and higher
+bin/logstash-plugin install --no-verify
+
+# Prior to Logstash 2.3
+bin/plugin install --no-verify
+
+```
+- Run Logstash with your plugin
+```sh
+bin/logstash -e 'filter {awesome {}}'
+```
+At this point any modifications to the plugin code will be applied to this local Logstash setup. After modifying the plugin, simply rerun Logstash.
+
+#### 2.2 Run in an installed Logstash
+
+You can use the same **2.1** method to run your plugin in an installed Logstash by editing its `Gemfile` and pointing the `:path` to your local plugin development directory or you can build the gem and install it using:
+
+- Build your plugin gem
+```sh
+gem build logstash-filter-awesome.gemspec
+```
+- Install the plugin from the Logstash home
+```sh
+# Logstash 2.3 and higher
+bin/logstash-plugin install --no-verify
+
+# Prior to Logstash 2.3
+bin/plugin install --no-verify
+
+```
+- Start Logstash and proceed to test the plugin
+
+## Contributing
+
+All contributions are welcome: ideas, patches, documentation, bug reports, complaints, and even something you drew up on a napkin.
+
+Programming is not a required skill. Whatever you've seen about open source and maintainers or community members  saying "send patches or die" - you will not see that here.
+
+It is more important to the community that you are able to contribute.
+
+For more information about contributing, see the [CONTRIBUTING](https://github.com/elastic/logstash/blob/master/CONTRIBUTING.md) file.

data/docs/index.asciidoc

@@ -0,0 +1,205 @@
+:plugin: tcp
+:type: input
+
+///////////////////////////////////////////
+START - GENERATED VARIABLES, DO NOT EDIT!
+///////////////////////////////////////////
+:version: %VERSION%
+:release_date: %RELEASE_DATE%
+:changelog_url: %CHANGELOG_URL%
+:include_path: ../../../../logstash/docs/include
+///////////////////////////////////////////
+END - GENERATED VARIABLES, DO NOT EDIT!
+///////////////////////////////////////////
+
+[id="plugins-{type}s-{plugin}"]
+
+=== Tcp input plugin
+
+include::{include_path}/plugin_header.asciidoc[]
+
+==== Description
+
+Read events over a TCP socket.
+
+Like stdin and file inputs, each event is assumed to be one line of text.
+
+Can either accept connections from clients or connect to a server,
+depending on `mode`.
+
+#### Accepting log4j2 logs
+
+Log4j2 can send JSON over a socket, and we can use that combined with our tcp
+input to accept the logs. 
+
+First, we need to configure your application to send logs in JSON over a
+socket. The following log4j2.xml accomplishes this task.
+
+Note, you will want to change the `host` and `port` settings in this
+configuration to match your needs.
+
+    <Configuration>
+      <Appenders>
+         <Socket name="Socket" host="localhost" port="12345">
+           <JsonLayout compact="true" eventEol="true" />
+        </Socket>
+      </Appenders>
+      <Loggers>
+        <Root level="info">
+          <AppenderRef ref="Socket"/>
+        </Root>
+      </Loggers>
+    </Configuration>
+
+To accept this in Logstash, you will want tcp input and a date filter:
+
+    input {
+      tcp {
+        port => 12345
+        codec => json
+      }
+    }
+
+and add a date filter to take log4j2's `timeMillis` field and use it as the
+event timestamp
+
+    filter {
+      date {
+        match => [ "timeMillis", "UNIX_MS" ]
+      }
+    }
+
+[id="plugins-{type}s-{plugin}-options"]
+==== Tcp Input Configuration Options
+
+This plugin supports the following configuration options plus the <<plugins-{type}s-{plugin}-common-options>> described later.
+
+[cols="<,<,<",options="header",]
+|=======================================================================
+|Setting |Input type|Required
+| <<plugins-{type}s-{plugin}-host>> |<<string,string>>|No
+| <<plugins-{type}s-{plugin}-mode>> |<<string,string>>, one of `["server", "client"]`|No
+| <<plugins-{type}s-{plugin}-port>> |<<number,number>>|Yes
+| <<plugins-{type}s-{plugin}-proxy_protocol>> |<<boolean,boolean>>|No
+| <<plugins-{type}s-{plugin}-ssl_cert>> |a valid filesystem path|No
+| <<plugins-{type}s-{plugin}-ssl_enable>> |<<boolean,boolean>>|No
+| <<plugins-{type}s-{plugin}-ssl_extra_chain_certs>> |<<array,array>>|No
+| <<plugins-{type}s-{plugin}-ssl_key>> |a valid filesystem path|No
+| <<plugins-{type}s-{plugin}-ssl_key_passphrase>> |<<password,password>>|No
+| <<plugins-{type}s-{plugin}-ssl_verify>> |<<boolean,boolean>>|No
+|=======================================================================
+
+Also see <<plugins-{type}s-{plugin}-common-options>> for a list of options supported by all
+input plugins.
+
+&nbsp;
+
+[id="plugins-{type}s-{plugin}-data_timeout"]
+===== `data_timeout`  (DEPRECATED)
+
+  * DEPRECATED WARNING: This configuration item is deprecated and may not be available in future versions.
+  * Value type is <<number,number>>
+  * Default value is `-1`
+
+
+
+[id="plugins-{type}s-{plugin}-host"]
+===== `host` 
+
+  * Value type is <<string,string>>
+  * Default value is `"0.0.0.0"`
+
+When mode is `server`, the address to listen on.
+When mode is `client`, the address to connect to.
+
+[id="plugins-{type}s-{plugin}-mode"]
+===== `mode` 
+
+  * Value can be any of: `server`, `client`
+  * Default value is `"server"`
+
+Mode to operate in. `server` listens for client connections,
+`client` connects to a server.
+
+[id="plugins-{type}s-{plugin}-port"]
+===== `port` 
+
+  * This is a required setting.
+  * Value type is <<number,number>>
+  * There is no default value for this setting.
+
+When mode is `server`, the port to listen on.
+When mode is `client`, the port to connect to.
+
+[id="plugins-{type}s-{plugin}-proxy_protocol"]
+===== `proxy_protocol` 
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `false`
+
+Proxy protocol support, only v1 is supported at this time
+http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt
+
+[id="plugins-{type}s-{plugin}-ssl_cacert"]
+===== `ssl_cacert`  (DEPRECATED)
+
+  * DEPRECATED WARNING: This configuration item is deprecated and may not be available in future versions.
+  * Value type is <<path,path>>
+  * There is no default value for this setting.
+
+The SSL CA certificate, chainfile or CA path. The system CA path is automatically included.
+
+[id="plugins-{type}s-{plugin}-ssl_cert"]
+===== `ssl_cert` 
+
+  * Value type is <<path,path>>
+  * There is no default value for this setting.
+
+SSL certificate path
+
+[id="plugins-{type}s-{plugin}-ssl_enable"]
+===== `ssl_enable` 
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `false`
+
+Enable SSL (must be set for other `ssl_` options to take effect).
+
+[id="plugins-{type}s-{plugin}-ssl_extra_chain_certs"]
+===== `ssl_extra_chain_certs` 
+
+  * Value type is <<array,array>>
+  * Default value is `[]`
+
+An Array of extra X509 certificates to be added to the certificate chain.
+Useful when the CA chain is not necessary in the system store.
+
+[id="plugins-{type}s-{plugin}-ssl_key"]
+===== `ssl_key` 
+
+  * Value type is <<path,path>>
+  * There is no default value for this setting.
+
+SSL key path
+
+[id="plugins-{type}s-{plugin}-ssl_key_passphrase"]
+===== `ssl_key_passphrase` 
+
+  * Value type is <<password,password>>
+  * Default value is `nil`
+
+SSL key passphrase
+
+[id="plugins-{type}s-{plugin}-ssl_verify"]
+===== `ssl_verify` 
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `true`
+
+Verify the identity of the other end of the SSL connection against the CA.
+For input, sets the field `sslsubject` to that of the client certificate.
+
+
+
+[id="plugins-{type}s-{plugin}-common-options"]
+include::{include_path}/{type}.asciidoc[]

data/lib/logstash-input-tcp_jars.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'jar_dependencies'
+require_jar('org.logstash.inputs', 'logstash-input-tcp', ::File.read(::File.join(::File.dirname(__FILE__), '../version')).split("\n").first)

data/lib/logstash/inputs/tcp.rb

@@ -0,0 +1,387 @@
+# encoding: utf-8
+
+require "java"
+
+require "logstash/inputs/base"
+require "logstash/util/socket_peer"
+require "logstash-input-tcp_jars"
+require "logstash/inputs/tcp/decoder_impl"
+
+require "socket"
+require "openssl"
+
+java_import org.logstash.tcp.InputLoop
+
+# Read events over a TCP socket.
+#
+# Like stdin and file inputs, each event is assumed to be one line of text.
+#
+# Can either accept connections from clients or connect to a server,
+# depending on `mode`.
+#
+# #### Accepting log4j2 logs
+#
+# Log4j2 can send JSON over a socket, and we can use that combined with our tcp
+# input to accept the logs. 
+#
+# First, we need to configure your application to send logs in JSON over a
+# socket. The following log4j2.xml accomplishes this task.
+#
+# Note, you will want to change the `host` and `port` settings in this
+# configuration to match your needs.
+#
+#     <Configuration>
+#       <Appenders>
+#          <Socket name="Socket" host="localhost" port="12345">
+#            <JsonLayout compact="true" eventEol="true" />
+#         </Socket>
+#       </Appenders>
+#       <Loggers>
+#         <Root level="info">
+#           <AppenderRef ref="Socket"/>
+#         </Root>
+#       </Loggers>
+#     </Configuration>
+#
+# To accept this in Logstash, you will want tcp input and a date filter:
+#
+#     input {
+#       tcp {
+#         port => 12345
+#         codec => json
+#       }
+#     }
+#
+# and add a date filter to take log4j2's `timeMillis` field and use it as the
+# event timestamp
+#
+#     filter {
+#       date {
+#         match => [ "timeMillis", "UNIX_MS" ]
+#       }
+#     }
+class LogStash::Inputs::Tcp < LogStash::Inputs::Base
+  config_name "tcp"
+
+  default :codec, "line"
+
+  # When mode is `server`, the address to listen on.
+  # When mode is `client`, the address to connect to.
+  config :host, :validate => :string, :default => "0.0.0.0"
+
+  # When mode is `server`, the port to listen on.
+  # When mode is `client`, the port to connect to.
+  config :port, :validate => :number, :required => true
+
+  config :data_timeout, :validate => :number, :default => -1, :deprecated => "This setting is not used by this plugin. It will be removed soon."
+
+  # Mode to operate in. `server` listens for client connections,
+  # `client` connects to a server.
+  config :mode, :validate => ["server", "client"], :default => "server"
+
+  # Proxy protocol support, only v1 is supported at this time
+  # http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt
+  config :proxy_protocol, :validate => :boolean, :default => false
+
+  # Enable SSL (must be set for other `ssl_` options to take effect).
+  config :ssl_enable, :validate => :boolean, :default => false
+
+  # Verify the identity of the other end of the SSL connection against the CA.
+  # For input, sets the field `sslsubject` to that of the client certificate.
+  config :ssl_verify, :validate => :boolean, :default => true
+
+  # The SSL CA certificate, chainfile or CA path. The system CA path is automatically included.
+  config :ssl_cacert, :validate => :path, :deprecated => "This setting is deprecated in favor of ssl_extra_chain_certs as it sets a more clear expectation to add more X509 certificates to the store"
+
+  # SSL certificate path
+  config :ssl_cert, :validate => :path
+
+  # SSL key path
+  config :ssl_key, :validate => :path
+
+  # SSL key passphrase
+  config :ssl_key_passphrase, :validate => :password, :default => nil
+
+  # An Array of extra X509 certificates to be added to the certificate chain.
+  # Useful when the CA chain is not necessary in the system store.
+  config :ssl_extra_chain_certs, :validate => :array, :default => []
+
+  HOST_FIELD = "host".freeze
+  PORT_FIELD = "port".freeze
+  PROXY_HOST_FIELD = "proxy_host".freeze
+  PROXY_PORT_FIELD = "proxy_port".freeze
+  SSLSUBJECT_FIELD = "sslsubject".freeze
+
+  def initialize(*args)
+    super(*args)
+
+    # monkey patch TCPSocket and SSLSocket to include socket peer
+    TCPSocket.module_eval{include ::LogStash::Util::SocketPeer}
+    OpenSSL::SSL::SSLSocket.module_eval{include ::LogStash::Util::SocketPeer}
+
+    # threadsafe socket bookkeeping
+    @server_socket = nil
+    @client_socket = nil
+    @connection_sockets = {}
+    @socket_mutex = Mutex.new
+
+    @ssl_context = nil
+  end
+
+  def register
+    fix_streaming_codecs
+
+    # note that since we are opening a socket in register, we must also make sure we close it
+    # in the close method even if we also close it in the stop method since we could have
+    # a situation where register is called but not run & stop.
+
+    if server?
+      if @ssl_enable
+        self.server_socket = new_server_socket
+      else
+        @loop = InputLoop.new(@host, @port, DecoderImpl.new(@codec, self))
+      end
+    end
+  end
+
+  def run(output_queue)
+    @output_queue = output_queue
+    if server?
+      if @ssl_enable
+        run_ssl_server
+      else
+        @loop.run
+      end
+    else
+      run_client()
+    end
+  end
+
+  def stop
+    # force close all sockets which will escape any blocking read with a IO exception
+    # and any thread using them will exit.
+    # catch all rescue nil on close to discard any close errors or invalid socket
+    server_socket.close rescue nil
+    @loop.close rescue nil
+    client_socket.close rescue nil
+    connection_sockets.each{|socket| socket.close rescue nil}
+  end
+
+  def close
+    # see related comment in register: we must make sure to close the server socket here
+    # because it is created in the register method and we could be in the context of having
+    # register called but never run & stop, only close.
+    # catch all rescue nil on close to discard any close errors or invalid socket
+    server_socket.close rescue nil
+    @loop.close rescue nil
+  end
+
+  def decode_buffer(client_address, client_port, codec, proxy_address, proxy_port, tbuf)
+    codec.decode(tbuf) do |event|
+      if @proxy_protocol
+        event.set(PROXY_HOST_FIELD, proxy_address) unless event.get(PROXY_HOST_FIELD)
+        event.set(PROXY_PORT_FIELD, proxy_port) unless event.get(PROXY_PORT_FIELD)
+      end
+      enqueue_decorated(event, client_address, client_port)
+    end
+  end
+
+  private
+
+  def run_ssl_server()
+    while !stop?
+      begin
+        socket = add_connection_socket(server_socket.accept)
+        # start a new thread for each connection.
+        server_connection_thread(socket)
+      rescue OpenSSL::SSL::SSLError => e
+        # log error, close socket, accept next connection
+        @logger.debug? && @logger.debug("SSL Error", :exception => e, :backtrace => e.backtrace)
+      rescue => e
+        # if this exception occured while the plugin is stopping
+        # just ignore and exit
+        raise e unless stop?
+      end
+    end
+  ensure
+    # catch all rescue nil on close to discard any close errors or invalid socket
+    server_socket.close rescue nil
+  end
+
+  def run_client()
+    while !stop?
+      self.client_socket = new_client_socket
+      handle_socket(client_socket)
+    end
+  ensure
+    # catch all rescue nil on close to discard any close errors or invalid socket
+    client_socket.close rescue nil
+  end
+
+  def server_connection_thread(socket)
+    Thread.new(socket) do |s|
+      begin
+        @logger.debug? && @logger.debug("Accepted connection", :client => s.peer, :server => "#{@host}:#{@port}")
+        handle_socket(s)
+      ensure
+        delete_connection_socket(s)
+      end
+    end
+  end
+
+  def handle_socket(socket)
+    client_address = socket.peeraddr[3]
+    client_port = socket.peeraddr[1]
+    peer = "#{client_address}:#{client_port}"
+    first_read = true
+    codec = @codec.clone
+    while !stop?
+      tbuf = socket.sysread(16384)
+      if @proxy_protocol && first_read
+        first_read = false
+        pp_hdr, tbuf = tbuf.split("\r\n", 2)
+
+        pp_info = pp_hdr.split(/\s/)
+        # PROXY proto clientip proxyip clientport proxyport
+        if pp_info[0] != "PROXY"
+          @logger.error("invalid proxy protocol header label", :hdr => pp_hdr)
+          raise IOError
+        else
+          proxy_address = pp_info[3]
+          proxy_port = pp_info[5]
+          client_address = pp_info[2]
+          client_port = pp_info[4]
+        end
+      end
+      decode_buffer(client_address, client_port, codec, proxy_address, proxy_port, tbuf)
+    end
+  rescue EOFError
+    @logger.debug? && @logger.debug("Connection closed", :client => peer)
+  rescue Errno::ECONNRESET
+    @logger.debug? && @logger.debug("Connection reset by peer", :client => peer)
+  rescue OpenSSL::SSL::SSLError => e
+    # Fixes issue #23
+    @logger.error("SSL Error", :exception => e, :backtrace => e.backtrace)
+    socket.close rescue nil
+  rescue => e
+    # if plugin is stopping, don't bother logging it as an error
+    !stop? && @logger.error("An error occurred. Closing connection", :client => peer, :exception => e, :backtrace => e.backtrace)
+  ensure
+    # catch all rescue nil on close to discard any close errors or invalid socket
+    socket.close rescue nil
+
+    codec.respond_to?(:flush) && codec.flush do |event|
+      enqueue_decorated(event, client_address, client_port)
+    end
+  end
+
+  def enqueue_decorated(event, client_address, client_port)
+    event.set(HOST_FIELD, client_address) unless event.get(HOST_FIELD)
+    event.set(PORT_FIELD, client_port) unless event.get(PORT_FIELD)
+    decorate(event)
+    @output_queue << event
+  end
+  
+  def server?
+    @mode == "server"
+  end
+
+  def ssl_context
+    return @ssl_context if @ssl_context
+
+    begin
+      @ssl_context = OpenSSL::SSL::SSLContext.new
+      @ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(@ssl_cert))
+      @ssl_context.key = OpenSSL::PKey::RSA.new(File.read(@ssl_key),@ssl_key_passphrase.value)
+      if @ssl_verify
+        @ssl_context.cert_store  = load_cert_store
+        @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+      end
+    rescue => e
+      @logger.error("Could not inititalize SSL context", :exception => e, :backtrace => e.backtrace)
+      raise e
+    end
+
+    @ssl_context
+  end
+
+  def load_cert_store
+    cert_store = OpenSSL::X509::Store.new
+    cert_store.set_default_paths
+    if File.directory?(@ssl_cacert)
+      cert_store.add_path(@ssl_cacert)
+    else
+      cert_store.add_file(@ssl_cacert)
+    end if @ssl_cacert
+    @ssl_extra_chain_certs.each do |cert|
+      cert_store.add_file(cert)
+    end
+    cert_store
+  end
+
+  def new_server_socket
+    @logger.info("Starting tcp input listener", :address => "#{@host}:#{@port}")
+    begin
+      socket = TCPServer.new(@host, @port)
+    rescue Errno::EADDRINUSE
+      @logger.error("Could not start TCP server: Address in use", :host => @host, :port => @port)
+      raise
+    end
+
+    @ssl_enable ? OpenSSL::SSL::SSLServer.new(socket, ssl_context) : socket
+  end
+
+  def new_client_socket
+    socket = TCPSocket.new(@host, @port)
+
+    if @ssl_enable
+      socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      socket.connect
+    end
+
+    @logger.debug? && @logger.debug("Opened connection", :client => "#{socket.peer}")
+
+    socket
+  rescue OpenSSL::SSL::SSLError => e
+    @logger.error("SSL Error", :exception => e, :backtrace => e.backtrace)
+    # catch all rescue nil on close to discard any close errors or invalid socket
+    socket.close rescue nil
+    sleep(1) # prevent hammering peer
+    retry
+  rescue
+    # if this exception occured while the plugin is stopping
+    # just ignore and exit
+    raise unless stop?
+  end
+
+  # threadsafe sockets bookkeeping
+
+  def client_socket=(socket)
+    @socket_mutex.synchronize{@client_socket = socket}
+  end
+
+  def client_socket
+    @socket_mutex.synchronize{@client_socket}
+  end
+
+  def server_socket=(socket)
+    @socket_mutex.synchronize{@server_socket = socket}
+  end
+
+  def server_socket
+    @socket_mutex.synchronize{@server_socket}
+  end
+
+  def add_connection_socket(socket)
+    @socket_mutex.synchronize{@connection_sockets[socket] = true}
+    socket
+  end
+
+  def delete_connection_socket(socket)
+    @socket_mutex.synchronize{@connection_sockets.delete(socket)}
+  end
+
+  def connection_sockets
+    @socket_mutex.synchronize{@connection_sockets.keys.dup}
+  end
+end