ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent-MP/MP/Transport.pm
(Generate patch)

Comparing AnyEvent-MP/MP/Transport.pm (file contents):
Revision 1.8 by root, Mon Aug 3 14:58:13 2009 UTC vs.
Revision 1.24 by root, Wed Aug 5 23:50:46 2009 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent::MP::Transport - actual transport protocol 3AnyEvent::MP::Transport - actual transport protocol handler
4 4
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use AnyEvent::MP::Transport; 7 use AnyEvent::MP::Transport;
8 8
9=head1 DESCRIPTION 9=head1 DESCRIPTION
10 10
11This is the superclass for MP transports, most of which is considered an 11This implements the actual transport protocol for MP (it represents a
12implementation detail. 12single link), most of which is considered an implementation detail.
13 13
14See the "PROTOCOL" section below if you want to write another client for 14See the "PROTOCOL" section below if you want to write another client for
15this protocol. 15this protocol.
16 16
17=head1 FUNCTIONS/METHODS 17=head1 FUNCTIONS/METHODS
… …
27use Scalar::Util; 27use Scalar::Util;
28use MIME::Base64 (); 28use MIME::Base64 ();
29use Storable (); 29use Storable ();
30use JSON::XS (); 30use JSON::XS ();
31 31
32use Digest::MD6 ();
33use Digest::HMAC_MD6 ();
34
32use AE (); 35use AE ();
33use AnyEvent::Socket (); 36use AnyEvent::Socket ();
34use AnyEvent::Handle (); 37use AnyEvent::Handle ();
35 38
36use base Exporter::; 39use base Exporter::;
… …
43Creates a listener on the given host/port using 46Creates a listener on the given host/port using
44C<AnyEvent::Socket::tcp_server>. 47C<AnyEvent::Socket::tcp_server>.
45 48
46See C<new>, below, for constructor arguments. 49See C<new>, below, for constructor arguments.
47 50
48Defaults for peerhost, peerport, fh and tls are provided. 51Defaults for peerhost, peerport and fh are provided.
49 52
50=cut 53=cut
51 54
52sub mp_server($$@) { 55sub mp_server($$@) {
53 my $cb = pop; 56 my $cb = pop;
… …
58 61
59 $cb->(new AnyEvent::MP::Transport 62 $cb->(new AnyEvent::MP::Transport
60 fh => $fh, 63 fh => $fh,
61 peerhost => $host, 64 peerhost => $host,
62 peerport => $port, 65 peerport => $port,
63 tls => "accept",
64 @args, 66 @args,
65 ); 67 );
66 } 68 }
67} 69}
68 70
… …
82 $cb->(new AnyEvent::MP::Transport 84 $cb->(new AnyEvent::MP::Transport
83 fh => $fh, 85 fh => $fh,
84 peername => $host, 86 peername => $host,
85 peerhost => $nhost, 87 peerhost => $nhost,
86 peerport => $nport, 88 peerport => $nport,
87 tls => "accept",
88 @args, 89 @args,
89 ); 90 );
90 } 91 }
91} 92}
92 93
… …
105 on_eof => sub { clean-close-callback }, 106 on_eof => sub { clean-close-callback },
106 on_connect => sub { successful-connect-callback }, 107 on_connect => sub { successful-connect-callback },
107 greeting => { key => value }, 108 greeting => { key => value },
108 109
109 # tls support 110 # tls support
110 tls => "accept|connect",
111 tls_ctx => AnyEvent::TLS, 111 tls_ctx => AnyEvent::TLS,
112 peername => $peername, # for verification 112 peername => $peername, # for verification
113 ; 113 ;
114 114
115=cut 115=cut
116 116
117our @FRAMINGS = qw(json storable); # the framing types we accept and send, in order of preference 117our @FRAMINGS = qw(json storable); # the framing types we accept and send, in order of preference
118our @AUTH_SND = qw(hmac_md6_64_256); # auth types we send 118our @AUTH_SND = qw(hmac_md6_64_256); # auth types we send
119our @AUTH_RCV = (@AUTH_SND, qw(hex_secret)); # auth types we accept 119our @AUTH_RCV = (@AUTH_SND, qw(cleartext)); # auth types we accept
120 120
121#AnyEvent::Handle::register_write_type mp_record => sub { 121#AnyEvent::Handle::register_write_type mp_record => sub {
122#}; 122#};
123 123
124sub new { 124sub new {
… …
129 $self->{queue} = []; 129 $self->{queue} = [];
130 130
131 { 131 {
132 Scalar::Util::weaken (my $self = $self); 132 Scalar::Util::weaken (my $self = $self);
133 133
134 if (exists $arg{connect}) {
135 $arg{tls_ctx} ||= { sslv2 => 0, sslv3 => 0, tlsv1 => 1, verify => 1 };
136 }
137
138 $arg{secret} = AnyEvent::MP::Base::default_secret () 134 $arg{secret} = AnyEvent::MP::Base::default_secret ()
139 unless exists $arg{secret}; 135 unless exists $arg{secret};
140 136
137 $arg{timeout} = 30
138 unless exists $arg{timeout};
139
140 my $keepalive = (int $arg{timeout} * 0.75) || 1;
141
142 my $secret = $arg{secret};
143
144 if ($secret =~ /-----BEGIN RSA PRIVATE KEY-----.*-----END RSA PRIVATE KEY-----.*-----BEGIN CERTIFICATE-----.*-----END CERTIFICATE-----/s) {
145 # assume TLS mode
146 $arg{tls_ctx} = {
147 sslv2 => 0,
148 sslv3 => 0,
149 tlsv1 => 1,
150 verify => 1,
151 cert => $secret,
152 ca_cert => $secret,
153 verify_require_client_cert => 1,
154 };
155 }
156
141 $self->{hdl} = new AnyEvent::Handle 157 $self->{hdl} = new AnyEvent::Handle
142 fh => delete $arg{fh}, 158 fh => delete $arg{fh},
143 rbuf_max => 64 * 1024,
144 autocork => 1, 159 autocork => 1,
145 no_delay => 1, 160 no_delay => 1,
146 on_error => sub { 161 on_error => sub {
147 $self->error ($_[2]); 162 $self->error ($_[2]);
148 }, 163 },
164 timeout => $AnyEvent::MP::Base::CONNECT_TIMEOUT,
149 peername => delete $arg{peername}, 165 peername => delete $arg{peername},
150 ; 166 ;
151 167
152 my $secret = $arg{secret};
153 my $greeting_kv = $self->{greeting} ||= {}; 168 my $greeting_kv = $self->{greeting} ||= {};
169
170 $self->{local_node} = $AnyEvent::MP::Base::NODE;
171
154 $greeting_kv->{"tls"} = "1.0" 172 $greeting_kv->{"tls"} = "1.0" if $arg{tls_ctx};
155 if $arg{tls_ctx};
156 $greeting_kv->{provider} = "AE-$VERSION"; 173 $greeting_kv->{provider} = "AE-$VERSION";
157 $greeting_kv->{peeraddr} = AnyEvent::Socket::format_hostport $self->{peerhost}, $self->{peerport}; 174 $greeting_kv->{peeraddr} = AnyEvent::Socket::format_hostport $self->{peerhost}, $self->{peerport};
175 $greeting_kv->{maxidle} = $keepalive;
158 176
159 # send greeting 177 # send greeting
160 my $lgreeting1 = "aemp;$PROTOCOL_VERSION;$PROTOCOL_VERSION" # version, min 178 my $lgreeting1 = "aemp;$PROTOCOL_VERSION"
161 . ";$AnyEvent::MP::Base::UNIQ" 179 . ";$AnyEvent::MP::Base::UNIQ"
162 . ";$AnyEvent::MP::Base::NODE" 180 . ";$self->{local_node}"
163 . ";" . (join ",", @AUTH_RCV) 181 . ";" . (join ",", @AUTH_RCV)
164 . ";" . (join ",", @FRAMINGS) 182 . ";" . (join ",", @FRAMINGS)
165 . (join "", map ";$_=$greeting_kv->{$_}", keys %$greeting_kv); 183 . (join "", map ";$_=$greeting_kv->{$_}", keys %$greeting_kv);
184
166 my $lgreeting2 = MIME::Base64::encode_base64 AnyEvent::MP::Base::nonce (33), ""; 185 my $lgreeting2 = MIME::Base64::encode_base64 AnyEvent::MP::Base::nonce (33), "";
167 186
168 $self->{hdl}->push_write ("$lgreeting1\012$lgreeting2\012"); 187 $self->{hdl}->push_write ("$lgreeting1\012$lgreeting2\012");
169 188
170 # expect greeting 189 # expect greeting
190 $self->{hdl}->rbuf_max (4 * 1024);
171 $self->{hdl}->push_read (line => sub { 191 $self->{hdl}->push_read (line => sub {
172 my $rgreeting1 = $_[1]; 192 my $rgreeting1 = $_[1];
173 193
174 my ($aemp, $version, $version_min, $uniq, $rnode, $auths, $framings, @kv) = split /;/, $rgreeting1; 194 my ($aemp, $version, $uniq, $rnode, $auths, $framings, @kv) = split /;/, $rgreeting1;
175 195
176 if ($aemp ne "aemp") { 196 if ($aemp ne "aemp") {
177 return $self->error ("unparsable greeting"); 197 return $self->error ("unparsable greeting");
178 } elsif ($version_min > $PROTOCOL_VERSION) { 198 } elsif ($version != $PROTOCOL_VERSION) {
179 return $self->error ("version mismatch (we: $PROTOCOL_VERSION, they: $version_min .. $version)"); 199 return $self->error ("version mismatch (we: $PROTOCOL_VERSION, they: $version)");
180 } 200 }
181 201
182 my $s_auth; 202 my $s_auth;
183 for my $auth_ (split /,/, $auths) { 203 for my $auth_ (split /,/, $auths) {
184 if (grep $auth_ eq $_, @AUTH_SND) { 204 if (grep $auth_ eq $_, @AUTH_SND) {
… …
213 233
214 # read nonce 234 # read nonce
215 $self->{hdl}->push_read (line => sub { 235 $self->{hdl}->push_read (line => sub {
216 my $rgreeting2 = $_[1]; 236 my $rgreeting2 = $_[1];
217 237
238 "$lgreeting1\012$lgreeting2" ne "$rgreeting1\012$rgreeting2" # echo attack?
239 or return $self->error ("authentication error, echo attack?");
240
241 my $key = Digest::MD6::md6 $secret;
242 my $lauth;
243
218 if ($self->{tls_ctx} and 1 == int $self->{remote_greeting}{"tls"}) { 244 if ($self->{tls_ctx} and 1 == int $self->{remote_greeting}{tls}) {
219 $self->{tls} = $lgreeting2 lt $rgreeting2 ? "connect" : "accept"; 245 $self->{tls} = $lgreeting2 lt $rgreeting2 ? "connect" : "accept";
220 $self->{hdl}->starttls ($self->{tls}, $self->{tls_ctx}); 246 $self->{hdl}->starttls ($self->{tls}, $self->{tls_ctx});
247 $s_auth = "tls";
248 $lauth = "";
249 } else {
250 # we currently only support hmac_md6_64_256
251 $lauth = Digest::HMAC_MD6::hmac_md6_hex $key, "$lgreeting1\012$lgreeting2\012$rgreeting1\012$rgreeting2\012", 64, 256;
221 } 252 }
222
223 # auth
224 require Digest::MD6;
225 require Digest::HMAC_MD6;
226
227 my $key = Digest::MD6::md6_hex ($secret);
228 my $lauth = Digest::HMAC_MD6::hmac_md6_base64 ($key, "$lgreeting1\012$lgreeting2\012$rgreeting1\012$rgreeting2\012", 64, 256);
229
230 my $rauth =
231 $s_auth eq "hmac_md6_64_256" ? Digest::HMAC_MD6::hmac_md6_base64 ($key, "$rgreeting1\012$rgreeting2\012$lgreeting1\012$lgreeting2\012", 64, 256)
232 : $s_auth eq "hex_secret" ? unpack "H*", $secret
233 : die;
234
235 $lauth ne $rauth # echo attack?
236 or return $self->error ("authentication error");
237 253
238 $self->{hdl}->push_write ("$s_auth;$lauth;$s_framing\012"); 254 $self->{hdl}->push_write ("$s_auth;$lauth;$s_framing\012");
239 255
240 $self->{hdl}->rbuf_max (64); # enough for 44 reply bytes or so 256 # read the authentication response
241 $self->{hdl}->push_read (line => sub { 257 $self->{hdl}->push_read (line => sub {
242 my ($hdl, $rline) = @_; 258 my ($hdl, $rline) = @_;
243 259
244 my ($auth_method, $rauth2, $r_framing) = split /;/, $rline; 260 my ($auth_method, $rauth2, $r_framing) = split /;/, $rline;
261
262 my $rauth =
263 $auth_method eq "hmac_md6_64_256" ? Digest::HMAC_MD6::hmac_md6_hex $key, "$rgreeting1\012$rgreeting2\012$lgreeting1\012$lgreeting2\012", 64, 256
264 : $auth_method eq "cleartext" ? unpack "H*", $secret
265 : $auth_method eq "tls" ? ($self->{tls} ? "" : "\012\012") # \012\012 never matches
266 : return $self->error ("$auth_method: fatal, selected unsupported auth method");
245 267
246 if ($rauth2 ne $rauth) { 268 if ($rauth2 ne $rauth) {
247 return $self->error ("authentication failure/shared secret mismatch"); 269 return $self->error ("authentication failure/shared secret mismatch");
248 } 270 }
249 271
250 $self->{s_framing} = $s_framing; 272 $self->{s_framing} = $s_framing;
251 273
252 $hdl->rbuf_max (undef); 274 $hdl->rbuf_max (undef);
253 my $queue = delete $self->{queue}; # we are connected 275 my $queue = delete $self->{queue}; # we are connected
254 276
277# $self->{hdl}->timeout ($self->{remote_greeting}{keepalive} + 5)
278# if $self->{remote_greeting}{keepalive};
279
255 $self->connected; 280 $self->connected;
256 281
257 $hdl->push_write ($self->{s_framing} => $_) 282 my $src_node = $self->{node};
283
284 $self->send ($_)
258 for @$queue; 285 for @$queue;
259 286
260 my $rmsg; $rmsg = sub { 287 my $rmsg; $rmsg = sub {
261 $_[0]->push_read ($r_framing => $rmsg); 288 $_[0]->push_read ($r_framing => $rmsg);
262 289
290 local $AnyEvent::MP::Base::SRCNODE = $src_node;
263 AnyEvent::MP::Base::_inject ($_[1]); 291 AnyEvent::MP::Base::_inject (@{ $_[1] });
264 }; 292 };
265 $hdl->push_read ($r_framing => $rmsg); 293 $hdl->push_read ($r_framing => $rmsg);
266 }); 294 });
267 }); 295 });
268 }); 296 });
… …
273 301
274sub error { 302sub error {
275 my ($self, $msg) = @_; 303 my ($self, $msg) = @_;
276 304
277 if ($self->{node} && $self->{node}{transport} == $self) { 305 if ($self->{node} && $self->{node}{transport} == $self) {
306 #TODO: store error, but do not instantly fail
307 $self->{node}->fail (transport_error => $self->{node}{noderef}, $msg);
278 $self->{node}->clr_transport; 308 $self->{node}->clr_transport;
279 } 309 }
280 $AnyEvent::MP::Base::WARN->("$self->{peerhost}:$self->{peerport}: $msg"); 310 $AnyEvent::MP::Base::WARN->("$self->{peerhost}:$self->{peerport}: $msg");
281 $self->destroy; 311 $self->destroy;
282} 312}
283 313
284sub connected { 314sub connected {
285 my ($self) = @_; 315 my ($self) = @_;
286 316
317 if (ref $AnyEvent::MP::Base::SLAVE) {
318 # first connect with a master node
319 my $via = $self->{remote_node};
320 $via =~ s/,/!/g;
321 $AnyEvent::MP::Base::NODE .= "\@$via";
322 $AnyEvent::MP::Base::NODE{$AnyEvent::MP::Base::NODE} = $AnyEvent::MP::Base::NODE{""};
323 $AnyEvent::MP::Base::SLAVE->();
324 }
325
326 if ($self->{local_node} ne $AnyEvent::MP::Base::NODE) {
327 # node changed its name since first greeting
328 $self->send (["", iam => $AnyEvent::MP::Base::NODE]);
329 }
330
287 my $node = AnyEvent::MP::Base::add_node ($self->{remote_node}); 331 my $node = AnyEvent::MP::Base::add_node ($self->{remote_node});
288 Scalar::Util::weaken ($self->{node} = $node); 332 Scalar::Util::weaken ($self->{node} = $node);
289 $node->set_transport ($self); 333 $node->set_transport ($self);
290} 334}
291 335
… …
319The greeting consists of two text lines that are ended by either an ASCII 363The greeting consists of two text lines that are ended by either an ASCII
320CR LF pair, or a single ASCII LF (recommended). 364CR LF pair, or a single ASCII LF (recommended).
321 365
322=head2 GREETING 366=head2 GREETING
323 367
368All the lines until after authentication must not exceed 4kb in length,
369including delimiter. Afterwards there is no limit on the packet size that
370can be received.
371
372=head3 First Greeting Line
373
374Example:
375
376 aemp;0;fec.4a7720fc;127.0.0.1:1235,[::1]:1235;hmac_md6_64_256;json,storable;provider=AE-0.0
377
324The first line contains strings separated (not ended) by C<;> 378The first line contains strings separated (not ended) by C<;>
325characters. The first seven strings are fixed by the protocol, the 379characters. The first even ixtrings are fixed by the protocol, the
326remaining strings are C<KEY=VALUE> pairs. None of them may contain C<;> 380remaining strings are C<KEY=VALUE> pairs. None of them may contain C<;>
327characters themselves. 381characters themselves.
328 382
329The seven fixed strings are: 383The fixed strings are:
330 384
331=over 4 385=over 4
332 386
333=item C<aemp> 387=item protocol identification
334 388
335The constant C<aemp> to identify the protocol. 389The constant C<aemp> to identify the protocol.
336 390
337=item protocol version 391=item protocol version
338 392
339The (maximum) protocol version supported by this end, currently C<0>.
340
341=item minimum protocol version
342
343The minimum protocol version supported by this end, currently C<0>. 393The protocol version supported by this end, currently C<0>. If the
394versions don't match then no communication is possible. Minor extensions
395are supposed to be handled through additional key-value pairs.
344 396
345=item a token uniquely identifying the current node instance 397=item a token uniquely identifying the current node instance
346 398
347This is a string that must change between restarts. It usually contains 399This is a string that must change between restarts. It usually contains
348things like the current time, the (OS) process id or similar values, but 400things like the current time, the (OS) process id or similar values, but
… …
366 418
367A comma-separated list of packet encoding/framign formats understood. The 419A comma-separated list of packet encoding/framign formats understood. The
368receiving side should choose the first framing format it supports for 420receiving side should choose the first framing format it supports for
369sending packets (which might be different from the format it has to accept). 421sending packets (which might be different from the format it has to accept).
370 422
371=cut 423=back
372 424
373The remaining arguments are C<KEY=VALUE> pairs. The following key-value 425The remaining arguments are C<KEY=VALUE> pairs. The following key-value
374pairs are known at this time: 426pairs are known at this time:
375 427
376=over 4 428=over 4
… …
388=item tls=<major>.<minor> 440=item tls=<major>.<minor>
389 441
390Indicates that the other side supports TLS (version should be 1.0) and 442Indicates that the other side supports TLS (version should be 1.0) and
391wishes to do a TLS handshake. 443wishes to do a TLS handshake.
392 444
445=item maxidle=<seconds>
446
447The maximum amount of time the node will not sent data, i.e., idle. This
448can be used to close the conenction when no data has been received for a
449too-long time (say, maxidle + 5 seconds).
450
393=back 451=back
452
453=head3 Second Greeting Line
394 454
395After this greeting line there will be a second line containing a 455After this greeting line there will be a second line containing a
396cryptographic nonce, i.e. random data of high quality. To keep the 456cryptographic nonce, i.e. random data of high quality. To keep the
397protocol text-only, these are usually 32 base64-encoded octets, but 457protocol text-only, these are usually 32 base64-encoded octets, but
398it could be anything that doesn't contain any ASCII CR or ASCII LF 458it could be anything that doesn't contain any ASCII CR or ASCII LF
399characters. 459characters.
400 460
401Example of the two lines of greeting: 461I<< The two nonces B<must> be different, and an aemp implementation
462B<must> check and fail when they are identical >>.
402 463
403 aemp;0;0;e7d.4a76f48f;10.0.0.1:4040;hmac_md6_64_256,hex_secret;json,storable;provider=AE-0.0;peeraddr=127.0.0.1:1235 464Example of a nonce line:
404 XntegV2Guvss0qNn7phCPnoU87xqxV+4Mqm/5y4iQm6a 465
466 p/I122ql7kJR8lumW3lXlXCeBnyDAvz8NQo3x5IFowE4
405 467
406=head2 TLS handshake 468=head2 TLS handshake
407 469
408If, after the handshake, both sides indicate interest in TLS, then the 470I<< If, after the handshake, both sides indicate interest in TLS, then the
409connection I<must> use TLS, or fail. 471connection B<must> use TLS, or fail. >>
410 472
411Both sides compare their nonces, and the side who sent the lower nonce 473Both sides compare their nonces, and the side who sent the lower nonce
412value ("string" comparison on the raw octet values) becomes the client, 474value ("string" comparison on the raw octet values) becomes the client,
413and the one with the higher nonce the server. 475and the one with the higher nonce the server.
414 476
… …
425 487
426=item the authentication method chosen 488=item the authentication method chosen
427 489
428This must be one of the methods offered by the other side in the greeting. 490This must be one of the methods offered by the other side in the greeting.
429 491
492The currently supported authentication methods are:
493
494=over 4
495
496=item cleartext
497
498This is simply the shared secret, lowercase-hex-encoded. This method is of
499course very insecure, unless TLS is used, which is why this module will
500accept, but not generate, cleartext auth replies.
501
502=item hmac_md6_64_256
503
504This method uses an MD6 HMAC with 64 bit blocksize and 256 bit hash. First, the shared secret
505is hashed with MD6:
506
507 key = MD6 (secret)
508
509This secret is then used to generate the "local auth reply", by taking
510the two local greeting lines and the two remote greeting lines (without
511line endings), appending \012 to all of them, concatenating them and
512calculating the MD6 HMAC with the key.
513
514 lauth = HMAC_MD6 key, "lgreeting1\012lgreeting2\012rgreeting1\012rgreeting2\012"
515
516This authentication token is then lowercase-hex-encoded and sent to the
517other side.
518
519Then the remote auth reply is generated using the same method, but local
520and remote greeting lines swapped:
521
522 rauth = HMAC_MD6 key, "rgreeting1\012rgreeting2\012lgreeting1\012lgreeting2\012"
523
524This is the token that is expected from the other side.
525
526=item tls
527
528This type is only valid iff TLS was enabled and the TLS handshake
529was successful. It has no authentication data, as the server/client
530certificate was successfully verified.
531
532Implementations supporting TLS I<must> accept this authentication type.
533
534=back
535
430=item the authentication data 536=item the authentication data
431 537
432The authentication data itself, usually base64 or hex-encoded data. 538The authentication data itself, usually base64 or hex-encoded data, see
539above.
433 540
434=item the framing protocol chosen 541=item the framing protocol chosen
435 542
436This must be one of the framing protocols offered by the other side in the 543This must be one of the framing protocols offered by the other side in the
437greeting. Each side must accept the choice of the other side. 544greeting. Each side must accept the choice of the other side.
438 545
439=back 546=back
440 547
548Example of an authentication reply:
549
550 hmac_md6_64_256;363d5175df38bd9eaddd3f6ca18aa1c0c4aa22f0da245ac638d048398c26b8d3;json
551
441=head2 DATA PHASE 552=head2 DATA PHASE
442 553
443After this, packets get exchanged using the chosen framing protocol. It is 554After this, packets get exchanged using the chosen framing protocol. It is
444quite possible that both sides use a different framing protocol. 555quite possible that both sides use a different framing protocol.
445 556
557=head2 FULL EXAMPLE
558
559This is an actual protocol dump of a handshake, followed by a single data
560packet. The greater than/less than lines indicate the direction of the
561transfer only.
562
563 > aemp;0;nndKd+gn;10.0.0.1:4040;hmac_md6_64_256,cleartext;json,storable;provider=AE-0.0;peeraddr=127.0.0.1:1235
564 > sRG8bbc4TDbkpvH8FTP4HBs87OhepH6VuApoZqXXskuG
565 < aemp;0;nmpKd+gh;127.0.0.1:1235,[::1]:1235;hmac_md6_64_256,cleartext;json,storable;provider=AE-0.0;peeraddr=127.0.0.1:58760
566 < dCEUcL/LJVSTJcx8byEsOzrwhzJYOq+L3YcopA5T6EAo
567 > hmac_md6_64_256;9513d4b258975accfcb2ab7532b83690e9c119a502c612203332a591c7237788;json
568 < hmac_md6_64_256;0298d6ba2240faabb2b2e881cf86b97d70a113ca74a87dc006f9f1e9d3010f90;json
569 > ["","lookup","pinger","10.0.0.1:4040#nndKd+gn.a","resolved"]
570
446=head1 SEE ALSO 571=head1 SEE ALSO
447 572
448L<AnyEvent>. 573L<AnyEvent>.
449 574
450=head1 AUTHOR 575=head1 AUTHOR

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines