kono_epp_client 0.1.0 → 2.0.0

data/lib/epp/epp_command/transfer_domain.rb

@@ -1,36 +0,0 @@
-class KonoEppTransferDomain < KonoEppCommand
-  def initialize(name, authinfo, op, extension: nil)
-    super(nil, nil)
-
-    command = root.elements['command']
-    transfer = command.add_element("transfer", {"op" => op})
-    # FIXME dovremmo controllare che le possibili opzioni di OP sono  'request', 'cancel', 'approve', 'reject', 'query'
-
-    domain_transfer = transfer.add_element("domain:transfer", {"xmlns:domain" => "urn:ietf:params:xml:ns:domain-1.0",
-                                                               "xsi:schemaLocation" => "urn:ietf:params:xml:ns:domain-1.0 domain-1.0.xsd"})
-
-    domain_name = domain_transfer.add_element "domain:name"
-    domain_name.text = name
-
-    domain_authinfo = domain_transfer.add_element "domain:authInfo"
-    domain_pw = domain_authinfo.add_element "domain:pw"
-
-    domain_pw.text = authinfo
-
-    ## Questa estensione è per Modifica del Registrar con contestuale modifica del Registrante
-    if extension
-
-      ext_elm = command.add_element "extension"
-      ext_trade = ext_elm.add_element "extdom:trade", {"xmlns:extdom"=>"http://www.nic.it/ITNIC-EPP/extdom-2.0",
-                                                         "xsi:schemaLocation" => "http://www.nic.it/ITNIC-EPP/extdom-2.0 extdom-2.0.xsd"}
-
-      transfer_trade = ext_trade.add_element "extdom:transferTrade"
-      transfer_trade.add_element("extdom:newRegistrant").text = extension[:new_registrant] if extension[:new_registrant]
-      if extension[:new_auth_info]
-        transfer_trade.add_element("extdom:newAuthInfo").add_element("extdom:pw").tap{|x|x.text=extension[:new_auth_info]}
-      end
-
-    end
-
-  end
-end

data/lib/epp/epp_command/update_contact.rb

@@ -1,115 +0,0 @@
-class KonoEppUpdateContact < KonoEppCommand
-
-  # TODO: Add and remove fields
-  def initialize( options )
-    super( nil, nil )
-
-    command = root.elements['command']
-
-    update = command.add_element "update"
-
-    contact_update = update.add_element( "contact:update", { "xmlns:contact" => "urn:ietf:params:xml:ns:contact-1.0",
-                                                             "xsi:schemaLocation" => "urn:ietf:params:xml:ns:contact-1.0 contact-1.0.xsd" } )
-
-    id = contact_update.add_element "contact:id"
-    id.text = options[:id]
-
-    contact_chg = contact_update.add_element "contact:chg"
-
-    unless options[:name].blank?              \
-           and options[:organization].blank?  \
-           and options[:address].blank?       \
-           and options[:city].blank?          \
-           and options[:state].blank?         \
-           and options[:postal_code].blank?   \
-           and options[:country].blank?
-
-      postal_info = contact_chg.add_element "contact:postalInfo", { "type" => "loc" }
-
-      unless options[:name].blank?
-        name = postal_info.add_element "contact:name"
-        name.text = options[:name]
-      end
-
-      unless options[:organization].blank?
-        organization = postal_info.add_element "contact:org"
-        organization.text = options[:organization]
-      end
-
-      # NOTE: city and country are REQUIRED
-      unless options[:address].blank?         \
-             and options[:city].blank?        \
-             and options[:state].blank?       \
-             and options[:postal_code].blank? \
-             and options[:country].blank?
-
-        addr = postal_info.add_element "contact:addr"
-
-        unless options[:address].blank?
-          street = addr.add_element "contact:street"
-          street.text = options[:address]
-        end
-
-        city = addr.add_element "contact:city"
-        city.text = options[:city]
-
-        unless options[:state].blank?
-          state = addr.add_element "contact:sp"
-          state.text  = options[:state]
-        end
-
-        unless options[:postal_code].blank?
-          postal_code = addr.add_element "contact:pc"
-          postal_code.text = options[:postal_code]
-        end
-
-        country_code = addr.add_element "contact:cc"
-        country_code.text = options[:country]
-      end
-    end
-
-    if options[:voice]
-      voice = contact_chg.add_element "contact:voice"
-      voice.text = options[:voice]
-    end
-
-    if options[:fax]
-      fax = contact_chg.add_element "contact:fax"
-      fax.text = options[:fax]
-    end
-
-    if options[:email]
-      email = contact_chg.add_element "contact:email"
-      email.text = options[:email]
-    end
-
-
-    unless not options.has_key?( :publish ) \
-           and options[:nationality].blank? \
-           and options[:entity_type].blank? \
-           and options[:reg_code].blank?
-
-      # FIXME
-      extension = command.add_element "extension"
-      extension_update = extension.add_element "extcon:update", { "xmlns:extcon"       => 'http://www.nic.it/ITNIC-EPP/extcon-1.0',
-                                                                  "xsi:schemaLocation" => 'http://www.nic.it/ITNIC-EPP/extcon-1.0 extcon-1.0.xsd' }
-      if options.has_key?( :publish )
-        publish = extension_update.add_element "extcon:consentForPublishing"
-        publish.text = options[:publish]
-      end
-
-      if options[:becomes_registrant]
-        extcon_registrant = extension_update.add_element "extcon:registrant"
-
-        extcon_nationality = extcon_registrant.add_element "extcon:nationalityCode"
-        extcon_nationality.text = options[:nationality]
-
-        extcon_entity = extcon_registrant.add_element "extcon:entityType"
-        extcon_entity.text = options[:entity_type]
-
-        extcon_regcode = extcon_registrant.add_element "extcon:regCode"
-        extcon_regcode.text = options[:reg_code]
-      end
-    end
-  end
-end

data/lib/epp/epp_command/update_domain.rb

@@ -1,104 +0,0 @@
-class KonoEppUpdateDomain < KonoEppCommand
-  def initialize(options)
-    super(nil, nil)
-
-    command = root.elements['command']
-    update = command.add_element("update")
-
-    domain_update = update.add_element("domain:update", {"xmlns:domain" => "urn:ietf:params:xml:ns:domain-1.0",
-                                                         "xsi:schemaLocation" => "urn:ietf:params:xml:ns:domain-1.0 domain-1.0.xsd"})
-
-    name = domain_update.add_element "domain:name"
-    name.text = options[:name]
-
-    if not options[:add_nameservers].blank? or options[:add_admin] or options[:add_tech] or options[:add_status]
-      # <domain:add>
-      domain_add = domain_update.add_element "domain:add"
-
-      unless options[:add_nameservers].blank?
-        domain_add_ns = domain_add.add_element "domain:ns"
-
-        options[:add_nameservers].each do |ns|
-          host_attr = domain_add_ns.add_element "domain:hostAttr"
-          host_name = host_attr.add_element "domain:hostName"
-
-          host_name.text = ns[0]
-
-          # FIXME IPv6
-          if ns[1]
-            host_addr = host_attr.add_element "domain:hostAddr", {"ip" => "v4"}
-            host_addr.text = ns[1]
-          end
-        end
-      end
-
-      if options[:add_admin]
-        domain_contact = domain_add.add_element "domain:contact", {"type" => "admin"}
-        domain_contact.text = options[:add_admin]
-      end
-
-      if options[:add_status]
-        domain_add.add_element "domain:status", {"s" => options[:add_status]}
-      end
-
-      if options[:add_tech]
-        domain_contact = domain_add.add_element "domain:contact", {"type" => "tech"}
-        domain_contact.text = options[:add_tech]
-      end
-    end
-
-    if not options[:remove_nameservers].blank? or options[:remove_admin] or options[:remove_tech] or options[:remove_status]
-      # <domain:rem>
-      domain_remove = domain_update.add_element "domain:rem"
-
-      unless options[:remove_nameservers].blank?
-        domain_remove_ns = domain_remove.add_element "domain:ns"
-
-        options[:remove_nameservers].each do |ns_name|
-          host_attr = domain_remove_ns.add_element "domain:hostAttr"
-          host_name = host_attr.add_element "domain:hostName"
-
-          host_name.text = ns_name
-        end
-      end
-
-      if options[:remove_admin]
-        domain_contact = domain_remove.add_element "domain:contact", {"type" => "admin"}
-        domain_contact.text = options[:remove_admin]
-      end
-
-      if options[:remove_status]
-        domain_remove.add_element "domain:status", {"s" => options[:remove_status]}
-      end
-
-      if options[:remove_tech]
-        domain_contact = domain_remove.add_element "domain:contact", {"type" => "tech"}
-        domain_contact.text = options[:remove_tech]
-      end
-    end
-
-    # <domain:chg>
-    if options[:auth_info]
-      domain_change = domain_update.add_element "domain:chg"
-
-      if options[:registrant]
-        domain_registrant = domain_change.add_element "domain:registrant"
-        domain_registrant.text = options[:registrant]
-      end
-
-      domain_authinfo = domain_change.add_element "domain:authInfo"
-
-      domain_pw = domain_authinfo.add_element "domain:pw"
-      domain_pw.text = options[:auth_info]
-    end
-
-    if options[:restore]
-      command.add_element("extension").tap do |ext|
-        ext.add_element("rgp:update", {"xmlns:rgp"=>"urn:ietf:params:xml:ns:rgp-1.0",
-                        "xsi:schemaLocation"=>"urn:ietf:params:xml:ns:rgp-1.0 rgp-1.0.xsd"}).
-          add_element("rgp:restore", {"op"=> "request"})
-      end
-    end
-    # TODO: Registrant
-  end
-end

data/lib/epp/epp_command.rb

@@ -1,15 +0,0 @@
-include REXML
-
-class KonoEppCommand < REXML::Document
-  def initialize( source = nil, context = nil )
-    super( source, context )
-
-    add( XMLDecl.new( "1.0", "UTF-8", "no" ) )
-
-    epp = 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" } )
-
-    epp.add_element( "command" )
-  end
-end

data/lib/epp/exceptions.rb

@@ -1,28 +0,0 @@
-class KonoEppErrorResponse < StandardError #:nodoc:
-  attr_accessor :response_xml, :response_code, :reason_code, :message
-
-  # Generic EPP exception. Accepts a response code and a message
-  def initialize(attributes = {})
-    @response_xml = attributes[:xml]
-    @response_code = attributes[:response_code]
-    @reason_code = attributes[:reason_code]
-    @message = attributes[:message]
-  end
-
-  def to_s
-    "#{@message} (reason: #{@reason_code} code: #{@response_code})"
-  end
-end
-
-class KonoEppAuthenticationPasswordExpired < KonoEppErrorResponse ; end
-class KonoEppLoginNeeded < KonoEppErrorResponse ; end
-
-##
-# Errore NIC:
-# 2304=Object status prohibits operation 9022=Domain has status clientTransferProhibited
-class KonoEppDomainHasStatusCliTransProhibited < KonoEppErrorResponse; end
-
-##
-# Errore NIC:
-# 2304=Object status prohibits operation 9026=Domain has status clientUpdateProhibited
-class KonoEppDomainHasStatusClientUpdateProhibited < KonoEppErrorResponse; end

data/lib/epp/server.rb

@@ -1,295 +0,0 @@
-module KonoEppClient #:nodoc:
-  class Server
-    include REXML
-    include RequiresParameters
-
-    require 'nokogiri'
-
-    attr_accessor :tag, :password, :server, :port, :ssl_version, :old_server, :services, :lang, :extensions, :version, :credit, :timeout
-
-    # ==== 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 older EPP servers. Default is false.
-    # * <tt>:lang</tt> - Set custom language attribute. Default is 'en'.
-    # * <tt>:services</tt> - Use custom EPP services in the <login> frame. The defaults use the EPP standard domain, contact and host 1.0 services.
-    # * <tt>:extensions</tt> - URLs to custom extensions to standard EPP. Use these to extend the standard EPP (e.g., Nominet uses extensions). Defaults to none.
-    # * <tt>:version</tt> - Set the EPP version. Defaults to "1.0".
-    # * <tt>:transport</tt> - Type of connection (http or tcp). Default to "tcp"
-    # * <tt>:timeout</tt> - Timeou for connections in seconds. Default to "30"
-    # * <tt>:ssl_version</tt> - Version of the ssl protocol versione. Default to TLSv1
-    # * <tt>:ssl_version</tt> - Version of the ssl protocol versione. Default to TLSv1
-    #
-    def initialize(attributes = {})
-      requires!(attributes, :tag, :password, :server)
-
-      @tag          = attributes[:tag]
-      @password     = attributes[:password]
-      @server       = attributes[:server]
-      @port         = attributes[:port]        || 700
-      @old_server   = attributes[:old_server]  || false
-      @lang         = attributes[:lang]        || "en"
-      @services     = attributes[:services]    || ["urn:ietf:params:xml:ns:domain-1.0", "urn:ietf:params:xml:ns:contact-1.0", "urn:ietf:params:xml:ns:host-1.0"]
-      @extensions   = attributes[:extensions]  || []
-      @version      = attributes[:version]     || "1.0"
-      @transport    = attributes[:transport]   || :tcp
-      @timeout      = attributes[:timeout]     || 30
-      @ssl_version  = attributes[:ssl_version] || :TLSv1
-
-      @logged_in  = false
-    end
-
-    def connect_and_hello
-      open_connection
-
-      hello
-    end
-
-    # Closes the connection to the EPP server.
-    def close_connection
-      @connection.close
-    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
-
-      # @logged_in = true if login
-
-      begin
-        @response = send_request( xml )
-      ensure
-        if @logged_in && !old_server
-          @logged_in = false if logout
-        end
-      end
-
-      return @response
-    end
-
-    # Sends a standard login request to the EPP server.
-    def login
-      login = KonoEppLogin.new( tag, password )
-
-      # FIXME: Order matters
-      login.version = version
-      login.lang = lang
-
-      login.services = services
-      login.extensions = extensions
-
-      send_command( login )
-    end
-
-    def change_password( new_password )
-      login = KonoEppLogin.new( tag, password )
-
-      # FIXME: Order matters
-      login.new_password = new_password
-
-      login.version = version
-      login.lang = lang
-
-      login.services = services
-      login.extensions = extensions
-
-      send_command( login )
-    end
-
-    def logged_in?
-      begin
-        poll
-      rescue
-        return false
-      end
-
-      return true
-    end
-
-    # FIXME: Remove command wrappers?
-    def hello
-      send_request( KonoEppHello.new.to_s )
-    end
-
-    def poll( id = nil )
-      poll = KonoEppPoll.new( id ? :ack : :req )
-
-      poll.ack_id = id if id
-
-      send_command( poll )
-    end
-
-    def create_contact( options )
-      contact = KonoEppCreateContact.new options
-      send_command( contact )
-    end
-
-    def check_contacts(ids)
-      send_command( KonoEppCheckContacts.new(ids) )
-    end
-
-    def delete_contact( id )
-      contact = KonoEppDeleteContact.new id
-      send_command( contact )
-    end
-
-    def update_contact( options )
-      contact = KonoEppUpdateContact.new options
-      send_command( contact )
-    end
-
-    def create_domain( options )
-      domain = KonoEppCreateDomain.new options
-      send_command( domain )
-    end
-
-    def check_domains( *domains )
-      send_command( KonoEppCheckDomains.new *domains )
-    end
-
-    def update_domain( options )
-      domain = KonoEppUpdateDomain.new options
-      send_command( domain )
-    end
-
-    def delete_domain( name )
-      domain = KonoEppDeleteDomain.new name
-      send_command( domain )
-    end
-
-    def info_contact( id )
-      contact = KonoEppInfoContact.new id
-      send_command( contact )
-    end
-
-    def info_domain( name )
-      info = KonoEppInfoDomain.new name
-      send_command( info )
-    end
-
-    def transfer_domain(name, authinfo, op, extension: nil)
-      send_command(KonoEppTransferDomain.new( name, authinfo, op, extension: extension))
-    end
-
-    # Sends a standard logout request to the EPP server.
-    def logout
-      send_command( KonoEppLogout.new, 1500 )
-    end
-
-# private
-    # Wrapper which sends XML to the server, and receives
-    # the response in return.
-    def send_request( xml )
-      write( xml )
-      read
-    end
-
-    def send_command( command, expected_result = 1000..1999 )
-      namespaces = { 'extepp' => 'http://www.nic.it/ITNIC-EPP/extepp-2.0',
-                     'xmlns' => "urn:ietf:params:xml:ns:epp-1.0" }
-
-      xml = Nokogiri.XML( send_request( command.to_s ) )
-
-      # TODO: multiple <response> RFC 3730 §2.6
-      result = xml.at_xpath( "/xmlns:epp/xmlns:response[1]/xmlns:result",
-                             namespaces )
-      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if result.nil?
-
-      xmlns_code = result.at_xpath( "@code" )
-      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if xmlns_code.nil?
-
-      response_code = xmlns_code.value.to_i
-
-      xmlns_msg = result.xpath( "xmlns:msg/text ()",
-                                namespaces )
-      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if xmlns_msg.empty?
-
-      result_message = xmlns_msg.text.strip
-
-      # TODO: value
-
-      xmlns_ext_reason = result.xpath( "xmlns:extValue/xmlns:reason",
-                                       namespaces)
-      result_message += ": #{xmlns_ext_reason.text.strip}" unless xmlns_ext_reason.empty?
-
-      xmlns_reason_code = result.xpath( "xmlns:extValue/xmlns:value/extepp:reasonCode",
-                                        namespaces )
-      reason_code = xmlns_reason_code.text.strip.to_i unless xmlns_reason_code.empty?
-
-      credit_msg = xml.xpath( "//extepp:credit/text ()",
-                              namespaces )
-      @credit = credit_msg.text.to_f unless credit_msg.empty?
-
-      if expected_result === response_code
-        return xml
-      end
-
-      args = { :xml           => xml,
-               :response_code => response_code,
-               :reason_code   => reason_code,
-               :message       => result_message }
-
-      case [ response_code, reason_code ]
-        when [2200, 6004]
-          raise KonoEppAuthenticationPasswordExpired.new( args )
-        when [2002, 4015]
-          raise KonoEppLoginNeeded.new( args )
-        when [2304, 9022]
-          raise KonoEppDomainHasStatusCliTransProhibited.new(args)
-        when [2304, 9026]
-          raise KonoEppDomainHasStatusClientUpdateProhibited.new(args)
-        else
-          raise KonoEppErrorResponse.new( args )
-      end
-    end
-
-    # Establishes the connection to the server. If the connection is
-		# established, then this method will call read and return
-		# the EPP <tt><greeting></tt> which is sent by the
-		# server upon connection.
-    def open_connection
-      # FIXME il timeout serve solamente nella versione tcp
-      # FIXME perchè utilizzare un'istanza di classe? non sarebbe meglio avere un metodo che genera il transport
-      #       e successivamente viene utilizzato sempre quello?
-      Timeout.timeout @timeout do
-        case @transport
-        when :tcp
-          @connection = KonoEppClient::Transport::TcpTransport.new(server, port)
-        when :http
-          @connection = KonoEppClient::Transport::HttpTransport.new(server, port,
-                                                                    ssl_version: ssl_version,
-                                                                    cookie_file: "#{@tag.downcase}.cookies.pstore"
-          )
-        end
-      end
-    end
-
-    # Receive an EPP response 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 read
-      Timeout.timeout @timeout do
-        @connection.read
-      end
-    end
-
-    # Send XML to the server. If the socket returns EOF,
-    # the connection has closed and a SocketError is raised.
-    def write( xml )
-      Timeout.timeout @timeout do
-        @connection.write( xml )
-      end
-    end
-  end
-end

data/lib/epp/transport/tcp.rb

@@ -1,93 +0,0 @@
-module KonoEppClient::Transport
-  class TcpTransport
-    include KonoEppClient::Transport
-
-    def initialize( server, port )
-      @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
-      read
-    end
-
-    def read
-     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
-
-    def write
-      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
-
-    def close
-      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
-  private
-    # 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
-      end
-
-  end
-end