git.m6w6.name Git - m6w6/ext-http/blob - http_api.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: http                                                       |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2004-2010, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 /* $Id$ */
  14
  15 #define HTTP_WANT_SAPI
  16 #include "php_http.h"
  17
  18 #include "php_output.h"
  19 #include "ext/standard/url.h"
  20 #include "ext/standard/php_lcg.h"
  21
  22 #include "php_http_api.h"
  23 #include "php_http_send_api.h"
  24
  25 #ifdef ZEND_ENGINE_2
  26 #       include "php_http_exception_object.h"
  27 #endif
  28
  29 PHP_MINIT_FUNCTION(http_support)
  30 {
  31         HTTP_LONG_CONSTANT("HTTP_SUPPORT", HTTP_SUPPORT);
  32         HTTP_LONG_CONSTANT("HTTP_SUPPORT_REQUESTS", HTTP_SUPPORT_REQUESTS);
  33         HTTP_LONG_CONSTANT("HTTP_SUPPORT_MAGICMIME", HTTP_SUPPORT_MAGICMIME);
  34         HTTP_LONG_CONSTANT("HTTP_SUPPORT_ENCODINGS", HTTP_SUPPORT_ENCODINGS);
  35         HTTP_LONG_CONSTANT("HTTP_SUPPORT_SSLREQUESTS", HTTP_SUPPORT_SSLREQUESTS);
  36         HTTP_LONG_CONSTANT("HTTP_SUPPORT_EVENTS", HTTP_SUPPORT_EVENTS);
  37
  38         HTTP_LONG_CONSTANT("HTTP_PARAMS_ALLOW_COMMA", HTTP_PARAMS_ALLOW_COMMA);
  39         HTTP_LONG_CONSTANT("HTTP_PARAMS_ALLOW_FAILURE", HTTP_PARAMS_ALLOW_FAILURE);
  40         HTTP_LONG_CONSTANT("HTTP_PARAMS_RAISE_ERROR", HTTP_PARAMS_RAISE_ERROR);
  41         HTTP_LONG_CONSTANT("HTTP_PARAMS_DEFAULT", HTTP_PARAMS_DEFAULT);
  42
  43         return SUCCESS;
  44 }
  45
  46 PHP_HTTP_API long _http_support(long feature)
  47 {
  48         long support = HTTP_SUPPORT;
  49
  50 #ifdef HTTP_HAVE_CURL
  51         support |= HTTP_SUPPORT_REQUESTS;
  52 #       ifdef HTTP_HAVE_SSL
  53         support |= HTTP_SUPPORT_SSLREQUESTS;
  54 #       endif
  55 #       ifdef HTTP_HAVE_EVENT
  56         support |= HTTP_SUPPORT_EVENTS;
  57 #       endif
  58 #endif
  59 #ifdef HTTP_HAVE_MAGIC
  60         support |= HTTP_SUPPORT_MAGICMIME;
  61 #endif
  62 #ifdef HTTP_HAVE_ZLIB
  63         support |= HTTP_SUPPORT_ENCODINGS;
  64 #endif
  65
  66         if (feature) {
  67                 return (feature == (support & feature));
  68         }
  69         return support;
  70 }
  71
  72 /* char *pretty_key(char *, size_t, zend_bool, zend_bool) */
  73 char *_http_pretty_key(char *key, size_t key_len, zend_bool uctitle, zend_bool xhyphen)
  74 {
  75         size_t i;
  76         int wasalpha;
  77
  78         if (key && key_len) {
  79                 if ((wasalpha = HTTP_IS_CTYPE(alpha, key[0]))) {
  80                         key[0] = (char) (uctitle ? HTTP_TO_CTYPE(upper, key[0]) : HTTP_TO_CTYPE(lower, key[0]));
  81                 }
  82                 for (i = 1; i < key_len; i++) {
  83                         if (HTTP_IS_CTYPE(alpha, key[i])) {
  84                                 key[i] = (char) (((!wasalpha) && uctitle) ? HTTP_TO_CTYPE(upper, key[i]) : HTTP_TO_CTYPE(lower, key[i]));
  85                                 wasalpha = 1;
  86                         } else {
  87                                 if (xhyphen && (key[i] == '_')) {
  88                                         key[i] = '-';
  89                                 }
  90                                 wasalpha = 0;
  91                         }
  92                 }
  93         }
  94         return key;
  95 }
  96 /* }}} */
  97
  98 /* {{{ http_boundary(char *, size_t) */
  99 size_t _http_boundary(char *buf, size_t buf_len TSRMLS_DC)
 100 {
 101         return snprintf(buf, buf_len, "%lu%0.9f", (ulong) HTTP_G->request.time, (float) php_combined_lcg(TSRMLS_C));
 102 }
 103 /* }}} */
 104
 105 /* {{{ void http_error(long, long, char*) */
 106 void _http_error_ex(long type TSRMLS_DC, long code, const char *format, ...)
 107 {
 108         va_list args;
 109
 110         va_start(args, format);
 111 #ifdef ZEND_ENGINE_2
 112         if ((type == E_THROW) || (GLOBAL_ERROR_HANDLING == EH_THROW)) {
 113                 char *message;
 114                 zend_class_entry *ce = http_exception_get_for_code(code);
 115
 116                 http_try {
 117                         vspprintf(&message, 0, format, args);
 118                         zend_throw_exception(ce, message, code TSRMLS_CC);
 119                         efree(message);
 120                 } http_catch(GLOBAL_EXCEPTION_CLASS ? GLOBAL_EXCEPTION_CLASS : HTTP_EX_DEF_CE);
 121         } else
 122 #endif
 123         php_verror(NULL, "", type, format, args TSRMLS_CC);
 124         va_end(args);
 125 }
 126 /* }}} */
 127
 128 #ifdef ZEND_ENGINE_2
 129 static inline void copy_bt_args(zval *from, zval *to TSRMLS_DC)
 130 {
 131         zval **args, **trace_0, *old_trace_0, *trace = NULL;
 132
 133         if ((trace = zend_read_property(ZEND_EXCEPTION_GET_DEFAULT(), from, "trace", lenof("trace"), 0 TSRMLS_CC))) {
 134                 if (Z_TYPE_P(trace) == IS_ARRAY && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(trace), 0, (void *) &trace_0)) {
 135                         old_trace_0 = *trace_0;
 136                         if (Z_TYPE_PP(trace_0) == IS_ARRAY && SUCCESS == zend_hash_find(Z_ARRVAL_PP(trace_0), "args", sizeof("args"), (void *) &args)) {
 137                                 if ((trace = zend_read_property(ZEND_EXCEPTION_GET_DEFAULT(), to, "trace", lenof("trace"), 0 TSRMLS_CC))) {
 138                                         if (Z_TYPE_P(trace) == IS_ARRAY && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(trace), 0, (void *) &trace_0)) {
 139                                                 ZVAL_ADDREF(*args);
 140                                                 add_assoc_zval(*trace_0, "args", *args);
 141                                         }
 142                                 }
 143                         }
 144                 }
 145         }
 146 }
 147
 148 /* {{{ zval *http_exception_wrap(zval *, zval *, zend_class_entry *) */
 149 zval *_http_exception_wrap(zval *old_exception, zval *new_exception, zend_class_entry *ce TSRMLS_DC)
 150 {
 151         int inner = 1;
 152         char *message;
 153         zval *sub_exception, *tmp_exception;
 154
 155         if (!new_exception) {
 156                 MAKE_STD_ZVAL(new_exception);
 157                 object_init_ex(new_exception, ce);
 158
 159                 zend_update_property(ce, new_exception, "innerException", lenof("innerException"), old_exception TSRMLS_CC);
 160                 copy_bt_args(old_exception, new_exception TSRMLS_CC);
 161
 162                 sub_exception = old_exception;
 163
 164                 while ((sub_exception = zend_read_property(Z_OBJCE_P(sub_exception), sub_exception, "innerException", lenof("innerException"), 0 TSRMLS_CC)) && Z_TYPE_P(sub_exception) == IS_OBJECT) {
 165                         ++inner;
 166                 }
 167
 168                 spprintf(&message, 0, "Exception caused by %d inner exception(s)", inner);
 169                 zend_update_property_string(ZEND_EXCEPTION_GET_DEFAULT(), new_exception, "message", lenof("message"), message TSRMLS_CC);
 170                 efree(message);
 171         } else {
 172                 sub_exception = new_exception;
 173                 tmp_exception = new_exception;
 174
 175                 while ((tmp_exception = zend_read_property(Z_OBJCE_P(tmp_exception), tmp_exception, "innerException", lenof("innerException"), 0 TSRMLS_CC)) && Z_TYPE_P(tmp_exception) == IS_OBJECT) {
 176                         sub_exception = tmp_exception;
 177                 }
 178
 179                 zend_update_property(Z_OBJCE_P(sub_exception), sub_exception, "innerException", lenof("innerException"), old_exception TSRMLS_CC);
 180                 copy_bt_args(old_exception, new_exception TSRMLS_CC);
 181                 copy_bt_args(old_exception, sub_exception TSRMLS_CC);
 182         }
 183 #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3
 184         Z_ADDREF_P(old_exception);
 185         zend_exception_set_previous(new_exception, old_exception TSRMLS_CC);
 186 #endif
 187         zval_ptr_dtor(&old_exception);
 188         return new_exception;
 189 }
 190 /* }}} */
 191
 192 /* {{{ STATUS http_object_new(zend_object_value *, const char *, uint, http_object_new_t, zend_class_entry *, void *, void **) */
 193 STATUS _http_object_new(zend_object_value *ov, const char *cname_str, uint cname_len, http_object_new_t create, zend_class_entry *parent_ce, void *intern_ptr, void **obj_ptr TSRMLS_DC)
 194 {
 195         zend_class_entry *ce = parent_ce;
 196
 197         if (cname_str && cname_len) {
 198                 if (!(ce = zend_fetch_class(HTTP_ZAPI_CONST_CAST(char *) cname_str, cname_len, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC))) {
 199                         return FAILURE;
 200                 }
 201                 if (!instanceof_function(ce, parent_ce TSRMLS_CC)) {
 202                         http_error_ex(HE_WARNING, HTTP_E_RUNTIME, "Class %s does not extend %s", cname_str, parent_ce->name);
 203                         return FAILURE;
 204                 }
 205         }
 206
 207         *ov = create(ce, intern_ptr, obj_ptr TSRMLS_CC);
 208         return SUCCESS;
 209 }
 210 /* }}} */
 211 #endif /* ZEND_ENGINE_2 */
 212
 213 /* {{{ void http_log(char *, char *, char *) */
 214 void _http_log_ex(char *file, const char *ident, const char *message TSRMLS_DC)
 215 {
 216         time_t now;
 217         struct tm nowtm;
 218         char datetime[20] = {0};
 219
 220         now = HTTP_G->request.time;
 221         strftime(datetime, sizeof(datetime), "%Y-%m-%d %H:%M:%S", php_localtime_r(&now, &nowtm));
 222
 223 #define HTTP_LOG_WRITE(file, type, msg) \
 224         if (file && *file) { \
 225                 php_stream *log = php_stream_open_wrapper_ex(file, "ab", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL, HTTP_DEFAULT_STREAM_CONTEXT); \
 226                  \
 227                 if (log) { \
 228                         php_stream_printf(log TSRMLS_CC, "%s\t[%s]\t%s\t<%s>%s", datetime, type, msg, SG(request_info).request_uri, PHP_EOL); \
 229                         php_stream_close(log); \
 230                 } \
 231          \
 232         }
 233
 234         HTTP_LOG_WRITE(file, ident, message);
 235         HTTP_LOG_WRITE(HTTP_G->log.composite, ident, message);
 236 }
 237 /* }}} */
 238
 239 static void http_ob_blackhole(char *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC)
 240 {
 241         *handled_output = ecalloc(1,1);
 242         *handled_output_len = 0;
 243 }
 244
 245 /* {{{ STATUS http_exit(int, char*, char*) */
 246 STATUS _http_exit_ex(int status, char *header, char *body, zend_bool send_header TSRMLS_DC)
 247 {
 248         if (    (send_header && (SUCCESS != http_send_status_header(status, header))) ||
 249                         (status && (SUCCESS != http_send_status(status)))) {
 250                 http_error_ex(HE_WARNING, HTTP_E_HEADER, "Failed to exit with status/header: %d - %s", status, STR_PTR(header));
 251                 STR_FREE(header);
 252                 STR_FREE(body);
 253                 return FAILURE;
 254         }
 255
 256 #ifndef PHP_OUTPUT_NEWAPI
 257         if (!OG(ob_lock) &&
 258                 !php_ob_handler_used("zlib output compression" TSRMLS_CC) && !php_ob_handler_used("ob_gzhandler" TSRMLS_CC)) {
 259                 php_end_ob_buffers(0 TSRMLS_CC);
 260         }
 261 #endif
 262
 263         if ((SUCCESS == sapi_send_headers(TSRMLS_C)) && body) {
 264                 PHPWRITE(body, strlen(body));
 265         }
 266
 267         switch (status) {
 268                 case 301:       http_log(HTTP_G->log.redirect, "301-REDIRECT", header);                 break;
 269                 case 302:       http_log(HTTP_G->log.redirect, "302-REDIRECT", header);                 break;
 270                 case 303:       http_log(HTTP_G->log.redirect, "303-REDIRECT", header);                 break;
 271                 case 305:       http_log(HTTP_G->log.redirect, "305-REDIRECT", header);                 break;
 272                 case 307:       http_log(HTTP_G->log.redirect, "307-REDIRECT", header);                 break;
 273                 case 304:       http_log(HTTP_G->log.cache, "304-CACHE", header);                               break;
 274                 case 404:       http_log(HTTP_G->log.not_found, "404-NOTFOUND", NULL);                  break;
 275                 case 405:       http_log(HTTP_G->log.allowed_methods, "405-ALLOWED", header);   break;
 276                 default:        http_log(NULL, header, body);                                                                   break;
 277         }
 278
 279         STR_FREE(header);
 280         STR_FREE(body);
 281
 282         if (HTTP_G->force_exit) {
 283                 zend_bailout();
 284         } else {
 285 #ifdef PHP_OUTPUT_NEWAPI
 286                 php_output_start_devnull(TSRMLS_C);
 287 #else
 288                 php_ob_set_internal_handler(http_ob_blackhole, 4096, "blackhole", 0 TSRMLS_CC);
 289 #endif
 290         }
 291
 292         return SUCCESS;
 293 }
 294 /* }}} */
 295
 296 /* {{{ STATUS http_check_method(char *) */
 297 STATUS _http_check_method_ex(const char *method, const char *methods)
 298 {
 299         const char *found;
 300
 301         if (    (found = strstr(methods, method)) &&
 302                         (found == method || !HTTP_IS_CTYPE(alpha, found[-1])) &&
 303                         (strlen(found) >= strlen(method) && !HTTP_IS_CTYPE(alpha, found[strlen(method)]))) {
 304                 return SUCCESS;
 305         }
 306         return FAILURE;
 307 }
 308 /* }}} */
 309
 310 /* {{{ zval *http_get_server_var_ex(char *, size_t) */
 311 PHP_HTTP_API zval *_http_get_server_var_ex(const char *key, size_t key_len, zend_bool check TSRMLS_DC)
 312 {
 313         zval **hsv, **var;
 314         char *env;
 315
 316         /* if available, this is a lot faster than accessing $_SERVER */
 317         if (sapi_module.getenv) {
 318                 if ((!(env = sapi_module.getenv((char *) key, key_len TSRMLS_CC))) || (check && !*env)) {
 319                         return NULL;
 320                 }
 321                 if (HTTP_G->server_var) {
 322                         zval_ptr_dtor(&HTTP_G->server_var);
 323                 }
 324                 MAKE_STD_ZVAL(HTTP_G->server_var);
 325                 ZVAL_STRING(HTTP_G->server_var, env, 1);
 326                 return HTTP_G->server_var;
 327         }
 328
 329 #ifdef ZEND_ENGINE_2
 330         zend_is_auto_global("_SERVER", lenof("_SERVER") TSRMLS_CC);
 331 #endif
 332
 333         if ((SUCCESS != zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void *) &hsv)) || (Z_TYPE_PP(hsv) != IS_ARRAY)) {
 334                 return NULL;
 335         }
 336         if ((SUCCESS != zend_hash_find(Z_ARRVAL_PP(hsv), HTTP_ZAPI_CONST_CAST(char *) key, key_len + 1, (void *) &var))) {
 337                 return NULL;
 338         }
 339         if (check && !((Z_TYPE_PP(var) == IS_STRING) && Z_STRVAL_PP(var) && Z_STRLEN_PP(var))) {
 340                 return NULL;
 341         }
 342         return *var;
 343 }
 344 /* }}} */
 345
 346 /* {{{ STATUS http_get_request_body(char **, size_t *) */
 347 PHP_HTTP_API STATUS _http_get_request_body_ex(char **body, size_t *length, zend_bool dup TSRMLS_DC)
 348 {
 349         *length = 0;
 350         *body = NULL;
 351
 352         if (SG(request_info).raw_post_data) {
 353                 *length = SG(request_info).raw_post_data_length;
 354                 *body = SG(request_info).raw_post_data;
 355
 356                 if (dup) {
 357                         *body = estrndup(*body, *length);
 358                 }
 359                 return SUCCESS;
 360         } else if (sapi_module.read_post && !HTTP_G->read_post_data) {
 361                 char *buf = emalloc(4096);
 362                 int len;
 363
 364                 HTTP_G->read_post_data = 1;
 365
 366                 while (0 < (len = sapi_module.read_post(buf, 4096 TSRMLS_CC))) {
 367                         SG(read_post_bytes) += len;
 368                         *body = erealloc(*body, *length + len + 1);
 369                         memcpy(*body + *length, buf, len);
 370                         *length += len;
 371                         (*body)[*length] = '\0';
 372                         if (len < 4096) {
 373                                 break;
 374                         }
 375                 }
 376                 efree(buf);
 377
 378                 /* check for error */
 379                 if (len < 0) {
 380                         STR_FREE(*body);
 381                         *length = 0;
 382                         return FAILURE;
 383                 }
 384
 385                 SG(request_info).raw_post_data = *body;
 386                 SG(request_info).raw_post_data_length = *length;
 387
 388                 if (dup) {
 389                         *body = estrndup(*body, *length);
 390                 }
 391                 return SUCCESS;
 392         }
 393
 394         return FAILURE;
 395 }
 396 /* }}} */
 397
 398 /* {{{ php_stream *http_get_request_body_stream(void) */
 399 PHP_HTTP_API php_stream *_http_get_request_body_stream(TSRMLS_D)
 400 {
 401         php_stream *s = NULL;
 402
 403         if (SG(request_info).raw_post_data) {
 404                 s = php_stream_open_wrapper("php://input", "rb", 0, NULL);
 405         } else if (sapi_module.read_post && !HTTP_G->read_post_data) {
 406                 HTTP_G->read_post_data = 1;
 407
 408                 if ((s = php_stream_temp_new())) {
 409                         char *buf = emalloc(4096);
 410                         int len;
 411
 412                         while (0 < (len = sapi_module.read_post(buf, 4096 TSRMLS_CC))) {
 413                                 SG(read_post_bytes) += len;
 414                                 php_stream_write(s, buf, len);
 415                                 if (len < 4096) {
 416                                         break;
 417                                 }
 418                         }
 419                         efree(buf);
 420
 421                         if (len < 0) {
 422                                 php_stream_close(s);
 423                                 s = NULL;
 424                         } else {
 425                                 php_stream_rewind(s);
 426                         }
 427                 }
 428         }
 429
 430         return s;
 431 }
 432 /* }}} */
 433
 434 /* {{{ void http_parse_params_default_callback(...) */
 435 PHP_HTTP_API void _http_parse_params_default_callback(void *arg, const char *key, int keylen, const char *val, int vallen TSRMLS_DC)
 436 {
 437         char *kdup;
 438         zval tmp, *entry;
 439         HashTable *ht = (HashTable *) arg;
 440
 441         if (ht) {
 442                 INIT_ZARR(tmp, ht);
 443
 444                 if (vallen) {
 445                         MAKE_STD_ZVAL(entry);
 446                         array_init(entry);
 447                         if (keylen) {
 448                                 kdup = estrndup(key, keylen);
 449                                 add_assoc_stringl_ex(entry, kdup, keylen + 1, (char *) val, vallen, 1);
 450                                 efree(kdup);
 451                         } else {
 452                                 add_next_index_stringl(entry, (char *) val, vallen, 1);
 453                         }
 454                         add_next_index_zval(&tmp, entry);
 455                 } else {
 456                         add_next_index_stringl(&tmp, (char *) key, keylen, 1);
 457                 }
 458         }
 459 }
 460 /* }}} */
 461
 462 /* {{{ STATUS http_parse_params(const char *, HashTable *) */
 463 PHP_HTTP_API STATUS _http_parse_params_ex(const char *param, int flags, http_parse_params_callback cb, void *cb_arg TSRMLS_DC)
 464 {
 465 #define ST_QUOTE        1
 466 #define ST_VALUE        2
 467 #define ST_KEY          3
 468 #define ST_ASSIGN       4
 469 #define ST_ADD          5
 470
 471         int st = ST_KEY, keylen = 0, vallen = 0;
 472         char *s, *c, *key = NULL, *val = NULL;
 473
 474         for(c = s = estrdup(param);;) {
 475         continued:
 476 #if 0
 477         {
 478                 char *tk = NULL, *tv = NULL;
 479
 480                 if (key) {
 481                         if (keylen) {
 482                                 tk= estrndup(key, keylen);
 483                         } else {
 484                                 tk = ecalloc(1, 7);
 485                                 memcpy(tk, key, 3);
 486                                 tk[3]='.'; tk[4]='.'; tk[5]='.';
 487                         }
 488                 }
 489                 if (val) {
 490                         if (vallen) {
 491                                 tv = estrndup(val, vallen);
 492                         } else {
 493                                 tv = ecalloc(1, 7);
 494                                 memcpy(tv, val, 3);
 495                                 tv[3]='.'; tv[4]='.'; tv[5]='.';
 496                         }
 497                 }
 498                 fprintf(stderr, "[%6s] %c \"%s=%s\"\n",
 499                                 (
 500                                                 st == ST_QUOTE ? "QUOTE" :
 501                                                 st == ST_VALUE ? "VALUE" :
 502                                                 st == ST_KEY ? "KEY" :
 503                                                 st == ST_ASSIGN ? "ASSIGN" :
 504                                                 st == ST_ADD ? "ADD":
 505                                                 "HUH?"
 506                                 ), *c?*c:'0', tk, tv
 507                 );
 508                 STR_FREE(tk); STR_FREE(tv);
 509         }
 510 #endif
 511                 switch (st) {
 512                         case ST_QUOTE:
 513                         quote:
 514                                 if (*c == '"') {
 515                                         if (*(c-1) == '\\') {
 516                                                 memmove(c-1, c, strlen(c)+1);
 517                                                 goto quote;
 518                                         } else {
 519                                                 goto add;
 520                                         }
 521                                 } else {
 522                                         if (!val) {
 523                                                 val = c;
 524                                         }
 525                                         if (!*c) {
 526                                                 --val;
 527                                                 st = ST_ADD;
 528                                         }
 529                                 }
 530                                 break;
 531
 532                         case ST_VALUE:
 533                                 switch (*c) {
 534                                         case '"':
 535                                                 if (!val) {
 536                                                         st = ST_QUOTE;
 537                                                 }
 538                                                 break;
 539
 540                                         case ' ':
 541                                                 break;
 542
 543                                         case ';':
 544                                         case '\0':
 545                                                 goto add;
 546                                                 break;
 547                                         case ',':
 548                                                 if (flags & HTTP_PARAMS_ALLOW_COMMA) {
 549                                                         goto add;
 550                                                 }
 551                                         default:
 552                                                 if (!val) {
 553                                                         val = c;
 554                                                 }
 555                                                 break;
 556                                 }
 557                                 break;
 558
 559                         case ST_KEY:
 560                                 switch (*c) {
 561                                         case ',':
 562                                                 if (flags & HTTP_PARAMS_ALLOW_COMMA) {
 563                                                         goto allow_comma;
 564                                                 }
 565                                         case '\r':
 566                                         case '\n':
 567                                         case '\t':
 568                                         case '\013':
 569                                         case '\014':
 570                                                 goto failure;
 571                                                 break;
 572
 573                                         case ' ':
 574                                                 if (key) {
 575                                                         keylen = c - key;
 576                                                         st = ST_ASSIGN;
 577                                                 }
 578                                                 break;
 579
 580                                         case ';':
 581                                         case '\0':
 582                                         allow_comma:
 583                                                 if (key) {
 584                                                         keylen = c-- - key;
 585                                                         st = ST_ADD;
 586                                                 }
 587                                                 break;
 588
 589                                         case ':':
 590                                                 if (!(flags & HTTP_PARAMS_COLON_SEPARATOR)) {
 591                                                         goto not_separator;
 592                                                 }
 593                                                 if (key) {
 594                                                         keylen = c - key;
 595                                                         st = ST_VALUE;
 596                                                 } else {
 597                                                         goto failure;
 598                                                 }
 599                                                 break;
 600
 601                                         case '=':
 602                                                 if (flags & HTTP_PARAMS_COLON_SEPARATOR) {
 603                                                         goto not_separator;
 604                                                 }
 605                                                 if (key) {
 606                                                         keylen = c - key;
 607                                                         st = ST_VALUE;
 608                                                 } else {
 609                                                         goto failure;
 610                                                 }
 611                                                 break;
 612
 613                                         default:
 614                                         not_separator:
 615                                                 if (!key) {
 616                                                         key = c;
 617                                                 }
 618                                                 break;
 619                                 }
 620                                 break;
 621
 622                         case ST_ASSIGN:
 623                                 if (*c == '=') {
 624                                         st = ST_VALUE;
 625                                 } else if (!*c || *c == ';' || ((flags & HTTP_PARAMS_ALLOW_COMMA) && *c == ',')) {
 626                                         st = ST_ADD;
 627                                 } else if (*c != ' ') {
 628                                         goto failure;
 629                                 }
 630                                 break;
 631
 632                         case ST_ADD:
 633                         add:
 634                                 if (val) {
 635                                         vallen = c - val;
 636                                         if (st != ST_QUOTE) {
 637                                                 while (val[vallen-1] == ' ') --vallen;
 638                                         }
 639                                 } else {
 640                                         val = "";
 641                                         vallen = 0;
 642                                 }
 643
 644                                 cb(cb_arg, key, keylen, val, vallen TSRMLS_CC);
 645
 646                                 st = ST_KEY;
 647                                 key = val = NULL;
 648                                 keylen = vallen = 0;
 649                                 break;
 650                 }
 651                 if (*c) {
 652                         ++c;
 653                 } else if (st == ST_ADD) {
 654                         goto add;
 655                 } else {
 656                         break;
 657                 }
 658         }
 659
 660         efree(s);
 661         return SUCCESS;
 662
 663 failure:
 664         if (flags & HTTP_PARAMS_RAISE_ERROR) {
 665                 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Unexpected character (%c) at pos %tu of %zu", *c, c-s, strlen(s));
 666         }
 667         if (flags & HTTP_PARAMS_ALLOW_FAILURE) {
 668                 if (st == ST_KEY) {
 669                         if (key) {
 670                                 keylen = c - key;
 671                         } else {
 672                                 key = c;
 673                         }
 674                 } else {
 675                         --c;
 676                 }
 677                 st = ST_ADD;
 678                 goto continued;
 679         }
 680         efree(s);
 681         return FAILURE;
 682 }
 683 /* }}} */
 684
 685 /* {{{ array_join */
 686 int apply_array_append_func(void *pDest HTTP_ZAPI_HASH_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 687 {
 688         int flags;
 689         char *key = NULL;
 690         HashTable *dst;
 691         zval **data = NULL, **value = (zval **) pDest;
 692
 693         dst = va_arg(args, HashTable *);
 694         flags = va_arg(args, int);
 695
 696         if ((!(flags & ARRAY_JOIN_STRONLY)) || hash_key->nKeyLength) {
 697                 if ((flags & ARRAY_JOIN_PRETTIFY) && hash_key->nKeyLength) {
 698                         key = pretty_key(estrndup(hash_key->arKey, hash_key->nKeyLength - 1), hash_key->nKeyLength - 1, 1, 1);
 699                         zend_hash_find(dst, key, hash_key->nKeyLength, (void *) &data);
 700                 } else {
 701                         zend_hash_quick_find(dst, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void *) &data);
 702                 }
 703
 704                 ZVAL_ADDREF(*value);
 705                 if (data) {
 706                         add_next_index_zval(http_zset(IS_ARRAY, *data), *value);
 707                 } else if (key) {
 708                         zend_hash_add(dst, key, hash_key->nKeyLength, value, sizeof(zval *), NULL);
 709                 } else {
 710                         zend_hash_quick_add(dst, hash_key->arKey, hash_key->nKeyLength, hash_key->h, value, sizeof(zval *), NULL);
 711                 }
 712
 713                 if (key) {
 714                         efree(key);
 715                 }
 716         }
 717
 718         return ZEND_HASH_APPLY_KEEP;
 719 }
 720
 721 int apply_array_merge_func(void *pDest HTTP_ZAPI_HASH_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 722 {
 723         int flags;
 724         char *key = NULL;
 725         HashTable *dst;
 726         zval **value = (zval **) pDest;
 727
 728         dst = va_arg(args, HashTable *);
 729         flags = va_arg(args, int);
 730
 731         if ((!(flags & ARRAY_JOIN_STRONLY)) || hash_key->nKeyLength) {
 732                 ZVAL_ADDREF(*value);
 733                 if ((flags & ARRAY_JOIN_PRETTIFY) && hash_key->nKeyLength) {
 734                         key = pretty_key(estrndup(hash_key->arKey, hash_key->nKeyLength - 1), hash_key->nKeyLength - 1, 1, 1);
 735                         zend_hash_update(dst, key, hash_key->nKeyLength, (void *) value, sizeof(zval *), NULL);
 736                         efree(key);
 737                 } else {
 738                         zend_hash_quick_update(dst, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void *) value, sizeof(zval *), NULL);
 739                 }
 740         }
 741
 742         return ZEND_HASH_APPLY_KEEP;
 743 }
 744 /* }}} */
 745
 746 /*
 747  * Local variables:
 748  * tab-width: 4
 749  * c-basic-offset: 4
 750  * End:
 751  * vim600: noet sw=4 ts=4 fdm=marker
 752  * vim<600: noet sw=4 ts=4
 753  */
 754