diff --git a/helpers/DATA/ruby1.9.1/gserver.rb b/helpers/DATA/ruby1.9.1/gserver.rb
new file mode 100644
index 0000000000000000000000000000000000000000..4dd5ad0c0807d303de61b9be4a471b3fe0ce65a1
--- /dev/null
+++ b/helpers/DATA/ruby1.9.1/gserver.rb
@@ -0,0 +1,309 @@
+#
+# Copyright (C) 2001 John W. Small All Rights Reserved
+#
+# Author:: John W. Small
+# Documentation:: Gavin Sinclair
+# Licence:: Ruby License
+
+require "socket"
+require "thread"
+
+#
+# GServer implements a generic server, featuring thread pool management,
+# simple logging, and multi-server management. See HttpServer in
+# <tt>xmlrpc/httpserver.rb</tt> in the Ruby standard library for an example of
+# GServer in action.
+#
+# Any kind of application-level server can be implemented using this class.
+# It accepts multiple simultaneous connections from clients, up to an optional
+# maximum number. Several _services_ (i.e. one service per TCP port) can be
+# run simultaneously, and stopped at any time through the class method
+# <tt>GServer.stop(port)</tt>. All the threading issues are handled, saving
+# you the effort. All events are optionally logged, but you can provide your
+# own event handlers if you wish.
+#
+# == Example
+#
+# Using GServer is simple. Below we implement a simple time server, run it,
+# query it, and shut it down. Try this code in +irb+:
+#
+# require 'gserver'
+#
+# #
+# # A server that returns the time in seconds since 1970.
+# #
+# class TimeServer < GServer
+# def initialize(port=10001, *args)
+# super(port, *args)
+# end
+# def serve(io)
+# io.puts(Time.now.to_s)
+# end
+# end
+#
+# # Run the server with logging enabled (it's a separate thread).
+# server = TimeServer.new
+# server.audit = true # Turn logging on.
+# server.start
+#
+# # *** Now point your browser to http://localhost:10001 to see it working ***
+#
+# # See if it's still running.
+# GServer.in_service?(10001) # -> true
+# server.stopped? # -> false
+#
+# # Shut the server down gracefully.
+# server.shutdown
+#
+# # Alternatively, stop it immediately.
+# GServer.stop(10001)
+# # or, of course, "server.stop".
+#
+# All the business of accepting connections and exception handling is taken
+# care of. All we have to do is implement the method that actually serves the
+# client.
+#
+# === Advanced
+#
+# As the example above shows, the way to use GServer is to subclass it to
+# create a specific server, overriding the +serve+ method. You can override
+# other methods as well if you wish, perhaps to collect statistics, or emit
+# more detailed logging.
+#
+# * #connecting
+# * #disconnecting
+# * #starting
+# * #stopping
+#
+# The above methods are only called if auditing is enabled, via #audit=.
+#
+# You can also override #log and #error if, for example, you wish to use a
+# more sophisticated logging system.
+#
+class GServer
+
+ DEFAULT_HOST = "127.0.0.1"
+
+ def serve(io)
+ end
+
+ @@services = {} # Hash of opened ports, i.e. services
+ @@servicesMutex = Mutex.new
+
+ # Stop the server running on the given port, bound to the given host
+ #
+ # +port+:: port, as a FixNum, of the server to stop
+ # +host+:: host on which to find the server to stop
+ def GServer.stop(port, host = DEFAULT_HOST)
+ @@servicesMutex.synchronize {
+ @@services[host][port].stop
+ }
+ end
+
+ # Check if a server is running on the given port and host
+ #
+ # +port+:: port, as a FixNum, of the server to check
+ # +host+:: host on which to find the server to check
+ #
+ # Returns true if a server is running on that port and host.
+ def GServer.in_service?(port, host = DEFAULT_HOST)
+ @@services.has_key?(host) and
+ @@services[host].has_key?(port)
+ end
+
+ # Stop the server
+ def stop
+ @connectionsMutex.synchronize {
+ if @tcpServerThread
+ @tcpServerThread.raise "stop"
+ end
+ }
+ end
+
+ # Returns true if the server has stopped.
+ def stopped?
+ @tcpServerThread == nil
+ end
+
+ # Schedule a shutdown for the server
+ def shutdown
+ @shutdown = true
+ end
+
+ # Return the current number of connected clients
+ def connections
+ @connections.size
+ end
+
+ # Join with the server thread
+ def join
+ @tcpServerThread.join if @tcpServerThread
+ end
+
+ # Port on which to listen, as a FixNum
+ attr_reader :port
+ # Host on which to bind, as a String
+ attr_reader :host
+ # Maximum number of connections to accept at at ime, as a FixNum
+ attr_reader :maxConnections
+ # IO Device on which log messages should be written
+ attr_accessor :stdlog
+ # Set to true to cause the callbacks #connecting, #disconnecting, #starting,
+ # and #stopping to be called during the server's lifecycle
+ attr_accessor :audit
+ # Set to true to show more detailed logging
+ attr_accessor :debug
+
+ # Called when a client connects, if auditing is enabled.
+ #
+ # +client+:: a TCPSocket instances representing the client that connected
+ #
+ # Return true to allow this client to connect, false to prevent it.
+ def connecting(client)
+ addr = client.peeraddr
+ log("#{self.class.to_s} #{@host}:#{@port} client:#{addr[1]} " +
+ "#{addr[2]}<#{addr[3]}> connect")
+ true
+ end
+
+
+ # Called when a client disconnects, if audition is enabled.
+ #
+ # +clientPort+:: the port of the client that is connecting
+ def disconnecting(clientPort)
+ log("#{self.class.to_s} #{@host}:#{@port} " +
+ "client:#{clientPort} disconnect")
+ end
+
+ protected :connecting, :disconnecting
+
+ # Called when the server is starting up, if auditing is enabled.
+ def starting()
+ log("#{self.class.to_s} #{@host}:#{@port} start")
+ end
+
+ # Called when the server is shutting down, if auditing is enabled.
+ def stopping()
+ log("#{self.class.to_s} #{@host}:#{@port} stop")
+ end
+
+ protected :starting, :stopping
+
+ # Called if #debug is true whenever an unhandled exception is raised.
+ # This implementation simply logs the backtrace.
+ #
+ # +detail+:: The Exception that was caught
+ def error(detail)
+ log(detail.backtrace.join("\n"))
+ end
+
+ # Log a message to #stdlog, if it's defined. This implementation
+ # outputs the timestamp and message to the log.
+ #
+ # +msg+:: the message to log
+ def log(msg)
+ if @stdlog
+ @stdlog.puts("[#{Time.new.ctime}] %s" % msg)
+ @stdlog.flush
+ end
+ end
+
+ protected :error, :log
+
+ # Create a new server
+ #
+ # +port+:: the port, as a FixNum, on which to listen.
+ # +host+:: the host to bind to
+ # +maxConnections+:: The maximum number of simultaneous connections to
+ # accept
+ # +stdlog+:: IO device on which to log messages
+ # +audit+:: if true, lifecycle callbacks will be called. See #audit
+ # +debug+:: if true, error messages are logged. See #debug
+ def initialize(port, host = DEFAULT_HOST, maxConnections = 4,
+ stdlog = $stderr, audit = false, debug = false)
+ @tcpServerThread = nil
+ @port = port
+ @host = host
+ @maxConnections = maxConnections
+ @connections = []
+ @connectionsMutex = Mutex.new
+ @connectionsCV = ConditionVariable.new
+ @stdlog = stdlog
+ @audit = audit
+ @debug = debug
+ end
+
+ # Start the server if it isn't already running
+ #
+ # +maxConnections+::
+ # override +maxConnections+ given to the constructor. A negative
+ # value indicates that the value from the constructor should be used.
+ def start(maxConnections = -1)
+ raise "server is already running" if !stopped?
+ @shutdown = false
+ @maxConnections = maxConnections if maxConnections > 0
+ @@servicesMutex.synchronize {
+ if GServer.in_service?(@port,@host)
+ raise "Port already in use: #{host}:#{@port}!"
+ end
+ @tcpServer = TCPServer.new(@host,@port)
+ @port = @tcpServer.addr[1]
+ @@services[@host] = {} unless @@services.has_key?(@host)
+ @@services[@host][@port] = self;
+ }
+ @tcpServerThread = Thread.new {
+ begin
+ starting if @audit
+ while !@shutdown
+ @connectionsMutex.synchronize {
+ while @connections.size >= @maxConnections
+ @connectionsCV.wait(@connectionsMutex)
+ end
+ }
+ client = @tcpServer.accept
+ @connections << Thread.new(client) { |myClient|
+ begin
+ myPort = myClient.peeraddr[1]
+ serve(myClient) if !@audit or connecting(myClient)
+ rescue => detail
+ error(detail) if @debug
+ ensure
+ begin
+ myClient.close
+ rescue
+ end
+ @connectionsMutex.synchronize {
+ @connections.delete(Thread.current)
+ @connectionsCV.signal
+ }
+ disconnecting(myPort) if @audit
+ end
+ }
+ end
+ rescue => detail
+ error(detail) if @debug
+ ensure
+ begin
+ @tcpServer.close
+ rescue
+ end
+ if @shutdown
+ @connectionsMutex.synchronize {
+ while @connections.size > 0
+ @connectionsCV.wait(@connectionsMutex)
+ end
+ }
+ else
+ @connections.each { |c| c.raise "stop" }
+ end
+ @tcpServerThread = nil
+ @@servicesMutex.synchronize {
+ @@services[@host].delete(@port)
+ }
+ stopping if @audit
+ end
+ }
+ self
+ end
+
+end
diff --git a/helpers/make-ruby1.9.1 b/helpers/make-ruby1.9.1
new file mode 100644
index 0000000000000000000000000000000000000000..9b337c023d612e6baa8c878643b188c8d5352c42
--- /dev/null
+++ b/helpers/make-ruby1.9.1
@@ -0,0 +1,29 @@
+#!/bin/sh
+#
+# Copyright (C) 2015 Legimet <legimet.calc@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+
+VERSION=1
+
+. ./config
+
+cp $DATA/gserver.rb lib/gserver.rb
+
+changelog "Replace nonfree file with free version, #10078"
+
+compile
+