Example #1
0
 protected static String getClientTrid(String epp_client_id) {
   return "ABC:" + epp_client_id + ":" + System.currentTimeMillis();
 }
Example #2
0
  /**
   * Main of the example. Performs Domain check, info, create, update, renew, transfer and delete.
   */
  public static void main(String args[]) {

    System.out.println("Start of the Domain example");

    epp_Command command_data = null;
    epp_AuthInfo domain_auth_info = null;
    Date domain_exp_date = null;

    try {
      if (args.length < 5) {
        System.err.println(USAGE);
        System.exit(1);
      }

      // calling setDebugLevel() with no params makes the RTK
      // read the "rtk.debuglevel" property from rtk.properties file
      RTKBase.setDebugLevel();

      String epp_host_name = args[0];
      String epp_host_port_string = args[1];
      String epp_client_id = args[2];
      String epp_password = args[3];
      String epp_domain_name = args[4];

      int epp_host_port = Integer.parseInt(epp_host_port_string);

      EPPClient epp_client =
          new EPPClient(epp_host_name, epp_host_port, epp_client_id, epp_password);

      epp_client.setLang("en");

      // The protocol used is set by the rtk.transport property
      // in etc/rtk.properties

      System.out.println("Connecting to the EPP Server and getting the greeting");
      epp_Greeting greeting = epp_client.connectAndGetGreeting();

      System.out.println("greeting's server: [" + greeting.m_server_id + "]");
      System.out.println("greeting's server-date: [" + greeting.m_server_date + "]");
      if (greeting.m_versions != null && greeting.m_versions.length > 0) {
        System.out.println("greeting's version: [" + greeting.m_versions[0] + "]");
      }
      if (greeting.m_langs != null && greeting.m_langs.length > 0) {
        System.out.println("greeting's lang: [" + greeting.m_langs[0] + "]");
      }

      if (greeting.m_services != null && greeting.m_services.length > 0) {
        System.out.println("services provided by epp: ");
        for (int i = 0; i < greeting.m_services.length; i++) {
          System.out.println((epp_Service) greeting.m_services[i]);
        }
      }

      if (greeting.m_unspec_services != null && greeting.m_unspec_services.length > 0) {
        System.out.println("\nunspecified services provided by epp: ");
        for (int i = 0; i < greeting.m_unspec_services.length; i++) {
          System.out.println((epp_Service) greeting.m_unspec_services[i]);
        }
      }
      System.out.println();

      String client_trid = getClientTrid(epp_client_id);

      System.out.println("Logging into the EPP Server");

      // If epp_client.setEPPServices() or epp_client.setEPPUnspecServices()
      // have been called, epp_client.login() uses services values set by user,
      // otherwise, epp_client.login() fills in default service values for you
      // which are contact, domain and host (pretty standard stuff).
      epp_client.login(client_trid);

      try {
        // ***************************
        // Poll (for waiting messages)
        // ***************************
        System.out.println("Creating the Poll command");
        epp_PollReq poll_request = new epp_PollReq();
        command_data = new epp_Command();
        command_data.m_client_trid = getClientTrid(epp_client_id);

        poll_request.m_cmd = command_data;
        // Set the Poll "op" to REQ (i.e. request).  This will
        // query the message queue for the first message available.
        // Note that the REQ op does not dequeue the message.
        // The ACK op is required to acknowledge messages and
        // remove them from the waiting queue.
        //
        // Note that the Poll op type of REQ is the default, so
        // it could have been left null here.
        poll_request.m_op = epp_PollOpType.REQ;

        EPPPoll poll = new EPPPoll();
        poll.setRequestData(poll_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        poll = (EPPPoll) epp_client.processAction(poll);
        // or, alternatively, this method can be used...
        // poll.fromXML(epp_client.processXML(poll.toXML()));

        epp_PollRsp poll_response = poll.getResponseData();
        epp_Response response = poll_response.m_rsp;
        epp_Result[] results = response.m_results;
        System.out.println("Poll results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        System.err.println(
            "\tcode: ["
                + results[0].m_code
                + "] lang: ["
                + results[0].m_lang
                + "] msg: ["
                + results[0].m_msg
                + "]");
        if (results[0].m_values != null && results[0].m_values.length > 0) {
          System.err.println("\tvalue: [" + results[0].m_values[0] + "]");
        }
        // This single line will show you all data contained inside
        // this first result array element.
        // System.err.println("\tresult: ["+results[0]+"]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "EPP Poll failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Check
        // ***************************
        System.out.println("Creating the Domain Check command");
        epp_DomainCheckReq domain_check_request = new epp_DomainCheckReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_check_request.m_cmd = command_data;

        // The Domain Check request can accept an array of domain
        // names.  In this example, an ArrayList is used to dynamically
        // create the List of domain names and then EPPXMLBase's
        // utility method convertListToStringArray() is used
        // to convert the List to a String array.
        List domain_list = (List) new ArrayList();
        domain_list.add(epp_client_id + "1.info");
        domain_list.add(epp_client_id + "2.info");
        domain_list.add(epp_domain_name);
        domain_check_request.m_names = EPPXMLBase.convertListToStringArray(domain_list);

        EPPDomainCheck domain_check = new EPPDomainCheck();
        domain_check.setRequestData(domain_check_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_check = (EPPDomainCheck) epp_client.processAction(domain_check);
        // or, alternatively, this method can be used...
        // domain_check.fromXML(epp_client.processXML(domain_check.toXML()));

        epp_DomainCheckRsp domain_check_response = domain_check.getResponseData();
        epp_Response response = domain_check_response.m_rsp;
        epp_Result[] results = response.m_results;
        System.out.println(
            "DomainCheck results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
        // All EPP Check requests, regardless of the object being checked,
        // will return a generic epp_CheckResult array.  To find the
        // check results for a particular object, EPPXMLBase's utility
        // method getCheckResultFor() can be used.  This method returns
        // a Boolean object or null if the value was not found in the
        // epp_CheckResult array.
        epp_CheckResult[] check_results = domain_check_response.m_results;
        System.out.println(
            "DomainCheck results: domain ["
                + epp_client_id
                + "1.info] exists? ["
                + EPPXMLBase.getCheckResultFor(check_results, epp_client_id + "1.info")
                + "]");
        System.out.println(
            "DomainCheck results: domain ["
                + epp_client_id
                + "2.info] exists? ["
                + EPPXMLBase.getCheckResultFor(check_results, epp_client_id + "2.info")
                + "]");
        System.out.println(
            "DomainCheck results: domain ["
                + epp_domain_name
                + "] exists? ["
                + EPPXMLBase.getCheckResultFor(check_results, epp_domain_name)
                + "]");
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        System.err.println(
            "\tcode: ["
                + results[0].m_code
                + "] lang: ["
                + results[0].m_lang
                + "] msg: ["
                + results[0].m_msg
                + "]");
        if (results[0].m_values != null && results[0].m_values.length > 0) {
          System.err.println("\tvalue: [" + results[0].m_values[0] + "]");
        }
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Check failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      // Need to create a contact to be used by domain create
      // because some registries have minimum requirements for
      // contacts associated with domains (i.e. usually, one of
      // each type, plus the registrant)

      // declaring the contact create request outside the try block
      // because the contact id it contains is required elsewhere.
      System.out.println("Creating the Contact Create command");
      epp_ContactCreateReq contact_create_request = new epp_ContactCreateReq();

      try {
        // ***************************
        // Contact Create
        // ***************************

        // Please see the ContactExample.java source file for more information
        // on the Contact Create operation.  It is included here only because
        // a contact must exist before creating a domain.

        command_data = new epp_Command();
        command_data.m_client_trid = getClientTrid(epp_client_id);
        contact_create_request.m_cmd = command_data;

        // This example uses the client trid to generate a unique contact id
        // so the create doesn't fail throw the whole example out the window
        // (we're dividing the current time by 1000 because without it
        // the contact id is too long)
        contact_create_request.m_id = epp_client_id + (System.currentTimeMillis() / 1000);

        epp_ContactNameAddress name_address = new epp_ContactNameAddress();
        name_address.m_name = "John Doe";
        name_address.m_address = new epp_ContactAddress();
        name_address.m_address.m_street1 = "100 Centre St";
        name_address.m_address.m_city = "Townsville";
        name_address.m_address.m_state_province = "County Derry";
        name_address.m_address.m_postal_code = "Z1Z1Z1";
        // The country code must be a valid ISO country code.
        // Note that UK is not a valid ISO country code, use GB instead.
        name_address.m_address.m_country_code = "CA";

        contact_create_request.m_ascii_address = name_address;

        contact_create_request.m_email = "*****@*****.**";

        // Contact Auth Info must be set, just give a fixed value now
        epp_AuthInfo contact_auth_info = new epp_AuthInfo();
        contact_auth_info.m_value = "changeme";
        contact_auth_info.m_type = epp_AuthInfoType.PW;
        contact_create_request.m_auth_info = contact_auth_info;

        EPPContactCreate contact_create = new EPPContactCreate();
        contact_create.setRequestData(contact_create_request);

        contact_create = (EPPContactCreate) epp_client.processAction(contact_create);

        epp_ContactCreateRsp contact_create_response = contact_create.getResponseData();
        epp_Response response = contact_create_response.m_rsp;

        epp_Result[] results = response.m_results;
        System.out.println(
            "ContactCreate results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
        System.out.println(
            "ContactCreate results: contact id [" + contact_create_response.m_id + "]");
      } catch (epp_XMLException xcp) {
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Contact Create failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Create
        // ***************************
        System.out.println("Creating the Domain Create command");
        epp_DomainCreateReq domain_create_request = new epp_DomainCreateReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_create_request.m_cmd = command_data;

        domain_create_request.m_name = epp_domain_name;
        // The domain's period is optional.  It is specified with
        // an object that contains the unit of measurement (years or
        // months) and the actual period value.
        domain_create_request.m_period = new epp_DomainPeriod();
        domain_create_request.m_period.m_unit = epp_DomainPeriodUnitType.YEAR;
        domain_create_request.m_period.m_value = (short) 2;

        // At domain creation, if the registry requires nameservers,
        // you must specify another domain's nameserver's in the request.
        // You can't use nameserver in the same namespace as the domain,
        // but those host objects don't exist yet.
        List name_server_list = (List) new ArrayList();

        // quick little note -- it just happens that these
        // nameservers exist in many OT&E domain registries
        // out there, so they were chosen to make sure the
        // create succeeds.  Feel free to use other values
        // in this example.
        name_server_list.add("ns1.domaindirect.com");
        name_server_list.add("ns2.domaindirect.com");
        domain_create_request.m_name_servers =
            EPPXMLBase.convertListToStringArray(name_server_list);

        BufferedReader buffed_reader = new BufferedReader(new InputStreamReader(System.in));
        domain_auth_info = new epp_AuthInfo();
        System.out.print(
            "Dear registrant, please enter a passphrase for your new domain(min 6, max 16): ");
        while (domain_auth_info.m_value == null || domain_auth_info.m_value.length() == 0) {
          domain_auth_info.m_value = buffed_reader.readLine();
        }
        // For the current spec of EPP, PW is the only allowed type
        // of auth info.  So, the type can be left null and the RTK will
        // fill in the value for you.
        domain_auth_info.m_type = epp_AuthInfoType.PW;
        domain_create_request.m_auth_info = domain_auth_info;

        // Some registries require a minimum number of contacts for a domain
        Vector contacts = new Vector();
        contacts.add(new epp_DomainContact(epp_DomainContactType.TECH, "ABC-contact"));
        contacts.add(new epp_DomainContact(epp_DomainContactType.ADMIN, "ABC-contact"));
        contacts.add(new epp_DomainContact(epp_DomainContactType.BILLING, "ABC-contact"));
        domain_create_request.m_contacts =
            (epp_DomainContact[]) contacts.toArray(new epp_DomainContact[1]);

        domain_create_request.m_registrant = contact_create_request.m_id;

        EPPDomainCreate domain_create = new EPPDomainCreate();
        domain_create.setRequestData(domain_create_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_create = (EPPDomainCreate) epp_client.processAction(domain_create);
        // or, alternatively, this method can be used...
        // domain_create.fromXML(epp_client.processXML(domain_create.toXML()));

        epp_DomainCreateRsp domain_create_response = domain_create.getResponseData();
        epp_Response response = domain_create_response.m_rsp;

        epp_Result[] results = response.m_results;
        System.out.println(
            "DomainCreate results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
        // The domain's name and expiration date are returned on a
        // successful domain creation.
        System.out.println(
            "DomainCreate results: domain name ["
                + domain_create_response.m_name
                + "] exp date ["
                + domain_create_response.m_expiration_date
                + "]");
        // Save the expiration date for the renew command later
        domain_exp_date = RTKBase.UTC_FMT.parse(domain_create_response.m_expiration_date);
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Create failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Info
        // ***************************
        System.out.println("Creating the Domain Info command");
        epp_DomainInfoReq domain_info_request = new epp_DomainInfoReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_info_request.m_cmd = command_data;

        // The only domain-specific parameter is the domain name itself.
        domain_info_request.m_name = epp_domain_name;

        EPPDomainInfo domain_info = new EPPDomainInfo();
        domain_info.setRequestData(domain_info_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_info = (EPPDomainInfo) epp_client.processAction(domain_info);
        // or, alternatively, this method can be used...
        // domain_info.fromXML(epp_client.processXML(domain_info.toXML()));

        epp_DomainInfoRsp domain_info_response = domain_info.getResponseData();
        epp_Response response = domain_info_response.m_rsp;
        epp_Result[] results = response.m_results;

        // You can also save the authorization information from an info where
        // the calling registrar is the sponsoring client for the
        // object.
        domain_auth_info = domain_info_response.m_auth_info;

        System.out.println(
            "DomainInfo results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
        // The Info command returns some standard information like
        // the current sponsoring client id, the creator client id,
        // the create time and the last update time.
        // For a Domain Info, the domain's nameservers, hosts, status
        // last transfer client id, last transfer date,
        // expiration date and domain ROID are returned.
        System.out.println(
            "DomainInfo results: clID ["
                + domain_info_response.m_client_id
                + "] crID ["
                + domain_info_response.m_created_by
                + "]");
        System.out.println(
            "DomainInfo results: crDate ["
                + domain_info_response.m_created_date
                + "] upDate ["
                + domain_info_response.m_updated_date
                + "]");
        System.out.println(
            "DomainInfo results: exDate [" + domain_info_response.m_expiration_date + "]");
        // Save the expiration date for the renew command later
        domain_exp_date = RTKBase.UTC_FMT.parse(domain_info_response.m_expiration_date);
        if (domain_auth_info != null) {
          System.out.println("Domain's authID [" + domain_auth_info.m_value + "]");
        }
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Info failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Update
        // ***************************
        System.out.println("Creating the Domain Update command");
        epp_DomainUpdateReq domain_update_request = new epp_DomainUpdateReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_update_request.m_cmd = command_data;

        domain_update_request.m_name = epp_domain_name;

        epp_DomainUpdateAddRemove add = new epp_DomainUpdateAddRemove();
        // Here is a list of nameservers to add to the domain.
        // An array is expected here, but to avoid using Java native
        // arrays, we're using an ArrayList and then converting it to a
        // String array.
        List name_server_list = (List) new ArrayList();
        name_server_list.add("ns1.domain.info");
        name_server_list.add("ns2.domain.info");
        add.m_name_servers = EPPXMLBase.convertListToStringArray(name_server_list);
        // We also want to add the clientTransferProhibited status to the domain.
        // This time we'll create an array of epp_DomainStatus
        // directly.  EPP allows for registrar notes in the
        // status field.  EPP even allows for a language specifier.
        add.m_status = new epp_DomainStatus[1];
        add.m_status[0] = new epp_DomainStatus();
        add.m_status[0].m_type = epp_DomainStatusType.CLIENT_TRANSFER_PROHIBITED;
        add.m_status[0].m_lang = "fr";
        add.m_status[0].m_value = "Le client n'as pas envoyé de l'argent";

        // Set the add information
        domain_update_request.m_add = add;

        epp_DomainUpdateAddRemove remove = new epp_DomainUpdateAddRemove();
        // Now to remove the two old nameservers.
        name_server_list = (List) new ArrayList();
        name_server_list.add("ns1.domaindirect.com");
        name_server_list.add("ns2.domaindirect.com");
        remove.m_name_servers = EPPXMLBase.convertListToStringArray(name_server_list);

        // Set the remove information
        domain_update_request.m_remove = remove;

        // We're also specifying the information to change.
        // Only the auth info and the registrant information can be changed.
        domain_update_request.m_change = new epp_DomainUpdateChange();

        // We would need to have created another contact to really
        // change it, so we won't do this one for now.
        // domain_update_request.m_change.m_registrant = "registrar100";

        BufferedReader buffed_reader = new BufferedReader(new InputStreamReader(System.in));
        epp_AuthInfo domain_auth_info_new = new epp_AuthInfo();
        System.out.println(
            "---Now, give you an opportunity to change the passphrase for your domain---");
        System.out.print(
            "Input the new passphrase or just press \'Enter\' to ignore (min 6, max 16): ");
        domain_auth_info_new.m_value = buffed_reader.readLine();
        if (domain_auth_info_new.m_value != null) {
          domain_update_request.m_change.m_auth_info = domain_auth_info_new;
          domain_auth_info = domain_auth_info_new;
        }

        EPPDomainUpdate domain_update = new EPPDomainUpdate();
        domain_update.setRequestData(domain_update_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_update = (EPPDomainUpdate) epp_client.processAction(domain_update);
        // or, alternatively, this method can be used...
        // domain_update.fromXML(epp_client.processXML(domain_update.toXML()));

        epp_DomainUpdateRsp domain_update_response = domain_update.getResponseData();
        epp_Response response = domain_update_response.m_rsp;
        epp_Result[] results = response.m_results;
        System.out.println(
            "DomainUpdate results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Update failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Renew
        // ***************************
        System.out.println("Creating the Domain Renew command");
        epp_DomainRenewReq domain_renew_request = new epp_DomainRenewReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_renew_request.m_cmd = command_data;

        domain_renew_request.m_name = epp_domain_name;
        // As in the domain create operation, the domain period
        // may be specified here also.
        domain_renew_request.m_period = new epp_DomainPeriod();
        domain_renew_request.m_period.m_unit = epp_DomainPeriodUnitType.YEAR;
        domain_renew_request.m_period.m_value = (short) 2;
        // The domain's current expiration must also be specified
        // to unintentional multiple renew request from succeeding.
        // The format of the expiration date must be "YYYY-MM-DD"
        domain_renew_request.m_current_expiration_date = RTKBase.DATE_FMT.format(domain_exp_date);

        EPPDomainRenew domain_renew = new EPPDomainRenew();
        domain_renew.setRequestData(domain_renew_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_renew = (EPPDomainRenew) epp_client.processAction(domain_renew);
        // or, alternatively, this method can be used...
        // domain_renew.fromXML(epp_client.processXML(domain_renew.toXML()));

        epp_DomainRenewRsp domain_renew_response = domain_renew.getResponseData();
        epp_Response response = domain_renew_response.m_rsp;
        epp_Result[] results = response.m_results;
        System.out.println(
            "DomainRenew results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
        // The domain renew action returns the domain's new expiration
        // date if the request was successful
        System.out.println(
            "DomainRenew results: new exDate [" + domain_renew_response.m_expiration_date + "]");
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Renew failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Transfer (Query)
        // ***************************
        System.out.println("Creating the Domain Transfer command");
        epp_DomainTransferReq domain_transfer_request = new epp_DomainTransferReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_transfer_request.m_cmd = command_data;

        // The Domain Transfer request is an EPP "transfer" request,
        // meaning it requires an "op" value and the object's
        // current auth info for successful processing.
        epp_TransferRequest transfer_request = new epp_TransferRequest();
        // A transfer query will only query the status of the current
        // pending transfer or the last completed/cancelled/rejected
        // transfer.  To request a transfer, the "op" should be set to
        // REQUEST.
        //
        // QUERY is the default transfer op type, so it
        // could have been left null here.
        transfer_request.m_op = epp_TransferOpType.QUERY;
        // domain_auth_info is REQUIRED only when transfer op type
        // is REQUEST, so the line below is unnecessary, it will
        // be ignored by the server
        transfer_request.m_auth_info = domain_auth_info;
        domain_transfer_request.m_trans = transfer_request;

        domain_transfer_request.m_name = epp_domain_name;

        // On a transfer request, EPP allows for a domain renewal
        // to be bundled into a domain transfer.
        // If the period is not specified, 1 year is the default.
        //
        // So if this was a transfer request, we could do this.
        /*
        domain_transfer_request.m_period = new epp_DomainPeriod();
        domain_transfer_request.m_period.m_unit = epp_DomainPeriodUnitType.YEAR;
        domain_transfer_request.m_period.m_value = (short) 2;
        */

        EPPDomainTransfer domain_transfer = new EPPDomainTransfer();
        domain_transfer.setRequestData(domain_transfer_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_transfer = (EPPDomainTransfer) epp_client.processAction(domain_transfer);
        // or, alternatively, this method can be used...
        // domain_transfer.fromXML(epp_client.processXML(domain_transfer.toXML()));

        epp_DomainTransferRsp domain_transfer_response = domain_transfer.getResponseData();
        epp_Response response = domain_transfer_response.m_rsp;
        epp_Result[] results = response.m_results;
        System.out.println(
            "DomainTransfer results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");

        System.out.println(
            "DomainTransfer Results: transfer status ["
                + domain_transfer_response.m_trn_data.m_transfer_status
                + "]");
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Transfer (Query) failed! ["
                + xcp.getClass().getName()
                + "] ["
                + xcp.getMessage()
                + "]");
        xcp.printStackTrace();
      }

      try {
        // ***************************
        // Domain Delete
        // ***************************
        System.out.println("Creating the Domain Delete command");
        epp_DomainDeleteReq domain_delete_request = new epp_DomainDeleteReq();

        command_data = new epp_Command();
        // The client trid is optional by EPP.  it's main use
        // is for registrar tracking and logging of requests,
        // especially for data creation or modification requests.
        // Some registries make it mandatory and unique per session.
        command_data.m_client_trid = getClientTrid(epp_client_id);
        domain_delete_request.m_cmd = command_data;

        domain_delete_request.m_name = epp_domain_name;

        EPPDomainDelete domain_delete = new EPPDomainDelete();
        domain_delete.setRequestData(domain_delete_request);

        // Now ask the EPPClient to process the request and retrieve
        // a response from the server.
        domain_delete = (EPPDomainDelete) epp_client.processAction(domain_delete);
        // or, alternatively, this method can be used...
        // domain_delete.fromXML(epp_client.processXML(domain_delete.toXML()));

        epp_DomainDeleteRsp domain_delete_response = domain_delete.getResponseData();
        epp_Response response = domain_delete_response.m_rsp;
        epp_Result[] results = response.m_results;
        System.out.println(
            "DomainDelete results: [" + results[0].m_code + "] [" + results[0].m_msg + "]");
      } catch (epp_XMLException xcp) {
        // Either the request was missing some required data in
        // validation before sending to the server, or the server's
        // response was either unparsable or missing some required data.
        System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
      } catch (epp_Exception xcp) {
        // The EPP Server has responded with an error code with
        // some optional messages to describe the error.
        System.err.println("epp_Exception!");
        epp_Result[] results = xcp.m_details;
        // We're taking advantage epp_Result's toString() here
        // for debugging.  Take a look at the javadocs for
        // the full list of attributes in the class.
        System.err.println("\tresult: [" + results[0] + "]");
      } catch (Exception xcp) {
        // Other unexpected exceptions
        System.err.println(
            "Domain Delete failed! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
        xcp.printStackTrace();
      }

      // All done with this session, so let's log out...
      System.out.println("Logging out from the EPP Server");
      epp_client.logout(getClientTrid(epp_client_id));

      // ... and disconnect
      System.out.println("Disconnecting from the EPP Server");
      epp_client.disconnect();

    } catch (epp_XMLException xcp) {
      System.err.println("epp_XMLException! [" + xcp.m_error_message + "]");
    } catch (epp_Exception xcp) {
      System.err.println("epp_Exception!");
      epp_Result[] results = xcp.m_details;
      System.err.println("\tresult: [" + results[0] + "]");
    } catch (Exception xcp) {
      System.err.println(
          "Exception! [" + xcp.getClass().getName() + "] [" + xcp.getMessage() + "]");
      xcp.printStackTrace();
    }
  }