/src/php-src/ext/standard/url.c

Source (jump to first uncovered line)
/*
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Author: Jim Winstead <jimw@php.net>                                  |
   +----------------------------------------------------------------------+
 */

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>

#include "php.h"

#include "url.h"
#include "file.h"
#include "zend_simd.h"
#include "Zend/zend_smart_str.h"

/* {{{ free_url */
PHPAPI void php_url_free(php_url *theurl)
{
  if (theurl->scheme)
    zend_string_release_ex(theurl->scheme, 0);
  if (theurl->user)
    zend_string_release_ex(theurl->user, 0);
  if (theurl->pass)
    zend_string_release_ex(theurl->pass, 0);
  if (theurl->host)
    zend_string_release_ex(theurl->host, 0);
  if (theurl->path)
    zend_string_release_ex(theurl->path, 0);
  if (theurl->query)
    zend_string_release_ex(theurl->query, 0);
  if (theurl->fragment)
    zend_string_release_ex(theurl->fragment, 0);
  efree(theurl);
}
/* }}} */

static void php_replace_controlchars(char *str, size_t len)
{
  unsigned char *s = (unsigned char *)str;
  unsigned char *e = (unsigned char *)str + len;

  ZEND_ASSERT(str != NULL);

  while (s < e) {
    if (iscntrl(*s)) {
      *s='_';
    }
    s++;
  }
}

PHPAPI php_url *php_url_parse(char const *str)
{
  return php_url_parse_ex(str, strlen(str));
}

static const char *binary_strcspn(const char *s, const char *e, const char *chars) {
  while (*chars) {
    const char *p = memchr(s, *chars, e - s);
    if (p) {
      e = p;
    }
    chars++;
  }
  return e;
}

/* {{{ php_url_parse */
PHPAPI php_url *php_url_parse_ex(char const *str, size_t length)
{
  bool has_port;
  return php_url_parse_ex2(str, length, &has_port);
}

/* {{{ php_url_parse_ex2
 */
PHPAPI php_url *php_url_parse_ex2(char const *str, size_t length, bool *has_port)
{
  char port_buf[6];
  php_url *ret = ecalloc(1, sizeof(php_url));
  char const *s, *e, *p, *pp, *ue;

  *has_port = 0;
  s = str;
  ue = s + length;

  /* parse scheme */
  if ((e = memchr(s, ':', length)) && e != s) {
    /* validate scheme */
    p = s;
    while (p < e) {
      /* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */
      if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') {
        if (e + 1 < ue && e < binary_strcspn(s, ue, "?#")) {
          goto parse_port;
        } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
          s += 2;
          e = 0;
          goto parse_host;
        } else {
          goto just_path;
        }
      }
      p++;
    }

    if (e + 1 == ue) { /* only scheme is available */
      ret->scheme = zend_string_init(s, (e - s), 0);
      php_replace_controlchars(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme));
      return ret;
    }

    /*
     * certain schemas like mailto: and zlib: may not have any / after them
     * this check ensures we support those.
     */
    if (*(e+1) != '/') {
      /* check if the data we get is a port this allows us to
       * correctly parse things like a.com:80
       */
      p = e + 1;
      while (p < ue && isdigit(*p)) {
        p++;
      }

      if ((p == ue || *p == '/') && (p - e) < 7) {
        goto parse_port;
      }

      ret->scheme = zend_string_init(s, (e-s), 0);
      php_replace_controlchars(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme));

      s = e + 1;
      goto just_path;
    } else {
      ret->scheme = zend_string_init(s, (e-s), 0);
      php_replace_controlchars(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme));

      if (e + 2 < ue && *(e + 2) == '/') {
        s = e + 3;
        if (zend_string_equals_literal_ci(ret->scheme, "file")) {
          if (e + 3 < ue && *(e + 3) == '/') {
            /* support windows drive letters as in:
               file:///c:/somedir/file.txt
            */
            if (e + 5 < ue && *(e + 5) == ':') {
              s = e + 4;
            }
            goto just_path;
          }
        }
      } else {
        s = e + 1;
        goto just_path;
      }
    }
  } else if (e) { /* no scheme; starts with colon: look for port */
    parse_port:
    p = e + 1;
    pp = p;

    while (pp < ue && pp - p < 6 && isdigit(*pp)) {
      pp++;
    }

    if (pp - p > 0 && pp - p < 6 && (pp == ue || *pp == '/')) {
      zend_long port;
      char *end;
      memcpy(port_buf, p, (pp - p));
      port_buf[pp - p] = '\0';
      port = ZEND_STRTOL(port_buf, &end, 10);
      if (port >= 0 && port <= 65535 && end != port_buf) {
        *has_port = 1;
        ret->port = (unsigned short) port;
        if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
            s += 2;
        }
      } else {
        php_url_free(ret);
        return NULL;
      }
    } else if (p == pp && pp == ue) {
      php_url_free(ret);
      return NULL;
    } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
      s += 2;
    } else {
      goto just_path;
    }
  } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
    s += 2;
  } else {
    goto just_path;
  }

parse_host:
  e = binary_strcspn(s, ue, "/?#");

  /* check for login and password */
  if ((p = zend_memrchr(s, '@', (e-s)))) {
    if ((pp = memchr(s, ':', (p-s)))) {
      ret->user = zend_string_init(s, (pp-s), 0);
      php_replace_controlchars(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user));

      pp++;
      ret->pass = zend_string_init(pp, (p-pp), 0);
      php_replace_controlchars(ZSTR_VAL(ret->pass), ZSTR_LEN(ret->pass));
    } else {
      ret->user = zend_string_init(s, (p-s), 0);
      php_replace_controlchars(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user));
    }

    s = p + 1;
  }

  /* check for port */
  if (s < ue && *s == '[' && *(e-1) == ']') {
    /* Short circuit portscan,
       we're dealing with an
       IPv6 embedded address */
    p = NULL;
  } else {
    p = zend_memrchr(s, ':', (e-s));
  }

  if (p) {
    if (!ret->port) {
      p++;
      if (e-p > 5) { /* port cannot be longer then 5 characters */
        php_url_free(ret);
        return NULL;
      } else if (e - p > 0) {
        zend_long port;
        char *end;
        memcpy(port_buf, p, (e - p));
        port_buf[e - p] = '\0';
        port = ZEND_STRTOL(port_buf, &end, 10);
        if (port >= 0 && port <= 65535 && end != port_buf) {
          *has_port = 1;
          ret->port = (unsigned short)port;
        } else {
          php_url_free(ret);
          return NULL;
        }
      }
      p--;
    }
  } else {
    p = e;
  }

  /* check if we have a valid host, if we don't reject the string as url */
  if ((p-s) < 1) {
    php_url_free(ret);
    return NULL;
  }

  ret->host = zend_string_init(s, (p-s), 0);
  php_replace_controlchars(ZSTR_VAL(ret->host), ZSTR_LEN(ret->host));

  if (e == ue) {
    return ret;
  }

  s = e;

  just_path:

  e = ue;
  p = memchr(s, '#', (e - s));
  if (p) {
    p++;
    if (p < e) {
      ret->fragment = zend_string_init(p, (e - p), 0);
      php_replace_controlchars(ZSTR_VAL(ret->fragment), ZSTR_LEN(ret->fragment));
    } else {
      ret->fragment = ZSTR_EMPTY_ALLOC();
    }
    e = p-1;
  }

  p = memchr(s, '?', (e - s));
  if (p) {
    p++;
    if (p < e) {
      ret->query = zend_string_init(p, (e - p), 0);
      php_replace_controlchars(ZSTR_VAL(ret->query), ZSTR_LEN(ret->query));
    } else {
      ret->query = ZSTR_EMPTY_ALLOC();
    }
    e = p-1;
  }

  if (s < e || s == ue) {
    ret->path = zend_string_init(s, (e - s), 0);
    php_replace_controlchars(ZSTR_VAL(ret->path), ZSTR_LEN(ret->path));
  }

  return ret;
}
/* }}} */

/* {{{ Parse a URL and return its components */
PHP_FUNCTION(parse_url)
{
  char *str;
  size_t str_len;
  php_url *resource;
  zend_long key = -1;
  zval tmp;
  bool has_port;

  ZEND_PARSE_PARAMETERS_START(1, 2)
    Z_PARAM_STRING(str, str_len)
    Z_PARAM_OPTIONAL
    Z_PARAM_LONG(key)
  ZEND_PARSE_PARAMETERS_END();

  resource = php_url_parse_ex2(str, str_len, &has_port);
  if (resource == NULL) {
    /* @todo Find a method to determine why php_url_parse_ex() failed */
    RETURN_FALSE;
  }

  if (key > -1) {
    switch (key) {
      case PHP_URL_SCHEME:
        if (resource->scheme != NULL) RETVAL_STR_COPY(resource->scheme);
        break;
      case PHP_URL_HOST:
        if (resource->host != NULL) RETVAL_STR_COPY(resource->host);
        break;
      case PHP_URL_PORT:
        if (has_port) RETVAL_LONG(resource->port);
        break;
      case PHP_URL_USER:
        if (resource->user != NULL) RETVAL_STR_COPY(resource->user);
        break;
      case PHP_URL_PASS:
        if (resource->pass != NULL) RETVAL_STR_COPY(resource->pass);
        break;
      case PHP_URL_PATH:
        if (resource->path != NULL) RETVAL_STR_COPY(resource->path);
        break;
      case PHP_URL_QUERY:
        if (resource->query != NULL) RETVAL_STR_COPY(resource->query);
        break;
      case PHP_URL_FRAGMENT:
        if (resource->fragment != NULL) RETVAL_STR_COPY(resource->fragment);
        break;
      default:
        zend_argument_value_error(2, "must be a valid URL component identifier, " ZEND_LONG_FMT " given", key);
        break;
    }
    goto done;
  }

  /* allocate an array for return */
  array_init(return_value);

    /* add the various elements to the array */
  if (resource->scheme != NULL) {
    ZVAL_STR_COPY(&tmp, resource->scheme);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_SCHEME), &tmp);
  }
  if (resource->host != NULL) {
    ZVAL_STR_COPY(&tmp, resource->host);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_HOST), &tmp);
  }
  if (has_port) {
    ZVAL_LONG(&tmp, resource->port);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_PORT), &tmp);
  }
  if (resource->user != NULL) {
    ZVAL_STR_COPY(&tmp, resource->user);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_USER), &tmp);
  }
  if (resource->pass != NULL) {
    ZVAL_STR_COPY(&tmp, resource->pass);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_PASS), &tmp);
  }
  if (resource->path != NULL) {
    ZVAL_STR_COPY(&tmp, resource->path);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_PATH), &tmp);
  }
  if (resource->query != NULL) {
    ZVAL_STR_COPY(&tmp, resource->query);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_QUERY), &tmp);
  }
  if (resource->fragment != NULL) {
    ZVAL_STR_COPY(&tmp, resource->fragment);
    zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_FRAGMENT), &tmp);
  }
done:
  php_url_free(resource);
}
/* }}} */

/* https://stackoverflow.com/questions/34365746/whats-the-fastest-way-to-convert-hex-to-integer-in-c */
static unsigned int php_htoi_single(unsigned char x)
{
  ZEND_ASSERT((x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F') || (x >= '0' && x <= '9'));
  return 9 * (x >> 6) + (x & 0xf);
}

/* {{{ php_htoi */
static int php_htoi(const char *s)
{
  int value;
  unsigned char c;

  c = ((unsigned char *)s)[0];
  value = php_htoi_single(c) * 16;

  c = ((unsigned char *)s)[1];
  value += php_htoi_single(c);

  return (value);
}
/* }}} */

/* rfc1738:

   ...The characters ";",
   "/", "?", ":", "@", "=" and "&" are the characters which may be
   reserved for special meaning within a scheme...

   ...Thus, only alphanumerics, the special characters "$-_.+!*'(),", and
   reserved characters used for their reserved purposes may be used
   unencoded within a URL...

   For added safety, we only leave -_. unencoded.
 */

static const unsigned char hexchars[] = "0123456789ABCDEF";

static zend_always_inline size_t php_url_encode_impl(unsigned char *to, const char *s, size_t len, bool raw) /* {{{ */ {
  unsigned char c;
  unsigned char const *from, *end;
  const unsigned char *to_init = to;

  from = (unsigned char *)s;
  end = (unsigned char *)s + len;

#ifdef XSSE2
  while (from + 16 < end) {
    __m128i mask;
    uint32_t bits;
    const __m128i _A = _mm_set1_epi8('A' - 1);
    const __m128i Z_ = _mm_set1_epi8('Z' + 1);
    const __m128i _a = _mm_set1_epi8('a' - 1);
    const __m128i z_ = _mm_set1_epi8('z' + 1);
    const __m128i _zero = _mm_set1_epi8('0' - 1);
    const __m128i nine_ = _mm_set1_epi8('9' + 1);
    const __m128i dot = _mm_set1_epi8('.');
    const __m128i minus = _mm_set1_epi8('-');
    const __m128i under = _mm_set1_epi8('_');

    __m128i in = _mm_loadu_si128((__m128i *)from);

    __m128i gt = _mm_cmpgt_epi8(in, _A);
    __m128i lt = _mm_cmplt_epi8(in, Z_);
    mask = _mm_and_si128(lt, gt); /* upper */
    gt = _mm_cmpgt_epi8(in, _a);
    lt = _mm_cmplt_epi8(in, z_);
    mask = _mm_or_si128(mask, _mm_and_si128(lt, gt)); /* lower */
    gt = _mm_cmpgt_epi8(in, _zero);
    lt = _mm_cmplt_epi8(in, nine_);
    mask = _mm_or_si128(mask, _mm_and_si128(lt, gt)); /* number */
    mask = _mm_or_si128(mask, _mm_cmpeq_epi8(in, dot));
    mask = _mm_or_si128(mask, _mm_cmpeq_epi8(in, minus));
    mask = _mm_or_si128(mask, _mm_cmpeq_epi8(in, under));

    if (!raw) {
      const __m128i blank = _mm_set1_epi8(' ');
      __m128i eq = _mm_cmpeq_epi8(in, blank);
      if (_mm_movemask_epi8(eq)) {
        in = _mm_add_epi8(in, _mm_and_si128(eq, _mm_set1_epi8('+' - ' ')));
        mask = _mm_or_si128(mask, eq);
      }
    }
    if (raw) {
      const __m128i wavy = _mm_set1_epi8('~');
      mask = _mm_or_si128(mask, _mm_cmpeq_epi8(in, wavy));
    }
    if (((bits = _mm_movemask_epi8(mask)) & 0xffff) == 0xffff) {
      _mm_storeu_si128((__m128i*)to, in);
      to += 16;
    } else {
      unsigned char xmm[16];
      _mm_storeu_si128((__m128i*)xmm, in);
      for (size_t i = 0; i < sizeof(xmm); i++) {
        if ((bits & (0x1 << i))) {
          *to++ = xmm[i];
        } else {
          *to++ = '%';
          *to++ = hexchars[xmm[i] >> 4];
          *to++ = hexchars[xmm[i] & 0xf];
        }
      }
    }
    from += 16;
  }
#endif
  while (from < end) {
    c = *from++;

    if (!raw && c == ' ') {
      *to++ = '+';
    } else if ((c < '0' && c != '-' && c != '.') ||
        (c < 'A' && c > '9') ||
        (c > 'Z' && c < 'a' && c != '_') ||
        (c > 'z' && (!raw || c != '~'))) {
      to[0] = '%';
      to[1] = hexchars[c >> 4];
      to[2] = hexchars[c & 15];
      to += 3;
    } else {
      *to++ = c;
    }
  }

  return to - to_init;
}
/* }}} */

static zend_always_inline zend_string *php_url_encode_helper(char const *s, size_t len, bool raw)
{
  zend_string *result = zend_string_safe_alloc(3, len, 0, false);
  size_t length = php_url_encode_impl((unsigned char *) ZSTR_VAL(result), s, len, raw);
  ZSTR_VAL(result)[length] = '\0';
  ZEND_ASSERT(!ZSTR_IS_INTERNED(result) && GC_REFCOUNT(result) == 1);
  return zend_string_truncate(result, length, false);
}

/* {{{ php_url_encode */
PHPAPI zend_string *php_url_encode(char const *s, size_t len)
{
  return php_url_encode_helper(s, len, false);
}
/* }}} */

/* {{{ URL-encodes string */
PHP_FUNCTION(urlencode)
{
  zend_string *in_str;

  ZEND_PARSE_PARAMETERS_START(1, 1)
    Z_PARAM_STR(in_str)
  ZEND_PARSE_PARAMETERS_END();

  RETURN_NEW_STR(php_url_encode(ZSTR_VAL(in_str), ZSTR_LEN(in_str)));
}
/* }}} */

/* {{{ Decodes URL-encoded string */
PHP_FUNCTION(urldecode)
{
  zend_string *in_str, *out_str;

  ZEND_PARSE_PARAMETERS_START(1, 1)
    Z_PARAM_STR(in_str)
  ZEND_PARSE_PARAMETERS_END();

  out_str = zend_string_alloc(ZSTR_LEN(in_str), false);
  ZSTR_LEN(out_str) = php_url_decode_ex(ZSTR_VAL(out_str), ZSTR_VAL(in_str), ZSTR_LEN(in_str));

  RETURN_NEW_STR(out_str);
}
/* }}} */

PHPAPI size_t php_url_decode_ex(char *dest, const char *src, size_t src_len)
{
  char *dest_start = dest;
  const char *data = src;

  while (src_len--) {
    if (*data == '+') {
      *dest = ' ';
    }
    else if (*data == '%' && src_len >= 2 && isxdigit((int) *(data + 1))
         && isxdigit((int) *(data + 2))) {
      *dest = (char) php_htoi(data + 1);
      data += 2;
      src_len -= 2;
    } else {
      *dest = *data;
    }
    data++;
    dest++;
  }
  *dest = '\0';
  return dest - dest_start;
}

/* {{{ php_url_decode */
PHPAPI size_t php_url_decode(char *str, size_t len)
{
  return php_url_decode_ex(str, str, len);
}
/* }}} */

/* {{{ php_raw_url_encode */
PHPAPI zend_string *php_raw_url_encode(char const *s, size_t len)
{
  return php_url_encode_helper(s, len, true);
}
/* }}} */

PHPAPI void php_url_encode_to_smart_str(smart_str *buf, char const *s, size_t len, bool raw)
{
  size_t start_length = smart_str_get_len(buf);
  size_t extend = zend_safe_address_guarded(3, len, 0);
  char *dest = smart_str_extend(buf, extend);
  size_t length = php_url_encode_impl((unsigned char *) dest, s, len, raw);
  ZSTR_LEN(buf->s) = start_length + length;
}

/* {{{ URL-encodes string */
PHP_FUNCTION(rawurlencode)
{
  zend_string *in_str;

  ZEND_PARSE_PARAMETERS_START(1, 1)
    Z_PARAM_STR(in_str)
  ZEND_PARSE_PARAMETERS_END();

  RETURN_NEW_STR(php_raw_url_encode(ZSTR_VAL(in_str), ZSTR_LEN(in_str)));
}
/* }}} */

/* {{{ Decodes URL-encodes string */
PHP_FUNCTION(rawurldecode)
{
  zend_string *in_str, *out_str;

  ZEND_PARSE_PARAMETERS_START(1, 1)
    Z_PARAM_STR(in_str)
  ZEND_PARSE_PARAMETERS_END();

  out_str = zend_string_alloc(ZSTR_LEN(in_str), false);
  ZSTR_LEN(out_str) = php_raw_url_decode_ex(ZSTR_VAL(out_str), ZSTR_VAL(in_str), ZSTR_LEN(in_str));

  RETURN_NEW_STR(out_str);
}
/* }}} */

PHPAPI size_t php_raw_url_decode_ex(char *dest, const char *src, size_t src_len)
{
  char *dest_start = dest;
  const char *data = src;

  while (src_len--) {
    if (*data == '%' && src_len >= 2 && isxdigit((int) *(data + 1))
      && isxdigit((int) *(data + 2))) {
      *dest = (char) php_htoi(data + 1);
      data += 2;
      src_len -= 2;
    } else {
      *dest = *data;
    }
    data++;
    dest++;
  }
  *dest = '\0';
  return dest - dest_start;
}

/* {{{ php_raw_url_decode */
PHPAPI size_t php_raw_url_decode(char *str, size_t len)
{
  return php_raw_url_decode_ex(str, str, len);
}
/* }}} */

/* {{{ fetches all the headers sent by the server in response to a HTTP request */
PHP_FUNCTION(get_headers)
{
  char *url;
  size_t url_len;
  php_stream *stream;
  zval *prev_val, *hdr = NULL;
  bool format = 0;
  zval *zcontext = NULL;
  php_stream_context *context;

  ZEND_PARSE_PARAMETERS_START(1, 3)
    Z_PARAM_PATH(url, url_len)
    Z_PARAM_OPTIONAL
    Z_PARAM_BOOL(format)
    Z_PARAM_RESOURCE_OR_NULL(zcontext)
  ZEND_PARSE_PARAMETERS_END();

  context = php_stream_context_from_zval(zcontext, 0);

  if (!(stream = php_stream_open_wrapper_ex(url, "r", REPORT_ERRORS | STREAM_USE_URL | STREAM_ONLY_GET_HEADERS, NULL, context))) {
    RETURN_FALSE;
  }

  if (Z_TYPE(stream->wrapperdata) != IS_ARRAY) {
    php_stream_close(stream);
    RETURN_FALSE;
  }

  array_init(return_value);

  ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&stream->wrapperdata), hdr) {
    if (Z_TYPE_P(hdr) != IS_STRING) {
      continue;
    }
    if (!format) {
no_name_header:
      add_next_index_str(return_value, zend_string_copy(Z_STR_P(hdr)));
    } else {
      char c;
      char *s, *p;

      if ((p = strchr(Z_STRVAL_P(hdr), ':'))) {
        c = *p;
        *p = '\0';
        s = p + 1;
        while (isspace((int)*(unsigned char *)s)) {
          s++;
        }

        if ((prev_val = zend_hash_str_find(Z_ARRVAL_P(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) {
          add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
        } else { /* some headers may occur more than once, therefore we need to remake the string into an array */
          convert_to_array(prev_val);
          add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
        }

        *p = c;
      } else {
        goto no_name_header;
      }
    }
  } ZEND_HASH_FOREACH_END();

  php_stream_close(stream);
}
/* }}} */

Coverage Report

Created: 2025-06-13 06:43