projects / m6w6 / ext-http / blob
? search:


8e27b767ab08d11ae123b9aa074120c5ec83c6c6
[m6w6/ext-http] / http_functions.c
1 /*
2 +----------------------------------------------------------------------+
3 | PECL :: http |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.0 of the PHP license, that |
6 | is bundled with this package in the file LICENSE, and is available |
7 | through the world-wide-web at http://www.php.net/license/3_0.txt. |
8 | If you did not receive a copy of the PHP license and are unable to |
9 | obtain it through the world-wide-web, please send a note to |
10 | license@php.net so we can mail you a copy immediately. |
11 +----------------------------------------------------------------------+
12 | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
13 +----------------------------------------------------------------------+
14 */
15
16 /* $Id$ */
17
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
21
22 #include "php.h"
23 #include "php_ini.h"
24 #include "ext/standard/info.h"
25 #include "ext/session/php_session.h"
26 #include "ext/standard/php_string.h"
27
28 #include "SAPI.h"
29
30 #include "phpstr/phpstr.h"
31
32 #include "php_http.h"
33 #include "php_http_std_defs.h"
34 #include "php_http_api.h"
35 #include "php_http_auth_api.h"
36 #include "php_http_request_api.h"
37 #include "php_http_cache_api.h"
38 #include "php_http_request_api.h"
39 #include "php_http_date_api.h"
40 #include "php_http_headers_api.h"
41 #include "php_http_message_api.h"
42 #include "php_http_send_api.h"
43 #include "php_http_url_api.h"
44
45 ZEND_EXTERN_MODULE_GLOBALS(http)
46
47 /* {{{ proto string http_date([int timestamp])
48 *
49 * This function returns a valid HTTP date regarding RFC 822/1123
50 * looking like: "Wed, 22 Dec 2004 11:34:47 GMT"
51 *
52 */
53 PHP_FUNCTION(http_date)
54 {
55 long t = -1;
56
57 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
58 RETURN_FALSE;
59 }
60
61 if (t == -1) {
62 t = (long) time(NULL);
63 }
64
65 RETURN_STRING(http_date(t), 0);
66 }
67 /* }}} */
68
69 /* {{{ proto string http_absolute_uri(string url[, string proto[, string host[, int port]]])
70 *
71 * This function returns an absolute URI constructed from url.
72 * If the url is already abolute but a different proto was supplied,
73 * only the proto part of the URI will be updated. If url has no
74 * path specified, the path of the current REQUEST_URI will be taken.
75 * The host will be taken either from the Host HTTP header of the client
76 * the SERVER_NAME or just localhost if prior are not available.
77 *
78 * Some examples:
79 * <pre>
80 * url = "page.php" => http://www.example.com/current/path/page.php
81 * url = "/page.php" => http://www.example.com/page.php
82 * url = "/page.php", proto = "https" => https://www.example.com/page.php
83 * </pre>
84 *
85 */
86 PHP_FUNCTION(http_absolute_uri)
87 {
88 char *url = NULL, *proto = NULL, *host = NULL;
89 int url_len = 0, proto_len = 0, host_len = 0;
90 long port = 0;
91
92 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ssl", &url, &url_len, &proto, &proto_len, &host, &host_len, &port) != SUCCESS) {
93 RETURN_FALSE;
94 }
95
96 RETURN_STRING(http_absolute_uri_ex(url, url_len, proto, proto_len, host, host_len, port), 0);
97 }
98 /* }}} */
99
100 /* {{{ proto string http_negotiate_language(array supported[, string default = 'en-US'])
101 *
102 * This function negotiates the clients preferred language based on its
103 * Accept-Language HTTP header. It returns the negotiated language or
104 * the default language if none match.
105 *
106 * The qualifier is recognized and languages without qualifier are rated highest.
107 *
108 * The supported parameter is expected to be an array having
109 * the supported languages as array values.
110 *
111 * Example:
112 * <pre>
113 * <?php
114 * $langs = array(
115 * 'en-US',// default
116 * 'fr',
117 * 'fr-FR',
118 * 'de',
119 * 'de-DE',
120 * 'de-AT',
121 * 'de-CH',
122 * );
123 * include './langs/'. http_negotiate_language($langs) .'.php';
124 * ?>
125 * </pre>
126 *
127 */
128 PHP_FUNCTION(http_negotiate_language)
129 {
130 zval *supported;
131 char *def = NULL;
132 int def_len = 0;
133
134 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|s", &supported, &def, &def_len) != SUCCESS) {
135 RETURN_FALSE;
136 }
137
138 if (!def) {
139 def = "en-US";
140 }
141
142 RETURN_STRING(http_negotiate_language(supported, def), 0);
143 }
144 /* }}} */
145
146 /* {{{ proto string http_negotiate_charset(array supported[, string default = 'iso-8859-1'])
147 *
148 * This function negotiates the clients preferred charset based on its
149 * Accept-Charset HTTP header. It returns the negotiated charset or
150 * the default charset if none match.
151 *
152 * The qualifier is recognized and charset without qualifier are rated highest.
153 *
154 * The supported parameter is expected to be an array having
155 * the supported charsets as array values.
156 *
157 * Example:
158 * <pre>
159 * <?php
160 * $charsets = array(
161 * 'iso-8859-1', // default
162 * 'iso-8859-2',
163 * 'iso-8859-15',
164 * 'utf-8'
165 * );
166 * $pref = http_negotiate_charset($charsets);
167 * if (!strcmp($pref, 'iso-8859-1')) {
168 * iconv_set_encoding('internal_encoding', 'iso-8859-1');
169 * iconv_set_encoding('output_encoding', $pref);
170 * ob_start('ob_iconv_handler');
171 * }
172 * ?>
173 * </pre>
174 */
175 PHP_FUNCTION(http_negotiate_charset)
176 {
177 zval *supported;
178 char *def = NULL;
179 int def_len = 0;
180
181 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|s", &supported, &def, &def_len) != SUCCESS) {
182 RETURN_FALSE;
183 }
184
185 if (!def) {
186 def = "iso-8859-1";
187 }
188
189 RETURN_STRING(http_negotiate_charset(supported, def), 0);
190 }
191 /* }}} */
192
193 /* {{{ proto bool http_send_status(int status)
194 *
195 * Send HTTP status code.
196 *
197 */
198 PHP_FUNCTION(http_send_status)
199 {
200 int status = 0;
201
202 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status) != SUCCESS) {
203 RETURN_FALSE;
204 }
205 if (status < 100 || status > 510) {
206 http_error_ex(E_WARNING, HTTP_E_HEADER, "Invalid HTTP status code (100-510): %d", status);
207 RETURN_FALSE;
208 }
209
210 RETURN_SUCCESS(http_send_status(status));
211 }
212 /* }}} */
213
214 /* {{{ proto bool http_send_last_modified([int timestamp])
215 *
216 * This converts the given timestamp to a valid HTTP date and
217 * sends it as "Last-Modified" HTTP header. If timestamp is
218 * omitted, current time is sent.
219 *
220 */
221 PHP_FUNCTION(http_send_last_modified)
222 {
223 long t = -1;
224
225 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
226 RETURN_FALSE;
227 }
228
229 if (t == -1) {
230 t = (long) time(NULL);
231 }
232
233 RETURN_SUCCESS(http_send_last_modified(t));
234 }
235 /* }}} */
236
237 /* {{{ proto bool http_send_content_type([string content_type = 'application/x-octetstream'])
238 *
239 * Sets the content type.
240 *
241 */
242 PHP_FUNCTION(http_send_content_type)
243 {
244 char *ct;
245 int ct_len = 0;
246
247 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &ct, &ct_len) != SUCCESS) {
248 RETURN_FALSE;
249 }
250
251 if (!ct_len) {
252 RETURN_SUCCESS(http_send_content_type("application/x-octetstream", lenof("application/x-octetstream")));
253 }
254 RETURN_SUCCESS(http_send_content_type(ct, ct_len));
255 }
256 /* }}} */
257
258 /* {{{ proto bool http_send_content_disposition(string filename[, bool inline = false])
259 *
260 * Set the Content Disposition. The Content-Disposition header is very useful
261 * if the data actually sent came from a file or something similar, that should
262 * be "saved" by the client/user (i.e. by browsers "Save as..." popup window).
263 *
264 */
265 PHP_FUNCTION(http_send_content_disposition)
266 {
267 char *filename;
268 int f_len;
269 zend_bool send_inline = 0;
270
271 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &f_len, &send_inline) != SUCCESS) {
272 RETURN_FALSE;
273 }
274 RETURN_SUCCESS(http_send_content_disposition(filename, f_len, send_inline));
275 }
276 /* }}} */
277
278 /* {{{ proto bool http_match_modified([int timestamp[, for_range = false]])
279 *
280 * Matches the given timestamp against the clients "If-Modified-Since" resp.
281 * "If-Unmodified-Since" HTTP headers.
282 *
283 */
284 PHP_FUNCTION(http_match_modified)
285 {
286 long t = -1;
287 zend_bool for_range = 0;
288
289 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lb", &t, &for_range) != SUCCESS) {
290 RETURN_FALSE;
291 }
292
293 // current time if not supplied (senseless though)
294 if (t == -1) {
295 t = (long) time(NULL);
296 }
297
298 if (for_range) {
299 RETURN_BOOL(http_match_last_modified("HTTP_IF_UNMODIFIED_SINCE", t));
300 }
301 RETURN_BOOL(http_match_last_modified("HTTP_IF_MODIFIED_SINCE", t));
302 }
303 /* }}} */
304
305 /* {{{ proto bool http_match_etag(string etag[, for_range = false])
306 *
307 * This matches the given ETag against the clients
308 * "If-Match" resp. "If-None-Match" HTTP headers.
309 *
310 */
311 PHP_FUNCTION(http_match_etag)
312 {
313 int etag_len;
314 char *etag;
315 zend_bool for_range = 0;
316
317 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &etag, &etag_len, &for_range) != SUCCESS) {
318 RETURN_FALSE;
319 }
320
321 if (for_range) {
322 RETURN_BOOL(http_match_etag("HTTP_IF_MATCH", etag));
323 }
324 RETURN_BOOL(http_match_etag("HTTP_IF_NONE_MATCH", etag));
325 }
326 /* }}} */
327
328 /* {{{ proto bool http_cache_last_modified([int timestamp_or_expires]])
329 *
330 * If timestamp_or_expires is greater than 0, it is handled as timestamp
331 * and will be sent as date of last modification. If it is 0 or omitted,
332 * the current time will be sent as Last-Modified date. If it's negative,
333 * it is handled as expiration time in seconds, which means that if the
334 * requested last modification date is not between the calculated timespan,
335 * the Last-Modified header is updated and the actual body will be sent.
336 *
337 */
338 PHP_FUNCTION(http_cache_last_modified)
339 {
340 long last_modified = 0, send_modified = 0, t;
341 zval *zlm;
342
343 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &last_modified) != SUCCESS) {
344 RETURN_FALSE;
345 }
346
347 t = (long) time(NULL);
348
349 /* 0 or omitted */
350 if (!last_modified) {
351 /* does the client have? (att: caching "forever") */
352 if (zlm = http_get_server_var("HTTP_IF_MODIFIED_SINCE")) {
353 last_modified = send_modified = http_parse_date(Z_STRVAL_P(zlm));
354 /* send current time */
355 } else {
356 send_modified = t;
357 }
358 /* negative value is supposed to be expiration time */
359 } else if (last_modified < 0) {
360 last_modified += t;
361 send_modified = t;
362 /* send supplied time explicitly */
363 } else {
364 send_modified = last_modified;
365 }
366
367 RETURN_SUCCESS(http_cache_last_modified(last_modified, send_modified, HTTP_DEFAULT_CACHECONTROL, lenof(HTTP_DEFAULT_CACHECONTROL)));
368 }
369 /* }}} */
370
371 /* {{{ proto bool http_cache_etag([string etag])
372 *
373 * This function attempts to cache the HTTP body based on an ETag,
374 * either supplied or generated through calculation of the MD5
375 * checksum of the output (uses output buffering).
376 *
377 * If clients "If-None-Match" header matches the supplied/calculated
378 * ETag, the body is considered cached on the clients side and
379 * a "304 Not Modified" status code is issued.
380 *
381 */
382 PHP_FUNCTION(http_cache_etag)
383 {
384 char *etag = NULL;
385 int etag_len = 0;
386
387 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &etag, &etag_len) != SUCCESS) {
388 RETURN_FALSE;
389 }
390
391 RETURN_SUCCESS(http_cache_etag(etag, etag_len, HTTP_DEFAULT_CACHECONTROL, lenof(HTTP_DEFAULT_CACHECONTROL)));
392 }
393 /* }}} */
394
395 /* {{{ proto string ob_etaghandler(string data, int mode)
396 *
397 * For use with ob_start().
398 */
399 PHP_FUNCTION(ob_etaghandler)
400 {
401 char *data;
402 int data_len;
403 long mode;
404
405 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &data, &data_len, &mode)) {
406 RETURN_FALSE;
407 }
408
409 Z_TYPE_P(return_value) = IS_STRING;
410 http_ob_etaghandler(data, data_len, &Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value), mode);
411 }
412 /* }}} */
413
414 /* {{{ proto void http_throttle(double sec[, long bytes = 2097152])
415 *
416 * Use with http_send() API.
417 *
418 * Example:
419 * <pre>
420 * <?php
421 * // ~ 20 kbyte/s
422 * # http_throttle(1, 20000);
423 * # http_throttle(0.5, 10000);
424 * # http_throttle(0.1, 2000);
425 * http_send_file('document.pdf');
426 * ?>
427 * </pre>
428 */
429 PHP_FUNCTION(http_throttle)
430 {
431 long chunk_size;
432 double interval;
433
434 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dl", &interval, &chunk_size)) {
435 return;
436 }
437
438 HTTP_G(send).throttle_delay = interval;
439 HTTP_G(send).buffer_size = chunk_size;
440 }
441 /* }}} */
442
443 /* {{{ proto void http_redirect([string url[, array params[, bool session,[ bool permanent]]]])
444 *
445 * Redirect to a given url.
446 * The supplied url will be expanded with http_absolute_uri(), the params array will
447 * be treated with http_build_query() and the session identification will be appended
448 * if session is true.
449 *
450 * Depending on permanent the redirection will be issued with a permanent
451 * ("301 Moved Permanently") or a temporary ("302 Found") redirection
452 * status code.
453 *
454 * To be RFC compliant, "Redirecting to <a>URI</a>." will be displayed,
455 * if the client doesn't redirect immediatly.
456 */
457 PHP_FUNCTION(http_redirect)
458 {
459 int url_len;
460 size_t query_len = 0;
461 zend_bool session = 0, permanent = 0;
462 zval *params = NULL;
463 char *query = NULL, *url = NULL, *URI,
464 LOC[HTTP_URI_MAXLEN + sizeof("Location: ")],
465 RED[HTTP_URI_MAXLEN * 2 + sizeof("Redirecting to <a href=\"%s?%s\">%s?%s</a>.\n")];
466
467 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sa!/bb", &url, &url_len, &params, &session, &permanent) != SUCCESS) {
468 RETURN_FALSE;
469 }
470
471 /* append session info */
472 if (session && (PS(session_status) == php_session_active)) {
473 if (!params) {
474 MAKE_STD_ZVAL(params);
475 array_init(params);
476 }
477 if (add_assoc_string(params, PS(session_name), PS(id), 1) != SUCCESS) {
478 http_error(E_WARNING, HTTP_E_ENCODE, "Could not append session information");
479 }
480 }
481
482 /* treat params array with http_build_query() */
483 if (params) {
484 if (SUCCESS != http_urlencode_hash_ex(Z_ARRVAL_P(params), 0, NULL, 0, &query, &query_len)) {
485 RETURN_FALSE;
486 }
487 }
488
489 URI = http_absolute_uri(url);
490
491 if (query_len) {
492 snprintf(LOC, HTTP_URI_MAXLEN + sizeof("Location: "), "Location: %s?%s", URI, query);
493 sprintf(RED, "Redirecting to <a href=\"%s?%s\">%s?%s</a>.\n", URI, query, URI, query);
494 efree(query);
495 } else {
496 snprintf(LOC, HTTP_URI_MAXLEN + sizeof("Location: "), "Location: %s", URI);
497 sprintf(RED, "Redirecting to <a href=\"%s\">%s</a>.\n", URI, URI);
498 }
499 efree(URI);
500
501 if ((SUCCESS == http_send_header(LOC)) && (SUCCESS == http_send_status((permanent ? 301 : 302)))) {
502 php_body_write(RED, strlen(RED) TSRMLS_CC);
503 RETURN_TRUE;
504 }
505 RETURN_FALSE;
506 }
507 /* }}} */
508
509 /* {{{ proto bool http_send_data(string data)
510 *
511 * Sends raw data with support for (multiple) range requests.
512 *
513 */
514 PHP_FUNCTION(http_send_data)
515 {
516 zval *zdata;
517
518 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zdata) != SUCCESS) {
519 RETURN_FALSE;
520 }
521
522 convert_to_string_ex(&zdata);
523 RETURN_SUCCESS(http_send_data(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)));
524 }
525 /* }}} */
526
527 /* {{{ proto bool http_send_file(string file)
528 *
529 * Sends a file with support for (multiple) range requests.
530 *
531 */
532 PHP_FUNCTION(http_send_file)
533 {
534 char *file;
535 int flen = 0;
536
537 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &flen) != SUCCESS) {
538 RETURN_FALSE;
539 }
540 if (!flen) {
541 RETURN_FALSE;
542 }
543
544 RETURN_SUCCESS(http_send_file(file));
545 }
546 /* }}} */
547
548 /* {{{ proto bool http_send_stream(resource stream)
549 *
550 * Sends an already opened stream with support for (multiple) range requests.
551 *
552 */
553 PHP_FUNCTION(http_send_stream)
554 {
555 zval *zstream;
556 php_stream *file;
557
558 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream) != SUCCESS) {
559 RETURN_FALSE;
560 }
561
562 php_stream_from_zval(file, &zstream);
563 RETURN_SUCCESS(http_send_stream(file));
564 }
565 /* }}} */
566
567 /* {{{ proto string http_chunked_decode(string encoded)
568 *
569 * This function decodes a string that was HTTP-chunked encoded.
570 * Returns false on failure.
571 */
572 PHP_FUNCTION(http_chunked_decode)
573 {
574 char *encoded = NULL, *decoded = NULL;
575 int encoded_len = 0, decoded_len = 0;
576
577 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &encoded, &encoded_len) != SUCCESS) {
578 RETURN_FALSE;
579 }
580
581 if (NULL != http_chunked_decode(encoded, encoded_len, &decoded, &decoded_len)) {
582 RETURN_STRINGL(decoded, decoded_len, 0);
583 } else {
584 RETURN_FALSE;
585 }
586 }
587 /* }}} */
588
589 /* {{{ proto array http_split_response(string http_response)
590 *
591 * This function splits an HTTP response into an array with headers and the
592 * content body. The returned array may look simliar to the following example:
593 *
594 * <pre>
595 * <?php
596 * array(
597 * 0 => array(
598 * 'Response Status' => '200 Ok',
599 * 'Content-Type' => 'text/plain',
600 * 'Content-Language' => 'en-US'
601 * ),
602 * 1 => "Hello World!"
603 * );
604 * ?>
605 * </pre>
606 */
607 PHP_FUNCTION(http_split_response)
608 {
609 char *response, *body;
610 int response_len;
611 size_t body_len;
612 zval *zheaders;
613
614 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &response, &response_len) != SUCCESS) {
615 RETURN_FALSE;
616 }
617
618 MAKE_STD_ZVAL(zheaders);
619 array_init(zheaders);
620
621 if (SUCCESS != http_split_response(response, response_len, Z_ARRVAL_P(zheaders), &body, &body_len)) {
622 http_error(E_WARNING, HTTP_E_PARSE, "Could not parse HTTP response");
623 RETURN_FALSE;
624 }
625
626 array_init(return_value);
627 add_index_zval(return_value, 0, zheaders);
628 add_index_stringl(return_value, 1, body, body_len, 0);
629 }
630 /* }}} */
631
632 /* {{{ proto array http_parse_headers(string header)
633 *
634 */
635 PHP_FUNCTION(http_parse_headers)
636 {
637 char *header;
638 int header_len;
639
640 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &header, &header_len)) {
641 RETURN_FALSE;
642 }
643
644 array_init(return_value);
645 if (SUCCESS != http_parse_headers(header, return_value)) {
646 http_error(E_WARNING, HTTP_E_PARSE, "Could not parse HTTP headers");
647 zval_dtor(return_value);
648 RETURN_FALSE;
649 }
650 }
651 /* }}}*/
652
653 /* {{{ proto array http_get_request_headers(void)
654 *
655 * Get a list of incoming HTTP headers.
656 */
657 PHP_FUNCTION(http_get_request_headers)
658 {
659 NO_ARGS;
660
661 array_init(return_value);
662 http_get_request_headers(return_value);
663 }
664 /* }}} */
665
666 /* {{{ proto bool http_match_request_header(string header, string value[, bool match_case = false])
667 *
668 * Match an incoming HTTP header.
669 */
670 PHP_FUNCTION(http_match_request_header)
671 {
672 char *header, *value;
673 int header_len, value_len;
674 zend_bool match_case = 0, result = 0;
675
676 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &header, &header_len, &value, &value_len, &match_case)) {
677 RETURN_FALSE;
678 }
679
680 RETURN_BOOL(http_match_request_header_ex(header, value, match_case));
681 }
682 /* }}} */
683
684 /* {{{ HAVE_CURL */
685 #ifdef HTTP_HAVE_CURL
686
687 /* {{{ proto string http_get(string url[, array options[, array &info]])
688 *
689 * Performs an HTTP GET request on the supplied url.
690 *
691 * The second parameter is expected to be an associative
692 * array where the following keys will be recognized:
693 * <pre>
694 * - redirect: int, whether and how many redirects to follow
695 * - unrestrictedauth: bool, whether to continue sending credentials on
696 * redirects to a different host
697 * - proxyhost: string, proxy host in "host[:port]" format
698 * - proxyport: int, use another proxy port as specified in proxyhost
699 * - proxyauth: string, proxy credentials in "user:pass" format
700 * - proxyauthtype: int, HTTP_AUTH_BASIC and/or HTTP_AUTH_NTLM
701 * - httpauth: string, http credentials in "user:pass" format
702 * - httpauthtype: int, HTTP_AUTH_BASIC, DIGEST and/or NTLM
703 * - compress: bool, whether to allow gzip/deflate content encoding
704 * (defaults to true)
705 * - port: int, use another port as specified in the url
706 * - referer: string, the referer to sends
707 * - useragent: string, the user agent to send
708 * (defaults to PECL::HTTP/version (PHP/version)))
709 * - headers: array, list of custom headers as associative array
710 * like array("header" => "value")
711 * - cookies: array, list of cookies as associative array
712 * like array("cookie" => "value")
713 * - cookiestore: string, path to a file where cookies are/will be stored
714 * - resume: int, byte offset to start the download from;
715 * if the server supports ranges
716 * - maxfilesize: int, maximum file size that should be downloaded;
717 * has no effect, if the size of the requested entity is not known
718 * - lastmodified: int, timestamp for If-(Un)Modified-Since header
719 * - timeout: int, seconds the request may take
720 * - connecttimeout: int, seconds the connect may take
721 * - onprogress: mixed, progress callback
722 * - ondebug: mixed, debug callback
723 * </pre>
724 *
725 * The optional third parameter will be filled with some additional information
726 * in form af an associative array, if supplied, like the following example:
727 * <pre>
728 * <?php
729 * array (
730 * 'effective_url' => 'http://localhost',
731 * 'response_code' => 403,
732 * 'total_time' => 0.017,
733 * 'namelookup_time' => 0.013,
734 * 'connect_time' => 0.014,
735 * 'pretransfer_time' => 0.014,
736 * 'size_upload' => 0,
737 * 'size_download' => 202,
738 * 'speed_download' => 11882,
739 * 'speed_upload' => 0,
740 * 'header_size' => 145,
741 * 'request_size' => 62,
742 * 'ssl_verifyresult' => 0,
743 * 'filetime' => -1,
744 * 'content_length_download' => 202,
745 * 'content_length_upload' => 0,
746 * 'starttransfer_time' => 0.017,
747 * 'content_type' => 'text/html; charset=iso-8859-1',
748 * 'redirect_time' => 0,
749 * 'redirect_count' => 0,
750 * 'private' => '',
751 * 'http_connectcode' => 0,
752 * 'httpauth_avail' => 0,
753 * 'proxyauth_avail' => 0,
754 * )
755 * ?>
756 * </pre>
757 */
758 PHP_FUNCTION(http_get)
759 {
760 zval *options = NULL, *info = NULL;
761 char *URL;
762 int URL_len;
763 phpstr response;
764
765 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
766 RETURN_FALSE;
767 }
768
769 if (info) {
770 zval_dtor(info);
771 array_init(info);
772 }
773
774 phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
775 if (SUCCESS == http_get(URL, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
776 RETURN_PHPSTR_VAL(response);
777 } else {
778 RETURN_FALSE;
779 }
780 }
781 /* }}} */
782
783 /* {{{ proto string http_head(string url[, array options[, array &info]])
784 *
785 * Performs an HTTP HEAD request on the suppied url.
786 * Returns the HTTP response as string.
787 * See http_get() for a full list of available options.
788 */
789 PHP_FUNCTION(http_head)
790 {
791 zval *options = NULL, *info = NULL;
792 char *URL;
793 int URL_len;
794 phpstr response;
795
796 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
797 RETURN_FALSE;
798 }
799
800 if (info) {
801 zval_dtor(info);
802 array_init(info);
803 }
804
805 phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
806 if (SUCCESS == http_head(URL, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
807 RETURN_PHPSTR_VAL(response);
808 } else {
809 RETURN_FALSE;
810 }
811 }
812 /* }}} */
813
814 /* {{{ proto string http_post_data(string url, string data[, array options[, &info]])
815 *
816 * Performs an HTTP POST request, posting data.
817 * Returns the HTTP response as string.
818 * See http_get() for a full list of available options.
819 */
820 PHP_FUNCTION(http_post_data)
821 {
822 zval *options = NULL, *info = NULL;
823 char *URL, *postdata;
824 int postdata_len, URL_len;
825 phpstr response;
826 http_request_body body;
827
828 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &postdata, &postdata_len, &options, &info) != SUCCESS) {
829 RETURN_FALSE;
830 }
831
832 if (info) {
833 zval_dtor(info);
834 array_init(info);
835 }
836
837 body.type = HTTP_REQUEST_BODY_CSTRING;
838 body.data = postdata;
839 body.size = postdata_len;
840
841 phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
842 if (SUCCESS == http_post(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
843 RETVAL_PHPSTR_VAL(response);
844 } else {
845 RETVAL_FALSE;
846 }
847 }
848 /* }}} */
849
850 /* {{{ proto string http_post_fields(string url, array data[, array files[, array options[, array &info]]])
851 *
852 * Performs an HTTP POST request, posting www-form-urlencoded array data.
853 * Returns the HTTP response as string.
854 * See http_get() for a full list of available options.
855 */
856 PHP_FUNCTION(http_post_fields)
857 {
858 zval *options = NULL, *info = NULL, *fields, *files = NULL;
859 char *URL;
860 int URL_len;
861 phpstr response;
862 http_request_body body;
863
864 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|aa/!z", &URL, &URL_len, &fields, &files, &options, &info) != SUCCESS) {
865 RETURN_FALSE;
866 }
867
868 if (SUCCESS != http_request_body_fill(&body, Z_ARRVAL_P(fields), files ? Z_ARRVAL_P(files) : NULL)) {
869 RETURN_FALSE;
870 }
871
872 if (info) {
873 zval_dtor(info);
874 array_init(info);
875 }
876
877 phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
878 if (SUCCESS == http_post(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
879 RETVAL_PHPSTR_VAL(response);
880 } else {
881 RETVAL_FALSE;
882 }
883 http_request_body_dtor(&body);
884 }
885 /* }}} */
886
887 /* {{{ proto string http_put_file(string url, string file[, array options[, array &info]])
888 *
889 * Performs an HTTP PUT request, uploading file.
890 * Returns the HTTP response as string.
891 * See http_get() for a full list of available options.
892 */
893 PHP_FUNCTION(http_put_file)
894 {
895 char *URL, *file;
896 int URL_len, f_len;
897 zval *options = NULL, *info = NULL;
898 phpstr response;
899 php_stream *stream;
900 php_stream_statbuf ssb;
901 http_request_body body;
902
903 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &file, &f_len, &options, &info)) {
904 RETURN_FALSE;
905 }
906
907 if (!(stream = php_stream_open_wrapper(file, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL))) {
908 RETURN_FALSE;
909 }
910 if (php_stream_stat(stream, &ssb)) {
911 php_stream_close(stream);
912 RETURN_FALSE;
913 }
914
915 if (info) {
916 zval_dtor(info);
917 array_init(info);
918 }
919
920 body.type = HTTP_REQUEST_BODY_UPLOADFILE;
921 body.data = stream;
922 body.size = ssb.sb.st_size;
923
924 phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
925 if (SUCCESS == http_put(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
926 RETVAL_PHPSTR_VAL(response);
927 } else {
928 RETVAL_FALSE;
929 }
930 http_request_body_dtor(&body);
931 }
932 /* }}} */
933
934 /* {{{ proto string http_put_stream(string url, resource stream[, array options[, array &info]])
935 *
936 * Performs an HTTP PUT request, uploading stream.
937 * Returns the HTTP response as string.
938 * See http_get() for a full list of available options.
939 */
940 PHP_FUNCTION(http_put_stream)
941 {
942 zval *resource, *options = NULL, *info = NULL;
943 char *URL;
944 int URL_len;
945 phpstr response;
946 php_stream *stream;
947 php_stream_statbuf ssb;
948 http_request_body body;
949
950 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sr|a/!z", &URL, &URL_len, &resource, &options, &info)) {
951 RETURN_FALSE;
952 }
953
954 php_stream_from_zval(stream, &resource);
955 if (php_stream_stat(stream, &ssb)) {
956 RETURN_FALSE;
957 }
958
959 if (info) {
960 zval_dtor(info);
961 array_init(info);
962 }
963
964 body.type = HTTP_REQUEST_BODY_UPLOADFILE;
965 body.data = stream;
966 body.size = ssb.sb.st_size;
967
968 phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
969 if (SUCCESS == http_put(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
970 RETURN_PHPSTR_VAL(response);
971 } else {
972 RETURN_NULL();
973 }
974 }
975 /* }}} */
976
977 /* {{{ proto long http_request_method_register(string method)
978 *
979 * Register a custom request method.
980 */
981 PHP_FUNCTION(http_request_method_register)
982 {
983 char *method;
984 int *method_len;
985 unsigned long existing;
986
987 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len)) {
988 RETURN_FALSE;
989 }
990 if (existing = http_request_method_exists(1, 0, method)) {
991 RETURN_LONG((long) existing);
992 }
993
994 RETVAL_LONG((long) http_request_method_register(method));
995 }
996 /* }}} */
997
998 /* {{{ proto bool http_request_method_unregister(mixed method)
999 *
1000 * Unregister a previously registered custom request method.
1001 */
1002 PHP_FUNCTION(http_request_method_unregister)
1003 {
1004 zval *method;
1005
1006 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &method)) {
1007 RETURN_FALSE;
1008 }
1009
1010 switch (Z_TYPE_P(method))
1011 {
1012 case IS_OBJECT:
1013 convert_to_string(method);
1014 case IS_STRING:
1015 #include "zend_operators.h"
1016 if (is_numeric_string(Z_STRVAL_P(method), Z_STRLEN_P(method), NULL, NULL, 1)) {
1017 convert_to_long(method);
1018 } else {
1019 unsigned long mn;
1020 if (!(mn = http_request_method_exists(1, 0, Z_STRVAL_P(method)))) {
1021 RETURN_FALSE;
1022 }
1023 zval_dtor(method);
1024 ZVAL_LONG(method, (long)mn);
1025 }
1026 case IS_LONG:
1027 RETURN_SUCCESS(http_request_method_unregister(Z_LVAL_P(method)));
1028 default:
1029 RETURN_FALSE;
1030 }
1031 }
1032 /* }}} */
1033
1034 /* {{{ proto long http_request_method_exists(mixed method)
1035 *
1036 * Check if a request method is registered (or available by default).
1037 */
1038 PHP_FUNCTION(http_request_method_exists)
1039 {
1040 IF_RETVAL_USED {
1041 zval *method;
1042
1043 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &method)) {
1044 RETURN_FALSE;
1045 }
1046
1047 switch (Z_TYPE_P(method))
1048 {
1049 case IS_OBJECT:
1050 convert_to_string(method);
1051 case IS_STRING:
1052 if (is_numeric_string(Z_STRVAL_P(method), Z_STRLEN_P(method), NULL, NULL, 1)) {
1053 convert_to_long(method);
1054 } else {
1055 RETURN_LONG((long) http_request_method_exists(1, 0, Z_STRVAL_P(method)));
1056 }
1057 case IS_LONG:
1058 RETURN_LONG((long) http_request_method_exists(0, Z_LVAL_P(method), NULL));
1059 default:
1060 RETURN_FALSE;
1061 }
1062 }
1063 }
1064 /* }}} */
1065
1066 /* {{{ proto string http_request_method_name(long method)
1067 *
1068 * Get the literal string representation of a standard or registered request method.
1069 */
1070 PHP_FUNCTION(http_request_method_name)
1071 {
1072 IF_RETVAL_USED {
1073 long method;
1074
1075 if ((SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &method)) || (method < 0)) {
1076 RETURN_FALSE;
1077 }
1078
1079 RETURN_STRING(estrdup(http_request_method_name((unsigned long) method)), 0);
1080 }
1081 }
1082 /* }}} */
1083 #endif
1084 /* }}} HAVE_CURL */
1085
1086
1087 /* {{{ proto bool http_auth_basic(string user, string pass[, string realm = "Restricted"])
1088 *
1089 * Example:
1090 * <pre>
1091 * <?php
1092 * if (!http_auth_basic('mike', 's3c|r3t')) {
1093 * die('<h1>Authorization failed!</h1>');
1094 * }
1095 * ?>
1096 * </pre>
1097 */
1098 PHP_FUNCTION(http_auth_basic)
1099 {
1100 char *realm = NULL, *user, *pass, *suser, *spass;
1101 int r_len, u_len, p_len;
1102
1103 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &user, &u_len, &pass, &p_len, &realm, &r_len) != SUCCESS) {
1104 RETURN_FALSE;
1105 }
1106
1107 if (!realm) {
1108 realm = "Restricted";
1109 }
1110
1111 if (SUCCESS != http_auth_basic_credentials(&suser, &spass)) {
1112 http_auth_basic_header(realm);
1113 RETURN_FALSE;
1114 }
1115
1116 if (strcasecmp(suser, user)) {
1117 http_auth_basic_header(realm);
1118 RETURN_FALSE;
1119 }
1120
1121 if (strcmp(spass, pass)) {
1122 http_auth_basic_header(realm);
1123 RETURN_FALSE;
1124 }
1125
1126 RETURN_TRUE;
1127 }
1128 /* }}} */
1129
1130 /* {{{ proto bool http_auth_basic_cb(mixed callback[, string realm = "Restricted"])
1131 *
1132 * Example:
1133 * <pre>
1134 * <?php
1135 * function auth_cb($user, $pass)
1136 * {
1137 * global $db;
1138 * $query = 'SELECT pass FROM users WHERE user='. $db->quoteSmart($user);
1139 * if (strlen($realpass = $db->getOne($query)) {
1140 * return $pass === $realpass;
1141 * }
1142 * return false;
1143 * }
1144 * if (!http_auth_basic_cb('auth_cb')) {
1145 * die('<h1>Authorization failed</h1>');
1146 * }
1147 * ?>
1148 * </pre>
1149 */
1150 PHP_FUNCTION(http_auth_basic_cb)
1151 {
1152 zval *cb;
1153 char *realm = NULL, *user, *pass;
1154 int r_len;
1155
1156 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &cb, &realm, &r_len) != SUCCESS) {
1157 RETURN_FALSE;
1158 }
1159
1160 if (!realm) {
1161 realm = "Restricted";
1162 }
1163
1164 if (SUCCESS != http_auth_basic_credentials(&user, &pass)) {
1165 http_auth_basic_header(realm);
1166 RETURN_FALSE;
1167 }
1168 {
1169 zval *zparams[2] = {NULL, NULL}, retval;
1170 int result = 0;
1171
1172 MAKE_STD_ZVAL(zparams[0]);
1173 MAKE_STD_ZVAL(zparams[1]);
1174 ZVAL_STRING(zparams[0], user, 0);
1175 ZVAL_STRING(zparams[1], pass, 0);
1176
1177 if (SUCCESS == call_user_function(EG(function_table), NULL, cb,
1178 &retval, 2, zparams TSRMLS_CC)) {
1179 result = Z_LVAL(retval);
1180 }
1181
1182 efree(user);
1183 efree(pass);
1184 efree(zparams[0]);
1185 efree(zparams[1]);
1186
1187 if (!result) {
1188 http_auth_basic_header(realm);
1189 }
1190
1191 RETURN_BOOL(result);
1192 }
1193 }
1194 /* }}}*/
1195
1196 /* {{{ Sara Golemons http_build_query() */
1197 #ifndef ZEND_ENGINE_2
1198
1199 /* {{{ proto string http_build_query(mixed formdata [, string prefix[, string arg_separator]])
1200 Generates a form-encoded query string from an associative array or object. */
1201 PHP_FUNCTION(http_build_query)
1202 {
1203 zval *formdata;
1204 char *prefix = NULL, *arg_sep = INI_STR("arg_separator.output");
1205 int prefix_len = 0, arg_sep_len = strlen(arg_sep);
1206 phpstr *formstr;
1207
1208 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ss", &formdata, &prefix, &prefix_len, &arg_sep, &arg_sep_len) != SUCCESS) {
1209 RETURN_FALSE;
1210 }
1211
1212 if (Z_TYPE_P(formdata) != IS_ARRAY && Z_TYPE_P(formdata) != IS_OBJECT) {
1213 http_error(E_WARNING, HTTP_E_PARAM, "Parameter 1 expected to be Array or Object. Incorrect value given.");
1214 RETURN_FALSE;
1215 }
1216
1217 if (!arg_sep_len) {
1218 arg_sep = HTTP_URL_ARGSEP;
1219 }
1220
1221 formstr = phpstr_new();
1222 if (SUCCESS != http_urlencode_hash_implementation_ex(HASH_OF(formdata), formstr, arg_sep, prefix, prefix_len, NULL, 0, NULL, 0, (Z_TYPE_P(formdata) == IS_OBJECT ? formdata : NULL))) {
1223 phpstr_free(formstr);
1224 RETURN_FALSE;
1225 }
1226
1227 if (!formstr->used) {
1228 phpstr_free(formstr);
1229 RETURN_NULL();
1230 }
1231
1232 RETURN_PHPSTR_PTR(formstr);
1233 }
1234 /* }}} */
1235 #endif /* !ZEND_ENGINE_2 */
1236 /* }}} */
1237
1238 PHP_FUNCTION(http_test)
1239 {
1240 RETURN_NULL();
1241 }
1242
1243 /*
1244 * Local variables:
1245 * tab-width: 4
1246 * c-basic-offset: 4
1247 * End:
1248 * vim600: noet sw=4 ts=4 fdm=marker
1249 * vim<600: noet sw=4 ts=4
1250 */
Extended HTTP Support