1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 7 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2017 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Author: Jim Winstead <jimw@php.net> |
16 +----------------------------------------------------------------------+
17 */
18 /* $Id$ */
19
20 #include <stdlib.h>
21 #include <string.h>
22 #include <ctype.h>
23 #include <sys/types.h>
24
25 #include "php.h"
26
27 #include "url.h"
28 #include "file.h"
29 #ifdef _OSD_POSIX
30 #ifndef APACHE
31 #error On this EBCDIC platform, PHP is only supported as an Apache module.
32 #else /*APACHE*/
33 #ifndef CHARSET_EBCDIC
34 #define CHARSET_EBCDIC /* this machine uses EBCDIC, not ASCII! */
35 #endif
36 #include "ebcdic.h"
37 #endif /*APACHE*/
38 #endif /*_OSD_POSIX*/
39
40 /* {{{ free_url
41 */
php_url_free(php_url * theurl)42 PHPAPI void php_url_free(php_url *theurl)
43 {
44 if (theurl->scheme)
45 efree(theurl->scheme);
46 if (theurl->user)
47 efree(theurl->user);
48 if (theurl->pass)
49 efree(theurl->pass);
50 if (theurl->host)
51 efree(theurl->host);
52 if (theurl->path)
53 efree(theurl->path);
54 if (theurl->query)
55 efree(theurl->query);
56 if (theurl->fragment)
57 efree(theurl->fragment);
58 efree(theurl);
59 }
60 /* }}} */
61
62 /* {{{ php_replace_controlchars
63 */
php_replace_controlchars_ex(char * str,size_t len)64 PHPAPI char *php_replace_controlchars_ex(char *str, size_t len)
65 {
66 unsigned char *s = (unsigned char *)str;
67 unsigned char *e = (unsigned char *)str + len;
68
69 if (!str) {
70 return (NULL);
71 }
72
73 while (s < e) {
74
75 if (iscntrl(*s)) {
76 *s='_';
77 }
78 s++;
79 }
80
81 return (str);
82 }
83 /* }}} */
84
php_replace_controlchars(char * str)85 PHPAPI char *php_replace_controlchars(char *str)
86 {
87 return php_replace_controlchars_ex(str, strlen(str));
88 }
89
php_url_parse(char const * str)90 PHPAPI php_url *php_url_parse(char const *str)
91 {
92 return php_url_parse_ex(str, strlen(str));
93 }
94
95 /* {{{ php_url_parse
96 */
php_url_parse_ex(char const * str,size_t length)97 PHPAPI php_url *php_url_parse_ex(char const *str, size_t length)
98 {
99 char port_buf[6];
100 php_url *ret = ecalloc(1, sizeof(php_url));
101 char const *s, *e, *p, *pp, *ue;
102
103 s = str;
104 ue = s + length;
105
106 /* parse scheme */
107 if ((e = memchr(s, ':', length)) && e != s) {
108 /* validate scheme */
109 p = s;
110 while (p < e) {
111 /* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */
112 if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') {
113 if (e + 1 < ue && e < s + strcspn(s, "?#")) {
114 goto parse_port;
115 } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
116 s += 2;
117 e = 0;
118 goto parse_host;
119 } else {
120 goto just_path;
121 }
122 }
123 p++;
124 }
125
126 if (e + 1 == ue) { /* only scheme is available */
127 ret->scheme = estrndup(s, (e - s));
128 php_replace_controlchars_ex(ret->scheme, (e - s));
129 return ret;
130 }
131
132 /*
133 * certain schemas like mailto: and zlib: may not have any / after them
134 * this check ensures we support those.
135 */
136 if (*(e+1) != '/') {
137 /* check if the data we get is a port this allows us to
138 * correctly parse things like a.com:80
139 */
140 p = e + 1;
141 while (p < ue && isdigit(*p)) {
142 p++;
143 }
144
145 if ((p == ue || *p == '/') && (p - e) < 7) {
146 goto parse_port;
147 }
148
149 ret->scheme = estrndup(s, (e-s));
150 php_replace_controlchars_ex(ret->scheme, (e - s));
151
152 s = e + 1;
153 goto just_path;
154 } else {
155 ret->scheme = estrndup(s, (e-s));
156 php_replace_controlchars_ex(ret->scheme, (e - s));
157
158 if (e + 2 < ue && *(e + 2) == '/') {
159 s = e + 3;
160 if (!strncasecmp("file", ret->scheme, sizeof("file"))) {
161 if (e + 3 < ue && *(e + 3) == '/') {
162 /* support windows drive letters as in:
163 file:///c:/somedir/file.txt
164 */
165 if (e + 5 < ue && *(e + 5) == ':') {
166 s = e + 4;
167 }
168 goto just_path;
169 }
170 }
171 } else {
172 s = e + 1;
173 goto just_path;
174 }
175 }
176 } else if (e) { /* no scheme; starts with colon: look for port */
177 parse_port:
178 p = e + 1;
179 pp = p;
180
181 while (pp < ue && pp - p < 6 && isdigit(*pp)) {
182 pp++;
183 }
184
185 if (pp - p > 0 && pp - p < 6 && (pp == ue || *pp == '/')) {
186 zend_long port;
187 memcpy(port_buf, p, (pp - p));
188 port_buf[pp - p] = '\0';
189 port = ZEND_STRTOL(port_buf, NULL, 10);
190 if (port > 0 && port <= 65535) {
191 ret->port = (unsigned short) port;
192 if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
193 s += 2;
194 }
195 } else {
196 if (ret->scheme) efree(ret->scheme);
197 efree(ret);
198 return NULL;
199 }
200 } else if (p == pp && pp == ue) {
201 if (ret->scheme) efree(ret->scheme);
202 efree(ret);
203 return NULL;
204 } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
205 s += 2;
206 } else {
207 goto just_path;
208 }
209 } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
210 s += 2;
211 } else {
212 goto just_path;
213 }
214
215 parse_host:
216 /* Binary-safe strcspn(s, "/?#") */
217 e = ue;
218 if ((p = memchr(s, '/', e - s))) {
219 e = p;
220 }
221 if ((p = memchr(s, '?', e - s))) {
222 e = p;
223 }
224 if ((p = memchr(s, '#', e - s))) {
225 e = p;
226 }
227
228 /* check for login and password */
229 if ((p = zend_memrchr(s, '@', (e-s)))) {
230 if ((pp = memchr(s, ':', (p-s)))) {
231 ret->user = estrndup(s, (pp-s));
232 php_replace_controlchars_ex(ret->user, (pp - s));
233
234 pp++;
235 ret->pass = estrndup(pp, (p-pp));
236 php_replace_controlchars_ex(ret->pass, (p-pp));
237 } else {
238 ret->user = estrndup(s, (p-s));
239 php_replace_controlchars_ex(ret->user, (p-s));
240 }
241
242 s = p + 1;
243 }
244
245 /* check for port */
246 if (s < ue && *s == '[' && *(e-1) == ']') {
247 /* Short circuit portscan,
248 we're dealing with an
249 IPv6 embedded address */
250 p = NULL;
251 } else {
252 p = zend_memrchr(s, ':', (e-s));
253 }
254
255 if (p) {
256 if (!ret->port) {
257 p++;
258 if (e-p > 5) { /* port cannot be longer then 5 characters */
259 if (ret->scheme) efree(ret->scheme);
260 if (ret->user) efree(ret->user);
261 if (ret->pass) efree(ret->pass);
262 efree(ret);
263 return NULL;
264 } else if (e - p > 0) {
265 zend_long port;
266 memcpy(port_buf, p, (e - p));
267 port_buf[e - p] = '\0';
268 port = ZEND_STRTOL(port_buf, NULL, 10);
269 if (port > 0 && port <= 65535) {
270 ret->port = (unsigned short)port;
271 } else {
272 if (ret->scheme) efree(ret->scheme);
273 if (ret->user) efree(ret->user);
274 if (ret->pass) efree(ret->pass);
275 efree(ret);
276 return NULL;
277 }
278 }
279 p--;
280 }
281 } else {
282 p = e;
283 }
284
285 /* check if we have a valid host, if we don't reject the string as url */
286 if ((p-s) < 1) {
287 if (ret->scheme) efree(ret->scheme);
288 if (ret->user) efree(ret->user);
289 if (ret->pass) efree(ret->pass);
290 efree(ret);
291 return NULL;
292 }
293
294 ret->host = estrndup(s, (p-s));
295 php_replace_controlchars_ex(ret->host, (p - s));
296
297 if (e == ue) {
298 return ret;
299 }
300
301 s = e;
302
303 just_path:
304
305 e = ue;
306 p = memchr(s, '#', (e - s));
307 if (p) {
308 p++;
309 if (p < e) {
310 ret->fragment = estrndup(p, (e - p));
311 php_replace_controlchars_ex(ret->fragment, (e - p));
312 }
313 e = p-1;
314 }
315
316 p = memchr(s, '?', (e - s));
317 if (p) {
318 p++;
319 if (p < e) {
320 ret->query = estrndup(p, (e - p));
321 php_replace_controlchars_ex(ret->query, (e - p));
322 }
323 e = p-1;
324 }
325
326 if (s < e || s == ue) {
327 ret->path = estrndup(s, (e - s));
328 php_replace_controlchars_ex(ret->path, (e - s));
329 }
330
331 return ret;
332 }
333 /* }}} */
334
335 /* {{{ proto mixed parse_url(string url, [int url_component])
336 Parse a URL and return its components */
PHP_FUNCTION(parse_url)337 PHP_FUNCTION(parse_url)
338 {
339 char *str;
340 size_t str_len;
341 php_url *resource;
342 zend_long key = -1;
343
344 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &key) == FAILURE) {
345 return;
346 }
347
348 resource = php_url_parse_ex(str, str_len);
349 if (resource == NULL) {
350 /* @todo Find a method to determine why php_url_parse_ex() failed */
351 RETURN_FALSE;
352 }
353
354 if (key > -1) {
355 switch (key) {
356 case PHP_URL_SCHEME:
357 if (resource->scheme != NULL) RETVAL_STRING(resource->scheme);
358 break;
359 case PHP_URL_HOST:
360 if (resource->host != NULL) RETVAL_STRING(resource->host);
361 break;
362 case PHP_URL_PORT:
363 if (resource->port != 0) RETVAL_LONG(resource->port);
364 break;
365 case PHP_URL_USER:
366 if (resource->user != NULL) RETVAL_STRING(resource->user);
367 break;
368 case PHP_URL_PASS:
369 if (resource->pass != NULL) RETVAL_STRING(resource->pass);
370 break;
371 case PHP_URL_PATH:
372 if (resource->path != NULL) RETVAL_STRING(resource->path);
373 break;
374 case PHP_URL_QUERY:
375 if (resource->query != NULL) RETVAL_STRING(resource->query);
376 break;
377 case PHP_URL_FRAGMENT:
378 if (resource->fragment != NULL) RETVAL_STRING(resource->fragment);
379 break;
380 default:
381 php_error_docref(NULL, E_WARNING, "Invalid URL component identifier " ZEND_LONG_FMT, key);
382 RETVAL_FALSE;
383 }
384 goto done;
385 }
386
387 /* allocate an array for return */
388 array_init(return_value);
389
390 /* add the various elements to the array */
391 if (resource->scheme != NULL)
392 add_assoc_string(return_value, "scheme", resource->scheme);
393 if (resource->host != NULL)
394 add_assoc_string(return_value, "host", resource->host);
395 if (resource->port != 0)
396 add_assoc_long(return_value, "port", resource->port);
397 if (resource->user != NULL)
398 add_assoc_string(return_value, "user", resource->user);
399 if (resource->pass != NULL)
400 add_assoc_string(return_value, "pass", resource->pass);
401 if (resource->path != NULL)
402 add_assoc_string(return_value, "path", resource->path);
403 if (resource->query != NULL)
404 add_assoc_string(return_value, "query", resource->query);
405 if (resource->fragment != NULL)
406 add_assoc_string(return_value, "fragment", resource->fragment);
407 done:
408 php_url_free(resource);
409 }
410 /* }}} */
411
412 /* {{{ php_htoi
413 */
php_htoi(char * s)414 static int php_htoi(char *s)
415 {
416 int value;
417 int c;
418
419 c = ((unsigned char *)s)[0];
420 if (isupper(c))
421 c = tolower(c);
422 value = (c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10) * 16;
423
424 c = ((unsigned char *)s)[1];
425 if (isupper(c))
426 c = tolower(c);
427 value += c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10;
428
429 return (value);
430 }
431 /* }}} */
432
433 /* rfc1738:
434
435 ...The characters ";",
436 "/", "?", ":", "@", "=" and "&" are the characters which may be
437 reserved for special meaning within a scheme...
438
439 ...Thus, only alphanumerics, the special characters "$-_.+!*'(),", and
440 reserved characters used for their reserved purposes may be used
441 unencoded within a URL...
442
443 For added safety, we only leave -_. unencoded.
444 */
445
446 static unsigned char hexchars[] = "0123456789ABCDEF";
447
448 /* {{{ php_url_encode
449 */
php_url_encode(char const * s,size_t len)450 PHPAPI zend_string *php_url_encode(char const *s, size_t len)
451 {
452 register unsigned char c;
453 unsigned char *to;
454 unsigned char const *from, *end;
455 zend_string *start;
456
457 from = (unsigned char *)s;
458 end = (unsigned char *)s + len;
459 start = zend_string_safe_alloc(3, len, 0, 0);
460 to = (unsigned char*)ZSTR_VAL(start);
461
462 while (from < end) {
463 c = *from++;
464
465 if (c == ' ') {
466 *to++ = '+';
467 #ifndef CHARSET_EBCDIC
468 } else if ((c < '0' && c != '-' && c != '.') ||
469 (c < 'A' && c > '9') ||
470 (c > 'Z' && c < 'a' && c != '_') ||
471 (c > 'z')) {
472 to[0] = '%';
473 to[1] = hexchars[c >> 4];
474 to[2] = hexchars[c & 15];
475 to += 3;
476 #else /*CHARSET_EBCDIC*/
477 } else if (!isalnum(c) && strchr("_-.", c) == NULL) {
478 /* Allow only alphanumeric chars and '_', '-', '.'; escape the rest */
479 to[0] = '%';
480 to[1] = hexchars[os_toascii[c] >> 4];
481 to[2] = hexchars[os_toascii[c] & 15];
482 to += 3;
483 #endif /*CHARSET_EBCDIC*/
484 } else {
485 *to++ = c;
486 }
487 }
488 *to = '\0';
489
490 start = zend_string_truncate(start, to - (unsigned char*)ZSTR_VAL(start), 0);
491
492 return start;
493 }
494 /* }}} */
495
496 /* {{{ proto string urlencode(string str)
497 URL-encodes string */
PHP_FUNCTION(urlencode)498 PHP_FUNCTION(urlencode)
499 {
500 zend_string *in_str;
501
502 ZEND_PARSE_PARAMETERS_START(1, 1)
503 Z_PARAM_STR(in_str)
504 ZEND_PARSE_PARAMETERS_END();
505
506 RETURN_STR(php_url_encode(ZSTR_VAL(in_str), ZSTR_LEN(in_str)));
507 }
508 /* }}} */
509
510 /* {{{ proto string urldecode(string str)
511 Decodes URL-encoded string */
PHP_FUNCTION(urldecode)512 PHP_FUNCTION(urldecode)
513 {
514 zend_string *in_str, *out_str;
515
516 ZEND_PARSE_PARAMETERS_START(1, 1)
517 Z_PARAM_STR(in_str)
518 ZEND_PARSE_PARAMETERS_END();
519
520 out_str = zend_string_init(ZSTR_VAL(in_str), ZSTR_LEN(in_str), 0);
521 ZSTR_LEN(out_str) = php_url_decode(ZSTR_VAL(out_str), ZSTR_LEN(out_str));
522
523 RETURN_NEW_STR(out_str);
524 }
525 /* }}} */
526
527 /* {{{ php_url_decode
528 */
php_url_decode(char * str,size_t len)529 PHPAPI size_t php_url_decode(char *str, size_t len)
530 {
531 char *dest = str;
532 char *data = str;
533
534 while (len--) {
535 if (*data == '+') {
536 *dest = ' ';
537 }
538 else if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1))
539 && isxdigit((int) *(data + 2))) {
540 #ifndef CHARSET_EBCDIC
541 *dest = (char) php_htoi(data + 1);
542 #else
543 *dest = os_toebcdic[(char) php_htoi(data + 1)];
544 #endif
545 data += 2;
546 len -= 2;
547 } else {
548 *dest = *data;
549 }
550 data++;
551 dest++;
552 }
553 *dest = '\0';
554 return dest - str;
555 }
556 /* }}} */
557
558 /* {{{ php_raw_url_encode
559 */
php_raw_url_encode(char const * s,size_t len)560 PHPAPI zend_string *php_raw_url_encode(char const *s, size_t len)
561 {
562 register size_t x, y;
563 zend_string *str;
564
565 str = zend_string_safe_alloc(3, len, 0, 0);
566 for (x = 0, y = 0; len--; x++, y++) {
567 ZSTR_VAL(str)[y] = (unsigned char) s[x];
568 #ifndef CHARSET_EBCDIC
569 if ((ZSTR_VAL(str)[y] < '0' && ZSTR_VAL(str)[y] != '-' && ZSTR_VAL(str)[y] != '.') ||
570 (ZSTR_VAL(str)[y] < 'A' && ZSTR_VAL(str)[y] > '9') ||
571 (ZSTR_VAL(str)[y] > 'Z' && ZSTR_VAL(str)[y] < 'a' && ZSTR_VAL(str)[y] != '_') ||
572 (ZSTR_VAL(str)[y] > 'z' && ZSTR_VAL(str)[y] != '~')) {
573 ZSTR_VAL(str)[y++] = '%';
574 ZSTR_VAL(str)[y++] = hexchars[(unsigned char) s[x] >> 4];
575 ZSTR_VAL(str)[y] = hexchars[(unsigned char) s[x] & 15];
576 #else /*CHARSET_EBCDIC*/
577 if (!isalnum(ZSTR_VAL(str)[y]) && strchr("_-.~", ZSTR_VAL(str)[y]) != NULL) {
578 ZSTR_VAL(str)[y++] = '%';
579 ZSTR_VAL(str)[y++] = hexchars[os_toascii[(unsigned char) s[x]] >> 4];
580 ZSTR_VAL(str)[y] = hexchars[os_toascii[(unsigned char) s[x]] & 15];
581 #endif /*CHARSET_EBCDIC*/
582 }
583 }
584 ZSTR_VAL(str)[y] = '\0';
585 str = zend_string_truncate(str, y, 0);
586
587 return str;
588 }
589 /* }}} */
590
591 /* {{{ proto string rawurlencode(string str)
592 URL-encodes string */
593 PHP_FUNCTION(rawurlencode)
594 {
595 zend_string *in_str;
596
597 ZEND_PARSE_PARAMETERS_START(1, 1)
598 Z_PARAM_STR(in_str)
599 ZEND_PARSE_PARAMETERS_END();
600
601 RETURN_STR(php_raw_url_encode(ZSTR_VAL(in_str), ZSTR_LEN(in_str)));
602 }
603 /* }}} */
604
605 /* {{{ proto string rawurldecode(string str)
606 Decodes URL-encodes string */
607 PHP_FUNCTION(rawurldecode)
608 {
609 zend_string *in_str, *out_str;
610
611 ZEND_PARSE_PARAMETERS_START(1, 1)
612 Z_PARAM_STR(in_str)
613 ZEND_PARSE_PARAMETERS_END();
614
615 out_str = zend_string_init(ZSTR_VAL(in_str), ZSTR_LEN(in_str), 0);
616 ZSTR_LEN(out_str) = php_raw_url_decode(ZSTR_VAL(out_str), ZSTR_LEN(out_str));
617
618 RETURN_NEW_STR(out_str);
619 }
620 /* }}} */
621
622 /* {{{ php_raw_url_decode
623 */
624 PHPAPI size_t php_raw_url_decode(char *str, size_t len)
625 {
626 char *dest = str;
627 char *data = str;
628
629 while (len--) {
630 if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1))
631 && isxdigit((int) *(data + 2))) {
632 #ifndef CHARSET_EBCDIC
633 *dest = (char) php_htoi(data + 1);
634 #else
635 *dest = os_toebcdic[(char) php_htoi(data + 1)];
636 #endif
637 data += 2;
638 len -= 2;
639 } else {
640 *dest = *data;
641 }
642 data++;
643 dest++;
644 }
645 *dest = '\0';
646 return dest - str;
647 }
648 /* }}} */
649
650 /* {{{ proto array get_headers(string url[, int format])
651 fetches all the headers sent by the server in response to a HTTP request */
652 PHP_FUNCTION(get_headers)
653 {
654 char *url;
655 size_t url_len;
656 php_stream_context *context;
657 php_stream *stream;
658 zval *prev_val, *hdr = NULL, *h;
659 HashTable *hashT;
660 zend_long format = 0;
661
662 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &url, &url_len, &format) == FAILURE) {
663 return;
664 }
665 context = FG(default_context) ? FG(default_context) : (FG(default_context) = php_stream_context_alloc());
666
667 if (!(stream = php_stream_open_wrapper_ex(url, "r", REPORT_ERRORS | STREAM_USE_URL | STREAM_ONLY_GET_HEADERS, NULL, context))) {
668 RETURN_FALSE;
669 }
670
671 if (Z_TYPE(stream->wrapperdata) != IS_ARRAY) {
672 php_stream_close(stream);
673 RETURN_FALSE;
674 }
675
676 array_init(return_value);
677
678 /* check for curl-wrappers that provide headers via a special "headers" element */
679 if ((h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1)) != NULL && Z_TYPE_P(h) == IS_ARRAY) {
680 /* curl-wrappers don't load data until the 1st read */
681 if (!Z_ARRVAL_P(h)->nNumOfElements) {
682 php_stream_getc(stream);
683 }
684 h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1);
685 hashT = Z_ARRVAL_P(h);
686 } else {
687 hashT = HASH_OF(&stream->wrapperdata);
688 }
689
690 ZEND_HASH_FOREACH_VAL(hashT, hdr) {
691 if (Z_TYPE_P(hdr) != IS_STRING) {
692 continue;
693 }
694 if (!format) {
695 no_name_header:
696 add_next_index_str(return_value, zend_string_copy(Z_STR_P(hdr)));
697 } else {
698 char c;
699 char *s, *p;
700
701 if ((p = strchr(Z_STRVAL_P(hdr), ':'))) {
702 c = *p;
703 *p = '\0';
704 s = p + 1;
705 while (isspace((int)*(unsigned char *)s)) {
706 s++;
707 }
708
709 if ((prev_val = zend_hash_str_find(Z_ARRVAL_P(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) {
710 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))));
711 } else { /* some headers may occur more than once, therefor we need to remake the string into an array */
712 convert_to_array(prev_val);
713 add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
714 }
715
716 *p = c;
717 } else {
718 goto no_name_header;
719 }
720 }
721 } ZEND_HASH_FOREACH_END();
722
723 php_stream_close(stream);
724 }
725 /* }}} */
726
727 /*
728 * Local variables:
729 * tab-width: 4
730 * c-basic-offset: 4
731 * End:
732 * vim600: sw=4 ts=4 fdm=marker
733 * vim<600: sw=4 ts=4
734 */
735
