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

Comparing AnyEvent-HTTP/HTTP.pm (file contents):
Revision 1.19 by elmex, Mon Jun 9 13:02:13 2008 UTC vs.
Revision 1.76 by root, Sat Jan 1 02:20:49 2011 UTC

39package AnyEvent::HTTP; 39package AnyEvent::HTTP;
40 40
41use strict; 41use strict;
42no warnings; 42no warnings;
43 43
44use Carp; 44use Errno ();
45 45
46use AnyEvent (); 46use AnyEvent 5.0 ();
47use AnyEvent::Util (); 47use AnyEvent::Util ();
48use AnyEvent::Socket ();
49use AnyEvent::Handle (); 48use AnyEvent::Handle ();
50 49
51use base Exporter::; 50use base Exporter::;
52 51
53our $VERSION = '1.01'; 52our $VERSION = '1.5';
54 53
55our @EXPORT = qw(http_get http_post http_head http_request); 54our @EXPORT = qw(http_get http_post http_head http_request);
56 55
57our $USERAGENT = "Mozilla/5.0 (compatible; AnyEvent::HTTP/$VERSION; +http://software.schmorp.de/pkg/AnyEvent)"; 56our $USERAGENT = "Mozilla/5.0 (compatible; U; AnyEvent-HTTP/$VERSION; +http://software.schmorp.de/pkg/AnyEvent)";
58our $MAX_RECURSE = 10; 57our $MAX_RECURSE = 10;
59our $MAX_PERSISTENT = 8; 58our $MAX_PERSISTENT = 8;
60our $PERSISTENT_TIMEOUT = 2; 59our $PERSISTENT_TIMEOUT = 2;
61our $TIMEOUT = 300; 60our $TIMEOUT = 300;
62 61
63# changing these is evil 62# changing these is evil
64our $MAX_PERSISTENT_PER_HOST = 2; 63our $MAX_PERSISTENT_PER_HOST = 0;
65our $MAX_PER_HOST = 4; 64our $MAX_PER_HOST = 4;
66 65
67our $PROXY; 66our $PROXY;
68our $ACTIVE = 0; 67our $ACTIVE = 0;
69 68
71my %CO_SLOT; # number of open connections, and wait queue, per host 70my %CO_SLOT; # number of open connections, and wait queue, per host
72 71
73=item http_get $url, key => value..., $cb->($data, $headers) 72=item http_get $url, key => value..., $cb->($data, $headers)
74 73
75Executes an HTTP-GET request. See the http_request function for details on 74Executes an HTTP-GET request. See the http_request function for details on
76additional parameters. 75additional parameters and the return value.
77 76
78=item http_head $url, key => value..., $cb->($data, $headers) 77=item http_head $url, key => value..., $cb->($data, $headers)
79 78
80Executes an HTTP-HEAD request. See the http_request function for details on 79Executes an HTTP-HEAD request. See the http_request function for details
81additional parameters. 80on additional parameters and the return value.
82 81
83=item http_post $url, $body, key => value..., $cb->($data, $headers) 82=item http_post $url, $body, key => value..., $cb->($data, $headers)
84 83
85Executes an HTTP-POST request with a request body of C<$bod>. See the 84Executes an HTTP-POST request with a request body of C<$body>. See the
86http_request function for details on additional parameters. 85http_request function for details on additional parameters and the return
86value.
87 87
88=item http_request $method => $url, key => value..., $cb->($data, $headers) 88=item http_request $method => $url, key => value..., $cb->($data, $headers)
89 89
90Executes a HTTP request of type C<$method> (e.g. C<GET>, C<POST>). The URL 90Executes a HTTP request of type C<$method> (e.g. C<GET>, C<POST>). The URL
91must be an absolute http or https URL. 91must be an absolute http or https URL.
92 92
93When called in void context, nothing is returned. In other contexts,
94C<http_request> returns a "cancellation guard" - you have to keep the
95object at least alive until the callback get called. If the object gets
96destroyed before the callback is called, the request will be cancelled.
97
93The callback will be called with the response data as first argument 98The callback will be called with the response body data as first argument
94(or C<undef> if it wasn't available due to errors), and a hash-ref with 99(or C<undef> if an error occured), and a hash-ref with response headers
95response headers as second argument. 100(and trailers) as second argument.
96 101
97All the headers in that hash are lowercased. In addition to the response 102All the headers in that hash are lowercased. In addition to the response
98headers, the three "pseudo-headers" C<HTTPVersion>, C<Status> and 103headers, the "pseudo-headers" (uppercase to avoid clashing with possible
99C<Reason> contain the three parts of the HTTP Status-Line of the same 104response headers) C<HTTPVersion>, C<Status> and C<Reason> contain the
105three parts of the HTTP Status-Line of the same name. If an error occurs
106during the body phase of a request, then the original C<Status> and
107C<Reason> values from the header are available as C<OrigStatus> and
108C<OrigReason>.
109
110The pseudo-header C<URL> contains the actual URL (which can differ from
111the requested URL when following redirects - for example, you might get
112an error that your URL scheme is not supported even though your URL is a
113valid http URL because it redirected to an ftp URL, in which case you can
114look at the URL pseudo header).
115
116The pseudo-header C<Redirect> only exists when the request was a result
117of an internal redirect. In that case it is an array reference with
118the C<($data, $headers)> from the redirect response. Note that this
119response could in turn be the result of a redirect itself, and C<<
120$headers->{Redirect}[1]{Redirect} >> will then contain the original
121response, and so on.
122
100name. If the server sends a header multiple lines, then their contents 123If the server sends a header multiple times, then their contents will be
101will be joined together with C<\x00>. 124joined together with a comma (C<,>), as per the HTTP spec.
102 125
103If an internal error occurs, such as not being able to resolve a hostname, 126If an internal error occurs, such as not being able to resolve a hostname,
104then C<$data> will be C<undef>, C<< $headers->{Status} >> will be C<599> 127then C<$data> will be C<undef>, C<< $headers->{Status} >> will be C<59x>
105and the C<Reason> pseudo-header will contain an error message. 128(usually C<599>) and the C<Reason> pseudo-header will contain an error
129message.
106 130
107A typical callback might look like this: 131A typical callback might look like this:
108 132
109 sub { 133 sub {
110 my ($body, $hdr) = @_; 134 my ($body, $hdr) = @_;
126Whether to recurse requests or not, e.g. on redirects, authentication 150Whether to recurse requests or not, e.g. on redirects, authentication
127retries and so on, and how often to do so. 151retries and so on, and how often to do so.
128 152
129=item headers => hashref 153=item headers => hashref
130 154
131The request headers to use. Currently, C<http_request> may provide its 155The request headers to use. Currently, C<http_request> may provide its own
132own C<Host:>, C<Content-Length:>, C<Connection:> and C<Cookie:> headers 156C<Host:>, C<Content-Length:>, C<Connection:> and C<Cookie:> headers and
133and will provide defaults for C<User-Agent:> and C<Referer:>. 157will provide defaults at least for C<TE:>, C<Referer:> and C<User-Agent:>
158(this can be suppressed by using C<undef> for these headers in which case
159they won't be sent at all).
134 160
135=item timeout => $seconds 161=item timeout => $seconds
136 162
137The time-out to use for various stages - each connect attempt will reset 163The time-out to use for various stages - each connect attempt will reset
138the timeout, as will read or write activity. Default timeout is 5 minutes. 164the timeout, as will read or write activity, i.e. this is not an overall
165timeout.
166
167Default timeout is 5 minutes.
139 168
140=item proxy => [$host, $port[, $scheme]] or undef 169=item proxy => [$host, $port[, $scheme]] or undef
141 170
142Use the given http proxy for all requests. If not specified, then the 171Use the given http proxy for all requests. If not specified, then the
143default proxy (as specified by C<$ENV{http_proxy}>) is used. 172default proxy (as specified by C<$ENV{http_proxy}>) is used.
144 173
145C<$scheme> must be either missing or C<http> for HTTP, or C<https> for 174C<$scheme> must be either missing, C<http> for HTTP or C<https> for
146HTTPS. 175HTTPS.
147 176
148=item body => $string 177=item body => $string
149 178
150The request body, usually empty. Will be-sent as-is (future versions of 179The request body, usually empty. Will be sent as-is (future versions of
151this module might offer more options). 180this module might offer more options).
152 181
153=item cookie_jar => $hash_ref 182=item cookie_jar => $hash_ref
154 183
155Passing this parameter enables (simplified) cookie-processing, loosely 184Passing this parameter enables (simplified) cookie-processing, loosely
156based on the original netscape specification. 185based on the original netscape specification.
157 186
158The C<$hash_ref> must be an (initially empty) hash reference which will 187The C<$hash_ref> must be an (initially empty) hash reference which will
159get updated automatically. It is possible to save the cookie_jar to 188get updated automatically. It is possible to save the cookie jar to
160persistent storage with something like JSON or Storable, but this is not 189persistent storage with something like JSON or Storable, but this is not
161recommended, as expire times are currently being ignored. 190recommended, as session-only cookies might survive longer than expected.
162 191
163Note that this cookie implementation is not of very high quality, nor 192Note that this cookie implementation is not meant to be complete. If
164meant to be complete. If you want complete cookie management you have to 193you want complete cookie management you have to do that on your
165do that on your own. C<cookie_jar> is meant as a quick fix to get some 194own. C<cookie_jar> is meant as a quick fix to get some cookie-using sites
166cookie-using sites working. Cookies are a privacy disaster, do not use 195working. Cookies are a privacy disaster, do not use them unless required
167them unless required to. 196to.
197
198When cookie processing is enabled, the C<Cookie:> and C<Set-Cookie:>
199headers will be set and handled by this module, otherwise they will be
200left untouched.
201
202=item tls_ctx => $scheme | $tls_ctx
203
204Specifies the AnyEvent::TLS context to be used for https connections. This
205parameter follows the same rules as the C<tls_ctx> parameter to
206L<AnyEvent::Handle>, but additionally, the two strings C<low> or
207C<high> can be specified, which give you a predefined low-security (no
208verification, highest compatibility) and high-security (CA and common-name
209verification) TLS context.
210
211The default for this option is C<low>, which could be interpreted as "give
212me the page, no matter what".
213
214=item on_prepare => $callback->($fh)
215
216In rare cases you need to "tune" the socket before it is used to
217connect (for exmaple, to bind it on a given IP address). This parameter
218overrides the prepare callback passed to C<AnyEvent::Socket::tcp_connect>
219and behaves exactly the same way (e.g. it has to provide a
220timeout). See the description for the C<$prepare_cb> argument of
221C<AnyEvent::Socket::tcp_connect> for details.
222
223=item tcp_connect => $callback->($host, $service, $connect_cb, $prepare_cb)
224
225In even rarer cases you want total control over how AnyEvent::HTTP
226establishes connections. Normally it uses L<AnyEvent::Socket::tcp_connect>
227to do this, but you can provide your own C<tcp_connect> function -
228obviously, it has to follow the same calling conventions, except that it
229may always return a connection guard object.
230
231There are probably lots of weird uses for this function, starting from
232tracing the hosts C<http_request> actually tries to connect, to (inexact
233but fast) host => IP address caching or even socks protocol support.
234
235=item on_header => $callback->($headers)
236
237When specified, this callback will be called with the header hash as soon
238as headers have been successfully received from the remote server (not on
239locally-generated errors).
240
241It has to return either true (in which case AnyEvent::HTTP will continue),
242or false, in which case AnyEvent::HTTP will cancel the download (and call
243the finish callback with an error code of C<598>).
244
245This callback is useful, among other things, to quickly reject unwanted
246content, which, if it is supposed to be rare, can be faster than first
247doing a C<HEAD> request.
248
249The downside is that cancelling the request makes it impossible to re-use
250the connection. Also, the C<on_header> callback will not receive any
251trailer (headers sent after the response body).
252
253Example: cancel the request unless the content-type is "text/html".
254
255 on_header => sub {
256 $_[0]{"content-type"} =~ /^text\/html\s*(?:;|$)/
257 },
258
259=item on_body => $callback->($partial_body, $headers)
260
261When specified, all body data will be passed to this callback instead of
262to the completion callback. The completion callback will get the empty
263string instead of the body data.
264
265It has to return either true (in which case AnyEvent::HTTP will continue),
266or false, in which case AnyEvent::HTTP will cancel the download (and call
267the completion callback with an error code of C<598>).
268
269The downside to cancelling the request is that it makes it impossible to
270re-use the connection.
271
272This callback is useful when the data is too large to be held in memory
273(so the callback writes it to a file) or when only some information should
274be extracted, or when the body should be processed incrementally.
275
276It is usually preferred over doing your own body handling via
277C<want_body_handle>, but in case of streaming APIs, where HTTP is
278only used to create a connection, C<want_body_handle> is the better
279alternative, as it allows you to install your own event handler, reducing
280resource usage.
281
282=item want_body_handle => $enable
283
284When enabled (default is disabled), the behaviour of AnyEvent::HTTP
285changes considerably: after parsing the headers, and instead of
286downloading the body (if any), the completion callback will be
287called. Instead of the C<$body> argument containing the body data, the
288callback will receive the L<AnyEvent::Handle> object associated with the
289connection. In error cases, C<undef> will be passed. When there is no body
290(e.g. status C<304>), the empty string will be passed.
291
292The handle object might or might not be in TLS mode, might be connected to
293a proxy, be a persistent connection etc., and configured in unspecified
294ways. The user is responsible for this handle (it will not be used by this
295module anymore).
296
297This is useful with some push-type services, where, after the initial
298headers, an interactive protocol is used (typical example would be the
299push-style twitter API which starts a JSON/XML stream).
300
301If you think you need this, first have a look at C<on_body>, to see if
302that doesn't solve your problem in a better way.
168 303
169=back 304=back
170 305
171Example: make a simple HTTP GET request for http://www.nethype.de/ 306Example: do a simple HTTP GET request for http://www.nethype.de/ and print
307the response body.
172 308
173 http_request GET => "http://www.nethype.de/", sub { 309 http_request GET => "http://www.nethype.de/", sub {
174 my ($body, $hdr) = @_; 310 my ($body, $hdr) = @_;
175 print "$body\n"; 311 print "$body\n";
176 }; 312 };
177 313
178Example: make a HTTP HEAD request on https://www.google.com/, use a 314Example: do a HTTP HEAD request on https://www.google.com/, use a
179timeout of 30 seconds. 315timeout of 30 seconds.
180 316
181 http_request 317 http_request
182 GET => "https://www.google.com", 318 GET => "https://www.google.com",
183 timeout => 30, 319 timeout => 30,
185 my ($body, $hdr) = @_; 321 my ($body, $hdr) = @_;
186 use Data::Dumper; 322 use Data::Dumper;
187 print Dumper $hdr; 323 print Dumper $hdr;
188 } 324 }
189 ; 325 ;
326
327Example: do another simple HTTP GET request, but immediately try to
328cancel it.
329
330 my $request = http_request GET => "http://www.nethype.de/", sub {
331 my ($body, $hdr) = @_;
332 print "$body\n";
333 };
334
335 undef $request;
190 336
191=cut 337=cut
192 338
193sub _slot_schedule; 339sub _slot_schedule;
194sub _slot_schedule($) { 340sub _slot_schedule($) {
218 push @{ $CO_SLOT{$_[0]}[1] }, $_[1]; 364 push @{ $CO_SLOT{$_[0]}[1] }, $_[1];
219 365
220 _slot_schedule $_[0]; 366 _slot_schedule $_[0];
221} 367}
222 368
369# extract cookies from jar
370sub cookie_jar_extract($$$$) {
371 my ($jar, $uscheme, $uhost, $upath) = @_;
372
373 %$jar = () if $jar->{version} != 1;
374
375 my @cookies;
376
377 while (my ($chost, $paths) = each %$jar) {
378 next unless ref $paths;
379
380 if ($chost =~ /^\./) {
381 next unless $chost eq substr $uhost, -length $chost;
382 } elsif ($chost =~ /\./) {
383 next unless $chost eq $uhost;
384 } else {
385 next;
386 }
387
388 while (my ($cpath, $cookies) = each %$paths) {
389 next unless $cpath eq substr $upath, 0, length $cpath;
390
391 while (my ($cookie, $kv) = each %$cookies) {
392 next if $uscheme ne "https" && exists $kv->{secure};
393
394 if (exists $kv->{expires}) {
395 if (AE::now > parse_date ($kv->{expires})) {
396 delete $cookies->{$cookie};
397 next;
398 }
399 }
400
401 my $value = $kv->{value};
402
403 if ($value =~ /[=;,[:space:]]/) {
404 $value =~ s/([\\"])/\\$1/g;
405 $value = "\"$value\"";
406 }
407
408 push @cookies, "$cookie=$value";
409 }
410 }
411 }
412
413 \@cookies
414}
415
416# parse set_cookie header into jar
417sub cookie_jar_set_cookie($$$) {
418 my ($jar, $set_cookie, $uhost) = @_;
419
420 for ($set_cookie) {
421 # parse NAME=VALUE
422 my @kv;
423
424 while (
425 m{
426 \G\s*
427 (?:
428 expires \s*=\s* ([A-Z][a-z][a-z],\ [^,;]+)
429 | ([^=;,[:space:]]+) \s*=\s* (?: "((?:[^\\"]+|\\.)*)" | ([^=;,[:space:]]*) )
430 )
431 }gcxsi
432 ) {
433 my $name = $2;
434 my $value = $4;
435
436 unless (defined $name) {
437 # expires
438 $name = "expires";
439 $value = $1;
440 } elsif (!defined $value) {
441 # quoted
442 $value = $3;
443 $value =~ s/\\(.)/$1/gs;
444 }
445
446 push @kv, lc $name, $value;
447
448 last unless /\G\s*;/gc;
449 }
450
451 last unless @kv;
452
453 my $name = shift @kv;
454 my %kv = (value => shift @kv, @kv);
455
456 $kv{expires} ||= format_date (AE::now + $kv{"max-age"})
457 if exists $kv{"max-age"};
458
459 my $cdom;
460 my $cpath = (delete $kv{path}) || "/";
461
462 if (exists $kv{domain}) {
463 $cdom = delete $kv{domain};
464
465 $cdom =~ s/^\.?/./; # make sure it starts with a "."
466
467 next if $cdom =~ /\.$/;
468
469 # this is not rfc-like and not netscape-like. go figure.
470 my $ndots = $cdom =~ y/.//;
471 next if $ndots < ($cdom =~ /\.[^.][^.]\.[^.][^.]$/ ? 3 : 2);
472 } else {
473 $cdom = $uhost;
474 }
475
476 # store it
477 $jar->{version} = 1;
478 $jar->{$cdom}{$cpath}{$name} = \%kv;
479
480 redo if /\G\s*,/gc;
481 }
482}
483
484# continue to parse $_ for headers and place them into the arg
485sub parse_hdr() {
486 my %hdr;
487
488 # things seen, not parsed:
489 # p3pP="NON CUR OTPi OUR NOR UNI"
490
491 $hdr{lc $1} .= ",$2"
492 while /\G
493 ([^:\000-\037]*):
494 [\011\040]*
495 ((?: [^\012]+ | \012[\011\040] )*)
496 \012
497 /gxc;
498
499 /\G$/
500 or return;
501
502 # remove the "," prefix we added to all headers above
503 substr $_, 0, 1, ""
504 for values %hdr;
505
506 \%hdr
507}
508
509our $qr_nlnl = qr{(?<![^\012])\015?\012};
510
511our $TLS_CTX_LOW = { cache => 1, sslv2 => 1 };
512our $TLS_CTX_HIGH = { cache => 1, verify => 1, verify_peername => "https" };
513
223sub http_request($$@) { 514sub http_request($$@) {
224 my $cb = pop; 515 my $cb = pop;
225 my ($method, $url, %arg) = @_; 516 my ($method, $url, %arg) = @_;
226 517
227 my %hdr; 518 my %hdr;
519
520 $arg{tls_ctx} = $TLS_CTX_LOW if $arg{tls_ctx} eq "low" || !exists $arg{tls_ctx};
521 $arg{tls_ctx} = $TLS_CTX_HIGH if $arg{tls_ctx} eq "high";
228 522
229 $method = uc $method; 523 $method = uc $method;
230 524
231 if (my $hdr = $arg{headers}) { 525 if (my $hdr = $arg{headers}) {
232 while (my ($k, $v) = each %$hdr) { 526 while (my ($k, $v) = each %$hdr) {
233 $hdr{lc $k} = $v; 527 $hdr{lc $k} = $v;
234 } 528 }
235 } 529 }
236 530
531 # pseudo headers for all subsequent responses
532 my @pseudo = (URL => $url);
533 push @pseudo, Redirect => delete $arg{Redirect} if exists $arg{Redirect};
534
237 my $recurse = exists $arg{recurse} ? $arg{recurse} : $MAX_RECURSE; 535 my $recurse = exists $arg{recurse} ? delete $arg{recurse} : $MAX_RECURSE;
238 536
239 return $cb->(undef, { Status => 599, Reason => "recursion limit reached", URL => $url }) 537 return $cb->(undef, { @pseudo, Status => 599, Reason => "Too many redirections" })
240 if $recurse < 0; 538 if $recurse < 0;
241 539
242 my $proxy = $arg{proxy} || $PROXY; 540 my $proxy = $arg{proxy} || $PROXY;
243 my $timeout = $arg{timeout} || $TIMEOUT; 541 my $timeout = $arg{timeout} || $TIMEOUT;
244 542
245 $hdr{"user-agent"} ||= $USERAGENT;
246
247 my ($scheme, $authority, $upath, $query, $fragment) = 543 my ($uscheme, $uauthority, $upath, $query, $fragment) =
248 $url =~ m|(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?|; 544 $url =~ m|(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:(\?[^#]*))?(?:#(.*))?|;
249 545
250 $scheme = lc $scheme; 546 $uscheme = lc $uscheme;
251 547
252 my $uport = $scheme eq "http" ? 80 548 my $uport = $uscheme eq "http" ? 80
253 : $scheme eq "https" ? 443 549 : $uscheme eq "https" ? 443
254 : return $cb->(undef, { Status => 599, Reason => "only http and https URL schemes supported", URL => $url }); 550 : return $cb->(undef, { @pseudo, Status => 599, Reason => "Only http and https URL schemes supported" });
255 551
256 $hdr{referer} ||= "$scheme://$authority$upath"; # leave out fragment and query string, just a heuristic
257
258 $authority =~ /^(?: .*\@ )? ([^\@:]+) (?: : (\d+) )?$/x 552 $uauthority =~ /^(?: .*\@ )? ([^\@:]+) (?: : (\d+) )?$/x
259 or return $cb->(undef, { Status => 599, Reason => "unparsable URL", URL => $url }); 553 or return $cb->(undef, { @pseudo, Status => 599, Reason => "Unparsable URL" });
260 554
261 my $uhost = $1; 555 my $uhost = $1;
262 $uport = $2 if defined $2; 556 $uport = $2 if defined $2;
263 557
558 $hdr{host} = defined $2 ? "$uhost:$2" : "$uhost"
559 unless exists $hdr{host};
560
264 $uhost =~ s/^\[(.*)\]$/$1/; 561 $uhost =~ s/^\[(.*)\]$/$1/;
265 $upath .= "?$query" if length $query; 562 $upath .= $query if length $query;
266 563
267 $upath =~ s%^/?%/%; 564 $upath =~ s%^/?%/%;
268 565
269 # cookie processing 566 # cookie processing
270 if (my $jar = $arg{cookie_jar}) { 567 if (my $jar = $arg{cookie_jar}) {
271 %$jar = () if $jar->{version} < 1; 568 my $cookies = cookie_jar_extract $jar, $uscheme, $uhost, $upath;
272 569
273 my @cookie;
274
275 while (my ($chost, $v) = each %$jar) {
276 next unless $chost eq substr $uhost, -length $chost;
277 next unless $chost =~ /^\./;
278
279 while (my ($cpath, $v) = each %$v) {
280 next unless $cpath eq substr $upath, 0, length $cpath;
281
282 while (my ($k, $v) = each %$v) {
283 next if $scheme ne "https" && exists $v->{secure};
284 push @cookie, "$k=$v->{value}";
285 }
286 }
287 }
288
289 $hdr{cookie} = join "; ", @cookie 570 $hdr{cookie} = join "; ", @$cookies
290 if @cookie; 571 if @$cookies;
291 } 572 }
292 573
293 my ($rhost, $rport, $rpath); # request host, port, path 574 my ($rhost, $rport, $rscheme, $rpath); # request host, port, path
294 575
295 if ($proxy) { 576 if ($proxy) {
296 ($rhost, $rport, $scheme) = @$proxy; 577 ($rpath, $rhost, $rport, $rscheme) = ($url, @$proxy);
297 $rpath = $url; 578
579 $rscheme = "http" unless defined $rscheme;
580
581 # don't support https requests over https-proxy transport,
582 # can't be done with tls as spec'ed, unless you double-encrypt.
583 $rscheme = "http" if $uscheme eq "https" && $rscheme eq "https";
298 } else { 584 } else {
299 ($rhost, $rport, $rpath) = ($uhost, $uport, $upath); 585 ($rhost, $rport, $rscheme, $rpath) = ($uhost, $uport, $uscheme, $upath);
300 $hdr{host} = $uhost;
301 } 586 }
302 587
588 # leave out fragment and query string, just a heuristic
589 $hdr{referer} = "$uscheme://$uauthority$upath" unless exists $hdr{referer};
590 $hdr{"user-agent"} = $USERAGENT unless exists $hdr{"user-agent"};
591
303 $hdr{"content-length"} = length $arg{body}; 592 $hdr{"content-length"} = length $arg{body}
593 if length $arg{body} || $method ne "GET";
594
595 $hdr{connection} = "close TE"; #1.1
596 $hdr{te} = "trailers" unless exists $hdr{te}; #1.1
304 597
305 my %state = (connect_guard => 1); 598 my %state = (connect_guard => 1);
306 599
307 _get_slot $uhost, sub { 600 _get_slot $uhost, sub {
308 $state{slot_guard} = shift; 601 $state{slot_guard} = shift;
309 602
310 return unless $state{connect_guard}; 603 return unless $state{connect_guard};
311 604
312 $state{connect_guard} = AnyEvent::Socket::tcp_connect $rhost, $rport, sub { 605 my $connect_cb = sub {
313 $state{fh} = shift 606 $state{fh} = shift
607 or do {
608 my $err = "$!";
609 %state = ();
314 or return $cb->(undef, { Status => 599, Reason => "$!", URL => $url }); 610 return $cb->(undef, { @pseudo, Status => 599, Reason => $err });
611 };
315 612
316 delete $state{connect_guard}; # reduce memory usage, save a tree 613 return unless delete $state{connect_guard};
317 614
318 # get handle 615 # get handle
319 $state{handle} = new AnyEvent::Handle 616 $state{handle} = new AnyEvent::Handle
320 fh => $state{fh}, 617 fh => $state{fh},
321 ($scheme eq "https" ? (tls => "connect") : ()); 618 peername => $rhost,
619 tls_ctx => $arg{tls_ctx},
620 # these need to be reconfigured on keepalive handles
621 timeout => $timeout,
622 on_error => sub {
623 %state = ();
624 $cb->(undef, { @pseudo, Status => 599, Reason => $_[2] });
625 },
626 on_eof => sub {
627 %state = ();
628 $cb->(undef, { @pseudo, Status => 599, Reason => "Unexpected end-of-file" });
629 },
630 ;
322 631
323 # limit the number of persistent connections 632 # limit the number of persistent connections
633 # keepalive not yet supported
324 if ($KA_COUNT{$_[1]} < $MAX_PERSISTENT_PER_HOST) { 634# if ($KA_COUNT{$_[1]} < $MAX_PERSISTENT_PER_HOST) {
325 ++$KA_COUNT{$_[1]}; 635# ++$KA_COUNT{$_[1]};
326 $state{handle}{ka_count_guard} = AnyEvent::Util::guard { --$KA_COUNT{$_[1]} }; 636# $state{handle}{ka_count_guard} = AnyEvent::Util::guard {
637# --$KA_COUNT{$_[1]}
638# };
327 $hdr{connection} = "keep-alive"; 639# $hdr{connection} = "keep-alive";
328 delete $hdr{connection}; # keep-alive not yet supported
329 } else {
330 delete $hdr{connection};
331 } 640# }
332 641
333 # (re-)configure handle 642 $state{handle}->starttls ("connect") if $rscheme eq "https";
334 $state{handle}->timeout ($timeout);
335 $state{handle}->on_error (sub {
336 my $errno = "$!";
337 %state = ();
338 $cb->(undef, { Status => 599, Reason => $errno, URL => $url });
339 });
340 $state{handle}->on_eof (sub {
341 %state = ();
342 $cb->(undef, { Status => 599, Reason => "unexpected end-of-file", URL => $url });
343 });
344 643
644 # handle actual, non-tunneled, request
645 my $handle_actual_request = sub {
646 $state{handle}->starttls ("connect") if $uscheme eq "https" && !exists $state{handle}{tls};
647
345 # send request 648 # send request
346 $state{handle}->push_write ( 649 $state{handle}->push_write (
347 "$method $rpath HTTP/1.0\015\012" 650 "$method $rpath HTTP/1.1\015\012"
348 . (join "", map "$_: $hdr{$_}\015\012", keys %hdr) 651 . (join "", map "\u$_: $hdr{$_}\015\012", grep defined $hdr{$_}, keys %hdr)
349 . "\015\012" 652 . "\015\012"
350 . (delete $arg{body}) 653 . (delete $arg{body})
351 );
352
353 %hdr = (); # reduce memory usage, save a kitten
354
355 # status line
356 $state{handle}->push_read (line => qr/\015?\012/, sub {
357 $_[1] =~ /^HTTP\/([0-9\.]+) \s+ ([0-9]{3}) \s+ ([^\015\012]+)/ix
358 or return (%state = (), $cb->(undef, { Status => 599, Reason => "invalid server response ($_[1])", URL => $url }));
359
360 my %hdr = ( # response headers
361 HTTPVersion => "\x00$1",
362 Status => "\x00$2",
363 Reason => "\x00$3",
364 URL => "\x00$url"
365 ); 654 );
366 655
367 # headers, could be optimized a bit 656 # return if error occured during push_write()
368 $state{handle}->unshift_read (line => qr/\015?\012\015?\012/, sub { 657 return unless %state;
658
659 %hdr = (); # reduce memory usage, save a kitten, also make it possible to re-use
660
661 # status line and headers
662 $state{read_response} = sub {
369 for ("$_[1]\012") { 663 for ("$_[1]") {
370 # we support spaces in field names, as lotus domino 664 y/\015//d; # weed out any \015, as they show up in the weirdest of places.
371 # creates them.
372 $hdr{lc $1} .= "\x00$2"
373 while /\G
374 ([^:\000-\037]+):
375 [\011\040]*
376 ((?: [^\015\012]+ | \015?\012[\011\040] )*)
377 \015?\012
378 /gxc;
379 665
666 /^HTTP\/0*([0-9\.]+) \s+ ([0-9]{3}) (?: \s+ ([^\012]*) )? \012/gxci
667 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Invalid server response" }));
668
669 # 100 Continue handling
670 # should not happen as we don't send expect: 100-continue,
671 # but we handle it just in case.
672 # since we send the request body regardless, if we get an error
673 # we are out of-sync, which we currently do NOT handle correctly.
674 return $state{handle}->push_read (line => $qr_nlnl, $state{read_response})
675 if $2 eq 100;
676
677 push @pseudo,
678 HTTPVersion => $1,
679 Status => $2,
680 Reason => $3,
380 /\G$/ 681 ;
682
683 my $hdr = parse_hdr
381 or return (%state = (), $cb->(undef, { Status => 599, Reason => "garbled response headers", URL => $url })); 684 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Garbled response headers" }));
685
686 %hdr = (%$hdr, @pseudo);
382 } 687 }
383 688
384 substr $_, 0, 1, "" 689 # redirect handling
385 for values %hdr; 690 # microsoft and other shitheads don't give a shit for following standards,
691 # try to support some common forms of broken Location headers.
692 if ($hdr{location} !~ /^(?: $ | [^:\/?\#]+ : )/x) {
693 $hdr{location} =~ s/^\.\/+//;
386 694
387 my $finish = sub { 695 my $url = "$rscheme://$uhost:$uport";
696
697 unless ($hdr{location} =~ s/^\///) {
698 $url .= $upath;
699 $url =~ s/\/[^\/]*$//;
700 }
701
702 $hdr{location} = "$url/$hdr{location}";
703 }
704
705 my $redirect;
706
707 if ($recurse) {
708 my $status = $hdr{Status};
709
710 # industry standard is to redirect POST as GET for
711 # 301, 302 and 303, in contrast to HTTP/1.0 and 1.1.
712 # also, the UA should ask the user for 301 and 307 and POST,
713 # industry standard seems to be to simply follow.
714 # we go with the industry standard.
715 if ($status == 301 or $status == 302 or $status == 303) {
716 # HTTP/1.1 is unclear on how to mutate the method
717 $method = "GET" unless $method eq "HEAD";
718 $redirect = 1;
719 } elsif ($status == 307) {
720 $redirect = 1;
721 }
722 }
723
724 my $finish = sub { # ($data, $err_status, $err_reason[, $keepalive])
725 my $may_keep_alive = $_[3];
726
727 $state{handle}->destroy if $state{handle};
388 %state = (); 728 %state = ();
389 729
730 if (defined $_[1]) {
731 $hdr{OrigStatus} = $hdr{Status}; $hdr{Status} = $_[1];
732 $hdr{OrigReason} = $hdr{Reason}; $hdr{Reason} = $_[2];
733 }
734
390 # set-cookie processing 735 # set-cookie processing
391 if ($arg{cookie_jar} && exists $hdr{"set-cookie"}) { 736 if ($arg{cookie_jar}) {
392 for (split /\x00/, $hdr{"set-cookie"}) { 737 cookie_jar_set_cookie $arg{cookie_jar}, $hdr{"set-cookie"}, $uhost;
393 my ($cookie, @arg) = split /;\s*/; 738 }
394 my ($name, $value) = split /=/, $cookie, 2;
395 my %kv = (value => $value, map { split /=/, $_, 2 } @arg);
396
397 my $cdom = (delete $kv{domain}) || $uhost;
398 my $cpath = (delete $kv{path}) || "/";
399
400 $cdom =~ s/^.?/./; # make sure it starts with a "."
401 739
402 next if $cdom =~ /\.$/; 740 if ($redirect && exists $hdr{location}) {
403 741 # we ignore any errors, as it is very common to receive
404 # this is not rfc-like and not netscape-like. go figure. 742 # Content-Length != 0 but no actual body
405 my $ndots = $cdom =~ y/.//; 743 # we also access %hdr, as $_[1] might be an erro
406 next if $ndots < ($cdom =~ /\.[^.][^.]\.[^.][^.]$/ ? 3 : 2); 744 http_request (
407 745 $method => $hdr{location},
746 %arg,
747 recurse => $recurse - 1,
748 Redirect => [$_[0], \%hdr],
749 $cb);
750 } else {
751 $cb->($_[0], \%hdr);
752 }
753 };
754
755 my $len = $hdr{"content-length"};
756
757 if (!$redirect && $arg{on_header} && !$arg{on_header}(\%hdr)) {
758 $finish->(undef, 598 => "Request cancelled by on_header");
759 } elsif (
760 $hdr{Status} =~ /^(?:1..|204|205|304)$/
761 or $method eq "HEAD"
762 or (defined $len && !$len)
763 ) {
764 # no body
765 $finish->("", undef, undef, 1);
766 } else {
767 # body handling, many different code paths
768 # - no body expected
769 # - want_body_handle
770 # - te chunked
771 # - 2x length known (with or without on_body)
772 # - 2x length not known (with or without on_body)
773 if (!$redirect && $arg{want_body_handle}) {
774 $_[0]->on_eof (undef);
775 $_[0]->on_error (undef);
776 $_[0]->on_read (undef);
777
778 $finish->(delete $state{handle});
779
780 } elsif ($hdr{"transfer-encoding"} =~ /\bchunked\b/i) {
781 my $cl = 0;
782 my $body = undef;
783 my $on_body = $arg{on_body} || sub { $body .= shift; 1 };
784
785 $_[0]->on_error (sub { $finish->(undef, 599 => $_[2]) });
786
787 my $read_chunk; $read_chunk = sub {
788 $_[1] =~ /^([0-9a-fA-F]+)/
789 or $finish->(undef, 599 => "Garbled chunked transfer encoding");
790
791 my $len = hex $1;
792
793 if ($len) {
794 $cl += $len;
795
796 $_[0]->push_read (chunk => $len, sub {
797 $on_body->($_[1], \%hdr)
798 or return $finish->(undef, 598 => "Request cancelled by on_body");
799
800 $_[0]->push_read (line => sub {
801 length $_[1]
802 and return $finish->(undef, 599 => "Garbled chunked transfer encoding");
803 $_[0]->push_read (line => $read_chunk);
804 });
805 });
408 # store it 806 } else {
409 $arg{cookie_jar}{version} = 1; 807 $hdr{"content-length"} ||= $cl;
410 $arg{cookie_jar}{$cdom}{$cpath}{$name} = \%kv; 808
809 $_[0]->push_read (line => $qr_nlnl, sub {
810 if (length $_[1]) {
811 for ("$_[1]") {
812 y/\015//d; # weed out any \015, as they show up in the weirdest of places.
813
814 my $hdr = parse_hdr
815 or return $finish->(undef, 599 => "Garbled response trailers");
816
817 %hdr = (%hdr, %$hdr);
818 }
819 }
820
821 $finish->($body, undef, undef, 1);
822 });
823 }
824 };
825
826 $_[0]->push_read (line => $read_chunk);
827
828 } elsif ($arg{on_body}) {
829 $_[0]->on_error (sub { $finish->(undef, 599 => $_[2]) });
830
831 if ($len) {
832 $_[0]->on_read (sub {
833 $len -= length $_[0]{rbuf};
834
835 $arg{on_body}(delete $_[0]{rbuf}, \%hdr)
836 or return $finish->(undef, 598 => "Request cancelled by on_body");
837
838 $len > 0
839 or $finish->("", undef, undef, 1);
840 });
841 } else {
842 $_[0]->on_eof (sub {
843 $finish->("");
844 });
845 $_[0]->on_read (sub {
846 $arg{on_body}(delete $_[0]{rbuf}, \%hdr)
847 or $finish->(undef, 598 => "Request cancelled by on_body");
848 });
849 }
850 } else {
851 $_[0]->on_eof (undef);
852
853 if ($len) {
854 $_[0]->on_error (sub { $finish->(undef, 599 => $_[2]) });
855 $_[0]->on_read (sub {
856 $finish->((substr delete $_[0]{rbuf}, 0, $len, ""), undef, undef, 1)
857 if $len <= length $_[0]{rbuf};
858 });
859 } else {
860 $_[0]->on_error (sub {
861 ($! == Errno::EPIPE || !$!)
862 ? $finish->(delete $_[0]{rbuf})
863 : $finish->(undef, 599 => $_[2]);
864 });
865 $_[0]->on_read (sub { });
411 } 866 }
412 } 867 }
413
414 if ($_[1]{Status} =~ /^30[12]$/ && $recurse) {
415 # microsoft and other assholes don't give a shit for following standards,
416 # try to support a common form of broken Location header.
417 $_[1]{location} =~ s%^/%$scheme://$uhost:$uport/%;
418
419 http_request ($method, $_[1]{location}, %arg, recurse => $recurse - 1, $cb);
420 } else {
421 $cb->($_[0], $_[1]);
422 }
423 }; 868 }
869 };
424 870
425 if ($hdr{Status} =~ /^(?:1..|204|304)$/ or $method eq "HEAD") { 871 $state{handle}->push_read (line => $qr_nlnl, $state{read_response});
426 $finish->(undef, \%hdr); 872 };
873
874 # now handle proxy-CONNECT method
875 if ($proxy && $uscheme eq "https") {
876 # oh dear, we have to wrap it into a connect request
877
878 # maybe re-use $uauthority with patched port?
879 $state{handle}->push_write ("CONNECT $uhost:$uport HTTP/1.0\015\012Host: $uhost\015\012\015\012");
880 $state{handle}->push_read (line => $qr_nlnl, sub {
881 $_[1] =~ /^HTTP\/([0-9\.]+) \s+ ([0-9]{3}) (?: \s+ ([^\015\012]*) )?/ix
882 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Invalid proxy connect response ($_[1])" }));
883
884 if ($2 == 200) {
885 $rpath = $upath;
886 &$handle_actual_request;
427 } else { 887 } else {
428 if (exists $hdr{"content-length"}) { 888 %state = ();
429 $_[0]->unshift_read (chunk => $hdr{"content-length"}, sub { 889 $cb->(undef, { @pseudo, Status => $2, Reason => $3 });
430 # could cache persistent connection now
431 if ($hdr{connection} =~ /\bkeep-alive\b/i) {
432 # but we don't, due to misdesigns, this is annoyingly complex
433 };
434
435 $finish->($_[1], \%hdr);
436 });
437 } else {
438 # too bad, need to read until we get an error or EOF,
439 # no way to detect winged data.
440 $_[0]->on_error (sub {
441 $finish->($_[0]{rbuf}, \%hdr);
442 });
443 $_[0]->on_eof (undef);
444 $_[0]->on_read (sub { });
445 }
446 } 890 }
447 }); 891 });
892 } else {
893 &$handle_actual_request;
448 }); 894 }
449 }, sub {
450 $timeout
451 }; 895 };
896
897 my $tcp_connect = $arg{tcp_connect}
898 || do { require AnyEvent::Socket; \&AnyEvent::Socket::tcp_connect };
899
900 $state{connect_guard} = $tcp_connect->($rhost, $rport, $connect_cb, $arg{on_prepare} || sub { $timeout });
901
452 }; 902 };
453 903
454 defined wantarray && AnyEvent::Util::guard { %state = () } 904 defined wantarray && AnyEvent::Util::guard { %state = () }
455} 905}
456 906
463 unshift @_, "HEAD"; 913 unshift @_, "HEAD";
464 &http_request 914 &http_request
465} 915}
466 916
467sub http_post($$@) { 917sub http_post($$@) {
918 my $url = shift;
468 unshift @_, "POST", "body"; 919 unshift @_, "POST", $url, "body";
469 &http_request 920 &http_request
470} 921}
471 922
472=back 923=back
473 924
925=head2 DNS CACHING
926
927AnyEvent::HTTP uses the AnyEvent::Socket::tcp_connect function for
928the actual connection, which in turn uses AnyEvent::DNS to resolve
929hostnames. The latter is a simple stub resolver and does no caching
930on its own. If you want DNS caching, you currently have to provide
931your own default resolver (by storing a suitable resolver object in
932C<$AnyEvent::DNS::RESOLVER>).
933
474=head2 GLOBAL FUNCTIONS AND VARIABLES 934=head2 GLOBAL FUNCTIONS AND VARIABLES
475 935
476=over 4 936=over 4
477 937
478=item AnyEvent::HTTP::set_proxy "proxy-url" 938=item AnyEvent::HTTP::set_proxy "proxy-url"
479 939
480Sets the default proxy server to use. The proxy-url must begin with a 940Sets the default proxy server to use. The proxy-url must begin with a
481string of the form C<http://host:port> (optionally C<https:...>). 941string of the form C<http://host:port> (optionally C<https:...>), croaks
942otherwise.
943
944To clear an already-set proxy, use C<undef>.
945
946=item $date = AnyEvent::HTTP::format_date $timestamp
947
948Takes a POSIX timestamp (seconds since the epoch) and formats it as a HTTP
949Date (RFC 2616).
950
951=item $timestamp = AnyEvent::HTTP::parse_date $date
952
953Takes a HTTP Date (RFC 2616) or a Cookie date (netscape cookie spec) and
954returns the corresponding POSIX timestamp, or C<undef> if the date cannot
955be parsed.
482 956
483=item $AnyEvent::HTTP::MAX_RECURSE 957=item $AnyEvent::HTTP::MAX_RECURSE
484 958
485The default value for the C<recurse> request parameter (default: C<10>). 959The default value for the C<recurse> request parameter (default: C<10>).
486 960
487=item $AnyEvent::HTTP::USERAGENT 961=item $AnyEvent::HTTP::USERAGENT
488 962
489The default value for the C<User-Agent> header (the default is 963The default value for the C<User-Agent> header (the default is
490C<Mozilla/5.0 (compatible; AnyEvent::HTTP/$VERSION; +http://software.schmorp.de/pkg/AnyEvent)>). 964C<Mozilla/5.0 (compatible; U; AnyEvent-HTTP/$VERSION; +http://software.schmorp.de/pkg/AnyEvent)>).
491 965
492=item $AnyEvent::HTTP::MAX_PERSISTENT 966=item $AnyEvent::HTTP::MAX_PER_HOST
493 967
494The maximum number of persistent connections to keep open (default: 8). 968The maximum number of concurrent connections to the same host (identified
969by the hostname). If the limit is exceeded, then the additional requests
970are queued until previous connections are closed.
495 971
496Not implemented currently. 972The default value for this is C<4>, and it is highly advisable to not
497 973increase it.
498=item $AnyEvent::HTTP::PERSISTENT_TIMEOUT
499
500The maximum time to cache a persistent connection, in seconds (default: 2).
501
502Not implemented currently.
503 974
504=item $AnyEvent::HTTP::ACTIVE 975=item $AnyEvent::HTTP::ACTIVE
505 976
506The number of active connections. This is not the number of currently 977The number of active connections. This is not the number of currently
507running requests, but the number of currently open and non-idle TCP 978running requests, but the number of currently open and non-idle TCP
509 980
510=back 981=back
511 982
512=cut 983=cut
513 984
985our @month = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
986our @weekday = qw(Sun Mon Tue Wed Thu Fri Sat);
987
988sub format_date($) {
989 my ($time) = @_;
990
991 # RFC 822/1123 format
992 my ($S, $M, $H, $mday, $mon, $year, $wday, $yday, undef) = gmtime $time;
993
994 sprintf "%s, %02d %s %04d %02d:%02d:%02d GMT",
995 $weekday[$wday], $mday, $month[$mon], $year + 1900,
996 $H, $M, $S;
997}
998
999sub parse_date($) {
1000 my ($date) = @_;
1001
1002 my ($d, $m, $y, $H, $M, $S);
1003
1004 if ($date =~ /^[A-Z][a-z][a-z], ([0-9][0-9])[\- ]([A-Z][a-z][a-z])[\- ]([0-9][0-9][0-9][0-9]) ([0-9][0-9]):([0-9][0-9]):([0-9][0-9]) GMT$/) {
1005 # RFC 822/1123, required by RFC 2616 (with " ")
1006 # cookie dates (with "-")
1007
1008 ($d, $m, $y, $H, $M, $S) = ($1, $2, $3, $4, $5, $6);
1009
1010 } elsif ($date =~ /^[A-Z][a-z]+, ([0-9][0-9])-([A-Z][a-z][a-z])-([0-9][0-9]) ([0-9][0-9]):([0-9][0-9]):([0-9][0-9]) GMT$/) {
1011 # RFC 850
1012 ($d, $m, $y, $H, $M, $S) = ($1, $2, $3 < 69 ? $3 + 2000 : $3 + 1900, $4, $5, $6);
1013
1014 } elsif ($date =~ /^[A-Z][a-z][a-z] ([A-Z][a-z][a-z]) ([0-9 ][0-9]) ([0-9][0-9]):([0-9][0-9]):([0-9][0-9]) ([0-9][0-9][0-9][0-9])$/) {
1015 # ISO C's asctime
1016 ($d, $m, $y, $H, $M, $S) = ($2, $1, $6, $3, $4, $5);
1017 }
1018 # other formats fail in the loop below
1019
1020 for (0..11) {
1021 if ($m eq $month[$_]) {
1022 require Time::Local;
1023 return Time::Local::timegm ($S, $M, $H, $d, $_, $y);
1024 }
1025 }
1026
1027 undef
1028}
1029
514sub set_proxy($) { 1030sub set_proxy($) {
1031 if (length $_[0]) {
515 $PROXY = [$2, $3 || 3128, $1] if $_[0] =~ m%^(https?):// ([^:/]+) (?: : (\d*) )?%ix; 1032 $_[0] =~ m%^(https?):// ([^:/]+) (?: : (\d*) )?%ix
1033 or Carp::croak "$_[0]: invalid proxy URL";
1034 $PROXY = [$2, $3 || 3128, $1]
1035 } else {
1036 undef $PROXY;
1037 }
516} 1038}
517 1039
518# initialise proxy from environment 1040# initialise proxy from environment
1041eval {
519set_proxy $ENV{http_proxy}; 1042 set_proxy $ENV{http_proxy};
1043};
1044
1045=head2 SOCKS PROXIES
1046
1047Socks proxies are not directly supported by AnyEvent::HTTP. You can
1048compile your perl to support socks, or use an external program such as
1049F<socksify> (dante) or F<tsocks> to make your program use a socks proxy
1050transparently.
1051
1052Alternatively, for AnyEvent::HTTP only, you can use your own
1053C<tcp_connect> function that does the proxy handshake - here is an example
1054that works with socks4a proxies:
1055
1056 use Errno;
1057 use AnyEvent::Util;
1058 use AnyEvent::Socket;
1059 use AnyEvent::Handle;
1060
1061 # host, port and username of/for your socks4a proxy
1062 my $socks_host = "10.0.0.23";
1063 my $socks_port = 9050;
1064 my $socks_user = "";
1065
1066 sub socks4a_connect {
1067 my ($host, $port, $connect_cb, $prepare_cb) = @_;
1068
1069 my $hdl = new AnyEvent::Handle
1070 connect => [$socks_host, $socks_port],
1071 on_prepare => sub { $prepare_cb->($_[0]{fh}) },
1072 on_error => sub { $connect_cb->() },
1073 ;
1074
1075 $hdl->push_write (pack "CCnNZ*Z*", 4, 1, $port, 1, $socks_user, $host);
1076
1077 $hdl->push_read (chunk => 8, sub {
1078 my ($hdl, $chunk) = @_;
1079 my ($status, $port, $ipn) = unpack "xCna4", $chunk;
1080
1081 if ($status == 0x5a) {
1082 $connect_cb->($hdl->{fh}, (format_address $ipn) . ":$port");
1083 } else {
1084 $! = Errno::ENXIO; $connect_cb->();
1085 }
1086 });
1087
1088 $hdl
1089 }
1090
1091Use C<socks4a_connect> instead of C<tcp_connect> when doing C<http_request>s,
1092possibly after switching off other proxy types:
1093
1094 AnyEvent::HTTP::set_proxy undef; # usually you do not want other proxies
1095
1096 http_get 'http://www.google.com', tcp_connect => \&socks4a_connect, sub {
1097 my ($data, $headers) = @_;
1098 ...
1099 };
520 1100
521=head1 SEE ALSO 1101=head1 SEE ALSO
522 1102
523L<AnyEvent>. 1103L<AnyEvent>.
524 1104
525=head1 AUTHOR 1105=head1 AUTHOR
526 1106
527 Marc Lehmann <schmorp@schmorp.de> 1107 Marc Lehmann <schmorp@schmorp.de>
528 http://home.schmorp.de/ 1108 http://home.schmorp.de/
529 1109
1110With many thanks to Дмитрий Шалашов, who provided countless
1111testcases and bugreports.
1112
530=cut 1113=cut
531 1114
5321 11151
533 1116

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines