Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
Net::EPP::Client(3)   User Contributed Perl Documentation  Net::EPP::Client(3)

       Net::EPP::Client	- a client library for the TCP transport for EPP, the
       Extensible Provisioning Protocol

	       use Net::EPP::Client;
	       use strict;

	       my $epp = Net::EPP::Client->new(
		       host    => 'epp.nic.tld',
		       port    => 700,
		       ssl     => 1,
		       frames  => 1,

	       my $greeting = $epp->connect;


	       my $answer = $epp->get_frame;

	       $epp->send_frame('<epp><logout /></epp>');

	       my $answer = $epp->get_frame;

       EPP is the Extensible Provisioning Protocol. EPP	(defined in RFC	4930)
       is an application layer client-server protocol for the provisioning and
       management of objects stored in a shared	central	repository. Specified
       in XML, the protocol defines generic object management operations and
       an extensible framework that maps protocol operations to	objects. As of
       writing,	its only well-developed	application is the provisioning	of
       Internet	domain names, hosts, and related contact details.

       RFC 4934	defines	a TCP based transport model for	EPP, and this module
       implements a client for that model. You can establish and manage	EPP
       connections and send and	receive	responses over this connection.

       "Net::EPP::Client" also provides	some time-saving features, such	as
       being able to provide request and response frames as "Net::EPP::Frame"

	       my $epp = Net::EPP::Client->new(PARAMS);

       The constructor method creates a	new EPP	client object. It accepts a
       number of parameters:

       o   host

	   "host" specifies the	computer to connect to.	This may be a DNS
	   hostname or an IP address.

       o   port

	   "port" specifies the	TCP port to connect to.	This is	usually	700.

       o   ssl

	   If the "ssl"	parameter is defined, then "IO::Socket::SSL" will be
	   used	to provide an encrypted	connection. If not, then a plaintext
	   connection will be created.

       o   dom (deprecated)

	   If the "dom"	parameter is defined, then all response	frames will be
	   returned as "XML::LibXML::Document" objects.

       o   frames

	   If the "frames" parameter is	defined, then all response frames will
	   be returned as "Net::EPP::Frame" objects (actually,
	   "XML::LibXML::Document" objects reblessed as	"Net::EPP::Frame"

   Connecting to a server:
	       my $greeting = $epp->connect(%PARAMS);

       This method establishes the TCP connection. You can use the %PARAMS
       hash to specify arguments that will be passed on	to the constructors
       for "IO::Socket::INET" (such as a timeout) or "IO::Socket::SSL" (such
       as certificate information). See	the relevant manpage for examples.

       This method will	"croak()" if connection	fails, so be sure to use
       "eval()"	if you want to catch the error.

       By default, the return value for	"connect()" will be the	EPP <greeting>
       frame returned by the server. Please note that the same caveat about
       blocking	applies	to this	method as to "get_frame()" (see	below).

       If you want to get the greeting yourself, set $params{no_greeting}.

   Communicating with the server:
	       my $answer = $epp->request($question);

       This is a simple	wrapper	around "get_frame()" and "send_frame()"	(see
       below).	This method accepts a "question" frame as an argument, sends
       it to the server, and then returns the next frame the server sends

   Getting a frame from	the server:
	       my $frame = $epp->get_frame;

       This method returns an EPP response frame from the server. This may
       either be a scalar filled with XML, an "XML::LibXML::Document" object
       (or an "XML::DOM::Document" object), depending on whether you defined
       the "dom" parameter to the constructor.

       Important Note: this method will	block your program until it receives
       the full	frame from the server. That could be a bad thing for your
       program,	so you might want to consider using the	"alarm()" function to
       apply a timeout,	like so:

	       my $timeout = 10; # ten seconds

	       eval {
		       local $SIG{ALRM}	= sub {	die "alarm\n" };
		       my $frame = $epp->get_frame;

	       if ($@ ne '') {
		       print "timed out\n";

       If the connection to the	server closes before the response can be
       received, or the	server returned	a mal-formed frame, this method	will

   Sending a frame to the server:
	       $epp->send_frame($frame,	$wfcheck);

       This sends a request frame to the server. $frame	may be one of:

       o   a scalar containing XML

       o   a scalar containing a filename

       o   an "XML::LibXML::Document" object (or an instance of	a subclass)

       o   an "XML::DOM::Document" object (or an instance of a subclass)

       Unless $wfcheck is false, the first two of these	will be	checked	for
       well-formedness.	If the XML data	is broken, then	this method will

   Disconnecting from the server:

       This closes the connection. An EPP server should	always close a
       connection after	a <logout> frame has been received and acknowledged;
       this method is provided to allow	you to clean up	on the client side, or
       close the connection out	of sync	with the server.

       CentralNic Ltd (<>).

       This module is (c) 2016 CentralNic Ltd. This module is free software;
       you can redistribute it and/or modify it	under the same terms as	Perl

       o   Net::EPP::Frame

       o   Net::EPP::Proxy

       o   RFCs	4930 and RFC 4934, available from <>.

       o   The CentralNic EPP site at

perl v5.32.1			  2016-04-06		   Net::EPP::Client(3)


Want to link to this manual page? Use this URL:

home | help