kono_epp_client 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c73e951c49f6a622590103b3359eb73b94f7534
-  data.tar.gz: 987a223e10b4e7c57c325e66c559d64780502971
+  metadata.gz: 80640a05d680c3d25c1371495913b4816266e4c2
+  data.tar.gz: 1e2fa73d4c1e1d51ef7a487c275a9a8a08226acb
 SHA512:
-  metadata.gz: 31994158d73ee50067dc702f35f9fb3a2519023f3dcbf84dfd471ad9af84bc9d83277005ab98c2a5ff5601d847b31159e6cc4ad5feec6bf06727e3a3113d330e
-  data.tar.gz: de2d01f1a0a142d05059ebfcdda1855d7095ba2f5fa5cd349d94493a55e0c315315e01d024dbc47992c1c3f7909ae64564992885e93671a8d1f2afb40e4d2723
+  metadata.gz: 3bdcb5660089b22ec5ec0f026a35517d04c4c75006b863154db2a04cc0c8809348f0eda14496cd3ed105941c195666ee7a78b8b0eace40db8f44b22efeb1b418
+  data.tar.gz: 4f1eca44ce49bee99b1ededec75b3e30c058de3ffd1a5cf186e3579355767bbbb25b9f7d83930595b8a7e721bc7b271ca295c23c5642f1353d870fdd7a6fd90b

data/README.md

@@ -0,0 +1,2 @@
+# kono_epp_client
+A simple EPP Client

data/lib/epp/epp_command.rb

@@ -0,0 +1,15 @@
+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/epp_command/create_contact.rb

@@ -0,0 +1,87 @@
+class KonoEppCreateContact < KonoEppCommand
+  def initialize( options )
+    super( nil, nil )
+
+    command = root.elements['command']
+
+    create = command.add_element "create"
+
+    contact_create = create.add_element( "contact:create", { "xmlns:contact" => "urn:ietf:params:xml:ns:contact-1.0",
+                                                             "xsi:schemaLocation" => "urn:ietf:params:xml:ns:contact-1.0 contact-1.0.xsd" } )
+
+    puts options
+    id = contact_create.add_element "contact:id"
+    id.text = options[:id]
+
+    postal_info = contact_create.add_element "contact:postalInfo", { "type" => "loc" }
+
+    name = postal_info.add_element "contact:name"
+    name.text = options[:name]
+
+    unless options[:organization].blank?
+      organization = postal_info.add_element "contact:org"
+      organization.text = options[:organization]
+    end
+
+    addr = postal_info.add_element "contact:addr"
+
+    unless options[:street].blank?
+      street = addr.add_element "contact:street"
+      street.text = options[:street]
+    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_code]
+
+    if options[:voice]
+      voice = contact_create.add_element "contact:voice"
+      voice.text = options[:voice]
+    end
+
+    if options[:fax]
+      fax = contact_create.add_element "contact:fax"
+      fax.text = options[:fax]
+    end
+
+    email = contact_create.add_element "contact:email"
+    email.text = options[:email]
+
+    auth_info = contact_create.add_element "contact:authInfo"
+    pw = auth_info.add_element "contact:pw"
+    pw.text = options[:auth_info]
+
+    # FIXME
+    extension = command.add_element "extension"
+    extension_create = extension.add_element "extcon:create", { "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' }
+
+    publish = extension_create.add_element "extcon:consentForPublishing"
+    publish.text = options[:publish] == "1" ? "true" : "false"
+
+    if options[:is_registrant]
+      extcon_registrant = extension_create.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

data/lib/epp/epp_command/create_domain.rb

@@ -0,0 +1,42 @@
+class KonoEppCreateDomain < KonoEppCommand
+  def initialize( options )
+    super( nil, nil )
+
+    command = root.elements['command']
+    create = command.add_element( "create" )
+
+
+    domain_create = create.add_element( "domain:create", { "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_create.add_element "domain:name"
+    name.text = options[:name]
+
+    domain_ns = domain_create.add_element "domain:ns"
+
+    options[:nameservers].each do |ns|
+      host_attr = domain_ns.add_element "domain:hostAttr"
+      host_name = host_attr.add_element "domain:hostName"
+
+      host_name.text = ns[0]
+
+      # FIXME IPv6
+      host_addr = host_attr.add_element "domain:hostAddr", { "ip" => "v4" }
+      host_addr.text = ns[1]
+    end
+
+    domain_registrant = domain_create.add_element "domain:registrant"
+    domain_registrant.text = options[:registrant]
+
+    domain_contact = domain_create.add_element "domain:contact", { "type" => "admin" }
+    domain_contact.text = options[:admin]
+
+    domain_contact = domain_create.add_element "domain:contact", { "type" => "tech" }
+    domain_contact.text = options[:tech]
+
+    domain_authinfo = domain_create.add_element "domain:authInfo"
+
+    domain_pw = domain_authinfo.add_element "domain:pw"
+    domain_pw.text = options[:authinfo]
+  end
+end

data/lib/epp/epp_command/delete_contact.rb

@@ -0,0 +1,15 @@
+class KonoEppDeleteContact < KonoEppCommand
+  def initialize( id )
+    super( nil, nil )
+
+    command = root.elements['command']
+
+    delete = command.add_element "delete"
+
+    contact_delete = delete.add_element( "contact:delete", { "xmlns:contact" => "urn:ietf:params:xml:ns:contact-1.0",
+                                                             "xsi:schemaLocation" => "urn:ietf:params:xml:ns:contact-1.0 contact-1.0.xsd" } )
+
+    contact_id = contact_delete.add_element "contact:id"
+    contact_id.text = id
+ end
+end

data/lib/epp/epp_command/delete_domain.rb

@@ -0,0 +1,14 @@
+class KonoEppDeleteDomain < KonoEppCommand
+  def initialize( name )
+    super( nil, nil )
+
+    command = root.elements['command']
+    delete = command.add_element( "delete" )
+
+    domain_delete = delete.add_element( "domain:delete", { "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_delete.add_element "domain:name"
+    domain_name.text = name
+  end
+end

data/lib/epp/epp_command/hello.rb

@@ -0,0 +1,13 @@
+class KonoEppHello < REXML::Document
+  def initialize
+    super
+
+    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( "hello" )
+  end
+end

data/lib/epp/epp_command/info_contact.rb

@@ -0,0 +1,15 @@
+class KonoEppInfoContact < KonoEppCommand
+  def initialize( id )
+    super( nil, nil )
+
+    command = root.elements['command']
+
+    info = command.add_element "info"
+
+    contact_info = info.add_element( "contact:info", { "xmlns:contact" => "urn:ietf:params:xml:ns:contact-1.0",
+                                                       "xsi:schemaLocation" => "urn:ietf:params:xml:ns:contact-1.0 contact-1.0.xsd" } )
+
+    contact_id = contact_info.add_element "contact:id"
+    contact_id.text = id
+ end
+end

data/lib/epp/epp_command/info_domain.rb

@@ -0,0 +1,14 @@
+class KonoEppInfoDomain < KonoEppCommand
+  def initialize( name )
+    super( nil, nil )
+
+    command = root.elements['command']
+    info = command.add_element( "info" )
+
+    domain_info = info.add_element( "domain:info", { "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_info.add_element "domain:name", { "hosts" => "all" }
+    domain_name.text = name
+  end
+end

data/lib/epp/epp_command/login.rb

@@ -0,0 +1,79 @@
+class KonoEppLogin < KonoEppCommand
+  def initialize( id = nil, password = nil )
+    super( nil, nil )
+
+    @command = root.elements['command']
+    @login = @command.add_element( "login" )
+
+    @login.add_element( "clID" ).text = id if id
+    @login.add_element( "pw" ).text = password if password
+
+    @command.add_element( "clTRID" ).text = "ABC-12345"
+  end
+
+  def version=( value )
+    @options = @login.add_element( "options" ) unless @options
+    @options.add_element( "version") unless @options.elements['version']
+
+    @options.elements['version'].text = value
+  end
+
+  def version
+    version = @options.elements['version']
+
+    version.text if version
+  end
+
+  def lang=( value )
+    @options = @login.add_element( "options" ) unless @options
+    @options.add_element( "lang") unless @options.elements['lang']
+
+    @options.elements['lang'].text = value
+  end
+
+  def lang
+    lang = @options.elements['lang']
+
+    lang.text if version
+  end
+
+  def new_password=( value )
+    newpw = @login.add_element( "newPW" )
+    newpw.text = value
+  end
+
+  def services=( services )
+    svcs = @login.add_element( "svcs" ) unless @login.elements['svcs']
+    services.each {|service| svcs.add_element("objURI").text = service }
+  end
+
+  def services
+    svcs = @login.elements['svcs']
+
+    res = []
+    svcs.elements.each( "objURI" ) { |obj| res << obj.text } if svcs
+
+    return res
+  end
+
+  def extensions=( extensions )
+    svcs = @login.elements['svcs']
+
+    svcs = @login.add_element( "svcs" ) unless svcs
+
+    # Include schema extensions for registrars which require it
+    extensions_container = svcs.add_element("svcExtension") unless extensions.empty?
+
+    for uri in extensions
+      extensions_container.add_element("extURI").text = uri
+    end
+  end
+
+  def extensions
+    svc_extension = @login.elements['svcs/svcExtension']
+
+    svc_extension.elements.each( "extURI" ) { |obj| res << obj.text } if svcs_extension
+
+    return res
+  end
+end

data/lib/epp/epp_command/logout.rb

@@ -0,0 +1,10 @@
+class KonoEppLogout < KonoEppCommand
+  def initialize( id = nil, password = nil )
+    super( nil, nil )
+
+    command = root.elements['command']
+    command.add_element( "logout" )
+
+    command.add_element( "clTRID" ).text = "ABC-12345"
+  end
+end

data/lib/epp/epp_command/poll.rb

@@ -0,0 +1,16 @@
+class KonoEppPoll < KonoEppCommand
+  def initialize( op = :req )
+    super( nil, nil )
+
+    command = root.elements['command']
+    poll = command.add_element( "poll" )
+
+    poll.add_attribute( "op", op.to_s )
+  end
+
+  def ack_id=( id )
+    poll = root.elements['command/poll']
+
+    poll.add_attribute( "msgID", id )
+  end
+end

data/lib/epp/epp_command/transfer_domain.rb

@@ -0,0 +1,19 @@
+class KonoEppTransferDomain < KonoEppCommand
+  def initialize( name, authinfo, op )
+    super( nil, nil )
+
+    command = root.elements['command']
+    transfer = command.add_element( "transfer", { "op" => op } )
+
+    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
+  end
+end

data/lib/epp/epp_command/update_contact.rb

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,88 @@
+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]
+      domain_add = domain_update.add_element "domain:add"
+    end
+
+    if not options[:remove_nameservers].blank? or options[:remove_admin] or options[:remove_tech]
+      domain_remove = domain_update.add_element "domain:rem"
+    end
+
+    # <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
+        host_addr = host_attr.add_element "domain:hostAddr", { "ip" => "v4" }
+        host_addr.text = ns[1]
+      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_tech]
+      domain_contact = domain_add.add_element "domain:contact", { "type" => "tech" }
+      domain_contact.text = options[:add_tech]
+    end
+
+    # <domain:rem>
+    unless options[:remove_nameservers].blank?
+      domain_remove_ns = domain_remove.add_element "domain:ns"
+
+      options[:remove_nameservers].each do |name|
+        host_attr = domain_remove_ns.add_element "domain:hostAttr"
+        host_name = host_attr.add_element "domain:hostName"
+
+        host_name.text = 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_tech]
+      domain_contact = domain_remove.add_element "domain:contact", { "type" => "tech" }
+      domain_contact.text = options[:remove_tech]
+    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
+
+    # TODO: Registrant
+  end
+end

data/lib/epp/exceptions.rb

@@ -0,0 +1,18 @@
+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

data/lib/epp/server.rb

@@ -0,0 +1,271 @@
+module KonoEppClient #:nodoc:
+  class Server
+    include REXML
+    include RequiresParameters
+
+    require 'nokogiri'
+
+    attr_accessor :tag, :password, :server, :port, :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".
+    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
+
+      @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
+      response = Hpricot.XML( 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 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 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 )
+      transfer = KonoEppTransferDomain.new name, authinfo, op
+      send_command( transfer )
+    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 )
+        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
+      Timeout.timeout @timeout do
+        @connection = case @transport
+          when :tcp then KonoEppClient::Transport::TcpTransport.new( server, port )
+          when :http then KonoEppClient::Transport::HttpTransport.new( server, port )
+        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.rb

@@ -0,0 +1,13 @@
+module KonoEppClient::Transport
+  def read
+    raise NotImplemented.new
+  end
+
+  def write
+    raise NotImplemented.new
+  end
+
+  def close
+    raise NotImplemented.new
+  end
+end

data/lib/epp/transport/http.rb

@@ -0,0 +1,66 @@
+require 'net/http'
+
+module KonoEppClient::Transport
+  class HttpTransport
+    include KonoEppClient::Transport
+
+    require 'pstore'
+
+    def initialize( server, port )
+      @net_http = Net::HTTP.new( server, port )
+
+      @net_http.use_ssl = true
+      @net_http.ssl_version = :TLSv1
+      @net_http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      
+      #FIXME: Commented because not work on MacOS (dev machine), is necessary for Linux machine?
+      #@net_http.ca_path = '/etc/ssl/certs' 
+      
+      # @net_http.set_debug_output $stderr
+       #@net_http.set_debug_output File.open( "/tmp/net.log", "a")
+
+      @store = PStore.new( "cookies.pstore" )
+    end
+
+    def read
+      #puts @response.body
+      @response.body
+    end
+
+    def write( xml )
+      @store.transaction do
+        cookie_str = '$Version="1"'
+        @store[:cookies].each do |c|
+          cookie_str += "; #{c[:name]}=#{c[:value]}"
+        end if @store[:cookies]
+
+        header = { "Cookie" => cookie_str }
+
+        @response = @net_http.post( "/", xml, header )
+
+        @store[:cookies] = parse_set_cookie( @response["Set-Cookie"] ) if @response["Set-Cookie"]
+      end
+    end
+
+    def close
+    end
+
+  private
+    def parse_set_cookie( string )
+      cookies = []
+
+      string.split( "," ).each do |cookie|
+        tokens = cookie.split ";"
+
+        name, value = tokens[0].split( "=", 2 )
+        # TODO: complete parsing. Maybe encapsulate the cookie as well.
+        cookies << { :name => name, :value => value }
+      end
+
+      return cookies
+    end
+
+    def http_post
+    end
+  end
+end

data/lib/epp/transport/tcp.rb

@@ -0,0 +1,93 @@
+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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kono_epp_client
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Fabio Bonelli
@@ -17,7 +17,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
+- lib/epp/epp_command.rb
+- lib/epp/epp_command/create_contact.rb
+- lib/epp/epp_command/create_domain.rb
+- lib/epp/epp_command/delete_contact.rb
+- lib/epp/epp_command/delete_domain.rb
+- lib/epp/epp_command/hello.rb
+- lib/epp/epp_command/info_contact.rb
+- lib/epp/epp_command/info_domain.rb
+- lib/epp/epp_command/login.rb
+- lib/epp/epp_command/logout.rb
+- lib/epp/epp_command/poll.rb
+- lib/epp/epp_command/transfer_domain.rb
+- lib/epp/epp_command/update_contact.rb
+- lib/epp/epp_command/update_domain.rb
+- lib/epp/exceptions.rb
+- lib/epp/server.rb
+- lib/epp/transport.rb
+- lib/epp/transport/http.rb
+- lib/epp/transport/tcp.rb
 - lib/kono_epp_client.rb
+- lib/require_parameters.rb
 homepage: https://github.com/ArchimediaZerogroup/kono_epp_client
 licenses:
 - MIT