epp-fork 1.0

data/README.rdoc

@@ -0,0 +1,88 @@
+= EPP (by {Ultraspeed}[http://ultraspeed.co.uk])
+
+The EPP gem provides basic functionality for connecting and making requests on EPP (Extensible Provisioning Protocol) servers. Currently, major providers Centralnic and Nominet have been tested.
+
+* {Nominet Standard EPP Documentation}[http://www.nominet.org.uk/registrars/systems/standardepp/]
+* {Centralnic Labs EPP Documentation}[http://labs.centralnic.com/epp/]
+
+== Installation
+
+You can install this gem with:
+
+    $ sudo gem sources -a http://gems.github.com
+    $ sudo gem install ultraspeed-epp
+    
+Then, you can require it in your Ruby app:
+
+    require "epp"
+    
+If you're using Rails, add the following line to your Rails <tt>config/environment.rb</tt>:
+
+    config.gem "ultraspeed-epp", :lib => "epp", :source => "http://gems.github.com"
+    
+Once you do that, you can install the gem by typing <tt>sudo rake gems:install</tt>.
+
+== Example Usage
+
+First, you must initialize an Epp::Server object to use. This requires the EPP server address, tag/username and password:
+
+    server = Epp::Server.new(
+      :server => "testbed-epp.nominet.org.uk",
+      :tag => "TESTING",
+      :password => "testing"
+    )
+    
+If no port is specified, it will be assumed that you will be using port 700.
+
+You would then make an XML request to the server. 
+
+    xml       = "<?xml ... </epp>"
+    response  = server.request(xml)
+  
+You can build this however you'd like. The process is as follows:
+
+* Connect to EPP server, get the <greeting> frame
+* Send a standard <login> request
+* Send your request
+* Send a standard <logout> request
+* Disconnect the socket from the server
+
+The EPP server would then return the XML response as a string. In this example, the response XML would be set equal to <tt>response</tt> for your usage.
+
+Once the request is complete, it will automatically close the connection. For simplicity purposes, this plug-in will *not* use a persistent connection to the EPP server.
+
+== Bugs/Issues
+
+Please report all issues using the GitHub issue tracker at:
+
+http://github.com/ultraspeed/epp/issues
+
+== Credit
+
+Author::          Josh Delsman at Ultraspeed (http://twitter.com/voxxit)
+Inspired from::   http://labs.centralnic.com/Net_EPP_Client.php
+
+== License
+
+The MIT License
+
+Copyright (c) 2009 Josh Delsman (Ultraspeed)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'hanna/rdoctask'
+require 'fileutils'
+
+require File.dirname(__FILE__) + '/lib/epp'
+
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# Rdoc
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end

data/lib/epp.rb

@@ -0,0 +1,16 @@
+# Gem and other dependencies
+require 'rubygems'
+require 'openssl'
+require 'socket'
+require 'active_support'
+require 'rexml/document'
+require 'hpricot'
+
+# Package files
+require File.dirname(__FILE__) + '/require_parameters.rb'
+require File.dirname(__FILE__) + '/epp/server.rb'
+require File.dirname(__FILE__) + '/epp/exceptions.rb'
+
+module Epp #:nodoc:
+  VERSION = '1.0.8'
+end

data/lib/epp/exceptions.rb

@@ -0,0 +1,13 @@
+class EppErrorResponse < StandardError #:nodoc:
+  attr_accessor :response
+  
+  # Generic EPP exception. Accepts a response code and a message
+  def initialize(attributes = {})
+    @response_code = attributes[:code]
+    @message = attributes[:message]
+  end
+  
+  def to_s
+    "#{@message} (code #{@response_code})"
+  end
+end

data/lib/epp/server.rb

@@ -0,0 +1,203 @@
+module Epp #:nodoc:
+  class Server
+    include RequiresParameters
+        
+    attr_accessor :tag, :password, :server, :port, :clTRID, :old_server
+    
+    # ==== Required Attrbiutes
+    # 
+    # * <tt>:server</tt> - The EPP server to connect to
+    # * <tt>:tag</tt> - The tag or username used with <tt><login></tt> requests.
+    # * <tt>:password</tt> - The password used with <tt><login></tt> requests.
+    # 
+    # ==== Optional Attributes
+    #
+    # * <tt>:port</tt> - The EPP standard port is 700. However, you can choose a different port to use.
+    # * <tt>:clTRID</tt> - The client transaction identifier is an element that EPP specifies MAY be used to uniquely identify the command to the server. You are responsible for maintaining your own transaction identifier space to ensure uniqueness. Defaults to "ABC-12345"
+    # * <tt>:old_server</tt> - Set to true to read and write frames in a way that is compatible with old EPP servers. Default is false.
+    # * <tt>:lang</tt> - Set custom language attribute. Default is 'en'.
+    def initialize(attributes = {})
+      requires!(attributes, :tag, :password, :server)
+      
+      @tag        = attributes[:tag]
+      @password   = attributes[:password]
+      @server     = attributes[:server]
+      @port       = attributes[:port] || 700
+      @clTRID     = attributes[:clTRID] || "ABC-12345"
+      @old_server = attributes[:old_server] || false
+      @lang       = attributes[:lang] || 'en'
+    end
+    
+    # Sends an XML request to the EPP server, and receives an XML response. 
+    # <tt><login></tt> and <tt><logout></tt> requests are also wrapped
+    # around the request, so we can close the socket immediately after
+    # the request is made.
+    def request(xml)
+      open_connection
+      
+      begin
+        login
+        @response = send_request(xml)
+      ensure
+        logout unless @old_server
+        close_connection
+      end
+      
+      return @response
+    end
+    
+    # private
+    
+    # Wrapper which sends an XML frame to the server, and receives 
+    # the response frame in return.
+    def send_request(xml)
+      send_frame(xml)
+      response = get_frame
+    end
+    
+    def login
+      xml = REXML::Document.new
+      xml << REXML::XMLDecl.new("1.0", "UTF-8", "no")
+      
+      xml.add_element("epp", {
+        "xmlns" => "urn:ietf:params:xml:ns:epp-1.0",
+        "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+        "xsi:schemaLocation" => "urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd"
+      })
+      
+      command = xml.root.add_element("command")
+      login = command.add_element("login")
+      
+      login.add_element("clID").text = @tag
+      login.add_element("pw").text = @password
+      
+      options = login.add_element("options")
+      options.add_element("version").text = "1.0"
+      options.add_element("lang").text = @lang
+      
+      services = login.add_element("svcs")
+      services.add_element("objURI").text = "urn:ietf:params:xml:ns:domain-1.0"
+      services.add_element("objURI").text = "urn:ietf:params:xml:ns:contact-1.0"
+      services.add_element("objURI").text = "urn:ietf:params:xml:ns:host-1.0"
+      
+      command.add_element("clTRID").text = @clTRID
+
+      # Receive the login response
+      response = Hpricot.XML(send_request(xml.to_s))
+
+      result_message  = (response/"epp"/"response"/"result"/"msg").text.strip
+      result_code     = (response/"epp"/"response"/"result").attr("code").to_i
+   
+      if result_code == 1000
+        return true
+      else
+        raise EppErrorResponse.new(:code => result_code, :message => result_message)
+      end
+    end
+    
+    def logout
+      xml = REXML::Document.new
+      xml << REXML::XMLDecl.new("1.0", "UTF-8", "no")
+      
+      xml.add_element('epp', {
+        'xmlns' => "urn:ietf:params:xml:ns:epp-1.0",
+        'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
+        'xsi:schemaLocation' => "urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd"
+      })
+      
+      command = xml.root.add_element("command")
+      login = command.add_element("logout")
+      
+      # Receive the logout response
+      response = Hpricot.XML(send_request(xml.to_s))
+      
+      result_message  = (response/"epp"/"response"/"result"/"msg").text.strip
+      result_code     = (response/"epp"/"response"/"result").attr("code").to_i
+      
+      if result_code == 1500
+        return true
+      else
+        raise EppErrorResponse.new(:code => result_code, :message => result_message)
+      end
+    end
+    
+    # Establishes the connection to the server. If the connection is
+		# established, then this method will call get_frame and return 
+		# the EPP <tt><greeting></tt> frame which is sent by the 
+		# server upon connection.
+    def open_connection
+      @connection = TCPSocket.new(@server, @port)
+      @socket     = OpenSSL::SSL::SSLSocket.new(@connection)
+      
+      # Synchronously close the connection & socket
+      @socket.sync_close
+      
+      # Connect
+      @socket.connect
+      
+      # Get the initial frame
+      get_frame
+    end
+    
+    # Closes the connection to the EPP server.
+    def close_connection
+      if defined?(@socket) and @socket.is_a?(OpenSSL::SSL::SSLSocket)
+        @socket.close
+        @socket = nil
+      end
+      
+      if defined?(@connection) and @connection.is_a?(TCPSocket)
+        @connection.close
+        @connection = nil
+      end
+      
+      return true if @connection.nil? and @socket.nil?
+    end
+    
+    # Receive an EPP frame from the server. Since the connection is blocking,
+    # this method will wait until the connection becomes available for use. If
+    # the connection is broken, a SocketError will be raised. Otherwise,
+    # it will return a string containing the XML from the server.
+    def get_frame
+       if @old_server
+          data = ''
+          first_char = @socket.read(1)
+          if first_char.nil? and @socket.eof?
+            raise SocketError.new("Connection closed by remote server")
+          elsif first_char.nil?
+            raise SocketError.new("Error reading frame from remote server")
+          else
+             data << first_char
+             while char = @socket.read(1)
+                data << char
+                return data if data =~ %r|<\/epp>\n$|mi # at end
+             end
+          end
+       else
+          header = @socket.read(4)
+
+          if header.nil? and @socket.eof?
+            raise SocketError.new("Connection closed by remote server")
+          elsif header.nil?
+            raise SocketError.new("Error reading frame from remote server")
+          else
+            unpacked_header = header.unpack("N")
+            length = unpacked_header[0]
+
+            if length < 5
+              raise SocketError.new("Got bad frame header length of #{length} bytes from the server")
+            else
+              response = @socket.read(length - 4)   
+            end
+          end
+       end      
+    end
+
+    # Send an XML frame to the server. Should return the total byte
+    # size of the frame sent to the server. If the socket returns EOF,
+    # the connection has closed and a SocketError is raised.
+    def send_frame(xml)      
+       @socket.write( @old_server ? (xml + "\r\n") : ([xml.size + 4].pack("N") + xml) )
+    end
+  end
+end

data/lib/require_parameters.rb

@@ -0,0 +1,14 @@
+module RequiresParameters #:nodoc:
+  def requires!(hash, *params)
+    params.each do |param| 
+      if param.is_a?(Array)
+        raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first) 
+
+        valid_options = param[1..-1]
+        raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:connector => 'or')}") unless valid_options.include?(hash[param.first])
+      else
+        raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param) 
+      end
+    end
+  end    
+end

data/test/test_epp.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestEpp < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/epp'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: epp-fork
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Blaz Grilc
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70114712986360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114712986360
+- !ruby/object:Gem::Dependency
+  name: hpricot
+  requirement: &70114712985900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114712985900
+description: Basic functionality for connecting and making requests on EPP (Extensible
+  Provisioning Protocol) servers.
+email: blaz.grilc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/epp/exceptions.rb
+- lib/epp/server.rb
+- lib/epp.rb
+- lib/require_parameters.rb
+- Rakefile
+- README.rdoc
+- test/test_epp.rb
+- test/test_helper.rb
+homepage: http://github.com/blaz/epp
+licenses: []
+post_install_message: 
+rdoc_options:
+- --inline-source
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Basic functionality for connecting and making requests on EPP (Extensible
+  Provisioning Protocol) servers.
+test_files: []