git.m6w6.name Git - m6w6/ext-http/blob - php_http_url.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-2011, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #include "php_http_api.h"
  14
  15 static inline char *localhostname(void)
  16 {
  17         char hostname[1024] = {0};
  18
  19 #ifdef PHP_WIN32
  20         if (SUCCESS == gethostname(hostname, lenof(hostname))) {
  21                 return estrdup(hostname);
  22         }
  23 #elif defined(HAVE_GETHOSTNAME)
  24         if (SUCCESS == gethostname(hostname, lenof(hostname))) {
  25 #       if defined(HAVE_GETDOMAINNAME)
  26                 size_t hlen = strlen(hostname);
  27                 if (hlen <= lenof(hostname) - lenof("(none)")) {
  28                         hostname[hlen++] = '.';
  29                         if (SUCCESS == getdomainname(&hostname[hlen], lenof(hostname) - hlen)) {
  30                                 if (!strcmp(&hostname[hlen], "(none)")) {
  31                                         hostname[hlen - 1] = '\0';
  32                                 }
  33                                 return estrdup(hostname);
  34                         }
  35                 }
  36 #       endif
  37                 if (strcmp(hostname, "(none)")) {
  38                         return estrdup(hostname);
  39                 }
  40         }
  41 #endif
  42         return estrndup("localhost", lenof("localhost"));
  43 }
  44
  45 static php_url *php_http_url_from_env(php_url *url TSRMLS_DC)
  46 {
  47         zval *https, *zhost, *zport;
  48         long port;
  49 #ifdef HAVE_GETSERVBYPORT
  50         struct servent *se;
  51 #endif
  52
  53         if (!url) {
  54                 url = ecalloc(1, sizeof(*url));
  55         }
  56
  57         /* port */
  58         zport = php_http_env_get_server_var(ZEND_STRL("SERVER_PORT"), 1 TSRMLS_CC);
  59         if (zport && IS_LONG == is_numeric_string(Z_STRVAL_P(zport), Z_STRLEN_P(zport), &port, NULL, 0)) {
  60                 url->port = port;
  61         }
  62
  63         /* scheme */
  64         https = php_http_env_get_server_var(ZEND_STRL("HTTPS"), 1 TSRMLS_CC);
  65         if (https && !strcasecmp(Z_STRVAL_P(https), "ON")) {
  66                 url->scheme = estrndup("https", lenof("https"));
  67         } else switch (url->port) {
  68                 case 443:
  69                         url->scheme = estrndup("https", lenof("https"));
  70                         break;
  71
  72 #ifndef HAVE_GETSERVBYPORT
  73                 default:
  74 #endif
  75                 case 80:
  76                 case 0:
  77                         url->scheme = estrndup("http", lenof("http"));
  78                         break;
  79
  80 #ifdef HAVE_GETSERVBYPORT
  81                 default:
  82                         if ((se = getservbyport(htons(url->port), "tcp")) && se->s_name) {
  83                                 url->scheme = estrdup(se->s_name);
  84                         } else {
  85                                 url->scheme = estrndup("http", lenof("http"));
  86                         }
  87                         break;
  88 #endif
  89         }
  90
  91         /* host */
  92         if ((((zhost = php_http_env_get_server_var(ZEND_STRL("HTTP_HOST"), 1 TSRMLS_CC)) ||
  93                         (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_NAME"), 1 TSRMLS_CC)) ||
  94                         (zhost = php_http_env_get_server_var(ZEND_STRL("SERVER_ADDR"), 1 TSRMLS_CC)))) && Z_STRLEN_P(zhost)) {
  95                 url->host = estrndup(Z_STRVAL_P(zhost), Z_STRLEN_P(zhost));
  96         } else {
  97                 url->host = localhostname();
  98         }
  99
 100         /* path */
 101         if (SG(request_info).request_uri && SG(request_info).request_uri[0]) {
 102                 const char *q = strchr(SG(request_info).request_uri, '?');
 103
 104                 if (q) {
 105                         url->path = estrndup(SG(request_info).request_uri, q - SG(request_info).request_uri);
 106                 } else {
 107                         url->path = estrdup(SG(request_info).request_uri);
 108                 }
 109         }
 110
 111         /* query */
 112         if (SG(request_info).query_string && SG(request_info).query_string[0]) {
 113                 url->query = estrdup(SG(request_info).query_string);
 114         }
 115
 116         return url;
 117 }
 118
 119 PHP_HTTP_API void php_http_url(int flags, const php_url *old_url, const php_url *new_url, php_url **url_ptr, char **url_str, size_t *url_len TSRMLS_DC)
 120 {
 121         php_url *url, *tmp_url = NULL;
 122 #ifdef HAVE_GETSERVBYNAME
 123         struct servent *se;
 124 #endif
 125
 126         /* set from env if requested */
 127         if (flags & PHP_HTTP_URL_FROM_ENV) {
 128                 php_url *env_url = php_http_url_from_env(NULL TSRMLS_CC);
 129
 130                 php_http_url(flags ^ PHP_HTTP_URL_FROM_ENV, env_url, old_url, &tmp_url, NULL, NULL TSRMLS_CC);
 131
 132                 php_url_free(env_url);
 133                 old_url = tmp_url;
 134         }
 135
 136         url = ecalloc(1, sizeof(*url));
 137
 138 #define __URLSET(u,n) \
 139         ((u)&&(u)->n)
 140 #define __URLCPY(n) \
 141         url->n = __URLSET(new_url,n) ? estrdup(new_url->n) : (__URLSET(old_url,n) ? estrdup(old_url->n) : NULL)
 142
 143         if (!(flags & PHP_HTTP_URL_STRIP_PORT)) {
 144                 url->port = __URLSET(new_url, port) ? new_url->port : ((old_url) ? old_url->port : 0);
 145         }
 146         if (!(flags & PHP_HTTP_URL_STRIP_USER)) {
 147                 __URLCPY(user);
 148         }
 149         if (!(flags & PHP_HTTP_URL_STRIP_PASS)) {
 150                 __URLCPY(pass);
 151         }
 152
 153         __URLCPY(scheme);
 154         __URLCPY(host);
 155
 156         if (!(flags & PHP_HTTP_URL_STRIP_PATH)) {
 157                 if ((flags & PHP_HTTP_URL_JOIN_PATH) && __URLSET(old_url, path) && __URLSET(new_url, path) && *new_url->path != '/') {
 158                         size_t old_path_len = strlen(old_url->path), new_path_len = strlen(new_url->path);
 159
 160                         url->path = ecalloc(1, old_path_len + new_path_len + 1 + 1);
 161
 162                         strcat(url->path, old_url->path);
 163                         if (url->path[old_path_len - 1] != '/') {
 164                                 php_dirname(url->path, old_path_len);
 165                                 strcat(url->path, "/");
 166                         }
 167                         strcat(url->path, new_url->path);
 168                 } else {
 169                         __URLCPY(path);
 170                 }
 171         }
 172         if (!(flags & PHP_HTTP_URL_STRIP_QUERY)) {
 173                 if ((flags & PHP_HTTP_URL_JOIN_QUERY) && __URLSET(new_url, query) && __URLSET(old_url, query)) {
 174                         zval qarr, qstr;
 175
 176                         INIT_PZVAL(&qstr);
 177                         INIT_PZVAL(&qarr);
 178                         array_init(&qarr);
 179
 180                         ZVAL_STRING(&qstr, old_url->query, 0);
 181                         php_http_querystring_update(&qarr, &qstr, NULL TSRMLS_CC);
 182                         ZVAL_STRING(&qstr, new_url->query, 0);
 183                         php_http_querystring_update(&qarr, &qstr, NULL TSRMLS_CC);
 184
 185                         ZVAL_NULL(&qstr);
 186                         php_http_querystring_update(&qarr, NULL, &qstr TSRMLS_CC);
 187                         url->query = Z_STRVAL(qstr);
 188                         zval_dtor(&qarr);
 189                 } else {
 190                         __URLCPY(query);
 191                 }
 192         }
 193         if (!(flags & PHP_HTTP_URL_STRIP_FRAGMENT)) {
 194                 __URLCPY(fragment);
 195         }
 196
 197         /* done with copy & combine & strip */
 198
 199         if (flags & PHP_HTTP_URL_FROM_ENV) {
 200                 /* free old_url we tainted above */
 201                 php_url_free(tmp_url);
 202         }
 203
 204         /* set some sane defaults */
 205
 206         if (!url->scheme) {
 207                 url->scheme = estrndup("http", lenof("http"));
 208         }
 209
 210         if (!url->host) {
 211                 url->host = estrndup("localhost", lenof("localhost"));
 212         }
 213
 214         if (!url->path) {
 215                 url->path = estrndup("/", 1);
 216         } else if (url->path[0] != '/') {
 217                 size_t plen = strlen(url->path);
 218                 char *path = emalloc(plen + 1 + 1);
 219
 220                 path[0] = '/';
 221                 memcpy(&path[1], url->path, plen + 1);
 222                 STR_SET(url->path, path);
 223         }
 224         /* replace directory references if path is not a single slash */
 225         if (url->path[0] && (url->path[0] != '/' || url->path[1])) {
 226                 char *ptr, *end = url->path + strlen(url->path) + 1;
 227
 228                 for (ptr = strchr(url->path, '/'); ptr; ptr = strchr(ptr, '/')) {
 229                         switch (ptr[1]) {
 230                                 case '/':
 231                                         memmove(&ptr[1], &ptr[2], end - &ptr[2]);
 232                                         break;
 233
 234                                 case '.':
 235                                         switch (ptr[2]) {
 236                                                 case '\0':
 237                                                         ptr[1] = '\0';
 238                                                         break;
 239
 240                                                 case '/':
 241                                                         memmove(&ptr[1], &ptr[3], end - &ptr[3]);
 242                                                         break;
 243
 244                                                 case '.':
 245                                                         if (ptr[3] == '/') {
 246                                                                 char *pos = &ptr[4];
 247                                                                 while (ptr != url->path) {
 248                                                                         if (*--ptr == '/') {
 249                                                                                 break;
 250                                                                         }
 251                                                                 }
 252                                                                 memmove(&ptr[1], pos, end - pos);
 253                                                                 break;
 254                                                         } else if (!ptr[3]) {
 255                                                                 /* .. at the end */
 256                                                                 ptr[1] = '\0';
 257                                                         }
 258                                                         /* no break */
 259
 260                                                 default:
 261                                                         /* something else */
 262                                                         ++ptr;
 263                                                         break;
 264                                         }
 265                                         break;
 266
 267                                 default:
 268                                         ++ptr;
 269                                         break;
 270                         }
 271                 }
 272         }
 273         /* unset default ports */
 274         if (url->port) {
 275                 if (    ((url->port == 80) && !strcmp(url->scheme, "http"))
 276                         ||      ((url->port ==443) && !strcmp(url->scheme, "https"))
 277 #ifdef HAVE_GETSERVBYNAME
 278                         ||      ((se = getservbyname(url->scheme, "tcp")) && se->s_port &&
 279                                         (url->port == ntohs(se->s_port)))
 280 #endif
 281                 ) {
 282                         url->port = 0;
 283                 }
 284         }
 285
 286         if (url_str) {
 287                 size_t len;
 288
 289                 *url_str = emalloc(PHP_HTTP_URL_MAXLEN + 1);
 290
 291                 **url_str = '\0';
 292                 strlcat(*url_str, url->scheme, PHP_HTTP_URL_MAXLEN);
 293                 strlcat(*url_str, "://", PHP_HTTP_URL_MAXLEN);
 294
 295                 if (url->user && *url->user) {
 296                         strlcat(*url_str, url->user, PHP_HTTP_URL_MAXLEN);
 297                         if (url->pass && *url->pass) {
 298                                 strlcat(*url_str, ":", PHP_HTTP_URL_MAXLEN);
 299                                 strlcat(*url_str, url->pass, PHP_HTTP_URL_MAXLEN);
 300                         }
 301                         strlcat(*url_str, "@", PHP_HTTP_URL_MAXLEN);
 302                 }
 303
 304                 strlcat(*url_str, url->host, PHP_HTTP_URL_MAXLEN);
 305
 306                 if (url->port) {
 307                         char port_str[8];
 308
 309                         snprintf(port_str, sizeof(port_str), "%d", (int) url->port);
 310                         strlcat(*url_str, ":", PHP_HTTP_URL_MAXLEN);
 311                         strlcat(*url_str, port_str, PHP_HTTP_URL_MAXLEN);
 312                 }
 313
 314                 strlcat(*url_str, url->path, PHP_HTTP_URL_MAXLEN);
 315
 316                 if (url->query && *url->query) {
 317                         strlcat(*url_str, "?", PHP_HTTP_URL_MAXLEN);
 318                         strlcat(*url_str, url->query, PHP_HTTP_URL_MAXLEN);
 319                 }
 320
 321                 if (url->fragment && *url->fragment) {
 322                         strlcat(*url_str, "#", PHP_HTTP_URL_MAXLEN);
 323                         strlcat(*url_str, url->fragment, PHP_HTTP_URL_MAXLEN);
 324                 }
 325
 326                 if (PHP_HTTP_URL_MAXLEN == (len = strlen(*url_str))) {
 327                         php_http_error(HE_NOTICE, PHP_HTTP_E_URL, "Length of URL exceeds PHP_HTTP_URL_MAXLEN");
 328                 }
 329                 if (url_len) {
 330                         *url_len = len;
 331                 }
 332         }
 333
 334         if (url_ptr) {
 335                 *url_ptr = url;
 336         } else {
 337                 php_url_free(url);
 338         }
 339 }
 340
 341 PHP_HTTP_API STATUS php_http_url_encode_hash(HashTable *hash, const char *pre_encoded_str, size_t pre_encoded_len, char **encoded_str, size_t *encoded_len TSRMLS_DC)
 342 {
 343         const char *arg_sep_str;
 344         size_t arg_sep_len;
 345         php_http_buffer_t *qstr = php_http_buffer_new();
 346
 347         php_http_url_argsep(&arg_sep_str, &arg_sep_len TSRMLS_CC);
 348
 349         if (pre_encoded_len && pre_encoded_str) {
 350                 php_http_buffer_append(qstr, pre_encoded_str, pre_encoded_len);
 351         }
 352
 353         if (SUCCESS != php_http_url_encode_hash_ex(hash, qstr, arg_sep_str, arg_sep_len, ZEND_STRL("="), NULL, 0 TSRMLS_CC)) {
 354                 php_http_buffer_free(&qstr);
 355                 return FAILURE;
 356         }
 357
 358         php_http_buffer_data(qstr, encoded_str, encoded_len);
 359         php_http_buffer_free(&qstr);
 360
 361         return SUCCESS;
 362 }
 363
 364 PHP_HTTP_API STATUS php_http_url_encode_hash_ex(HashTable *ht, php_http_buffer_t *str, const char *arg_sep_str, size_t arg_sep_len, const char *val_sep_str, size_t val_sep_len, const char *prefix_str, size_t prefix_len TSRMLS_DC)
 365 {
 366         php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
 367         zval **data = NULL;
 368         HashPosition pos;
 369
 370         if (!ht || !str) {
 371                 php_http_error(HE_WARNING, PHP_HTTP_E_INVALID_PARAM, "Invalid parameters");
 372                 return FAILURE;
 373         }
 374         if (ht->nApplyCount > 0) {
 375                 return SUCCESS;
 376         }
 377
 378         FOREACH_HASH_KEYVAL(pos, ht, key, data) {
 379                 char *encoded_key;
 380                 int encoded_len;
 381                 php_http_buffer_t new_prefix;
 382
 383                 if (!data || !*data) {
 384                         php_http_buffer_dtor(str);
 385                         return FAILURE;
 386                 }
 387
 388                 if (key.type == HASH_KEY_IS_STRING) {
 389                         if (!*key.str) {
 390                                 /* only public properties */
 391                                 continue;
 392                         }
 393                         if (key.len && key.str[key.len - 1] == '\0') {
 394                                 --key.len;
 395                         }
 396                         encoded_key = php_url_encode(key.str, key.len, &encoded_len);
 397                 } else {
 398                         encoded_len = spprintf(&encoded_key, 0, "%ld", key.num);
 399                 }
 400
 401                 {
 402                         php_http_buffer_init(&new_prefix);
 403                         if (prefix_str && prefix_len) {
 404                                 php_http_buffer_append(&new_prefix, prefix_str, prefix_len);
 405                                 php_http_buffer_appends(&new_prefix, "%5B");
 406                         }
 407
 408                         php_http_buffer_append(&new_prefix, encoded_key, encoded_len);
 409                         efree(encoded_key);
 410
 411                         if (prefix_str && prefix_len) {
 412                                 php_http_buffer_appends(&new_prefix, "%5D");
 413                         }
 414                         php_http_buffer_fix(&new_prefix);
 415                 }
 416
 417                 if (Z_TYPE_PP(data) == IS_ARRAY || Z_TYPE_PP(data) == IS_OBJECT) {
 418                         STATUS status;
 419                         ++ht->nApplyCount;
 420                         status = php_http_url_encode_hash_ex(HASH_OF(*data), str, arg_sep_str, arg_sep_len, val_sep_str, val_sep_len, PHP_HTTP_BUFFER_VAL(&new_prefix), PHP_HTTP_BUFFER_LEN(&new_prefix) TSRMLS_CC);
 421                         --ht->nApplyCount;
 422                         if (SUCCESS != status) {
 423                                 php_http_buffer_dtor(&new_prefix);
 424                                 php_http_buffer_dtor(str);
 425                                 return FAILURE;
 426                         }
 427                 } else {
 428                         zval *val = php_http_ztyp(IS_STRING, *data);
 429
 430                         if (PHP_HTTP_BUFFER_LEN(str)) {
 431                                 php_http_buffer_append(str, arg_sep_str, arg_sep_len);
 432                         }
 433                         php_http_buffer_append(str, PHP_HTTP_BUFFER_VAL(&new_prefix), PHP_HTTP_BUFFER_LEN(&new_prefix));
 434                         php_http_buffer_append(str, val_sep_str, val_sep_len);
 435
 436                         if (Z_STRLEN_P(val) && Z_STRVAL_P(val)) {
 437                                 char *encoded_val;
 438                                 int encoded_len;
 439
 440                                 encoded_val = php_url_encode(Z_STRVAL_P(val), Z_STRLEN_P(val), &encoded_len);
 441                                 php_http_buffer_append(str, encoded_val, encoded_len);
 442                                 efree(encoded_val);
 443                         }
 444
 445                         zval_ptr_dtor(&val);
 446                 }
 447                 php_http_buffer_dtor(&new_prefix);
 448         }
 449         return SUCCESS;
 450 }
 451
 452 #define PHP_HTTP_BEGIN_ARGS(method, req_args)   PHP_HTTP_BEGIN_ARGS_EX(HttpUrl, method, 0, req_args)
 453 #define PHP_HTTP_EMPTY_ARGS(method)                             PHP_HTTP_EMPTY_ARGS_EX(HttpUrl, method, 0)
 454 #define PHP_HTTP_URL_ME(method, visibility)     PHP_ME(HttpUrl, method, PHP_HTTP_ARGS(HttpUrl, method), visibility)
 455
 456 PHP_HTTP_BEGIN_ARGS(__construct, 0)
 457         PHP_HTTP_ARG_VAL(old_url, 0)
 458         PHP_HTTP_ARG_VAL(new_url, 0)
 459         PHP_HTTP_ARG_VAL(flags, 0)
 460 PHP_HTTP_END_ARGS;
 461 PHP_HTTP_EMPTY_ARGS(toString);
 462 PHP_HTTP_EMPTY_ARGS(toArray);
 463
 464 PHP_HTTP_BEGIN_ARGS(mod, 1)
 465         PHP_HTTP_ARG_VAL(more_url_parts, 0)
 466         PHP_HTTP_ARG_VAL(flags, 0)
 467 PHP_HTTP_END_ARGS;
 468
 469 static zend_class_entry *php_http_url_class_entry;
 470
 471 zend_class_entry *php_http_url_get_class_entry(void)
 472 {
 473         return php_http_url_class_entry;
 474 }
 475
 476 static zend_function_entry php_http_url_method_entry[] = {
 477         PHP_HTTP_URL_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 478         PHP_HTTP_URL_ME(mod, ZEND_ACC_PUBLIC)
 479         PHP_HTTP_URL_ME(toString, ZEND_ACC_PUBLIC)
 480         ZEND_MALIAS(HttpUrl, __toString, toString, PHP_HTTP_ARGS(HttpUrl, toString), ZEND_ACC_PUBLIC)
 481         PHP_HTTP_URL_ME(toArray, ZEND_ACC_PUBLIC)
 482         EMPTY_FUNCTION_ENTRY
 483 };
 484
 485 PHP_METHOD(HttpUrl, __construct)
 486 {
 487         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
 488                 zval *new_url = NULL, *old_url = NULL;
 489                 long flags = PHP_HTTP_URL_FROM_ENV;
 490
 491                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!z!l", &old_url, &new_url, &flags)) {
 492                         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
 493                                 php_url *res_purl, *new_purl = NULL, *old_purl = NULL;
 494
 495                                 if (new_url) {
 496                                         switch (Z_TYPE_P(new_url)) {
 497                                                 case IS_OBJECT:
 498                                                 case IS_ARRAY:
 499                                                         new_purl = php_http_url_from_struct(NULL, HASH_OF(new_url) TSRMLS_CC);
 500                                                         break;
 501                                                 default: {
 502                                                         zval *cpy = php_http_ztyp(IS_STRING, new_url);
 503
 504                                                         new_purl = php_url_parse(Z_STRVAL_P(cpy));
 505                                                         zval_ptr_dtor(&cpy);
 506                                                         break;
 507                                                 }
 508                                         }
 509                                         if (!new_purl) {
 510                                                 return;
 511                                         }
 512                                 }
 513                                 if (old_url) {
 514                                         switch (Z_TYPE_P(old_url)) {
 515                                                 case IS_OBJECT:
 516                                                 case IS_ARRAY:
 517                                                         old_purl = php_http_url_from_struct(NULL, HASH_OF(old_url) TSRMLS_CC);
 518                                                         break;
 519                                                 default: {
 520                                                         zval *cpy = php_http_ztyp(IS_STRING, old_url);
 521
 522                                                         old_purl = php_url_parse(Z_STRVAL_P(cpy));
 523                                                         zval_ptr_dtor(&cpy);
 524                                                         break;
 525                                                 }
 526                                         }
 527                                         if (!old_purl) {
 528                                                 if (new_purl) {
 529                                                         php_url_free(new_purl);
 530                                                 }
 531                                                 return;
 532                                         }
 533                                 }
 534
 535                                 php_http_url(flags, old_purl, new_purl, &res_purl, NULL, NULL TSRMLS_CC);
 536                                 php_http_url_to_struct(res_purl, getThis() TSRMLS_CC);
 537
 538                                 php_url_free(res_purl);
 539                                 if (old_purl) {
 540                                         php_url_free(old_purl);
 541                                 }
 542                                 if (new_purl) {
 543                                         php_url_free(new_purl);
 544                                 }
 545                         } end_error_handling();
 546                 }
 547         } end_error_handling();
 548 }
 549
 550 PHP_METHOD(HttpUrl, mod)
 551 {
 552         zval *new_url = NULL;
 553         long flags = PHP_HTTP_URL_JOIN_PATH | PHP_HTTP_URL_JOIN_QUERY;
 554
 555         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!|l", &new_url, &flags)) {
 556                 php_url *new_purl = NULL, *old_purl = NULL;
 557
 558                 if (new_url) {
 559                         switch (Z_TYPE_P(new_url)) {
 560                                 case IS_OBJECT:
 561                                 case IS_ARRAY:
 562                                         new_purl = php_http_url_from_struct(NULL, HASH_OF(new_url) TSRMLS_CC);
 563                                         break;
 564                                 default: {
 565                                         zval *cpy = php_http_ztyp(IS_STRING, new_url);
 566
 567                                         new_purl = php_url_parse(Z_STRVAL_P(new_url));
 568                                         zval_ptr_dtor(&cpy);
 569                                         break;
 570                                 }
 571                         }
 572                         if (!new_purl) {
 573                                 return;
 574                         }
 575                 }
 576
 577                 if ((old_purl = php_http_url_from_struct(NULL, HASH_OF(getThis()) TSRMLS_CC))) {
 578                         php_url *res_purl;
 579
 580                         ZVAL_OBJVAL(return_value, zend_objects_clone_obj(getThis() TSRMLS_CC), 0);
 581
 582                         php_http_url(flags, old_purl, new_purl, &res_purl, NULL, NULL TSRMLS_CC);
 583                         php_http_url_to_struct(res_purl, return_value TSRMLS_CC);
 584
 585                         php_url_free(res_purl);
 586                         php_url_free(old_purl);
 587                 }
 588                 if (new_purl) {
 589                         php_url_free(new_purl);
 590                 }
 591         }
 592 }
 593
 594 PHP_METHOD(HttpUrl, toString)
 595 {
 596         if (SUCCESS == zend_parse_parameters_none()) {
 597                 php_url *purl;
 598
 599                 if ((purl = php_http_url_from_struct(NULL, HASH_OF(getThis()) TSRMLS_CC))) {
 600                         char *str;
 601                         size_t len;
 602
 603                         php_http_url(0, purl, NULL, NULL, &str, &len TSRMLS_CC);
 604                         php_url_free(purl);
 605                         RETURN_STRINGL(str, len, 0);
 606                 }
 607         }
 608         RETURN_EMPTY_STRING();
 609 }
 610
 611 PHP_METHOD(HttpUrl, toArray)
 612 {
 613         if (SUCCESS != zend_parse_parameters_none()) {
 614                 RETURN_FALSE;
 615         }
 616         array_init(return_value);
 617         array_copy(HASH_OF(getThis()), HASH_OF(return_value));
 618 }
 619
 620 PHP_MINIT_FUNCTION(http_url)
 621 {
 622         PHP_HTTP_REGISTER_CLASS(http, Url, http_url, php_http_object_get_class_entry(), 0);
 623
 624         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("scheme"), ZEND_ACC_PUBLIC TSRMLS_CC);
 625         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("user"), ZEND_ACC_PUBLIC TSRMLS_CC);
 626         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("pass"), ZEND_ACC_PUBLIC TSRMLS_CC);
 627         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("host"), ZEND_ACC_PUBLIC TSRMLS_CC);
 628         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("port"), ZEND_ACC_PUBLIC TSRMLS_CC);
 629         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("path"), ZEND_ACC_PUBLIC TSRMLS_CC);
 630         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("query"), ZEND_ACC_PUBLIC TSRMLS_CC);
 631         zend_declare_property_null(php_http_url_class_entry, ZEND_STRL("fragment"), ZEND_ACC_PUBLIC TSRMLS_CC);
 632
 633         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("REPLACE"), PHP_HTTP_URL_REPLACE TSRMLS_CC);
 634         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_PATH"), PHP_HTTP_URL_JOIN_PATH TSRMLS_CC);
 635         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("JOIN_QUERY"), PHP_HTTP_URL_JOIN_QUERY TSRMLS_CC);
 636         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_USER"), PHP_HTTP_URL_STRIP_USER TSRMLS_CC);
 637         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PASS"), PHP_HTTP_URL_STRIP_PASS TSRMLS_CC);
 638         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_AUTH"), PHP_HTTP_URL_STRIP_AUTH TSRMLS_CC);
 639         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PORT"), PHP_HTTP_URL_STRIP_PORT TSRMLS_CC);
 640         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_PATH"), PHP_HTTP_URL_STRIP_PATH TSRMLS_CC);
 641         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_QUERY"), PHP_HTTP_URL_STRIP_QUERY TSRMLS_CC);
 642         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_FRAGMENT"), PHP_HTTP_URL_STRIP_FRAGMENT TSRMLS_CC);
 643         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("STRIP_ALL"), PHP_HTTP_URL_STRIP_ALL TSRMLS_CC);
 644         zend_declare_class_constant_long(php_http_url_class_entry, ZEND_STRL("FROM_ENV"), PHP_HTTP_URL_FROM_ENV TSRMLS_CC);
 645
 646         return SUCCESS;
 647 }
 648
 649
 650 /*
 651  * Local variables:
 652  * tab-width: 4
 653  * c-basic-offset: 4
 654  * End:
 655  * vim600: noet sw=4 ts=4 fdm=marker
 656  * vim<600: noet sw=4 ts=4
 657  */
 658