git.m6w6.name Git - m6w6/ext-http/blob - http_send_api.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 #include "php.h"
  22
  23 #include "SAPI.h"
  24 #include "php_streams.h"
  25 #include "ext/standard/php_lcg.h"
  26
  27 #include "php_http.h"
  28 #include "php_http_std_defs.h"
  29 #include "php_http_api.h"
  30 #include "php_http_date_api.h"
  31 #include "php_http_send_api.h"
  32 #include "php_http_headers_api.h"
  33 #include "php_http_date_api.h"
  34 #include "php_http_cache_api.h"
  35
  36 ZEND_EXTERN_MODULE_GLOBALS(http);
  37
  38 #define http_flush() _http_flush(TSRMLS_C)
  39 /* {{{ static inline void http_flush() */
  40 static inline void _http_flush(TSRMLS_D)
  41 {
  42         php_end_ob_buffer(1, 1 TSRMLS_CC);
  43         sapi_flush(TSRMLS_C);
  44 }
  45 /* }}} */
  46
  47 #define http_sleep() _http_sleep(TSRMLS_C)
  48 /* {{{ static inline void http_sleep() */
  49 static inline void _http_sleep(TSRMLS_D)
  50 {
  51 #define HTTP_MSEC(s) (s * 1000)
  52 #define HTTP_USEC(s) (HTTP_MSEC(s) * 1000)
  53 #define HTTP_NSEC(s) (HTTP_USEC(s) * 1000)
  54 #define HTTP_NANOSEC (1000 * 1000 * 1000)
  55 #define HTTP_DIFFSEC (0.001)
  56
  57         if (HTTP_G(send).throttle_delay >= HTTP_DIFFSEC) {
  58 #if defined(PHP_WIN32)
  59                 Sleep((DWORD) HTTP_MSEC(HTTP_G(send).throttle_delay));
  60 #elif defined(HAVE_USLEEP)
  61                 usleep(HTTP_USEC(HTTP_G(send).throttle_delay));
  62 #elif defined(HAVE_NANOSLEEP)
  63                 struct timespec req, rem;
  64
  65                 req.tv_sec = (time_t) HTTP_G(send).throttle_delay;
  66                 req.tv_nsec = HTTP_NSEC(HTTP_G(send).throttle_delay) % HTTP_NANOSEC;
  67
  68                 while (nanosleep(&req, &rem) && (errno == EINTR) && (HTTP_NSEC(rem.tv_sec) + rem.tv_nsec) > HTTP_NSEC(HTTP_DIFFSEC))) {
  69                         req.tv_sec = rem.tv_sec;
  70                         req.tv_nsec = rem.tv_nsec;
  71                 }
  72 #endif
  73         }
  74 }
  75 /* }}} */
  76
  77 #define HTTP_CHUNK_AVAIL(len) ((len -= HTTP_G(send).buffer_size) >= 0)
  78 #define HTTP_CHUNK_WRITE(data, l, dofree, dosleep) \
  79         { \
  80                 long size = (long) l; \
  81  \
  82                 if ((1 > size) || (size - PHPWRITE(data, size))) { \
  83                         if (dofree) { \
  84                                 efree(data); \
  85                         } \
  86                         return FAILURE; \
  87                 } \
  88  \
  89                 http_flush(); \
  90                 if (dosleep) { \
  91                         http_sleep(); \
  92                 } \
  93         }
  94
  95 #define http_send_chunk(d, b, e, m) _http_send_chunk((d), (b), (e), (m) TSRMLS_CC)
  96 /* {{{ static STATUS http_send_chunk(const void *, size_t, size_t, http_send_mode) */
  97 static STATUS _http_send_chunk(const void *data, size_t begin, size_t end, http_send_mode mode TSRMLS_DC)
  98 {
  99         long len = end - begin;
 100
 101         switch (mode)
 102         {
 103                 case SEND_RSRC:
 104                 {
 105                         char *buf;
 106                         php_stream *s = (php_stream *) data;
 107
 108                         if (php_stream_seek(s, begin, SEEK_SET)) {
 109                                 return FAILURE;
 110                         }
 111
 112                         buf = emalloc(HTTP_G(send).buffer_size);
 113
 114                         while (HTTP_CHUNK_AVAIL(len)) {
 115                                 HTTP_CHUNK_WRITE(buf, php_stream_read(s, buf, HTTP_G(send).buffer_size), 1, 1);
 116                         }
 117
 118                         /* read & write left over */
 119                         if (len) {
 120                                 HTTP_CHUNK_WRITE(buf, php_stream_read(s, buf, HTTP_G(send).buffer_size + len), 1, 0);
 121                         }
 122
 123                         efree(buf);
 124                         return SUCCESS;
 125                 }
 126
 127                 case SEND_DATA:
 128                 {
 129                         char *s = (char *) data + begin;
 130
 131                         while (HTTP_CHUNK_AVAIL(len)) {
 132                                 HTTP_CHUNK_WRITE(s, HTTP_G(send).buffer_size, 0, 1);
 133                                 s += HTTP_G(send).buffer_size;
 134                         }
 135
 136                         /* write left over */
 137                         if (len) {
 138                                 HTTP_CHUNK_WRITE(s, HTTP_G(send).buffer_size + len, 0, 0);
 139                         }
 140
 141                         return SUCCESS;
 142                 }
 143
 144                 default:
 145                         return FAILURE;
 146                 break;
 147         }
 148 }
 149 /* }}} */
 150
 151 /* {{{ STATUS http_send_header(char *, char *, zend_bool) */
 152 PHP_HTTP_API STATUS _http_send_header_ex(const char *name, size_t name_len, const char *value, size_t value_len, zend_bool replace, char **sent_header TSRMLS_DC)
 153 {
 154         STATUS ret;
 155         size_t header_len = sizeof(": ") + name_len + value_len + 1;
 156         char *header = emalloc(header_len + 1);
 157
 158         header[header_len] = '\0';
 159         snprintf(header, header_len, "%s: %s", name, value);
 160         ret = http_send_header_string_ex(header, replace);
 161         if (sent_header) {
 162                 *sent_header = header;
 163         } else {
 164                 efree(header);
 165         }
 166         return ret;
 167 }
 168 /* }}} */
 169
 170 /* {{{ STATUS http_send_status_header(int, char *) */
 171 PHP_HTTP_API STATUS _http_send_status_header_ex(int status, const char *header, zend_bool replace TSRMLS_DC)
 172 {
 173         STATUS ret;
 174         sapi_header_line h = {(char *) header, header ? strlen(header) : 0, status};
 175         if (SUCCESS != (ret = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD, &h TSRMLS_CC))) {
 176                 http_error_ex(HE_WARNING, HTTP_E_HEADER, "Could not send header: %s (%d)", header, status);
 177         }
 178         return ret;
 179 }
 180 /* }}} */
 181
 182 /* {{{ STATUS http_send_last_modified(int) */
 183 PHP_HTTP_API STATUS _http_send_last_modified_ex(time_t t, char **sent_header TSRMLS_DC)
 184 {
 185         STATUS ret;
 186         char *date = http_date(t);
 187
 188         if (!date) {
 189                 return FAILURE;
 190         }
 191
 192         ret = http_send_header_ex("Last-Modified", lenof("Last-Modified"), date, strlen(date), 1, sent_header);
 193         efree(date);
 194
 195         /* remember */
 196         HTTP_G(send).last_modified = t;
 197
 198         return ret;
 199 }
 200 /* }}} */
 201
 202 /* {{{ STATUS http_send_etag(char *, size_t) */
 203 PHP_HTTP_API STATUS _http_send_etag_ex(const char *etag, size_t etag_len, char **sent_header TSRMLS_DC)
 204 {
 205         STATUS status;
 206         char *etag_header;
 207
 208         if (!etag_len){
 209                 http_error_ex(HE_WARNING, HTTP_E_HEADER, "Attempt to send empty ETag (previous: %s)\n", HTTP_G(send).unquoted_etag);
 210                 return FAILURE;
 211         }
 212
 213         /* remember */
 214         STR_FREE(HTTP_G(send).unquoted_etag);
 215         HTTP_G(send).unquoted_etag = estrdup(etag);
 216
 217         etag_header = ecalloc(1, sizeof("ETag: \"\"") + etag_len);
 218         sprintf(etag_header, "ETag: \"%s\"", etag);
 219         status = http_send_header_string(etag_header);
 220
 221         if (sent_header) {
 222                 *sent_header = etag_header;
 223         } else {
 224                 efree(etag_header);
 225         }
 226
 227         return status;
 228 }
 229 /* }}} */
 230
 231 /* {{{ STATUS http_send_content_type(char *, size_t) */
 232 PHP_HTTP_API STATUS _http_send_content_type(const char *content_type, size_t ct_len TSRMLS_DC)
 233 {
 234         if (!strchr(content_type, '/')) {
 235                 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Content-Type '%s' doesn't seem to consist of a primary and a secondary part", content_type);
 236                 return FAILURE;
 237         }
 238
 239         /* remember for multiple ranges */
 240         STR_FREE(HTTP_G(send).content_type);
 241         HTTP_G(send).content_type = estrndup(content_type, ct_len);
 242
 243         return http_send_header_ex("Content-Type", lenof("Content-Type"), content_type, ct_len, 1, NULL);
 244 }
 245 /* }}} */
 246
 247 /* {{{ STATUS http_send_content_disposition(char *, size_t, zend_bool) */
 248 PHP_HTTP_API STATUS _http_send_content_disposition(const char *filename, size_t f_len, zend_bool send_inline TSRMLS_DC)
 249 {
 250         STATUS status;
 251         char *cd_header;
 252
 253         if (send_inline) {
 254                 cd_header = ecalloc(1, sizeof("Content-Disposition: inline; filename=\"\"") + f_len);
 255                 sprintf(cd_header, "Content-Disposition: inline; filename=\"%s\"", filename);
 256         } else {
 257                 cd_header = ecalloc(1, sizeof("Content-Disposition: attachment; filename=\"\"") + f_len);
 258                 sprintf(cd_header, "Content-Disposition: attachment; filename=\"%s\"", filename);
 259         }
 260
 261         status = http_send_header_string(cd_header);
 262         efree(cd_header);
 263         return status;
 264 }
 265 /* }}} */
 266
 267 /* {{{ STATUS http_send_ranges(HashTable *, void *, size_t, http_send_mode) */
 268 PHP_HTTP_API STATUS _http_send_ranges(HashTable *ranges, const void *data, size_t size, http_send_mode mode TSRMLS_DC)
 269 {
 270         zval **zbegin, **zend, **zrange;
 271
 272         /* single range */
 273         if (zend_hash_num_elements(ranges) == 1) {
 274                 char range_header[256] = {0};
 275
 276                 if (SUCCESS != zend_hash_index_find(ranges, 0, (void **) &zrange) ||
 277                         SUCCESS != zend_hash_index_find(Z_ARRVAL_PP(zrange), 0, (void **) &zbegin) ||
 278                         SUCCESS != zend_hash_index_find(Z_ARRVAL_PP(zrange), 1, (void **) &zend)) {
 279                         http_send_status(500);
 280                         return FAILURE;
 281                 }
 282
 283                 /* Send HTTP 206 Partial Content */
 284                 http_send_status(206);
 285
 286                 /* send content range header */
 287                 snprintf(range_header, 255, "Content-Range: bytes %ld-%ld/%lu", Z_LVAL_PP(zbegin), Z_LVAL_PP(zend), (ulong) size);
 288                 http_send_header_string(range_header);
 289
 290                 /* send requested chunk */
 291                 return http_send_chunk(data, Z_LVAL_PP(zbegin), Z_LVAL_PP(zend) + 1, mode);
 292         }
 293
 294         /* multi range */
 295         else {
 296                 size_t preface_len;
 297                 char bound[23] = {0}, preface[1024] = {0},
 298                         multi_header[68] = "Content-Type: multipart/byteranges; boundary=";
 299
 300                 /* Send HTTP 206 Partial Content */
 301                 http_send_status(206);
 302
 303                 /* send multipart/byteranges header */
 304                 snprintf(bound, 22, "--%lu%0.9f", (ulong) time(NULL), php_combined_lcg(TSRMLS_C));
 305                 strncat(multi_header, bound + 2, 21);
 306                 http_send_header_string(multi_header);
 307
 308                 /* send each requested chunk */
 309                 FOREACH_HASH_VAL(ranges, zrange) {
 310                         if (SUCCESS != zend_hash_index_find(Z_ARRVAL_PP(zrange), 0, (void **) &zbegin) ||
 311                                 SUCCESS != zend_hash_index_find(Z_ARRVAL_PP(zrange), 1, (void **) &zend)) {
 312                                 break;
 313                         }
 314
 315                         preface_len = snprintf(preface, 1023,
 316                                 HTTP_CRLF "%s"
 317                                 HTTP_CRLF "Content-Type: %s"
 318                                 HTTP_CRLF "Content-Range: bytes %ld-%ld/%lu"
 319                                 HTTP_CRLF
 320                                 HTTP_CRLF,
 321
 322                                 bound,
 323                                 HTTP_G(send).content_type ? HTTP_G(send).content_type : "application/x-octetstream",
 324                                 Z_LVAL_PP(zbegin),
 325                                 Z_LVAL_PP(zend),
 326                                 (ulong) size
 327                         );
 328
 329                         PHPWRITE(preface, preface_len);
 330                         http_send_chunk(data, Z_LVAL_PP(zbegin), Z_LVAL_PP(zend) + 1, mode);
 331                 }
 332
 333                 /* write boundary once more */
 334                 PHPWRITE(HTTP_CRLF, lenof(HTTP_CRLF));
 335                 PHPWRITE(bound, strlen(bound));
 336                 PHPWRITE("--", lenof("--"));
 337
 338                 return SUCCESS;
 339         }
 340 }
 341 /* }}} */
 342
 343 /* {{{ STATUS http_send(void *, size_t, http_send_mode) */
 344 PHP_HTTP_API STATUS _http_send_ex(const void *data_ptr, size_t data_size, http_send_mode data_mode, zend_bool no_cache TSRMLS_DC)
 345 {
 346         HashTable ranges;
 347         http_range_status range_status;
 348         int cache_etag = 0;
 349
 350         if (!data_ptr) {
 351                 return FAILURE;
 352         }
 353         if (!data_size) {
 354                 return SUCCESS;
 355         }
 356
 357         /* stop on-the-fly etag generation */
 358         if (cache_etag = HTTP_G(etag).started) {
 359                 /* interrupt ob_etaghandler */
 360                 HTTP_G(etag).started = 0;
 361         }
 362
 363         /* enable partial dl and resume */
 364         http_send_header_string("Accept-Ranges: bytes");
 365
 366         zend_hash_init(&ranges, 0, NULL, ZVAL_PTR_DTOR, 0);
 367         range_status = http_get_request_ranges(&ranges, data_size);
 368
 369         if (range_status == RANGE_ERR) {
 370                 zend_hash_destroy(&ranges);
 371                 http_send_status(416);
 372                 return FAILURE;
 373         }
 374
 375         /* Range Request - only send ranges if entity hasn't changed */
 376         if (    range_status == RANGE_OK &&
 377                         http_match_etag_ex("HTTP_IF_MATCH", HTTP_G(send).unquoted_etag, 0) &&
 378                         http_match_last_modified_ex("HTTP_IF_UNMODIFIED_SINCE", HTTP_G(send).last_modified, 0) &&
 379                         http_match_last_modified_ex("HTTP_UNLESS_MODIFIED_SINCE", HTTP_G(send).last_modified, 0)) {
 380                 STATUS result = http_send_ranges(&ranges, data_ptr, data_size, data_mode);
 381                 zend_hash_destroy(&ranges);
 382                 return result;
 383         }
 384
 385         zend_hash_destroy(&ranges);
 386
 387         /* send 304 Not Modified if etag matches - DON'T return on ETag generation failure */
 388         if (!no_cache && cache_etag) {
 389                 char *etag = NULL;
 390
 391                 if (!(etag = http_etag(data_ptr, data_size, data_mode))) {
 392                         http_error(HE_NOTICE, HTTP_E_RUNTIME, "Failed to generate ETag for data source");
 393                 } else {
 394                         char *sent_header = NULL;
 395
 396                         http_send_etag_ex(etag, 32, &sent_header);
 397                         if (http_match_etag("HTTP_IF_NONE_MATCH", etag)) {
 398                                 return http_exit_ex(304, sent_header, NULL, 0);
 399                         } else {
 400                                 STR_FREE(sent_header);
 401                         }
 402                         efree(etag);
 403                 }
 404         }
 405
 406         /* send 304 Not Modified if last modified matches */
 407         if (!no_cache && http_match_last_modified("HTTP_IF_MODIFIED_SINCE", HTTP_G(send).last_modified)) {
 408                 char *sent_header = NULL;
 409                 http_send_last_modified_ex(HTTP_G(send).last_modified, &sent_header);
 410                 return http_exit_ex(304, sent_header, NULL, 0);
 411         }
 412
 413         /* emit a content-length header */
 414         if (!php_ob_handler_used("ob_gzhandler" TSRMLS_CC)) {
 415                 char *cl;
 416                 spprintf(&cl, 0, "Content-Length: %lu", (unsigned long) data_size);
 417                 http_send_header_string(cl);
 418                 efree(cl);
 419         }
 420         /* send full entity */
 421         return http_send_chunk(data_ptr, 0, data_size, data_mode);
 422 }
 423 /* }}} */
 424
 425 /* {{{ STATUS http_send_stream(php_stream *) */
 426 PHP_HTTP_API STATUS _http_send_stream_ex(php_stream *file, zend_bool close_stream, zend_bool no_cache TSRMLS_DC)
 427 {
 428         STATUS status;
 429         php_stream_statbuf ssb;
 430
 431         if ((!file) || php_stream_stat(file, &ssb)) {
 432                 return FAILURE;
 433         }
 434
 435         status = http_send_ex(file, ssb.sb.st_size, SEND_RSRC, no_cache);
 436
 437         if (close_stream) {
 438                 php_stream_close(file);
 439         }
 440
 441         return status;
 442 }
 443 /* }}} */
 444
 445 /*
 446  * Local variables:
 447  * tab-width: 4
 448  * c-basic-offset: 4
 449  * End:
 450  * vim600: sw=4 ts=4 fdm=marker
 451  * vim<600: sw=4 ts=4
 452  */
 453