epp-ruby 3.0.0

data/lib/epp-client/response.rb

@@ -0,0 +1,100 @@
+module EPP
+  # An EPP XML Response
+  class Response
+    # Creates an instance of an EPP::Response
+    #
+    # @param [String] xml_string XML Response
+    def initialize(xml_string)
+      @xml = XML::Parser.string(xml_string).parse
+      @xml.root.namespaces.default_prefix = 'e'
+    end
+
+    # Indicates if the response is successful.
+    # @return [Boolean] if the response is successful
+    def success?
+      code == 1000
+    end
+
+    def pending?
+      code == 1001
+    end
+
+    # Response code
+    # @return [Integer] response code
+    def code
+      @code ||= result['code'].to_i
+    end
+
+    # Response message
+    # @return [String] response message
+    def message
+      @message ||= result.find('e:msg/text()').first.content.strip
+    end
+
+    # Descriptive Error Information
+    # @return [XML::Node] error information
+    def error_value
+      @error_value ||= result.find('e:extValue/e:value/node()').first
+    end
+
+    # Error reason
+    # @return [String] error reason
+    def error_reason
+      unless defined?(@error_reason)
+        reason = result.find('e:extValue/e:reason/text()').first
+        @error_reason = reason && reason.content.strip
+      end
+
+      @error_reason
+    end
+
+    # Response data
+    # @return [XML::Node, Array<XML::Node>] response data
+    def data
+      @data ||= begin
+        list = @xml.find('/e:epp/e:response/e:resData/node()').reject { |n| n.empty? }
+        list.size > 1 ? list : list[0]
+      end
+    end
+
+    # Response Message Queue
+    # @return [XML::Node] message queue
+    def msgQ
+      @msgQ ||= @xml.find('/e:epp/e:response/e:msgQ').first
+    end
+
+    # Response extension block
+    # @return [XML::Node, Array<XML::Node>] extension
+    def extension
+      @extension ||= begin
+        list = @xml.find('/e:epp/e:response/e:extension/node()').reject { |n| n.empty? }
+        list.size > 1 ? list : list[0]
+      end
+    end
+
+    # @see Object#inspect
+    def inspect
+      @xml.inspect
+    end
+
+    # Returns the XML response document
+    # @return [XML::Document] XML response document
+    def to_xml
+      @xml
+    end
+
+    # Convert the receiver to a string
+    #
+    # @param [Hash] opts Formatting options, passed to the XML::Document
+    # @return [String] formatted XML response
+    def to_s(opts = {})
+      @xml.to_s({:indent => false}.merge(opts))
+    end
+
+    private
+      # @return [XML::Node] Result node
+      def result
+        @result ||= @xml.find('/e:epp/e:response/e:result').first
+      end
+  end
+end

data/lib/epp-client/response_error.rb

@@ -0,0 +1,15 @@
+module EPP
+  # Error response
+  class ResponseError < RuntimeError
+    attr_accessor :code, :xml
+    # Create new ResponseError
+    def initialize(code, msg, xml)
+      super(msg)
+      @code, @xml = code, xml
+    end
+    # @return [String] Formatted Response error
+    def message
+      "#{to_s} (code #{code})"
+    end
+  end
+end

data/lib/epp-client/response_helper.rb

@@ -0,0 +1,25 @@
+module EPP
+  module ResponseHelper
+    def value_for_xpath(xpath, base = nil, &block)
+      values_for_xpath(xpath, base, &block).first
+    end
+    def values_for_xpath(xpath, base = nil)
+      nodes_for_xpath(xpath, base).map do |node|
+        if block_given?
+          yield node
+        else
+          case node
+          when XML::Node
+            node.content.strip
+          when XML::Attr
+            node.value
+          end
+        end
+      end
+    end
+    def nodes_for_xpath(xpath, base = nil)
+      base ||= @response.data
+      base.find(xpath, namespaces)
+    end
+  end
+end

data/lib/epp-client/server.rb

@@ -0,0 +1,330 @@
+module EPP
+  # A server error
+  class ServerError < Error; end
+
+  # A connection error
+  class ConnectionError < Error
+    attr_reader :error, :addr, :peeraddr
+    def initialize(message, addr, peeraddr, error)
+      super(message)
+      @error = error
+      @addr = addr
+      @peeraddr = peeraddr
+    end
+  end
+
+  # Handles sending and receiving data to EPP servers.
+  # Supports new style EPP servers which include length of payloads in transmission.
+  class Server
+    # @!attribute DEFAULT_SERVICES
+    # Provided for legacy clients who might be using it.
+    # The constant has been moved into the EPP::Client class which
+    # is the primary client facing API.
+    #
+    # @deprecated please use EPP::Client::DEFAULT_SERVICES
+    # @see EPP::Client::DEFAULT_SERVICES
+
+    # Handles emitting warnings for deprecated constants.
+    #
+    # @private
+    # @param [Symbol] const_name Name of the missing constant
+    # @see Module.const_missing
+    def self.const_missing(const_name)
+      case const_name
+      when :DEFAULT_SERVICES
+        warn "EPP::Server::DEFAULT_SERVICES has been deprecated, please use EPP::Client::DEFAULT_SERVICES"
+        EPP::Client::DEFAULT_SERVICES
+      else
+        super
+      end
+    end
+
+    # Default connection options
+    DEFAULTS = { :port => 700, :compatibility => false, :lang => 'en', :version => '1.0',
+      :extensions => [], :services => EPP::Client::DEFAULT_SERVICES, :address_family => nil }
+
+    # Receive frame header length
+    # @private
+    HEADER_LEN = 4
+
+    # @param [String] tag EPP Tag
+    # @param [String] passwd EPP Tag password
+    # @param [String] host EPP Server address
+    # @param [Hash] options configuration options
+    # @option options [Integer] :port EPP Port number, default 700
+    # @option options [OpenSSL::SSL::SSLContext] :ssl_context For client certificate auth
+    # @option options [Boolean] :compatibility Compatibility mode, default false
+    # @option options [String] :lang EPP Language code, default 'en'
+    # @option options [String] :version EPP protocol version, default '1.0'
+    # @option options [Array<String>] :extensions EPP Extension URNs
+    # @option options [Array<String>] :services EPP Service URNs
+    # @option options [String] :address_family 'AF_INET' or 'AF_INET6' or either of the
+    #                          appropriate socket constants. Will cause connections to be
+    #                          limited to this address family. Default try all addresses.
+
+    def initialize(tag, passwd, host, options = {})
+      @tag, @passwd, @host = tag, passwd, host
+      @options = DEFAULTS.merge(options)
+    end
+
+    # Sends a Hello Request to the server
+    # @return [Boolean] True if greeting was returned
+    def hello
+      hello   = EPP::Requests::Hello.new
+      request = EPP::Request.new(hello)
+      send_frame(request)
+      return true if recv_frame =~ /<greeting>/
+      false
+    end
+
+    # Send request to server
+    #
+    # @overload request(command, payload)
+    #   @param [String, #to_s] command EPP Command to call
+    #   @param [XML::Node, XML::Document, String] payload EPP XML Payload
+    # @overload request(command)
+    #   @param [String, #to_s] command EPP Command to call
+    #   @yield [xml] block to construct payload
+    #   @yieldparam [XML::Node] xml XML Node of the command
+    #     for the payload to be added into
+    # @return [Response] EPP Response object
+    # def request(command, payload = nil, extension = nil, &block)
+    #   @req = if payload.nil? && block_given?
+    #     Request.new(command, req_tid, &block)
+    #   else
+    #     Request.new(command, payload, extension, req_tid)
+    #   end
+    #
+    #   @resp = send_recv_frame(@req)
+    # end
+
+    # @note Primarily an internal method, exposed to enable testing
+    # @param [] command
+    # @param [] extension
+    # @return [EPP::Request]
+    # @see request
+    def prepare_request(command, extension = nil)
+      cmd = EPP::Requests::Command.new(req_tid, command, extension)
+      EPP::Request.new(cmd)
+    end
+
+    def request(command, extension = nil)
+      @req = command.is_a?(EPP::Request) ? command :
+                prepare_request(command, extension)
+
+      @resp = send_recv_frame(@req)
+    end
+
+    # Return the Request object created by the last call to #request
+    #
+    # @return [Request] Last created EPP Request object
+    def last_request
+      @req
+    end
+    # Return the Response object created by the last call to #request
+    #
+    # @return [Response] Last created EPP Response object
+    def last_response
+      @resp
+    end
+    # Return the error from the last login or logout request
+    #
+    # @return [ResponseError] last error from login or logout
+    def last_error
+      @error
+    end
+    # Return the options the receiver was initialized with
+    #
+    # @return [Hash] configuration options
+    def options
+      @options
+    end
+    # Return the greeting XML received during the last connection
+    #
+    # @return [String]
+    def greeting
+      @greeting
+    end
+
+    # Runs a block while logged into the receiver
+    #
+    # @yield logged in EPP server session
+    # @example typical usage
+    #   connection do
+    #     with_login do
+    #       # .. do stuff with logged in session ..
+    #     end
+    #   end
+    def with_login
+      login!
+
+      begin
+        yield
+      ensure
+        logout!
+      end
+    end
+
+    # EPP Server Connection
+    #
+    # @yield connected session
+    # @example typical usage
+    #   connection do
+    #     # .. do stuff with logged in session ..
+    #   end
+    # @example usage with with_login
+    #   connection do
+    #     with_login do
+    #       # .. do stuff with logged in session ..
+    #     end
+    #   end
+    def connection
+      @connection_errors = []
+      addrinfo.each do |_,port,_,addr,_,_,_|
+        retried = false
+        begin
+          @conn = TCPSocket.new(addr, port)
+        rescue Errno::EINVAL => e
+          if retried
+            message = e.message.split(" - ")[1]
+            @connection_errors << Errno::EINVAL.new(
+              "#{message}: TCPSocket.new(#{addr.inspect}, #{port.inspect})")
+            next
+          end
+
+          retried = true
+          retry
+        end
+
+        args = [@conn]
+        args << options[:ssl_context] if options[:ssl_context]
+        @sock = OpenSSL::SSL::SSLSocket.new(*args)
+        @sock.sync_close = true
+
+        begin
+          @sock.connect
+          @greeting = recv_frame  # Perform initial recv
+
+          return yield
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH => e
+          @connection_errors << e
+          next # try the next address in the list
+        rescue OpenSSL::SSL::SSLError => e
+          # Connection error, most likely the IP isn't in the allow list
+          if e.message =~ /returned=5 errno=0/
+            @connection_errors << ConnectionError.new("SSL Connection error, IP may not be permitted to connect to #{@host}",
+               @conn.addr, @conn.peeraddr, e)
+            next
+          else
+            raise e
+          end
+        ensure
+          @sock.close # closes @conn
+          @conn = @sock = nil
+        end
+      end
+
+      # Should only get here if we didn't return from the block above
+
+      addrinfo(true) # Update our addrinfo in case the DNS has changed
+      raise @connection_errors.last unless @connection_errors.empty?
+      raise Errno::EHOSTUNREACH, "Failed to connect to host #{@host}"
+    end
+    private
+      def addrinfo(refresh = false)
+        @addrinfo = nil if refresh
+        @addrinfo ||= resolve_addrinfo
+      end
+      def resolve_addrinfo
+        family = case @options[:address_family]
+        when 'AF_INET',  Socket::AF_INET  then Socket::AF_INET
+        when 'AF_INET6', Socket::AF_INET6 then Socket::AF_INET6
+        else nil end
+
+        Socket.getaddrinfo(@host, @options[:port], family, Socket::SOCK_STREAM)
+      end
+
+      # @return [String] next transaction id
+      def req_tid
+        @req_tid ||= 0
+        @req_tid += 1
+        date = Time.now.strftime("%Y%m%d")
+        "%s-%s%06d" % [@tag, date, @req_tid]
+      end
+
+      # @return [String] next auth transaction id
+      def auth_tid
+        @auth_tid ||= 0
+        @auth_tid += 1
+        date = Time.now.strftime("%Y%m%d")
+        "%s-AUTH-%s%06d" % [@tag, date, @auth_tid]
+      end
+
+      # Perform login
+      #
+      # @return [true] login successful
+      # @raise [ResponseError] login failed
+      # @see login_request
+      def login!
+        @error   = nil
+        login    = EPP::Commands::Login.new(@tag, @passwd, @options)
+        command  = EPP::Requests::Command.new(auth_tid, login)
+        request  = EPP::Request.new(command)
+        response = send_recv_frame(request)
+
+        return true if response.code == 1000
+        raise @error = ResponseError.new(response.code, response.message, response.to_xml)
+      end
+
+      # Perform logout
+      #
+      # @return [true] logout successful
+      # @raise [ResponseError] logout failed
+      # @see logout_request
+      def logout!
+        logout   = EPP::Commands::Logout.new
+        command  = EPP::Requests::Command.new(auth_tid, logout)
+        request  = EPP::Request.new(command)
+        response = send_recv_frame(request)
+
+        return true if response.code == 1500
+        raise @error = ResponseError.new(response.code, response.message, response.to_xml)
+      end
+
+      # Send a frame and receive its response
+      #
+      # @param [String] xml XML Payload to send
+      # @return [Response] EPP Response
+      # @see send_frame
+      # @see recv_frame
+      def send_recv_frame(xml)
+        send_frame(xml)
+        Response.new(recv_frame)
+      end
+
+      # Send XML frame
+      # @param [String,Request] xml Payload to send
+      # @return [Integer] number of bytes written
+      def send_frame(xml)
+        xml = xml.to_s if xml.kind_of?(Request)
+        @sock.write([xml.size + HEADER_LEN].pack("N") + xml)
+      end
+
+      # Receive XML frame
+      # @return [String] XML response
+      def recv_frame
+        header = @sock.read(HEADER_LEN)
+
+        if header.nil? && @sock.eof?
+          raise ServerError, "Connection terminated by remote host"
+        elsif header.nil?
+          raise ServerError, "Failed to read header from remote host"
+        else
+          len = header.unpack('N')[0]
+
+          raise ServerError, "Bad frame header from server, should be greater than #{HEADER_LEN}" unless len > HEADER_LEN
+          @sock.read(len - HEADER_LEN)
+        end
+      end
+  end
+end

data/lib/epp-client/testing.rb

@@ -0,0 +1,59 @@
+require 'epp-client'
+
+module EPP
+  class Client
+    # Request Preparation Methods
+    def check_prepare(payload, extension = nil)
+      check = EPP::Commands::Check.new(payload)
+      prepare_request(check, extension)
+    end
+
+    def create_prepare(payload, extension = nil)
+      create = EPP::Commands::Create.new(payload)
+      prepare_request(create, extension)
+    end
+
+    def delete_prepare(payload, extension = nil)
+      delete = EPP::Commands::Delete.new(payload)
+      prepare_request(delete, extension)
+    end
+
+    def info_prepare(payload, extension = nil)
+      info = EPP::Commands::Info.new(payload)
+      prepare_request(info, extension)
+    end
+
+    def renew_prepare(payload, extension = nil)
+      renew = EPP::Commands::Renew.new(payload)
+      prepare_request(renew, extension)
+    end
+
+    def transfer_prepare(op, payload, extension = nil)
+      transfer = EPP::Commands::Transfer.new(op, payload)
+      prepare_request(transfer, extension)
+    end
+
+    def update_prepare(payload, extension = nil)
+      update = EPP::Commands::Update.new(payload)
+      prepare_request(update, extension)
+    end
+
+    def poll_prepare
+      poll = EPP::Commands::Poll.new
+      prepare_request(poll)
+    end
+    def ack_prepare(msgID)
+      ack = EPP::Commands::Poll.new(msgID)
+      prepare_request(ack)
+    end
+
+    def prepare_request(cmd, extension = nil)
+      @conn.prepare_request(cmd, extension)
+    end
+    
+    # Response Preparation Methods
+    def load_response(xml_data)
+      EPP::Response.new(xml_data)
+    end
+  end
+end

data/lib/epp-client/version.rb

@@ -0,0 +1,3 @@
+module EPP
+  VERSION = '3.0.0'
+end

data/lib/epp-client/xml_helper.rb

@@ -0,0 +1,71 @@
+module EPP
+  module XMLHelpers
+    # Creates and returns an instance of the EPP 1.0 namespace
+    #
+    # @param [XML::Node] node to create the namespace on
+    # @param [String, nil] Name to give the namespace
+    # @return [XML::Namespace] EPP 1.0 namespace
+    def epp_namespace(node, name = nil, namespaces = {})
+      return namespaces['epp'] if namespaces.has_key?('epp')
+      xml_namespace(node, name, 'urn:ietf:params:xml:ns:epp-1.0')
+    end
+    
+    # Creates and returns a new node in the EPP 1.0 namespace
+    #
+    # @param [String] name of the node to create
+    # @param [String,XML::Node,nil] value of the node
+    # @return [XML::Node]
+    def epp_node(name, value = nil, namespaces = {})
+      value, namespaces = nil, value if value.kind_of?(Hash)
+
+      node = xml_node(name, value)
+      node.namespaces.namespace = epp_namespace(node, nil, namespaces)
+      node
+    end
+
+    # Creates and returns a new XML node
+    #
+    # @param [String] name of the node to create
+    # @param [String,XML::Node,nil] value of the node
+    # @return [XML::Node]
+    def xml_node(name, value = nil)
+      XML::Node.new(name, value)
+    end
+
+    # Creates and returns a new XML namespace
+    #
+    # @param [XML::Node] node XML node to add the namespace to
+    # @param [String] name Name of the namespace to create
+    # @param [String] uri URI of the namespace to create
+    # @return [XML::Namespace]
+    def xml_namespace(node, name, uri, namespaces = {})
+      XML::Namespace.new(node, name, uri)
+    end
+
+    # Creates and returns a new XML document
+    #
+    # @param [XML::Document,String] obj Object to create the document with
+    # @return [XML::Document]
+    def xml_document(obj)
+      case obj
+      when XML::Document
+        XML::Document.document(obj)
+      else
+        XML::Document.new('1.0')
+      end
+    end    
+    
+    def as_xml(obj)
+      return obj.to_xml if obj.respond_to?(:to_xml)
+
+      case obj
+      when String
+        XML::Document.string(obj).root
+      when XML::Node
+        obj
+      when XML::Document
+        obj.root
+      end
+    end
+  end
+end