kono_epp_client 0.1.1 → 2.0.0

data/lib/kono_epp_client/commands/update_contact.rb

@@ -0,0 +1,116 @@
+module KonoEppClient::Commands
+  class UpdateContact < Command
+
+    # 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
+end

data/lib/kono_epp_client/commands/update_domain.rb

@@ -0,0 +1,117 @@
+module KonoEppClient::Commands
+  class UpdateDomain < Command
+    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
+
+      if options[:dns_sec_data] and options[:dns_sec_data].any?
+        extension = command.elements['extension'] || command.add_element("extension")
+
+        create_list = extension.add_element("secDNS:update", {"xmlns:secDNS"=> "urn:ietf:params:xml:ns:secDNS-1.1"})
+
+        options[:dns_sec_data].each do |d|
+          create_list.add_element(d)
+        end
+      end
+
+    end
+  end
+end

data/lib/kono_epp_client/dns_sec/add.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KonoEppClient::DnsSec
+  class Add < REXML::Element
+    def initialize(*ds_datas)
+      super("secDNS:add")
+
+      ds_datas.each do |ds_data|
+        self.add_element ds_data
+      end
+    end
+  end
+end

data/lib/kono_epp_client/dns_sec/ds_data.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module KonoEppClient::DnsSec
+  class DsData < REXML::Element
+
+    attr_accessor :key_tag, :alg, :digest_type, :digest
+
+    ALG = {
+      :dsa_sha_1 => 3,
+      :rsa_sha_1 => 5,
+      :dsa_nsec_3_sha_1 => 6,
+      :rsasha_1_nsec_3_sha_1 => 7,
+      :rsa_sha_256 => 8,
+      :rsa_sha_512 => 10,
+      :ecc_gost => 12,
+      :ecdsap_256_sha_256 => 13,
+      :ecdsap_384_sha_384 => 14
+    }.freeze
+    DIGEST_TYPES = {
+      :sha_1 => 1,
+      :sha_256 => 2,
+      :gost_r_34_11_94 => 3,
+      :sha_384 => 4
+    }.freeze
+
+    ##
+    # Inizializzazione di un DsData
+    #
+    # @param [Integer] key_tag 0<=X<=65535
+    # @param [Symbol] alg
+    #              :dsa_sha_1                  =>  3 (DSA/SHA-1)
+    #              :rsa_sha_1                  =>  5 (RSA/SHA-1)
+    #              :dsa_nsec_3_sha_1           =>  6 (DSA-NSEC3-SHA1)
+    #              :rsasha_1_nsec_3_sha_1      =>  7 (RSASHA1-NSEC3-SHA1)
+    #              :rsa_sha_256                =>  8 (RSA/SHA-256)
+    #              :rsa_sha_512                =>  10 (RSA/SHA-512)
+    #              :ecc_gost                   =>  12 (ECC-GOST)
+    #              :ecdsap_256_sha_256         =>  13 (ECDSAP256SHA256)
+    #              :ecdsap_384_sha_384         =>  14 (ECDSAP384SHA384)
+    # @param [Symbol] digest_type
+    #                :sha_1           => 1 (SHA-1)
+    #                :sha_256         => 2 (SHA-256)
+    #                :gost_r_34_11_94 => 3 (GOST R 34.11-94)
+    #                :sha_384         => 4 (SHA-384)
+    # @param [String] digest
+    def initialize(key_tag, alg, digest_type, digest)
+      key_tag = key_tag.to_i
+      @alg = ALG[alg] || raise("Invalid alg #{alg}")
+      @digest = digest
+      if (0..65535).include?(key_tag)
+        @key_tag = key_tag
+      else
+        raise "Invalid key tag #{key_tag}, should be 0<=key_tag<=65535"
+      end
+      @digest_type = DIGEST_TYPES[digest_type] || raise("Invalid digest type #{digest_type}")
+
+      super("secDNS:dsData")
+      self.add_element("secDNS:keyTag").text = @key_tag
+      self.add_element("secDNS:alg").text = @alg
+      self.add_element("secDNS:digestType").text = @digest_type
+      self.add_element("secDNS:digest").text = @digest
+
+    end
+
+  end
+end

data/lib/kono_epp_client/dns_sec/rem.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module KonoEppClient::DnsSec
+  class Rem < REXML::Element
+    def initialize(*ds_datas)
+      super("secDNS:rem")
+
+      ds_datas.each do |ds_data|
+        self.add_element ds_data
+      end
+
+    end
+  end
+end

data/lib/kono_epp_client/dns_sec/rem_all.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KonoEppClient::DnsSec
+  class RemAll < REXML::Element
+    def initialize
+      super("secDNS:rem")
+      self.add_element("secDNS:all").text="true"
+    end
+  end
+end

data/lib/kono_epp_client/exceptions/error_response.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module KonoEppClient::Exceptions
+  class ErrorResponse < 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
+end

data/lib/kono_epp_client/exceptions.rb

@@ -0,0 +1,15 @@
+module KonoEppClient::Exceptions
+  class AuthenticationPasswordExpired < ErrorResponse; end
+
+  class LoginNeeded < ErrorResponse; end
+
+  ##
+  # Errore NIC:
+  # 2304=Object status prohibits operation 9022=Domain has status clientTransferProhibited
+  class DomainHasStatusCliTransProhibited < ErrorResponse; end
+
+  ##
+  # Errore NIC:
+  # 2304=Object status prohibits operation 9026=Domain has status clientUpdateProhibited
+  class DomainHasStatusClientUpdateProhibited < ErrorResponse; end
+end

data/lib/kono_epp_client/requires_parameters.rb

@@ -0,0 +1,16 @@
+module KonoEppClient
+  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
+end

data/lib/{epp → kono_epp_client}/server.rb

@@ -3,12 +3,22 @@ module KonoEppClient #:nodoc:
     include REXML
     include RequiresParameters
 
+    ##
+    # Se la risposta al login contiene questo tipo di chiave-valore, allora la comunicazione può avvenire con
+    # comandi aggiuntivi DNSSEC
+    DNS_CHECK_NS_SET = Set.new([["xmlns:secDNS", "urn:ietf:params:xml:ns:secDNS-1.1"],
+                                ["xmlns:extsecDNS", "http://www.nic.it/ITNIC-EPP/extsecDNS-1.0"]],
+    )
+
     require 'nokogiri'
 
     attr_accessor :tag, :password, :server, :port, :ssl_version, :old_server,
                   :services, :lang, :extensions, :version, :credit, :timeout,
                   :transport, :transport_options
 
+    attr_reader :dns_sec_enabled
+    alias_method :dns_sec_enabled?, :dns_sec_enabled
+
     # ==== Required Attrbiutes
     #
     # * <tt>:server</tt> - The EPP server to connect to
@@ -19,16 +29,16 @@ module KonoEppClient #:nodoc:
     #
     # * <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>:transport</tt> - Type of connection (http). Default to "html"
     # * <tt>:transport_options</tt> - Overrides for transport configurations. Default to {}
-    # * <tt>:timeout</tt> - Timeou for connections in seconds. Default to "30"
+    # * <tt>:timeout</tt> - Timeout 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
+    # * <tt>:enable_dns_sec</tt> - Try to enable DNSSEC, the response from login command will say it. default false
     #
     def initialize(attributes = {})
       requires!(attributes, :tag, :password, :server)
@@ -37,17 +47,22 @@ module KonoEppClient #:nodoc:
       @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
+      @transport = attributes[:transport] || :http
       @transport_options = attributes[:transport_options] || {}
       @timeout = attributes[:timeout] || 30
       @ssl_version = attributes[:ssl_version] || :TLSv1
 
+      if attributes[:enable_dns_sec]
+        @extensions << "urn:ietf:params:xml:ns:secDNS-1.1"
+        @extensions << "http://www.nic.it/ITNIC-EPP/extsecDNS-1.0"
+      end
+
       @logged_in = false
+      @dns_sec_enabled = false
     end
 
     def connect_and_hello
@@ -61,29 +76,9 @@ module KonoEppClient #:nodoc:
       @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)
+      login = Commands::Login.new(tag, password)
 
       # FIXME: Order matters
       login.version = version
@@ -92,11 +87,18 @@ module KonoEppClient #:nodoc:
       login.services = services
       login.extensions = extensions
 
-      send_command(login)
+      response = send_command(login)
+
+      response_set = Set.new(response.namespaces.to_a)
+      if response_set.superset?(DNS_CHECK_NS_SET)
+        @dns_sec_enabled = true
+      end
+
+      response
     end
 
     def change_password(new_password)
-      login = KonoEppLogin.new(tag, password)
+      login = Commands::Login.new(tag, password)
 
       # FIXME: Order matters
       login.new_password = new_password
@@ -122,11 +124,11 @@ module KonoEppClient #:nodoc:
 
     # FIXME: Remove command wrappers?
     def hello
-      send_request(KonoEppHello.new.to_s)
+      send_request(Commands::Hello.new.to_s)
     end
 
     def poll(id = nil)
-      poll = KonoEppPoll.new(id ? :ack : :req)
+      poll = Commands::Poll.new(id ? :ack : :req)
 
       poll.ack_id = id if id
 
@@ -134,60 +136,68 @@ module KonoEppClient #:nodoc:
     end
 
     def create_contact(options)
-      contact = KonoEppCreateContact.new options
+      contact = Commands::CreateContact.new options
       send_command(contact)
     end
 
     def check_contacts(ids)
-      send_command(KonoEppCheckContacts.new(ids))
+      send_command(Commands::CheckContacts.new(ids))
     end
 
     def delete_contact(id)
-      contact = KonoEppDeleteContact.new id
+      contact = Commands::DeleteContact.new id
       send_command(contact)
     end
 
     def update_contact(options)
-      contact = KonoEppUpdateContact.new options
+      contact = Commands::UpdateContact.new options
       send_command(contact)
     end
 
     def create_domain(options)
-      domain = KonoEppCreateDomain.new options
+      dns_sec_data = options.delete(:dns_sec_data)||[]
+      if dns_sec_enabled?
+        options[:dns_sec_data] = dns_sec_data
+      end
+      domain = Commands::CreateDomain.new options
       send_command(domain)
     end
 
     def check_domains(*domains)
-      send_command(KonoEppCheckDomains.new *domains)
+      send_command(Commands::CheckDomains.new *domains)
     end
 
     def update_domain(options)
-      domain = KonoEppUpdateDomain.new options
+      dns_sec_data = options.delete(:dns_sec_data)||[]
+      if dns_sec_enabled?
+        options[:dns_sec_data] = dns_sec_data
+      end
+      domain = Commands::UpdateDomain.new options
       send_command(domain)
     end
 
     def delete_domain(name)
-      domain = KonoEppDeleteDomain.new name
+      domain = Commands::DeleteDomain.new name
       send_command(domain)
     end
 
     def info_contact(id)
-      contact = KonoEppInfoContact.new id
+      contact = Commands::InfoContact.new id
       send_command(contact)
     end
 
     def info_domain(name)
-      info = KonoEppInfoDomain.new name
+      info = Commands::InfoDomain.new name
       send_command(info)
     end
 
     def transfer_domain(name, authinfo, op, extension: nil)
-      send_command(KonoEppTransferDomain.new(name, authinfo, op, extension: extension))
+      send_command(Commands::TransferDomain.new(name, authinfo, op, extension: extension))
     end
 
     # Sends a standard logout request to the EPP server.
     def logout
-      send_command(KonoEppLogout.new, 1500)
+      send_command(Commands::Logout.new, 1500)
     end
 
     # private
@@ -207,16 +217,16 @@ module KonoEppClient #:nodoc:
       # 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?
+      raise Exceptions::ErrorResponse.new(:message => 'Malformed response') if result.nil?
 
       xmlns_code = result.at_xpath("@code")
-      raise KonoEppErrorResponse.new(:message => 'Malformed response') if xmlns_code.nil?
+      raise Exceptions::ErrorResponse.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?
+      raise Exceptions::ErrorResponse.new(:message => 'Malformed response') if xmlns_msg.empty?
 
       result_message = xmlns_msg.text.strip
 
@@ -230,8 +240,7 @@ module KonoEppClient #:nodoc:
                                        namespaces)
       reason_code = xmlns_reason_code.text.strip.to_i unless xmlns_reason_code.empty?
 
-      credit_msg = xml.xpath("//extepp:credit/text ()",
-                             namespaces)
+      credit_msg = xml.xpath("//extepp:credit/text ()", namespaces)
       @credit = credit_msg.text.to_f unless credit_msg.empty?
 
       if expected_result === response_code
@@ -245,15 +254,15 @@ module KonoEppClient #:nodoc:
 
       case [response_code, reason_code]
       when [2200, 6004]
-        raise KonoEppAuthenticationPasswordExpired.new(args)
+        raise Exceptions::AuthenticationPasswordExpired.new(args)
       when [2002, 4015]
-        raise KonoEppLoginNeeded.new(args)
+        raise Exceptions::LoginNeeded.new(args)
       when [2304, 9022]
-        raise KonoEppDomainHasStatusCliTransProhibited.new(args)
+        raise Exceptions::DomainHasStatusCliTransProhibited.new(args)
       when [2304, 9026]
-        raise KonoEppDomainHasStatusClientUpdateProhibited.new(args)
+        raise Exceptions::DomainHasStatusClientUpdateProhibited.new(args)
       else
-        raise KonoEppErrorResponse.new(args)
+        raise Exceptions::ErrorResponse.new(args)
       end
     end
 
@@ -267,8 +276,6 @@ module KonoEppClient #:nodoc:
       #       e successivamente viene utilizzato sempre quello?
       Timeout.timeout @timeout do
         case @transport
-        when :tcp
-          @connection = KonoEppClient::Transport::TcpTransport.new(server, port)
         when :http
 
           options = {
@@ -277,7 +284,8 @@ module KonoEppClient #:nodoc:
           }.merge(@transport_options)
 
           @connection = KonoEppClient::Transport::HttpTransport.new(server, port, **options)
-
+        else
+          raise "Not Implemented #{@transport}"
         end
       end
     end