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         if (
 257 #if defined(PHP_VERSION_ID) && (PHP_VERSION_ID >= 50399)
 258                 OG(active) && (OG(active)->flags & PHP_OUTPUT_HANDLER_FLUSHABLE) &&
 259 #else
 260                 !OG(ob_lock) &&
 261 #endif
 262                 !php_ob_handler_used("zlib output compression" TSRMLS_CC) && !php_ob_handler_used("ob_gzhandler" TSRMLS_CC)) {
 263                 php_end_ob_buffers(0 TSRMLS_CC);
 264         }
 265
 266         if ((SUCCESS == sapi_send_headers(TSRMLS_C)) && body) {
 267                 PHPWRITE(body, strlen(body));
 268         }
 269
 270         switch (status) {
 271                 case 301:       http_log(HTTP_G->log.redirect, "301-REDIRECT", header);                 break;
 272                 case 302:       http_log(HTTP_G->log.redirect, "302-REDIRECT", header);                 break;
 273                 case 303:       http_log(HTTP_G->log.redirect, "303-REDIRECT", header);                 break;
 274                 case 305:       http_log(HTTP_G->log.redirect, "305-REDIRECT", header);                 break;
 275                 case 307:       http_log(HTTP_G->log.redirect, "307-REDIRECT", header);                 break;
 276                 case 304:       http_log(HTTP_G->log.cache, "304-CACHE", header);                               break;
 277                 case 404:       http_log(HTTP_G->log.not_found, "404-NOTFOUND", NULL);                  break;
 278                 case 405:       http_log(HTTP_G->log.allowed_methods, "405-ALLOWED", header);   break;
 279                 default:        http_log(NULL, header, body);                                                                   break;
 280         }
 281
 282         STR_FREE(header);
 283         STR_FREE(body);
 284
 285         if (HTTP_G->force_exit) {
 286                 zend_bailout();
 287         } else {
 288                 php_ob_set_internal_handler(http_ob_blackhole, 4096, "blackhole", 0 TSRMLS_CC);
 289         }
 290
 291         return SUCCESS;
 292 }
 293 /* }}} */
 294
 295 /* {{{ STATUS http_check_method(char *) */
 296 STATUS _http_check_method_ex(const char *method, const char *methods)
 297 {
 298         const char *found;
 299
 300         if (    (found = strstr(methods, method)) &&
 301                         (found == method || !HTTP_IS_CTYPE(alpha, found[-1])) &&
 302                         (strlen(found) >= strlen(method) && !HTTP_IS_CTYPE(alpha, found[strlen(method)]))) {
 303                 return SUCCESS;
 304         }
 305         return FAILURE;
 306 }
 307 /* }}} */
 308
 309 /* {{{ zval *http_get_server_var_ex(char *, size_t) */
 310 PHP_HTTP_API zval *_http_get_server_var_ex(const char *key, size_t key_len, zend_bool check TSRMLS_DC)
 311 {
 312         zval **hsv, **var;
 313         char *env;
 314
 315         /* if available, this is a lot faster than accessing $_SERVER */
 316         if (sapi_module.getenv) {
 317                 if ((!(env = sapi_module.getenv((char *) key, key_len TSRMLS_CC))) || (check && !*env)) {
 318                         return NULL;
 319                 }
 320                 if (HTTP_G->server_var) {
 321                         zval_ptr_dtor(&HTTP_G->server_var);
 322                 }
 323                 MAKE_STD_ZVAL(HTTP_G->server_var);
 324                 ZVAL_STRING(HTTP_G->server_var, env, 1);
 325                 return HTTP_G->server_var;
 326         }
 327
 328 #ifdef ZEND_ENGINE_2
 329         zend_is_auto_global("_SERVER", lenof("_SERVER") TSRMLS_CC);
 330 #endif
 331
 332         if ((SUCCESS != zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void *) &hsv)) || (Z_TYPE_PP(hsv) != IS_ARRAY)) {
 333                 return NULL;
 334         }
 335         if ((SUCCESS != zend_hash_find(Z_ARRVAL_PP(hsv), HTTP_ZAPI_CONST_CAST(char *) key, key_len + 1, (void *) &var))) {
 336                 return NULL;
 337         }
 338         if (check && !((Z_TYPE_PP(var) == IS_STRING) && Z_STRVAL_PP(var) && Z_STRLEN_PP(var))) {
 339                 return NULL;
 340         }
 341         return *var;
 342 }
 343 /* }}} */
 344
 345 /* {{{ STATUS http_get_request_body(char **, size_t *) */
 346 PHP_HTTP_API STATUS _http_get_request_body_ex(char **body, size_t *length, zend_bool dup TSRMLS_DC)
 347 {
 348         *length = 0;
 349         *body = NULL;
 350
 351         if (SG(request_info).raw_post_data) {
 352                 *length = SG(request_info).raw_post_data_length;
 353                 *body = SG(request_info).raw_post_data;
 354
 355                 if (dup) {
 356                         *body = estrndup(*body, *length);
 357                 }
 358                 return SUCCESS;
 359         } else if (sapi_module.read_post && !HTTP_G->read_post_data) {
 360                 char *buf = emalloc(4096);
 361                 int len;
 362
 363                 HTTP_G->read_post_data = 1;
 364
 365                 while (0 < (len = sapi_module.read_post(buf, 4096 TSRMLS_CC))) {
 366                         SG(read_post_bytes) += len;
 367                         *body = erealloc(*body, *length + len + 1);
 368                         memcpy(*body + *length, buf, len);
 369                         *length += len;
 370                         (*body)[*length] = '\0';
 371                         if (len < 4096) {
 372                                 break;
 373                         }
 374                 }
 375                 efree(buf);
 376
 377                 /* check for error */
 378                 if (len < 0) {
 379                         STR_FREE(*body);
 380                         *length = 0;
 381                         return FAILURE;
 382                 }
 383
 384                 SG(request_info).raw_post_data = *body;
 385                 SG(request_info).raw_post_data_length = *length;
 386
 387                 if (dup) {
 388                         *body = estrndup(*body, *length);
 389                 }
 390                 return SUCCESS;
 391         }
 392
 393         return FAILURE;
 394 }
 395 /* }}} */
 396
 397 /* {{{ php_stream *http_get_request_body_stream(void) */
 398 PHP_HTTP_API php_stream *_http_get_request_body_stream(TSRMLS_D)
 399 {
 400         php_stream *s = NULL;
 401
 402         if (SG(request_info).raw_post_data) {
 403                 s = php_stream_open_wrapper("php://input", "rb", 0, NULL);
 404         } else if (sapi_module.read_post && !HTTP_G->read_post_data) {
 405                 HTTP_G->read_post_data = 1;
 406
 407                 if ((s = php_stream_temp_new())) {
 408                         char *buf = emalloc(4096);
 409                         int len;
 410
 411                         while (0 < (len = sapi_module.read_post(buf, 4096 TSRMLS_CC))) {
 412                                 php_stream_write(s, buf, len);
 413                                 if (len < 4096) {
 414                                         break;
 415                                 }
 416                         }
 417                         efree(buf);
 418
 419                         if (len < 0) {
 420                                 php_stream_close(s);
 421                                 s = NULL;
 422                         } else {
 423                                 php_stream_rewind(s);
 424                         }
 425                 }
 426         }
 427
 428         return s;
 429 }
 430 /* }}} */
 431
 432 /* {{{ void http_parse_params_default_callback(...) */
 433 PHP_HTTP_API void _http_parse_params_default_callback(void *arg, const char *key, int keylen, const char *val, int vallen TSRMLS_DC)
 434 {
 435         char *kdup;
 436         zval tmp, *entry;
 437         HashTable *ht = (HashTable *) arg;
 438
 439         if (ht) {
 440                 INIT_ZARR(tmp, ht);
 441
 442                 if (vallen) {
 443                         MAKE_STD_ZVAL(entry);
 444                         array_init(entry);
 445                         if (keylen) {
 446                                 kdup = estrndup(key, keylen);
 447                                 add_assoc_stringl_ex(entry, kdup, keylen + 1, (char *) val, vallen, 1);
 448                                 efree(kdup);
 449                         } else {
 450                                 add_next_index_stringl(entry, (char *) val, vallen, 1);
 451                         }
 452                         add_next_index_zval(&tmp, entry);
 453                 } else {
 454                         add_next_index_stringl(&tmp, (char *) key, keylen, 1);
 455                 }
 456         }
 457 }
 458 /* }}} */
 459
 460 /* {{{ STATUS http_parse_params(const char *, HashTable *) */
 461 PHP_HTTP_API STATUS _http_parse_params_ex(const char *param, int flags, http_parse_params_callback cb, void *cb_arg TSRMLS_DC)
 462 {
 463 #define ST_QUOTE        1
 464 #define ST_VALUE        2
 465 #define ST_KEY          3
 466 #define ST_ASSIGN       4
 467 #define ST_ADD          5
 468
 469         int st = ST_KEY, keylen = 0, vallen = 0;
 470         char *s, *c, *key = NULL, *val = NULL;
 471
 472         for(c = s = estrdup(param);;) {
 473         continued:
 474 #if 0
 475         {
 476                 char *tk = NULL, *tv = NULL;
 477
 478                 if (key) {
 479                         if (keylen) {
 480                                 tk= estrndup(key, keylen);
 481                         } else {
 482                                 tk = ecalloc(1, 7);
 483                                 memcpy(tk, key, 3);
 484                                 tk[3]='.'; tk[4]='.'; tk[5]='.';
 485                         }
 486                 }
 487                 if (val) {
 488                         if (vallen) {
 489                                 tv = estrndup(val, vallen);
 490                         } else {
 491                                 tv = ecalloc(1, 7);
 492                                 memcpy(tv, val, 3);
 493                                 tv[3]='.'; tv[4]='.'; tv[5]='.';
 494                         }
 495                 }
 496                 fprintf(stderr, "[%6s] %c \"%s=%s\"\n",
 497                                 (
 498                                                 st == ST_QUOTE ? "QUOTE" :
 499                                                 st == ST_VALUE ? "VALUE" :
 500                                                 st == ST_KEY ? "KEY" :
 501                                                 st == ST_ASSIGN ? "ASSIGN" :
 502                                                 st == ST_ADD ? "ADD":
 503                                                 "HUH?"
 504                                 ), *c?*c:'0', tk, tv
 505                 );
 506                 STR_FREE(tk); STR_FREE(tv);
 507         }
 508 #endif
 509                 switch (st) {
 510                         case ST_QUOTE:
 511                         quote:
 512                                 if (*c == '"') {
 513                                         if (*(c-1) == '\\') {
 514                                                 memmove(c-1, c, strlen(c)+1);
 515                                                 goto quote;
 516                                         } else {
 517                                                 goto add;
 518                                         }
 519                                 } else {
 520                                         if (!val) {
 521                                                 val = c;
 522                                         }
 523                                         if (!*c) {
 524                                                 --val;
 525                                                 st = ST_ADD;
 526                                         }
 527                                 }
 528                                 break;
 529
 530                         case ST_VALUE:
 531                                 switch (*c) {
 532                                         case '"':
 533                                                 if (!val) {
 534                                                         st = ST_QUOTE;
 535                                                 }
 536                                                 break;
 537
 538                                         case ' ':
 539                                                 break;
 540
 541                                         case ';':
 542                                         case '\0':
 543                                                 goto add;
 544                                                 break;
 545                                         case ',':
 546                                                 if (flags & HTTP_PARAMS_ALLOW_COMMA) {
 547                                                         goto add;
 548                                                 }
 549                                         default:
 550                                                 if (!val) {
 551                                                         val = c;
 552                                                 }
 553                                                 break;
 554                                 }
 555                                 break;
 556
 557                         case ST_KEY:
 558                                 switch (*c) {
 559                                         case ',':
 560                                                 if (flags & HTTP_PARAMS_ALLOW_COMMA) {
 561                                                         goto allow_comma;
 562                                                 }
 563                                         case '\r':
 564                                         case '\n':
 565                                         case '\t':
 566                                         case '\013':
 567                                         case '\014':
 568                                                 goto failure;
 569                                                 break;
 570
 571                                         case ' ':
 572                                                 if (key) {
 573                                                         keylen = c - key;
 574                                                         st = ST_ASSIGN;
 575                                                 }
 576                                                 break;
 577
 578                                         case ';':
 579                                         case '\0':
 580                                         allow_comma:
 581                                                 if (key) {
 582                                                         keylen = c-- - key;
 583                                                         st = ST_ADD;
 584                                                 }
 585                                                 break;
 586
 587                                         case ':':
 588                                                 if (!(flags & HTTP_PARAMS_COLON_SEPARATOR)) {
 589                                                         goto not_separator;
 590                                                 }
 591                                                 if (key) {
 592                                                         keylen = c - key;
 593                                                         st = ST_VALUE;
 594                                                 } else {
 595                                                         goto failure;
 596                                                 }
 597                                                 break;
 598
 599                                         case '=':
 600                                                 if (flags & HTTP_PARAMS_COLON_SEPARATOR) {
 601                                                         goto not_separator;
 602                                                 }
 603                                                 if (key) {
 604                                                         keylen = c - key;
 605                                                         st = ST_VALUE;
 606                                                 } else {
 607                                                         goto failure;
 608                                                 }
 609                                                 break;
 610
 611                                         default:
 612                                         not_separator:
 613                                                 if (!key) {
 614                                                         key = c;
 615                                                 }
 616                                                 break;
 617                                 }
 618                                 break;
 619
 620                         case ST_ASSIGN:
 621                                 if (*c == '=') {
 622                                         st = ST_VALUE;
 623                                 } else if (!*c || *c == ';' || ((flags & HTTP_PARAMS_ALLOW_COMMA) && *c == ',')) {
 624                                         st = ST_ADD;
 625                                 } else if (*c != ' ') {
 626                                         goto failure;
 627                                 }
 628                                 break;
 629
 630                         case ST_ADD:
 631                         add:
 632                                 if (val) {
 633                                         vallen = c - val;
 634                                         if (st != ST_QUOTE) {
 635                                                 while (val[vallen-1] == ' ') --vallen;
 636                                         }
 637                                 } else {
 638                                         val = "";
 639                                         vallen = 0;
 640                                 }
 641
 642                                 cb(cb_arg, key, keylen, val, vallen TSRMLS_CC);
 643
 644                                 st = ST_KEY;
 645                                 key = val = NULL;
 646                                 keylen = vallen = 0;
 647                                 break;
 648                 }
 649                 if (*c) {
 650                         ++c;
 651                 } else if (st == ST_ADD) {
 652                         goto add;
 653                 } else {
 654                         break;
 655                 }
 656         }
 657
 658         efree(s);
 659         return SUCCESS;
 660
 661 failure:
 662         if (flags & HTTP_PARAMS_RAISE_ERROR) {
 663                 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Unexpected character (%c) at pos %tu of %zu", *c, c-s, strlen(s));
 664         }
 665         if (flags & HTTP_PARAMS_ALLOW_FAILURE) {
 666                 if (st == ST_KEY) {
 667                         if (key) {
 668                                 keylen = c - key;
 669                         } else {
 670                                 key = c;
 671                         }
 672                 } else {
 673                         --c;
 674                 }
 675                 st = ST_ADD;
 676                 goto continued;
 677         }
 678         efree(s);
 679         return FAILURE;
 680 }
 681 /* }}} */
 682
 683 /* {{{ array_join */
 684 int apply_array_append_func(void *pDest HTTP_ZAPI_HASH_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 685 {
 686         int flags;
 687         char *key = NULL;
 688         HashTable *dst;
 689         zval **data = NULL, **value = (zval **) pDest;
 690
 691         dst = va_arg(args, HashTable *);
 692         flags = va_arg(args, int);
 693
 694         if ((!(flags & ARRAY_JOIN_STRONLY)) || hash_key->nKeyLength) {
 695                 if ((flags & ARRAY_JOIN_PRETTIFY) && hash_key->nKeyLength) {
 696                         key = pretty_key(estrndup(hash_key->arKey, hash_key->nKeyLength - 1), hash_key->nKeyLength - 1, 1, 1);
 697                         zend_hash_find(dst, key, hash_key->nKeyLength, (void *) &data);
 698                 } else {
 699                         zend_hash_quick_find(dst, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void *) &data);
 700                 }
 701
 702                 ZVAL_ADDREF(*value);
 703                 if (data) {
 704                         add_next_index_zval(http_zset(IS_ARRAY, *data), *value);
 705                 } else if (key) {
 706                         zend_hash_add(dst, key, hash_key->nKeyLength, value, sizeof(zval *), NULL);
 707                 } else {
 708                         zend_hash_quick_add(dst, hash_key->arKey, hash_key->nKeyLength, hash_key->h, value, sizeof(zval *), NULL);
 709                 }
 710
 711                 if (key) {
 712                         efree(key);
 713                 }
 714         }
 715
 716         return ZEND_HASH_APPLY_KEEP;
 717 }
 718
 719 int apply_array_merge_func(void *pDest HTTP_ZAPI_HASH_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 720 {
 721         int flags;
 722         char *key = NULL;
 723         HashTable *dst;
 724         zval **value = (zval **) pDest;
 725
 726         dst = va_arg(args, HashTable *);
 727         flags = va_arg(args, int);
 728
 729         if ((!(flags & ARRAY_JOIN_STRONLY)) || hash_key->nKeyLength) {
 730                 ZVAL_ADDREF(*value);
 731                 if ((flags & ARRAY_JOIN_PRETTIFY) && hash_key->nKeyLength) {
 732                         key = pretty_key(estrndup(hash_key->arKey, hash_key->nKeyLength - 1), hash_key->nKeyLength - 1, 1, 1);
 733                         zend_hash_update(dst, key, hash_key->nKeyLength, (void *) value, sizeof(zval *), NULL);
 734                         efree(key);
 735                 } else {
 736                         zend_hash_quick_update(dst, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void *) value, sizeof(zval *), NULL);
 737                 }
 738         }
 739
 740         return ZEND_HASH_APPLY_KEEP;
 741 }
 742 /* }}} */
 743
 744 /*
 745  * Local variables:
 746  * tab-width: 4
 747  * c-basic-offset: 4
 748  * End:
 749  * vim600: noet sw=4 ts=4 fdm=marker
 750  * vim<600: noet sw=4 ts=4
 751  */
 752