Annotation of embedaddon/php/ext/iconv/iconv.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 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: | Authors: Rui Hirokawa <rui_hirokawa@ybb.ne.jp> |
! 16: | Stig Bakken <ssb@php.net> |
! 17: | Moriyoshi Koizumi <moriyoshi@php.net> |
! 18: +----------------------------------------------------------------------+
! 19: */
! 20:
! 21: /* $Id: iconv.c 321634 2012-01-01 13:15:04Z felipe $ */
! 22:
! 23: #ifdef HAVE_CONFIG_H
! 24: #include "config.h"
! 25: #endif
! 26:
! 27: #include "php.h"
! 28: #include "php_globals.h"
! 29: #include "ext/standard/info.h"
! 30: #include "main/php_output.h"
! 31: #include "SAPI.h"
! 32: #include "php_ini.h"
! 33:
! 34: #ifdef HAVE_STDLIB_H
! 35: # include <stdlib.h>
! 36: #endif
! 37:
! 38: #include <errno.h>
! 39:
! 40: #include "php_iconv.h"
! 41:
! 42: #ifdef HAVE_ICONV
! 43:
! 44: #ifdef PHP_ICONV_H_PATH
! 45: #include PHP_ICONV_H_PATH
! 46: #else
! 47: #include <iconv.h>
! 48: #endif
! 49:
! 50: #ifdef HAVE_GLIBC_ICONV
! 51: #include <gnu/libc-version.h>
! 52: #endif
! 53:
! 54: #ifdef HAVE_LIBICONV
! 55: #undef iconv
! 56: #endif
! 57:
! 58: #include "ext/standard/php_smart_str.h"
! 59: #include "ext/standard/base64.h"
! 60: #include "ext/standard/quot_print.h"
! 61:
! 62: #define _php_iconv_memequal(a, b, c) \
! 63: ((c) == sizeof(unsigned long) ? *((unsigned long *)(a)) == *((unsigned long *)(b)) : ((c) == sizeof(unsigned int) ? *((unsigned int *)(a)) == *((unsigned int *)(b)) : memcmp(a, b, c) == 0))
! 64:
! 65: /* {{{ arginfo */
! 66: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_strlen, 0, 0, 1)
! 67: ZEND_ARG_INFO(0, str)
! 68: ZEND_ARG_INFO(0, charset)
! 69: ZEND_END_ARG_INFO()
! 70:
! 71: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_substr, 0, 0, 2)
! 72: ZEND_ARG_INFO(0, str)
! 73: ZEND_ARG_INFO(0, offset)
! 74: ZEND_ARG_INFO(0, length)
! 75: ZEND_ARG_INFO(0, charset)
! 76: ZEND_END_ARG_INFO()
! 77:
! 78: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_strpos, 0, 0, 2)
! 79: ZEND_ARG_INFO(0, haystack)
! 80: ZEND_ARG_INFO(0, needle)
! 81: ZEND_ARG_INFO(0, offset)
! 82: ZEND_ARG_INFO(0, charset)
! 83: ZEND_END_ARG_INFO()
! 84:
! 85: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_strrpos, 0, 0, 2)
! 86: ZEND_ARG_INFO(0, haystack)
! 87: ZEND_ARG_INFO(0, needle)
! 88: ZEND_ARG_INFO(0, charset)
! 89: ZEND_END_ARG_INFO()
! 90:
! 91: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_mime_encode, 0, 0, 2)
! 92: ZEND_ARG_INFO(0, field_name)
! 93: ZEND_ARG_INFO(0, field_value)
! 94: ZEND_ARG_INFO(0, preference) /* ZEND_ARG_ARRAY_INFO(0, preference, 1) */
! 95: ZEND_END_ARG_INFO()
! 96:
! 97: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_mime_decode, 0, 0, 1)
! 98: ZEND_ARG_INFO(0, encoded_string)
! 99: ZEND_ARG_INFO(0, mode)
! 100: ZEND_ARG_INFO(0, charset)
! 101: ZEND_END_ARG_INFO()
! 102:
! 103: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_mime_decode_headers, 0, 0, 1)
! 104: ZEND_ARG_INFO(0, headers)
! 105: ZEND_ARG_INFO(0, mode)
! 106: ZEND_ARG_INFO(0, charset)
! 107: ZEND_END_ARG_INFO()
! 108:
! 109: ZEND_BEGIN_ARG_INFO(arginfo_iconv, 0)
! 110: ZEND_ARG_INFO(0, in_charset)
! 111: ZEND_ARG_INFO(0, out_charset)
! 112: ZEND_ARG_INFO(0, str)
! 113: ZEND_END_ARG_INFO()
! 114:
! 115: ZEND_BEGIN_ARG_INFO(arginfo_ob_iconv_handler, 0)
! 116: ZEND_ARG_INFO(0, contents)
! 117: ZEND_ARG_INFO(0, status)
! 118: ZEND_END_ARG_INFO()
! 119:
! 120: ZEND_BEGIN_ARG_INFO(arginfo_iconv_set_encoding, 0)
! 121: ZEND_ARG_INFO(0, type)
! 122: ZEND_ARG_INFO(0, charset)
! 123: ZEND_END_ARG_INFO()
! 124:
! 125: ZEND_BEGIN_ARG_INFO_EX(arginfo_iconv_get_encoding, 0, 0, 0)
! 126: ZEND_ARG_INFO(0, type)
! 127: ZEND_END_ARG_INFO()
! 128:
! 129: /* }}} */
! 130:
! 131: /* {{{ iconv_functions[]
! 132: */
! 133: const zend_function_entry iconv_functions[] = {
! 134: PHP_RAW_NAMED_FE(iconv,php_if_iconv, arginfo_iconv)
! 135: PHP_FE(ob_iconv_handler, arginfo_ob_iconv_handler)
! 136: PHP_FE(iconv_get_encoding, arginfo_iconv_get_encoding)
! 137: PHP_FE(iconv_set_encoding, arginfo_iconv_set_encoding)
! 138: PHP_FE(iconv_strlen, arginfo_iconv_strlen)
! 139: PHP_FE(iconv_substr, arginfo_iconv_substr)
! 140: PHP_FE(iconv_strpos, arginfo_iconv_strpos)
! 141: PHP_FE(iconv_strrpos, arginfo_iconv_strrpos)
! 142: PHP_FE(iconv_mime_encode, arginfo_iconv_mime_encode)
! 143: PHP_FE(iconv_mime_decode, arginfo_iconv_mime_decode)
! 144: PHP_FE(iconv_mime_decode_headers, arginfo_iconv_mime_decode_headers)
! 145: PHP_FE_END
! 146: };
! 147: /* }}} */
! 148:
! 149: ZEND_DECLARE_MODULE_GLOBALS(iconv)
! 150: static PHP_GINIT_FUNCTION(iconv);
! 151:
! 152: /* {{{ iconv_module_entry
! 153: */
! 154: zend_module_entry iconv_module_entry = {
! 155: STANDARD_MODULE_HEADER,
! 156: "iconv",
! 157: iconv_functions,
! 158: PHP_MINIT(miconv),
! 159: PHP_MSHUTDOWN(miconv),
! 160: NULL,
! 161: NULL,
! 162: PHP_MINFO(miconv),
! 163: NO_VERSION_YET,
! 164: PHP_MODULE_GLOBALS(iconv),
! 165: PHP_GINIT(iconv),
! 166: NULL,
! 167: NULL,
! 168: STANDARD_MODULE_PROPERTIES_EX
! 169: };
! 170: /* }}} */
! 171:
! 172: #ifdef COMPILE_DL_ICONV
! 173: ZEND_GET_MODULE(iconv)
! 174: #endif
! 175:
! 176: /* {{{ PHP_GINIT_FUNCTION */
! 177: static PHP_GINIT_FUNCTION(iconv)
! 178: {
! 179: iconv_globals->input_encoding = NULL;
! 180: iconv_globals->output_encoding = NULL;
! 181: iconv_globals->internal_encoding = NULL;
! 182: }
! 183: /* }}} */
! 184:
! 185: #if defined(HAVE_LIBICONV) && defined(ICONV_ALIASED_LIBICONV)
! 186: #define iconv libiconv
! 187: #endif
! 188:
! 189: /* {{{ typedef enum php_iconv_enc_scheme_t */
! 190: typedef enum _php_iconv_enc_scheme_t {
! 191: PHP_ICONV_ENC_SCHEME_BASE64,
! 192: PHP_ICONV_ENC_SCHEME_QPRINT
! 193: } php_iconv_enc_scheme_t;
! 194: /* }}} */
! 195:
! 196: #define PHP_ICONV_MIME_DECODE_STRICT (1<<0)
! 197: #define PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR (1<<1)
! 198:
! 199: /* {{{ prototypes */
! 200: static php_iconv_err_t _php_iconv_appendl(smart_str *d, const char *s, size_t l, iconv_t cd);
! 201: static php_iconv_err_t _php_iconv_appendc(smart_str *d, const char c, iconv_t cd);
! 202:
! 203: static void _php_iconv_show_error(php_iconv_err_t err, const char *out_charset, const char *in_charset TSRMLS_DC);
! 204:
! 205: static php_iconv_err_t _php_iconv_strlen(unsigned int *pretval, const char *str, size_t nbytes, const char *enc);
! 206:
! 207: static php_iconv_err_t _php_iconv_substr(smart_str *pretval, const char *str, size_t nbytes, int offset, int len, const char *enc);
! 208:
! 209: static php_iconv_err_t _php_iconv_strpos(unsigned int *pretval, const char *haystk, size_t haystk_nbytes, const char *ndl, size_t ndl_nbytes, int offset, const char *enc);
! 210:
! 211: static php_iconv_err_t _php_iconv_mime_encode(smart_str *pretval, const char *fname, size_t fname_nbytes, const char *fval, size_t fval_nbytes, unsigned int max_line_len, const char *lfchars, php_iconv_enc_scheme_t enc_scheme, const char *out_charset, const char *enc);
! 212:
! 213: static php_iconv_err_t _php_iconv_mime_decode(smart_str *pretval, const char *str, size_t str_nbytes, const char *enc, const char **next_pos, int mode);
! 214:
! 215: static php_iconv_err_t php_iconv_stream_filter_register_factory(TSRMLS_D);
! 216: static php_iconv_err_t php_iconv_stream_filter_unregister_factory(TSRMLS_D);
! 217: /* }}} */
! 218:
! 219: /* {{{ static globals */
! 220: static char _generic_superset_name[] = ICONV_UCS4_ENCODING;
! 221: #define GENERIC_SUPERSET_NAME _generic_superset_name
! 222: #define GENERIC_SUPERSET_NBYTES 4
! 223: /* }}} */
! 224:
! 225: static PHP_INI_MH(OnUpdateStringIconvCharset)
! 226: {
! 227: if(new_value_length >= ICONV_CSNMAXLEN) {
! 228: return FAILURE;
! 229: }
! 230: OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
! 231: return SUCCESS;
! 232: }
! 233:
! 234: /* {{{ PHP_INI
! 235: */
! 236: PHP_INI_BEGIN()
! 237: STD_PHP_INI_ENTRY("iconv.input_encoding", ICONV_INPUT_ENCODING, PHP_INI_ALL, OnUpdateStringIconvCharset, input_encoding, zend_iconv_globals, iconv_globals)
! 238: STD_PHP_INI_ENTRY("iconv.output_encoding", ICONV_OUTPUT_ENCODING, PHP_INI_ALL, OnUpdateStringIconvCharset, output_encoding, zend_iconv_globals, iconv_globals)
! 239: STD_PHP_INI_ENTRY("iconv.internal_encoding", ICONV_INTERNAL_ENCODING, PHP_INI_ALL, OnUpdateStringIconvCharset, internal_encoding, zend_iconv_globals, iconv_globals)
! 240: PHP_INI_END()
! 241: /* }}} */
! 242:
! 243: /* {{{ PHP_MINIT_FUNCTION */
! 244: PHP_MINIT_FUNCTION(miconv)
! 245: {
! 246: char *version = "unknown";
! 247:
! 248: REGISTER_INI_ENTRIES();
! 249:
! 250: #if HAVE_LIBICONV
! 251: {
! 252: static char buf[16];
! 253: snprintf(buf, sizeof(buf), "%d.%d",
! 254: ((_libiconv_version >> 8) & 0x0f), (_libiconv_version & 0x0f));
! 255: version = buf;
! 256: }
! 257: #elif HAVE_GLIBC_ICONV
! 258: version = (char *)gnu_get_libc_version();
! 259: #elif defined(NETWARE)
! 260: version = "OS built-in";
! 261: #endif
! 262:
! 263: #ifdef PHP_ICONV_IMPL
! 264: REGISTER_STRING_CONSTANT("ICONV_IMPL", PHP_ICONV_IMPL, CONST_CS | CONST_PERSISTENT);
! 265: #elif HAVE_LIBICONV
! 266: REGISTER_STRING_CONSTANT("ICONV_IMPL", "libiconv", CONST_CS | CONST_PERSISTENT);
! 267: #elif defined(NETWARE)
! 268: REGISTER_STRING_CONSTANT("ICONV_IMPL", "Novell", CONST_CS | CONST_PERSISTENT);
! 269: #else
! 270: REGISTER_STRING_CONSTANT("ICONV_IMPL", "unknown", CONST_CS | CONST_PERSISTENT);
! 271: #endif
! 272: REGISTER_STRING_CONSTANT("ICONV_VERSION", version, CONST_CS | CONST_PERSISTENT);
! 273:
! 274: REGISTER_LONG_CONSTANT("ICONV_MIME_DECODE_STRICT", PHP_ICONV_MIME_DECODE_STRICT, CONST_CS | CONST_PERSISTENT);
! 275: REGISTER_LONG_CONSTANT("ICONV_MIME_DECODE_CONTINUE_ON_ERROR", PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR, CONST_CS | CONST_PERSISTENT);
! 276:
! 277: if (php_iconv_stream_filter_register_factory(TSRMLS_C) != PHP_ICONV_ERR_SUCCESS) {
! 278: return FAILURE;
! 279: }
! 280:
! 281: return SUCCESS;
! 282: }
! 283: /* }}} */
! 284:
! 285: /* {{{ PHP_MSHUTDOWN_FUNCTION */
! 286: PHP_MSHUTDOWN_FUNCTION(miconv)
! 287: {
! 288: php_iconv_stream_filter_unregister_factory(TSRMLS_C);
! 289: UNREGISTER_INI_ENTRIES();
! 290: return SUCCESS;
! 291: }
! 292: /* }}} */
! 293:
! 294: /* {{{ PHP_MINFO_FUNCTION */
! 295: PHP_MINFO_FUNCTION(miconv)
! 296: {
! 297: zval iconv_impl, iconv_ver;
! 298:
! 299: zend_get_constant("ICONV_IMPL", sizeof("ICONV_IMPL")-1, &iconv_impl TSRMLS_CC);
! 300: zend_get_constant("ICONV_VERSION", sizeof("ICONV_VERSION")-1, &iconv_ver TSRMLS_CC);
! 301:
! 302: php_info_print_table_start();
! 303: php_info_print_table_row(2, "iconv support", "enabled");
! 304: php_info_print_table_row(2, "iconv implementation", Z_STRVAL(iconv_impl));
! 305: php_info_print_table_row(2, "iconv library version", Z_STRVAL(iconv_ver));
! 306: php_info_print_table_end();
! 307:
! 308: DISPLAY_INI_ENTRIES();
! 309:
! 310: zval_dtor(&iconv_impl);
! 311: zval_dtor(&iconv_ver);
! 312: }
! 313: /* }}} */
! 314:
! 315: /* {{{ _php_iconv_appendl() */
! 316: static php_iconv_err_t _php_iconv_appendl(smart_str *d, const char *s, size_t l, iconv_t cd)
! 317: {
! 318: const char *in_p = s;
! 319: size_t in_left = l;
! 320: char *out_p;
! 321: size_t out_left = 0;
! 322: size_t buf_growth = 128;
! 323: #if !ICONV_SUPPORTS_ERRNO
! 324: size_t prev_in_left = in_left;
! 325: #endif
! 326:
! 327: if (in_p != NULL) {
! 328: while (in_left > 0) {
! 329: out_left = buf_growth - out_left;
! 330: {
! 331: size_t newlen;
! 332: smart_str_alloc((d), out_left, 0);
! 333: }
! 334:
! 335: out_p = (d)->c + (d)->len;
! 336:
! 337: if (iconv(cd, (char **)&in_p, &in_left, (char **) &out_p, &out_left) == (size_t)-1) {
! 338: #if ICONV_SUPPORTS_ERRNO
! 339: switch (errno) {
! 340: case EINVAL:
! 341: return PHP_ICONV_ERR_ILLEGAL_CHAR;
! 342:
! 343: case EILSEQ:
! 344: return PHP_ICONV_ERR_ILLEGAL_SEQ;
! 345:
! 346: case E2BIG:
! 347: break;
! 348:
! 349: default:
! 350: return PHP_ICONV_ERR_UNKNOWN;
! 351: }
! 352: #else
! 353: if (prev_in_left == in_left) {
! 354: return PHP_ICONV_ERR_UNKNOWN;
! 355: }
! 356: #endif
! 357: }
! 358: #if !ICONV_SUPPORTS_ERRNO
! 359: prev_in_left = in_left;
! 360: #endif
! 361: (d)->len += (buf_growth - out_left);
! 362: buf_growth <<= 1;
! 363: }
! 364: } else {
! 365: for (;;) {
! 366: out_left = buf_growth - out_left;
! 367: {
! 368: size_t newlen;
! 369: smart_str_alloc((d), out_left, 0);
! 370: }
! 371:
! 372: out_p = (d)->c + (d)->len;
! 373:
! 374: if (iconv(cd, NULL, NULL, (char **) &out_p, &out_left) == (size_t)0) {
! 375: (d)->len += (buf_growth - out_left);
! 376: break;
! 377: } else {
! 378: #if ICONV_SUPPORTS_ERRNO
! 379: if (errno != E2BIG) {
! 380: return PHP_ICONV_ERR_UNKNOWN;
! 381: }
! 382: #else
! 383: if (out_left != 0) {
! 384: return PHP_ICONV_ERR_UNKNOWN;
! 385: }
! 386: #endif
! 387: }
! 388: (d)->len += (buf_growth - out_left);
! 389: buf_growth <<= 1;
! 390: }
! 391: }
! 392: return PHP_ICONV_ERR_SUCCESS;
! 393: }
! 394: /* }}} */
! 395:
! 396: /* {{{ _php_iconv_appendc() */
! 397: static php_iconv_err_t _php_iconv_appendc(smart_str *d, const char c, iconv_t cd)
! 398: {
! 399: return _php_iconv_appendl(d, &c, 1, cd);
! 400: }
! 401: /* }}} */
! 402:
! 403: /* {{{ php_iconv_string()
! 404: */
! 405: PHP_ICONV_API php_iconv_err_t php_iconv_string(const char *in_p, size_t in_len,
! 406: char **out, size_t *out_len,
! 407: const char *out_charset, const char *in_charset)
! 408: {
! 409: #if !ICONV_SUPPORTS_ERRNO
! 410: size_t in_size, out_size, out_left;
! 411: char *out_buffer, *out_p;
! 412: iconv_t cd;
! 413: size_t result;
! 414:
! 415: *out = NULL;
! 416: *out_len = 0;
! 417:
! 418: /*
! 419: This is not the right way to get output size...
! 420: This is not space efficient for large text.
! 421: This is also problem for encoding like UTF-7/UTF-8/ISO-2022 which
! 422: a single char can be more than 4 bytes.
! 423: I added 15 extra bytes for safety. <yohgaki@php.net>
! 424: */
! 425: out_size = in_len * sizeof(int) + 15;
! 426: out_left = out_size;
! 427:
! 428: in_size = in_len;
! 429:
! 430: cd = iconv_open(out_charset, in_charset);
! 431:
! 432: if (cd == (iconv_t)(-1)) {
! 433: return PHP_ICONV_ERR_UNKNOWN;
! 434: }
! 435:
! 436: out_buffer = (char *) emalloc(out_size + 1);
! 437: out_p = out_buffer;
! 438:
! 439: #ifdef NETWARE
! 440: result = iconv(cd, (char **) &in_p, &in_size, (char **)
! 441: #else
! 442: result = iconv(cd, (const char **) &in_p, &in_size, (char **)
! 443: #endif
! 444: &out_p, &out_left);
! 445:
! 446: if (result == (size_t)(-1)) {
! 447: efree(out_buffer);
! 448: return PHP_ICONV_ERR_UNKNOWN;
! 449: }
! 450:
! 451: if (out_left < 8) {
! 452: out_buffer = (char *) erealloc(out_buffer, out_size + 8);
! 453: }
! 454:
! 455: /* flush the shift-out sequences */
! 456: result = iconv(cd, NULL, NULL, &out_p, &out_left);
! 457:
! 458: if (result == (size_t)(-1)) {
! 459: efree(out_buffer);
! 460: return PHP_ICONV_ERR_UNKNOWN;
! 461: }
! 462:
! 463: *out_len = out_size - out_left;
! 464: out_buffer[*out_len] = '\0';
! 465: *out = out_buffer;
! 466:
! 467: iconv_close(cd);
! 468:
! 469: return PHP_ICONV_ERR_SUCCESS;
! 470:
! 471: #else
! 472: /*
! 473: iconv supports errno. Handle it better way.
! 474: */
! 475: iconv_t cd;
! 476: size_t in_left, out_size, out_left;
! 477: char *out_p, *out_buf, *tmp_buf;
! 478: size_t bsz, result = 0;
! 479: php_iconv_err_t retval = PHP_ICONV_ERR_SUCCESS;
! 480:
! 481: *out = NULL;
! 482: *out_len = 0;
! 483:
! 484: cd = iconv_open(out_charset, in_charset);
! 485:
! 486: if (cd == (iconv_t)(-1)) {
! 487: if (errno == EINVAL) {
! 488: return PHP_ICONV_ERR_WRONG_CHARSET;
! 489: } else {
! 490: return PHP_ICONV_ERR_CONVERTER;
! 491: }
! 492: }
! 493: in_left= in_len;
! 494: out_left = in_len + 32; /* Avoid realloc() most cases */
! 495: out_size = 0;
! 496: bsz = out_left;
! 497: out_buf = (char *) emalloc(bsz+1);
! 498: out_p = out_buf;
! 499:
! 500: while (in_left > 0) {
! 501: result = iconv(cd, (char **) &in_p, &in_left, (char **) &out_p, &out_left);
! 502: out_size = bsz - out_left;
! 503: if (result == (size_t)(-1)) {
! 504: if (errno == E2BIG && in_left > 0) {
! 505: /* converted string is longer than out buffer */
! 506: bsz += in_len;
! 507:
! 508: tmp_buf = (char*) erealloc(out_buf, bsz+1);
! 509: out_p = out_buf = tmp_buf;
! 510: out_p += out_size;
! 511: out_left = bsz - out_size;
! 512: continue;
! 513: }
! 514: }
! 515: break;
! 516: }
! 517:
! 518: if (result != (size_t)(-1)) {
! 519: /* flush the shift-out sequences */
! 520: for (;;) {
! 521: result = iconv(cd, NULL, NULL, (char **) &out_p, &out_left);
! 522: out_size = bsz - out_left;
! 523:
! 524: if (result != (size_t)(-1)) {
! 525: break;
! 526: }
! 527:
! 528: if (errno == E2BIG) {
! 529: bsz += 16;
! 530: tmp_buf = (char *) erealloc(out_buf, bsz);
! 531:
! 532: out_p = out_buf = tmp_buf;
! 533: out_p += out_size;
! 534: out_left = bsz - out_size;
! 535: } else {
! 536: break;
! 537: }
! 538: }
! 539: }
! 540:
! 541: iconv_close(cd);
! 542:
! 543: if (result == (size_t)(-1)) {
! 544: switch (errno) {
! 545: case EINVAL:
! 546: retval = PHP_ICONV_ERR_ILLEGAL_CHAR;
! 547: break;
! 548:
! 549: case EILSEQ:
! 550: retval = PHP_ICONV_ERR_ILLEGAL_SEQ;
! 551: break;
! 552:
! 553: case E2BIG:
! 554: /* should not happen */
! 555: retval = PHP_ICONV_ERR_TOO_BIG;
! 556: break;
! 557:
! 558: default:
! 559: /* other error */
! 560: retval = PHP_ICONV_ERR_UNKNOWN;
! 561: efree(out_buf);
! 562: return PHP_ICONV_ERR_UNKNOWN;
! 563: }
! 564: }
! 565: *out_p = '\0';
! 566: *out = out_buf;
! 567: *out_len = out_size;
! 568: return retval;
! 569: #endif
! 570: }
! 571: /* }}} */
! 572:
! 573: /* {{{ _php_iconv_strlen() */
! 574: static php_iconv_err_t _php_iconv_strlen(unsigned int *pretval, const char *str, size_t nbytes, const char *enc)
! 575: {
! 576: char buf[GENERIC_SUPERSET_NBYTES*2];
! 577:
! 578: php_iconv_err_t err = PHP_ICONV_ERR_SUCCESS;
! 579:
! 580: iconv_t cd;
! 581:
! 582: const char *in_p;
! 583: size_t in_left;
! 584:
! 585: char *out_p;
! 586: size_t out_left;
! 587:
! 588: unsigned int cnt;
! 589:
! 590: *pretval = (unsigned int)-1;
! 591:
! 592: cd = iconv_open(GENERIC_SUPERSET_NAME, enc);
! 593:
! 594: if (cd == (iconv_t)(-1)) {
! 595: #if ICONV_SUPPORTS_ERRNO
! 596: if (errno == EINVAL) {
! 597: return PHP_ICONV_ERR_WRONG_CHARSET;
! 598: } else {
! 599: return PHP_ICONV_ERR_CONVERTER;
! 600: }
! 601: #else
! 602: return PHP_ICONV_ERR_UNKNOWN;
! 603: #endif
! 604: }
! 605:
! 606: errno = out_left = 0;
! 607:
! 608: for (in_p = str, in_left = nbytes, cnt = 0; in_left > 0; cnt+=2) {
! 609: size_t prev_in_left;
! 610: out_p = buf;
! 611: out_left = sizeof(buf);
! 612:
! 613: prev_in_left = in_left;
! 614:
! 615: if (iconv(cd, (char **)&in_p, &in_left, (char **) &out_p, &out_left) == (size_t)-1) {
! 616: if (prev_in_left == in_left) {
! 617: break;
! 618: }
! 619: }
! 620: }
! 621:
! 622: if (out_left > 0) {
! 623: cnt -= out_left / GENERIC_SUPERSET_NBYTES;
! 624: }
! 625:
! 626: #if ICONV_SUPPORTS_ERRNO
! 627: switch (errno) {
! 628: case EINVAL:
! 629: err = PHP_ICONV_ERR_ILLEGAL_CHAR;
! 630: break;
! 631:
! 632: case EILSEQ:
! 633: err = PHP_ICONV_ERR_ILLEGAL_SEQ;
! 634: break;
! 635:
! 636: case E2BIG:
! 637: case 0:
! 638: *pretval = cnt;
! 639: break;
! 640:
! 641: default:
! 642: err = PHP_ICONV_ERR_UNKNOWN;
! 643: break;
! 644: }
! 645: #else
! 646: *pretval = cnt;
! 647: #endif
! 648:
! 649: iconv_close(cd);
! 650:
! 651: return err;
! 652: }
! 653:
! 654: /* }}} */
! 655:
! 656: /* {{{ _php_iconv_substr() */
! 657: static php_iconv_err_t _php_iconv_substr(smart_str *pretval,
! 658: const char *str, size_t nbytes, int offset, int len, const char *enc)
! 659: {
! 660: char buf[GENERIC_SUPERSET_NBYTES];
! 661:
! 662: php_iconv_err_t err = PHP_ICONV_ERR_SUCCESS;
! 663:
! 664: iconv_t cd1, cd2;
! 665:
! 666: const char *in_p;
! 667: size_t in_left;
! 668:
! 669: char *out_p;
! 670: size_t out_left;
! 671:
! 672: unsigned int cnt;
! 673: int total_len;
! 674:
! 675: err = _php_iconv_strlen(&total_len, str, nbytes, enc);
! 676: if (err != PHP_ICONV_ERR_SUCCESS) {
! 677: return err;
! 678: }
! 679:
! 680: if (len < 0) {
! 681: if ((len += (total_len - offset)) < 0) {
! 682: return PHP_ICONV_ERR_SUCCESS;
! 683: }
! 684: }
! 685:
! 686: if (offset < 0) {
! 687: if ((offset += total_len) < 0) {
! 688: return PHP_ICONV_ERR_SUCCESS;
! 689: }
! 690: }
! 691:
! 692: if(len > total_len) {
! 693: len = total_len;
! 694: }
! 695:
! 696:
! 697: if (offset >= total_len) {
! 698: return PHP_ICONV_ERR_SUCCESS;
! 699: }
! 700:
! 701: if ((offset + len) > total_len ) {
! 702: /* trying to compute the length */
! 703: len = total_len - offset;
! 704: }
! 705:
! 706: if (len == 0) {
! 707: smart_str_appendl(pretval, "", 0);
! 708: smart_str_0(pretval);
! 709: return PHP_ICONV_ERR_SUCCESS;
! 710: }
! 711:
! 712: cd1 = iconv_open(GENERIC_SUPERSET_NAME, enc);
! 713:
! 714: if (cd1 == (iconv_t)(-1)) {
! 715: #if ICONV_SUPPORTS_ERRNO
! 716: if (errno == EINVAL) {
! 717: return PHP_ICONV_ERR_WRONG_CHARSET;
! 718: } else {
! 719: return PHP_ICONV_ERR_CONVERTER;
! 720: }
! 721: #else
! 722: return PHP_ICONV_ERR_UNKNOWN;
! 723: #endif
! 724: }
! 725:
! 726: cd2 = (iconv_t)NULL;
! 727: errno = 0;
! 728:
! 729: for (in_p = str, in_left = nbytes, cnt = 0; in_left > 0 && len > 0; ++cnt) {
! 730: size_t prev_in_left;
! 731: out_p = buf;
! 732: out_left = sizeof(buf);
! 733:
! 734: prev_in_left = in_left;
! 735:
! 736: if (iconv(cd1, (char **)&in_p, &in_left, (char **) &out_p, &out_left) == (size_t)-1) {
! 737: if (prev_in_left == in_left) {
! 738: break;
! 739: }
! 740: }
! 741:
! 742: if (cnt >= (unsigned int)offset) {
! 743: if (cd2 == (iconv_t)NULL) {
! 744: cd2 = iconv_open(enc, GENERIC_SUPERSET_NAME);
! 745:
! 746: if (cd2 == (iconv_t)(-1)) {
! 747: cd2 = (iconv_t)NULL;
! 748: #if ICONV_SUPPORTS_ERRNO
! 749: if (errno == EINVAL) {
! 750: err = PHP_ICONV_ERR_WRONG_CHARSET;
! 751: } else {
! 752: err = PHP_ICONV_ERR_CONVERTER;
! 753: }
! 754: #else
! 755: err = PHP_ICONV_ERR_UNKNOWN;
! 756: #endif
! 757: break;
! 758: }
! 759: }
! 760:
! 761: if (_php_iconv_appendl(pretval, buf, sizeof(buf), cd2) != PHP_ICONV_ERR_SUCCESS) {
! 762: break;
! 763: }
! 764: --len;
! 765: }
! 766:
! 767: }
! 768:
! 769: #if ICONV_SUPPORTS_ERRNO
! 770: switch (errno) {
! 771: case EINVAL:
! 772: err = PHP_ICONV_ERR_ILLEGAL_CHAR;
! 773: break;
! 774:
! 775: case EILSEQ:
! 776: err = PHP_ICONV_ERR_ILLEGAL_SEQ;
! 777: break;
! 778:
! 779: case E2BIG:
! 780: break;
! 781: }
! 782: #endif
! 783: if (err == PHP_ICONV_ERR_SUCCESS) {
! 784: if (cd2 != (iconv_t)NULL) {
! 785: _php_iconv_appendl(pretval, NULL, 0, cd2);
! 786: }
! 787: smart_str_0(pretval);
! 788: }
! 789:
! 790: if (cd1 != (iconv_t)NULL) {
! 791: iconv_close(cd1);
! 792: }
! 793:
! 794: if (cd2 != (iconv_t)NULL) {
! 795: iconv_close(cd2);
! 796: }
! 797: return err;
! 798: }
! 799:
! 800: /* }}} */
! 801:
! 802: /* {{{ _php_iconv_strpos() */
! 803: static php_iconv_err_t _php_iconv_strpos(unsigned int *pretval,
! 804: const char *haystk, size_t haystk_nbytes,
! 805: const char *ndl, size_t ndl_nbytes,
! 806: int offset, const char *enc)
! 807: {
! 808: char buf[GENERIC_SUPERSET_NBYTES];
! 809:
! 810: php_iconv_err_t err = PHP_ICONV_ERR_SUCCESS;
! 811:
! 812: iconv_t cd;
! 813:
! 814: const char *in_p;
! 815: size_t in_left;
! 816:
! 817: char *out_p;
! 818: size_t out_left;
! 819:
! 820: unsigned int cnt;
! 821:
! 822: char *ndl_buf;
! 823: const char *ndl_buf_p;
! 824: size_t ndl_buf_len, ndl_buf_left;
! 825:
! 826: unsigned int match_ofs;
! 827:
! 828: *pretval = (unsigned int)-1;
! 829:
! 830: err = php_iconv_string(ndl, ndl_nbytes,
! 831: &ndl_buf, &ndl_buf_len, GENERIC_SUPERSET_NAME, enc);
! 832:
! 833: if (err != PHP_ICONV_ERR_SUCCESS) {
! 834: if (ndl_buf != NULL) {
! 835: efree(ndl_buf);
! 836: }
! 837: return err;
! 838: }
! 839:
! 840: cd = iconv_open(GENERIC_SUPERSET_NAME, enc);
! 841:
! 842: if (cd == (iconv_t)(-1)) {
! 843: if (ndl_buf != NULL) {
! 844: efree(ndl_buf);
! 845: }
! 846: #if ICONV_SUPPORTS_ERRNO
! 847: if (errno == EINVAL) {
! 848: return PHP_ICONV_ERR_WRONG_CHARSET;
! 849: } else {
! 850: return PHP_ICONV_ERR_CONVERTER;
! 851: }
! 852: #else
! 853: return PHP_ICONV_ERR_UNKNOWN;
! 854: #endif
! 855: }
! 856:
! 857: ndl_buf_p = ndl_buf;
! 858: ndl_buf_left = ndl_buf_len;
! 859: match_ofs = (unsigned int)-1;
! 860:
! 861: for (in_p = haystk, in_left = haystk_nbytes, cnt = 0; in_left > 0; ++cnt) {
! 862: size_t prev_in_left;
! 863: out_p = buf;
! 864: out_left = sizeof(buf);
! 865:
! 866: prev_in_left = in_left;
! 867:
! 868: if (iconv(cd, (char **)&in_p, &in_left, (char **) &out_p, &out_left) == (size_t)-1) {
! 869: if (prev_in_left == in_left) {
! 870: #if ICONV_SUPPORTS_ERRNO
! 871: switch (errno) {
! 872: case EINVAL:
! 873: err = PHP_ICONV_ERR_ILLEGAL_CHAR;
! 874: break;
! 875:
! 876: case EILSEQ:
! 877: err = PHP_ICONV_ERR_ILLEGAL_SEQ;
! 878: break;
! 879:
! 880: case E2BIG:
! 881: break;
! 882:
! 883: default:
! 884: err = PHP_ICONV_ERR_UNKNOWN;
! 885: break;
! 886: }
! 887: #endif
! 888: break;
! 889: }
! 890: }
! 891: if (offset >= 0) {
! 892: if (cnt >= (unsigned int)offset) {
! 893: if (_php_iconv_memequal(buf, ndl_buf_p, sizeof(buf))) {
! 894: if (match_ofs == (unsigned int)-1) {
! 895: match_ofs = cnt;
! 896: }
! 897: ndl_buf_p += GENERIC_SUPERSET_NBYTES;
! 898: ndl_buf_left -= GENERIC_SUPERSET_NBYTES;
! 899: if (ndl_buf_left == 0) {
! 900: *pretval = match_ofs;
! 901: break;
! 902: }
! 903: } else {
! 904: unsigned int i, j, lim;
! 905:
! 906: i = 0;
! 907: j = GENERIC_SUPERSET_NBYTES;
! 908: lim = (unsigned int)(ndl_buf_p - ndl_buf);
! 909:
! 910: while (j < lim) {
! 911: if (_php_iconv_memequal(&ndl_buf[j], &ndl_buf[i],
! 912: GENERIC_SUPERSET_NBYTES)) {
! 913: i += GENERIC_SUPERSET_NBYTES;
! 914: } else {
! 915: j -= i;
! 916: i = 0;
! 917: }
! 918: j += GENERIC_SUPERSET_NBYTES;
! 919: }
! 920:
! 921: if (_php_iconv_memequal(buf, &ndl_buf[i], sizeof(buf))) {
! 922: match_ofs += (lim - i) / GENERIC_SUPERSET_NBYTES;
! 923: i += GENERIC_SUPERSET_NBYTES;
! 924: ndl_buf_p = &ndl_buf[i];
! 925: ndl_buf_left = ndl_buf_len - i;
! 926: } else {
! 927: match_ofs = (unsigned int)-1;
! 928: ndl_buf_p = ndl_buf;
! 929: ndl_buf_left = ndl_buf_len;
! 930: }
! 931: }
! 932: }
! 933: } else {
! 934: if (_php_iconv_memequal(buf, ndl_buf_p, sizeof(buf))) {
! 935: if (match_ofs == (unsigned int)-1) {
! 936: match_ofs = cnt;
! 937: }
! 938: ndl_buf_p += GENERIC_SUPERSET_NBYTES;
! 939: ndl_buf_left -= GENERIC_SUPERSET_NBYTES;
! 940: if (ndl_buf_left == 0) {
! 941: *pretval = match_ofs;
! 942: ndl_buf_p = ndl_buf;
! 943: ndl_buf_left = ndl_buf_len;
! 944: match_ofs = -1;
! 945: }
! 946: } else {
! 947: unsigned int i, j, lim;
! 948:
! 949: i = 0;
! 950: j = GENERIC_SUPERSET_NBYTES;
! 951: lim = (unsigned int)(ndl_buf_p - ndl_buf);
! 952:
! 953: while (j < lim) {
! 954: if (_php_iconv_memequal(&ndl_buf[j], &ndl_buf[i],
! 955: GENERIC_SUPERSET_NBYTES)) {
! 956: i += GENERIC_SUPERSET_NBYTES;
! 957: } else {
! 958: j -= i;
! 959: i = 0;
! 960: }
! 961: j += GENERIC_SUPERSET_NBYTES;
! 962: }
! 963:
! 964: if (_php_iconv_memequal(buf, &ndl_buf[i], sizeof(buf))) {
! 965: match_ofs += (lim - i) / GENERIC_SUPERSET_NBYTES;
! 966: i += GENERIC_SUPERSET_NBYTES;
! 967: ndl_buf_p = &ndl_buf[i];
! 968: ndl_buf_left = ndl_buf_len - i;
! 969: } else {
! 970: match_ofs = (unsigned int)-1;
! 971: ndl_buf_p = ndl_buf;
! 972: ndl_buf_left = ndl_buf_len;
! 973: }
! 974: }
! 975: }
! 976: }
! 977:
! 978: if (ndl_buf) {
! 979: efree(ndl_buf);
! 980: }
! 981:
! 982: iconv_close(cd);
! 983:
! 984: return err;
! 985: }
! 986: /* }}} */
! 987:
! 988: /* {{{ _php_iconv_mime_encode() */
! 989: static php_iconv_err_t _php_iconv_mime_encode(smart_str *pretval, const char *fname, size_t fname_nbytes, const char *fval, size_t fval_nbytes, unsigned int max_line_len, const char *lfchars, php_iconv_enc_scheme_t enc_scheme, const char *out_charset, const char *enc)
! 990: {
! 991: php_iconv_err_t err = PHP_ICONV_ERR_SUCCESS;
! 992: iconv_t cd = (iconv_t)(-1), cd_pl = (iconv_t)(-1);
! 993: unsigned int char_cnt = 0;
! 994: size_t out_charset_len;
! 995: size_t lfchars_len;
! 996: char *buf = NULL;
! 997: char *encoded = NULL;
! 998: size_t encoded_len;
! 999: const char *in_p;
! 1000: size_t in_left;
! 1001: char *out_p;
! 1002: size_t out_left;
! 1003: static int qp_table[256] = {
! 1004: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x00 */
! 1005: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 */
! 1006: 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x20 */
! 1007: 1, 1, 1, 1, 1, 1, 1 ,1, 1, 1, 1, 1, 1, 3, 1, 3, /* 0x30 */
! 1008: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 */
! 1009: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, /* 0x50 */
! 1010: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 */
! 1011: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, /* 0x70 */
! 1012: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x80 */
! 1013: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x90 */
! 1014: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xA0 */
! 1015: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xB0 */
! 1016: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xC0 */
! 1017: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xD0 */
! 1018: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xE0 */
! 1019: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 /* 0xF0 */
! 1020: };
! 1021:
! 1022: out_charset_len = strlen(out_charset);
! 1023: lfchars_len = strlen(lfchars);
! 1024:
! 1025: if ((fname_nbytes + 2) >= max_line_len
! 1026: || (out_charset_len + 12) >= max_line_len) {
! 1027: /* field name is too long */
! 1028: err = PHP_ICONV_ERR_TOO_BIG;
! 1029: goto out;
! 1030: }
! 1031:
! 1032: cd_pl = iconv_open(ICONV_ASCII_ENCODING, enc);
! 1033: if (cd_pl == (iconv_t)(-1)) {
! 1034: #if ICONV_SUPPORTS_ERRNO
! 1035: if (errno == EINVAL) {
! 1036: err = PHP_ICONV_ERR_WRONG_CHARSET;
! 1037: } else {
! 1038: err = PHP_ICONV_ERR_CONVERTER;
! 1039: }
! 1040: #else
! 1041: err = PHP_ICONV_ERR_UNKNOWN;
! 1042: #endif
! 1043: goto out;
! 1044: }
! 1045:
! 1046: cd = iconv_open(out_charset, enc);
! 1047: if (cd == (iconv_t)(-1)) {
! 1048: #if ICONV_SUPPORTS_ERRNO
! 1049: if (errno == EINVAL) {
! 1050: err = PHP_ICONV_ERR_WRONG_CHARSET;
! 1051: } else {
! 1052: err = PHP_ICONV_ERR_CONVERTER;
! 1053: }
! 1054: #else
! 1055: err = PHP_ICONV_ERR_UNKNOWN;
! 1056: #endif
! 1057: goto out;
! 1058: }
! 1059:
! 1060: buf = safe_emalloc(1, max_line_len, 5);
! 1061:
! 1062: char_cnt = max_line_len;
! 1063:
! 1064: _php_iconv_appendl(pretval, fname, fname_nbytes, cd_pl);
! 1065: char_cnt -= fname_nbytes;
! 1066: smart_str_appendl(pretval, ": ", sizeof(": ") - 1);
! 1067: char_cnt -= 2;
! 1068:
! 1069: in_p = fval;
! 1070: in_left = fval_nbytes;
! 1071:
! 1072: do {
! 1073: size_t prev_in_left;
! 1074: size_t out_size;
! 1075:
! 1076: if (char_cnt < (out_charset_len + 12)) {
! 1077: /* lfchars must be encoded in ASCII here*/
! 1078: smart_str_appendl(pretval, lfchars, lfchars_len);
! 1079: smart_str_appendc(pretval, ' ');
! 1080: char_cnt = max_line_len - 1;
! 1081: }
! 1082:
! 1083: smart_str_appendl(pretval, "=?", sizeof("=?") - 1);
! 1084: char_cnt -= 2;
! 1085: smart_str_appendl(pretval, out_charset, out_charset_len);
! 1086: char_cnt -= out_charset_len;
! 1087: smart_str_appendc(pretval, '?');
! 1088: char_cnt --;
! 1089:
! 1090: switch (enc_scheme) {
! 1091: case PHP_ICONV_ENC_SCHEME_BASE64: {
! 1092: size_t ini_in_left;
! 1093: const char *ini_in_p;
! 1094: size_t out_reserved = 4;
! 1095: int dummy;
! 1096:
! 1097: smart_str_appendc(pretval, 'B');
! 1098: char_cnt--;
! 1099: smart_str_appendc(pretval, '?');
! 1100: char_cnt--;
! 1101:
! 1102: prev_in_left = ini_in_left = in_left;
! 1103: ini_in_p = in_p;
! 1104:
! 1105: out_size = (char_cnt - 2) / 4 * 3;
! 1106:
! 1107: for (;;) {
! 1108: out_p = buf;
! 1109:
! 1110: if (out_size <= out_reserved) {
! 1111: err = PHP_ICONV_ERR_TOO_BIG;
! 1112: goto out;
! 1113: }
! 1114:
! 1115: out_left = out_size - out_reserved;
! 1116:
! 1117: if (iconv(cd, (char **)&in_p, &in_left, (char **) &out_p, &out_left) == (size_t)-1) {
! 1118: #if ICONV_SUPPORTS_ERRNO
! 1119: switch (errno) {
! 1120: case EINVAL:
! 1121: err = PHP_ICONV_ERR_ILLEGAL_CHAR;
! 1122: goto out;
! 1123:
! 1124: case EILSEQ:
! 1125: err = PHP_ICONV_ERR_ILLEGAL_SEQ;
! 1126: goto out;
! 1127:
! 1128: case E2BIG:
! 1129: if (prev_in_left == in_left) {
! 1130: err = PHP_ICONV_ERR_TOO_BIG;
! 1131: goto out;
! 1132: }
! 1133: break;
! 1134:
! 1135: default:
! 1136: err = PHP_ICONV_ERR_UNKNOWN;
! 1137: goto out;
! 1138: }
! 1139: #else
! 1140: if (prev_in_left == in_left) {
! 1141: err = PHP_ICONV_ERR_UNKNOWN;
! 1142: goto out;
! 1143: }
! 1144: #endif
! 1145: }
! 1146:
! 1147: out_left += out_reserved;
! 1148:
! 1149: if (iconv(cd, NULL, NULL, (char **) &out_p, &out_left) == (size_t)-1) {
! 1150: #if ICONV_SUPPORTS_ERRNO
! 1151: if (errno != E2BIG) {
! 1152: err = PHP_ICONV_ERR_UNKNOWN;
! 1153: goto out;
! 1154: }
! 1155: #else
! 1156: if (out_left != 0) {
! 1157: err = PHP_ICONV_ERR_UNKNOWN;
! 1158: goto out;
! 1159: }
! 1160: #endif
! 1161: } else {
! 1162: break;
! 1163: }
! 1164:
! 1165: if (iconv(cd, NULL, NULL, NULL, NULL) == (size_t)-1) {
! 1166: err = PHP_ICONV_ERR_UNKNOWN;
! 1167: goto out;
! 1168: }
! 1169:
! 1170: out_reserved += 4;
! 1171: in_left = ini_in_left;
! 1172: in_p = ini_in_p;
! 1173: }
! 1174:
! 1175: prev_in_left = in_left;
! 1176:
! 1177: encoded = (char *) php_base64_encode((unsigned char *) buf, (int)(out_size - out_left), &dummy);
! 1178: encoded_len = (size_t)dummy;
! 1179:
! 1180: if (char_cnt < encoded_len) {
! 1181: /* something went wrong! */
! 1182: err = PHP_ICONV_ERR_UNKNOWN;
! 1183: goto out;
! 1184: }
! 1185:
! 1186: smart_str_appendl(pretval, encoded, encoded_len);
! 1187: char_cnt -= encoded_len;
! 1188: smart_str_appendl(pretval, "?=", sizeof("?=") - 1);
! 1189: char_cnt -= 2;
! 1190:
! 1191: efree(encoded);
! 1192: encoded = NULL;
! 1193: } break; /* case PHP_ICONV_ENC_SCHEME_BASE64: */
! 1194:
! 1195: case PHP_ICONV_ENC_SCHEME_QPRINT: {
! 1196: size_t ini_in_left;
! 1197: const char *ini_in_p;
! 1198: const unsigned char *p;
! 1199: size_t nbytes_required;
! 1200:
! 1201: smart_str_appendc(pretval, 'Q');
! 1202: char_cnt--;
! 1203: smart_str_appendc(pretval, '?');
! 1204: char_cnt--;
! 1205:
! 1206: prev_in_left = ini_in_left = in_left;
! 1207: ini_in_p = in_p;
! 1208:
! 1209: for (out_size = (char_cnt - 2) / 3; out_size > 0;) {
! 1210: size_t prev_out_left;
! 1211:
! 1212: nbytes_required = 0;
! 1213:
! 1214: out_p = buf;
! 1215: out_left = out_size;
! 1216:
! 1217: if (iconv(cd, (char **)&in_p, &in_left, (char **) &out_p, &out_left) == (size_t)-1) {
! 1218: #if ICONV_SUPPORTS_ERRNO
! 1219: switch (errno) {
! 1220: case EINVAL:
! 1221: err = PHP_ICONV_ERR_ILLEGAL_CHAR;
! 1222: goto out;
! 1223:
! 1224: case EILSEQ:
! 1225: err = PHP_ICONV_ERR_ILLEGAL_SEQ;
! 1226: goto out;
! 1227:
! 1228: case E2BIG:
! 1229: if (prev_in_left == in_left) {
! 1230: err = PHP_ICONV_ERR_UNKNOWN;
! 1231: goto out;
! 1232: }
! 1233: break;
! 1234:
! 1235: default:
! 1236: err = PHP_ICONV_ERR_UNKNOWN;
! 1237: goto out;
! 1238: }
! 1239: #else
! 1240: if (prev_in_left == in_left) {
! 1241: err = PHP_ICONV_ERR_UNKNOWN;
! 1242: goto out;
! 1243: }
! 1244: #endif
! 1245: }
! 1246:
! 1247: prev_out_left = out_left;
! 1248: if (iconv(cd, NULL, NULL, (char **) &out_p, &out_left) == (size_t)-1) {
! 1249: #if ICONV_SUPPORTS_ERRNO
! 1250: if (errno != E2BIG) {
! 1251: err = PHP_ICONV_ERR_UNKNOWN;
! 1252: goto out;
! 1253: }
! 1254: #else
! 1255: if (out_left == prev_out_left) {
! 1256: err = PHP_ICONV_ERR_UNKNOWN;
! 1257: goto out;
! 1258: }
! 1259: #endif
! 1260: }
! 1261:
! 1262: for (p = (unsigned char *)buf; p < (unsigned char *)out_p; p++) {
! 1263: nbytes_required += qp_table[*p];
! 1264: }
! 1265:
! 1266: if (nbytes_required <= char_cnt - 2) {
! 1267: break;
! 1268: }
! 1269:
! 1270: out_size -= ((nbytes_required - (char_cnt - 2)) + 1) / 3;
! 1271: in_left = ini_in_left;
! 1272: in_p = ini_in_p;
! 1273: }
! 1274:
! 1275: for (p = (unsigned char *)buf; p < (unsigned char *)out_p; p++) {
! 1276: if (qp_table[*p] == 1) {
! 1277: smart_str_appendc(pretval, *(char *)p);
! 1278: char_cnt--;
! 1279: } else {
! 1280: static char qp_digits[] = "0123456789ABCDEF";
! 1281: smart_str_appendc(pretval, '=');
! 1282: smart_str_appendc(pretval, qp_digits[(*p >> 4) & 0x0f]);
! 1283: smart_str_appendc(pretval, qp_digits[(*p & 0x0f)]);
! 1284: char_cnt -= 3;
! 1285: }
! 1286: }
! 1287:
! 1288: smart_str_appendl(pretval, "?=", sizeof("?=") - 1);
! 1289: char_cnt -= 2;
! 1290:
! 1291: if (iconv(cd, NULL, NULL, NULL, NULL) == (size_t)-1) {
! 1292: err = PHP_ICONV_ERR_UNKNOWN;
! 1293: goto out;
! 1294: }
! 1295:
! 1296: } break; /* case PHP_ICONV_ENC_SCHEME_QPRINT: */
! 1297: }
! 1298: } while (in_left > 0);
! 1299:
! 1300: smart_str_0(pretval);
! 1301:
! 1302: out:
! 1303: if (cd != (iconv_t)(-1)) {
! 1304: iconv_close(cd);
! 1305: }
! 1306: if (cd_pl != (iconv_t)(-1)) {
! 1307: iconv_close(cd_pl);
! 1308: }
! 1309: if (encoded != NULL) {
! 1310: efree(encoded);
! 1311: }
! 1312: if (buf != NULL) {
! 1313: efree(buf);
! 1314: }
! 1315: return err;
! 1316: }
! 1317: /* }}} */
! 1318:
! 1319: /* {{{ _php_iconv_mime_decode() */
! 1320: static php_iconv_err_t _php_iconv_mime_decode(smart_str *pretval, const char *str, size_t str_nbytes, const char *enc, const char **next_pos, int mode)
! 1321: {
! 1322: php_iconv_err_t err = PHP_ICONV_ERR_SUCCESS;
! 1323:
! 1324: iconv_t cd = (iconv_t)(-1), cd_pl = (iconv_t)(-1);
! 1325:
! 1326: const char *p1;
! 1327: size_t str_left;
! 1328: unsigned int scan_stat = 0;
! 1329: const char *csname = NULL;
! 1330: size_t csname_len;
! 1331: const char *encoded_text = NULL;
! 1332: size_t encoded_text_len = 0;
! 1333: const char *encoded_word = NULL;
! 1334: const char *spaces = NULL;
! 1335:
! 1336: php_iconv_enc_scheme_t enc_scheme = PHP_ICONV_ENC_SCHEME_BASE64;
! 1337:
! 1338: if (next_pos != NULL) {
! 1339: *next_pos = NULL;
! 1340: }
! 1341:
! 1342: cd_pl = iconv_open(enc, ICONV_ASCII_ENCODING);
! 1343:
! 1344: if (cd_pl == (iconv_t)(-1)) {
! 1345: #if ICONV_SUPPORTS_ERRNO
! 1346: if (errno == EINVAL) {
! 1347: err = PHP_ICONV_ERR_WRONG_CHARSET;
! 1348: } else {
! 1349: err = PHP_ICONV_ERR_CONVERTER;
! 1350: }
! 1351: #else
! 1352: err = PHP_ICONV_ERR_UNKNOWN;
! 1353: #endif
! 1354: goto out;
! 1355: }
! 1356:
! 1357: p1 = str;
! 1358: for (str_left = str_nbytes; str_left > 0; str_left--, p1++) {
! 1359: int eos = 0;
! 1360:
! 1361: switch (scan_stat) {
! 1362: case 0: /* expecting any character */
! 1363: switch (*p1) {
! 1364: case '\r': /* part of an EOL sequence? */
! 1365: scan_stat = 7;
! 1366: break;
! 1367:
! 1368: case '\n':
! 1369: scan_stat = 8;
! 1370: break;
! 1371:
! 1372: case '=': /* first letter of an encoded chunk */
! 1373: encoded_word = p1;
! 1374: scan_stat = 1;
! 1375: break;
! 1376:
! 1377: case ' ': case '\t': /* a chunk of whitespaces */
! 1378: spaces = p1;
! 1379: scan_stat = 11;
! 1380: break;
! 1381:
! 1382: default: /* first letter of a non-encoded word */
! 1383: _php_iconv_appendc(pretval, *p1, cd_pl);
! 1384: encoded_word = NULL;
! 1385: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1386: scan_stat = 12;
! 1387: }
! 1388: break;
! 1389: }
! 1390: break;
! 1391:
! 1392: case 1: /* expecting a delimiter */
! 1393: if (*p1 != '?') {
! 1394: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1395: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1396: goto out;
! 1397: }
! 1398: encoded_word = NULL;
! 1399: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1400: scan_stat = 12;
! 1401: } else {
! 1402: scan_stat = 0;
! 1403: }
! 1404: break;
! 1405: }
! 1406: csname = p1 + 1;
! 1407: scan_stat = 2;
! 1408: break;
! 1409:
! 1410: case 2: /* expecting a charset name */
! 1411: switch (*p1) {
! 1412: case '?': /* normal delimiter: encoding scheme follows */
! 1413: scan_stat = 3;
! 1414: break;
! 1415:
! 1416: case '*': /* new style delimiter: locale id follows */
! 1417: scan_stat = 10;
! 1418: break;
! 1419: }
! 1420: if (scan_stat != 2) {
! 1421: char tmpbuf[80];
! 1422:
! 1423: if (csname == NULL) {
! 1424: err = PHP_ICONV_ERR_MALFORMED;
! 1425: goto out;
! 1426: }
! 1427:
! 1428: csname_len = (size_t)(p1 - csname);
! 1429:
! 1430: if (csname_len > sizeof(tmpbuf) - 1) {
! 1431: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1432: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1433: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1434: goto out;
! 1435: }
! 1436: encoded_word = NULL;
! 1437: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1438: scan_stat = 12;
! 1439: } else {
! 1440: scan_stat = 0;
! 1441: }
! 1442: break;
! 1443: } else {
! 1444: err = PHP_ICONV_ERR_MALFORMED;
! 1445: goto out;
! 1446: }
! 1447: }
! 1448:
! 1449: memcpy(tmpbuf, csname, csname_len);
! 1450: tmpbuf[csname_len] = '\0';
! 1451:
! 1452: if (cd != (iconv_t)(-1)) {
! 1453: iconv_close(cd);
! 1454: }
! 1455:
! 1456: cd = iconv_open(enc, tmpbuf);
! 1457:
! 1458: if (cd == (iconv_t)(-1)) {
! 1459: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1460: /* Bad character set, but the user wants us to
! 1461: * press on. In this case, we'll just insert the
! 1462: * undecoded encoded word, since there isn't really
! 1463: * a more sensible behaviour available; the only
! 1464: * other options are to swallow the encoded word
! 1465: * entirely or decode it with an arbitrarily chosen
! 1466: * single byte encoding, both of which seem to have
! 1467: * a higher WTF factor than leaving it undecoded.
! 1468: *
! 1469: * Given this approach, we need to skip ahead to
! 1470: * the end of the encoded word. */
! 1471: int qmarks = 2;
! 1472: while (qmarks > 0 && str_left > 1) {
! 1473: if (*(++p1) == '?') {
! 1474: --qmarks;
! 1475: }
! 1476: --str_left;
! 1477: }
! 1478:
! 1479: /* Look ahead to check for the terminating = that
! 1480: * should be there as well; if it's there, we'll
! 1481: * also include that. If it's not, there isn't much
! 1482: * we can do at this point. */
! 1483: if (*(p1 + 1) == '=') {
! 1484: ++p1;
! 1485: --str_left;
! 1486: }
! 1487:
! 1488: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1489: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1490: goto out;
! 1491: }
! 1492:
! 1493: /* Let's go back and see if there are further
! 1494: * encoded words or bare content, and hope they
! 1495: * might actually have a valid character set. */
! 1496: scan_stat = 12;
! 1497: break;
! 1498: } else {
! 1499: #if ICONV_SUPPORTS_ERRNO
! 1500: if (errno == EINVAL) {
! 1501: err = PHP_ICONV_ERR_WRONG_CHARSET;
! 1502: } else {
! 1503: err = PHP_ICONV_ERR_CONVERTER;
! 1504: }
! 1505: #else
! 1506: err = PHP_ICONV_ERR_UNKNOWN;
! 1507: #endif
! 1508: goto out;
! 1509: }
! 1510: }
! 1511: }
! 1512: break;
! 1513:
! 1514: case 3: /* expecting a encoding scheme specifier */
! 1515: switch (*p1) {
! 1516: case 'b':
! 1517: case 'B':
! 1518: enc_scheme = PHP_ICONV_ENC_SCHEME_BASE64;
! 1519: scan_stat = 4;
! 1520: break;
! 1521:
! 1522: case 'q':
! 1523: case 'Q':
! 1524: enc_scheme = PHP_ICONV_ENC_SCHEME_QPRINT;
! 1525: scan_stat = 4;
! 1526: break;
! 1527:
! 1528: default:
! 1529: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1530: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1531: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1532: goto out;
! 1533: }
! 1534: encoded_word = NULL;
! 1535: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1536: scan_stat = 12;
! 1537: } else {
! 1538: scan_stat = 0;
! 1539: }
! 1540: break;
! 1541: } else {
! 1542: err = PHP_ICONV_ERR_MALFORMED;
! 1543: goto out;
! 1544: }
! 1545: }
! 1546: break;
! 1547:
! 1548: case 4: /* expecting a delimiter */
! 1549: if (*p1 != '?') {
! 1550: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1551: /* pass the entire chunk through the converter */
! 1552: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1553: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1554: goto out;
! 1555: }
! 1556: encoded_word = NULL;
! 1557: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1558: scan_stat = 12;
! 1559: } else {
! 1560: scan_stat = 0;
! 1561: }
! 1562: break;
! 1563: } else {
! 1564: err = PHP_ICONV_ERR_MALFORMED;
! 1565: goto out;
! 1566: }
! 1567: }
! 1568: encoded_text = p1 + 1;
! 1569: scan_stat = 5;
! 1570: break;
! 1571:
! 1572: case 5: /* expecting an encoded portion */
! 1573: if (*p1 == '?') {
! 1574: encoded_text_len = (size_t)(p1 - encoded_text);
! 1575: scan_stat = 6;
! 1576: }
! 1577: break;
! 1578:
! 1579: case 7: /* expecting a "\n" character */
! 1580: if (*p1 == '\n') {
! 1581: scan_stat = 8;
! 1582: } else {
! 1583: /* bare CR */
! 1584: _php_iconv_appendc(pretval, '\r', cd_pl);
! 1585: _php_iconv_appendc(pretval, *p1, cd_pl);
! 1586: scan_stat = 0;
! 1587: }
! 1588: break;
! 1589:
! 1590: case 8: /* checking whether the following line is part of a
! 1591: folded header */
! 1592: if (*p1 != ' ' && *p1 != '\t') {
! 1593: --p1;
! 1594: str_left = 1; /* quit_loop */
! 1595: break;
! 1596: }
! 1597: if (encoded_word == NULL) {
! 1598: _php_iconv_appendc(pretval, ' ', cd_pl);
! 1599: }
! 1600: spaces = NULL;
! 1601: scan_stat = 11;
! 1602: break;
! 1603:
! 1604: case 6: /* expecting a End-Of-Chunk character "=" */
! 1605: if (*p1 != '=') {
! 1606: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1607: /* pass the entire chunk through the converter */
! 1608: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1609: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1610: goto out;
! 1611: }
! 1612: encoded_word = NULL;
! 1613: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1614: scan_stat = 12;
! 1615: } else {
! 1616: scan_stat = 0;
! 1617: }
! 1618: break;
! 1619: } else {
! 1620: err = PHP_ICONV_ERR_MALFORMED;
! 1621: goto out;
! 1622: }
! 1623: }
! 1624: scan_stat = 9;
! 1625: if (str_left == 1) {
! 1626: eos = 1;
! 1627: } else {
! 1628: break;
! 1629: }
! 1630:
! 1631: case 9: /* choice point, seeing what to do next.*/
! 1632: switch (*p1) {
! 1633: default:
! 1634: /* Handle non-RFC-compliant formats
! 1635: *
! 1636: * RFC2047 requires the character that comes right
! 1637: * after an encoded word (chunk) to be a whitespace,
! 1638: * while there are lots of broken implementations that
! 1639: * generate such malformed headers that don't fulfill
! 1640: * that requirement.
! 1641: */
! 1642: if (!eos) {
! 1643: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1644: /* pass the entire chunk through the converter */
! 1645: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1646: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1647: goto out;
! 1648: }
! 1649: scan_stat = 12;
! 1650: break;
! 1651: }
! 1652: }
! 1653: /* break is omitted intentionally */
! 1654:
! 1655: case '\r': case '\n': case ' ': case '\t': {
! 1656: char *decoded_text;
! 1657: size_t decoded_text_len;
! 1658: int dummy;
! 1659:
! 1660: switch (enc_scheme) {
! 1661: case PHP_ICONV_ENC_SCHEME_BASE64:
! 1662: decoded_text = (char *)php_base64_decode((unsigned char*)encoded_text, (int)encoded_text_len, &dummy);
! 1663: decoded_text_len = (size_t)dummy;
! 1664: break;
! 1665:
! 1666: case PHP_ICONV_ENC_SCHEME_QPRINT:
! 1667: decoded_text = (char *)php_quot_print_decode((unsigned char*)encoded_text, (int)encoded_text_len, &decoded_text_len, 1);
! 1668: break;
! 1669: default:
! 1670: decoded_text = NULL;
! 1671: break;
! 1672: }
! 1673:
! 1674: if (decoded_text == NULL) {
! 1675: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1676: /* pass the entire chunk through the converter */
! 1677: err = _php_iconv_appendl(pretval, encoded_word, (size_t)((p1 + 1) - encoded_word), cd_pl);
! 1678: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1679: goto out;
! 1680: }
! 1681: encoded_word = NULL;
! 1682: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1683: scan_stat = 12;
! 1684: } else {
! 1685: scan_stat = 0;
! 1686: }
! 1687: break;
! 1688: } else {
! 1689: err = PHP_ICONV_ERR_UNKNOWN;
! 1690: goto out;
! 1691: }
! 1692: }
! 1693:
! 1694: err = _php_iconv_appendl(pretval, decoded_text, decoded_text_len, cd);
! 1695: efree(decoded_text);
! 1696:
! 1697: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1698: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1699: /* pass the entire chunk through the converter */
! 1700: err = _php_iconv_appendl(pretval, encoded_word, (size_t)(p1 - encoded_word), cd_pl);
! 1701: encoded_word = NULL;
! 1702: if (err != PHP_ICONV_ERR_SUCCESS) {
! 1703: break;
! 1704: }
! 1705: } else {
! 1706: goto out;
! 1707: }
! 1708: }
! 1709:
! 1710: if (eos) { /* reached end-of-string. done. */
! 1711: scan_stat = 0;
! 1712: break;
! 1713: }
! 1714:
! 1715: switch (*p1) {
! 1716: case '\r': /* part of an EOL sequence? */
! 1717: scan_stat = 7;
! 1718: break;
! 1719:
! 1720: case '\n':
! 1721: scan_stat = 8;
! 1722: break;
! 1723:
! 1724: case '=': /* first letter of an encoded chunk */
! 1725: scan_stat = 1;
! 1726: break;
! 1727:
! 1728: case ' ': case '\t': /* medial whitespaces */
! 1729: spaces = p1;
! 1730: scan_stat = 11;
! 1731: break;
! 1732:
! 1733: default: /* first letter of a non-encoded word */
! 1734: _php_iconv_appendc(pretval, *p1, cd_pl);
! 1735: scan_stat = 12;
! 1736: break;
! 1737: }
! 1738: } break;
! 1739: }
! 1740: break;
! 1741:
! 1742: case 10: /* expects a language specifier. dismiss it for now */
! 1743: if (*p1 == '?') {
! 1744: scan_stat = 3;
! 1745: }
! 1746: break;
! 1747:
! 1748: case 11: /* expecting a chunk of whitespaces */
! 1749: switch (*p1) {
! 1750: case '\r': /* part of an EOL sequence? */
! 1751: scan_stat = 7;
! 1752: break;
! 1753:
! 1754: case '\n':
! 1755: scan_stat = 8;
! 1756: break;
! 1757:
! 1758: case '=': /* first letter of an encoded chunk */
! 1759: if (spaces != NULL && encoded_word == NULL) {
! 1760: _php_iconv_appendl(pretval, spaces, (size_t)(p1 - spaces), cd_pl);
! 1761: spaces = NULL;
! 1762: }
! 1763: encoded_word = p1;
! 1764: scan_stat = 1;
! 1765: break;
! 1766:
! 1767: case ' ': case '\t':
! 1768: break;
! 1769:
! 1770: default: /* first letter of a non-encoded word */
! 1771: if (spaces != NULL) {
! 1772: _php_iconv_appendl(pretval, spaces, (size_t)(p1 - spaces), cd_pl);
! 1773: spaces = NULL;
! 1774: }
! 1775: _php_iconv_appendc(pretval, *p1, cd_pl);
! 1776: encoded_word = NULL;
! 1777: if ((mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1778: scan_stat = 12;
! 1779: } else {
! 1780: scan_stat = 0;
! 1781: }
! 1782: break;
! 1783: }
! 1784: break;
! 1785:
! 1786: case 12: /* expecting a non-encoded word */
! 1787: switch (*p1) {
! 1788: case '\r': /* part of an EOL sequence? */
! 1789: scan_stat = 7;
! 1790: break;
! 1791:
! 1792: case '\n':
! 1793: scan_stat = 8;
! 1794: break;
! 1795:
! 1796: case ' ': case '\t':
! 1797: spaces = p1;
! 1798: scan_stat = 11;
! 1799: break;
! 1800:
! 1801: case '=': /* first letter of an encoded chunk */
! 1802: if (!(mode & PHP_ICONV_MIME_DECODE_STRICT)) {
! 1803: encoded_word = p1;
! 1804: scan_stat = 1;
! 1805: break;
! 1806: }
! 1807: /* break is omitted intentionally */
! 1808:
! 1809: default:
! 1810: _php_iconv_appendc(pretval, *p1, cd_pl);
! 1811: break;
! 1812: }
! 1813: break;
! 1814: }
! 1815: }
! 1816: switch (scan_stat) {
! 1817: case 0: case 8: case 11: case 12:
! 1818: break;
! 1819: default:
! 1820: if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
! 1821: if (scan_stat == 1) {
! 1822: _php_iconv_appendc(pretval, '=', cd_pl);
! 1823: }
! 1824: err = PHP_ICONV_ERR_SUCCESS;
! 1825: } else {
! 1826: err = PHP_ICONV_ERR_MALFORMED;
! 1827: goto out;
! 1828: }
! 1829: }
! 1830:
! 1831: if (next_pos != NULL) {
! 1832: *next_pos = p1;
! 1833: }
! 1834:
! 1835: smart_str_0(pretval);
! 1836: out:
! 1837: if (cd != (iconv_t)(-1)) {
! 1838: iconv_close(cd);
! 1839: }
! 1840: if (cd_pl != (iconv_t)(-1)) {
! 1841: iconv_close(cd_pl);
! 1842: }
! 1843: return err;
! 1844: }
! 1845: /* }}} */
! 1846:
! 1847: /* {{{ php_iconv_show_error() */
! 1848: static void _php_iconv_show_error(php_iconv_err_t err, const char *out_charset, const char *in_charset TSRMLS_DC)
! 1849: {
! 1850: switch (err) {
! 1851: case PHP_ICONV_ERR_SUCCESS:
! 1852: break;
! 1853:
! 1854: case PHP_ICONV_ERR_CONVERTER:
! 1855: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Cannot open converter");
! 1856: break;
! 1857:
! 1858: case PHP_ICONV_ERR_WRONG_CHARSET:
! 1859: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Wrong charset, conversion from `%s' to `%s' is not allowed",
! 1860: in_charset, out_charset);
! 1861: break;
! 1862:
! 1863: case PHP_ICONV_ERR_ILLEGAL_CHAR:
! 1864: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Detected an incomplete multibyte character in input string");
! 1865: break;
! 1866:
! 1867: case PHP_ICONV_ERR_ILLEGAL_SEQ:
! 1868: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Detected an illegal character in input string");
! 1869: break;
! 1870:
! 1871: case PHP_ICONV_ERR_TOO_BIG:
! 1872: /* should not happen */
! 1873: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Buffer length exceeded");
! 1874: break;
! 1875:
! 1876: case PHP_ICONV_ERR_MALFORMED:
! 1877: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Malformed string");
! 1878: break;
! 1879:
! 1880: default:
! 1881: /* other error */
! 1882: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unknown error (%d)", errno);
! 1883: break;
! 1884: }
! 1885: }
! 1886: /* }}} */
! 1887:
! 1888: /* {{{ proto int iconv_strlen(string str [, string charset])
! 1889: Returns the character count of str */
! 1890: PHP_FUNCTION(iconv_strlen)
! 1891: {
! 1892: char *charset = ICONVG(internal_encoding);
! 1893: int charset_len = 0;
! 1894: char *str;
! 1895: int str_len;
! 1896:
! 1897: php_iconv_err_t err;
! 1898:
! 1899: unsigned int retval;
! 1900:
! 1901: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s",
! 1902: &str, &str_len, &charset, &charset_len) == FAILURE) {
! 1903: RETURN_FALSE;
! 1904: }
! 1905:
! 1906: if (charset_len >= ICONV_CSNMAXLEN) {
! 1907: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 1908: RETURN_FALSE;
! 1909: }
! 1910:
! 1911: err = _php_iconv_strlen(&retval, str, str_len, charset);
! 1912: _php_iconv_show_error(err, GENERIC_SUPERSET_NAME, charset TSRMLS_CC);
! 1913: if (err == PHP_ICONV_ERR_SUCCESS) {
! 1914: RETVAL_LONG(retval);
! 1915: } else {
! 1916: RETVAL_FALSE;
! 1917: }
! 1918: }
! 1919: /* }}} */
! 1920:
! 1921: /* {{{ proto string iconv_substr(string str, int offset, [int length, string charset])
! 1922: Returns specified part of a string */
! 1923: PHP_FUNCTION(iconv_substr)
! 1924: {
! 1925: char *charset = ICONVG(internal_encoding);
! 1926: int charset_len = 0;
! 1927: char *str;
! 1928: int str_len;
! 1929: long offset, length = 0;
! 1930:
! 1931: php_iconv_err_t err;
! 1932:
! 1933: smart_str retval = {0};
! 1934:
! 1935: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|ls",
! 1936: &str, &str_len, &offset, &length,
! 1937: &charset, &charset_len) == FAILURE) {
! 1938: RETURN_FALSE;
! 1939: }
! 1940:
! 1941: if (charset_len >= ICONV_CSNMAXLEN) {
! 1942: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 1943: RETURN_FALSE;
! 1944: }
! 1945:
! 1946: if (ZEND_NUM_ARGS() < 3) {
! 1947: length = str_len;
! 1948: }
! 1949:
! 1950: err = _php_iconv_substr(&retval, str, str_len, offset, length, charset);
! 1951: _php_iconv_show_error(err, GENERIC_SUPERSET_NAME, charset TSRMLS_CC);
! 1952:
! 1953: if (err == PHP_ICONV_ERR_SUCCESS && str != NULL && retval.c != NULL) {
! 1954: RETURN_STRINGL(retval.c, retval.len, 0);
! 1955: }
! 1956: smart_str_free(&retval);
! 1957: RETURN_FALSE;
! 1958: }
! 1959: /* }}} */
! 1960:
! 1961: /* {{{ proto int iconv_strpos(string haystack, string needle [, int offset [, string charset]])
! 1962: Finds position of first occurrence of needle within part of haystack beginning with offset */
! 1963: PHP_FUNCTION(iconv_strpos)
! 1964: {
! 1965: char *charset = ICONVG(internal_encoding);
! 1966: int charset_len = 0;
! 1967: char *haystk;
! 1968: int haystk_len;
! 1969: char *ndl;
! 1970: int ndl_len;
! 1971: long offset = 0;
! 1972:
! 1973: php_iconv_err_t err;
! 1974:
! 1975: unsigned int retval;
! 1976:
! 1977: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls",
! 1978: &haystk, &haystk_len, &ndl, &ndl_len,
! 1979: &offset, &charset, &charset_len) == FAILURE) {
! 1980: RETURN_FALSE;
! 1981: }
! 1982:
! 1983: if (charset_len >= ICONV_CSNMAXLEN) {
! 1984: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 1985: RETURN_FALSE;
! 1986: }
! 1987:
! 1988: if (offset < 0) {
! 1989: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset not contained in string.");
! 1990: RETURN_FALSE;
! 1991: }
! 1992:
! 1993: if (ndl_len < 1) {
! 1994: RETURN_FALSE;
! 1995: }
! 1996:
! 1997: err = _php_iconv_strpos(&retval, haystk, haystk_len, ndl, ndl_len,
! 1998: offset, charset);
! 1999: _php_iconv_show_error(err, GENERIC_SUPERSET_NAME, charset TSRMLS_CC);
! 2000:
! 2001: if (err == PHP_ICONV_ERR_SUCCESS && retval != (unsigned int)-1) {
! 2002: RETVAL_LONG((long)retval);
! 2003: } else {
! 2004: RETVAL_FALSE;
! 2005: }
! 2006: }
! 2007: /* }}} */
! 2008:
! 2009: /* {{{ proto int iconv_strrpos(string haystack, string needle [, string charset])
! 2010: Finds position of last occurrence of needle within part of haystack beginning with offset */
! 2011: PHP_FUNCTION(iconv_strrpos)
! 2012: {
! 2013: char *charset = ICONVG(internal_encoding);
! 2014: int charset_len = 0;
! 2015: char *haystk;
! 2016: int haystk_len;
! 2017: char *ndl;
! 2018: int ndl_len;
! 2019:
! 2020: php_iconv_err_t err;
! 2021:
! 2022: unsigned int retval;
! 2023:
! 2024: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s",
! 2025: &haystk, &haystk_len, &ndl, &ndl_len,
! 2026: &charset, &charset_len) == FAILURE) {
! 2027: RETURN_FALSE;
! 2028: }
! 2029:
! 2030: if (ndl_len < 1) {
! 2031: RETURN_FALSE;
! 2032: }
! 2033:
! 2034: if (charset_len >= ICONV_CSNMAXLEN) {
! 2035: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2036: RETURN_FALSE;
! 2037: }
! 2038:
! 2039: err = _php_iconv_strpos(&retval, haystk, haystk_len, ndl, ndl_len,
! 2040: -1, charset);
! 2041: _php_iconv_show_error(err, GENERIC_SUPERSET_NAME, charset TSRMLS_CC);
! 2042:
! 2043: if (err == PHP_ICONV_ERR_SUCCESS && retval != (unsigned int)-1) {
! 2044: RETVAL_LONG((long)retval);
! 2045: } else {
! 2046: RETVAL_FALSE;
! 2047: }
! 2048: }
! 2049: /* }}} */
! 2050:
! 2051: /* {{{ proto string iconv_mime_encode(string field_name, string field_value [, array preference])
! 2052: Composes a mime header field with field_name and field_value in a specified scheme */
! 2053: PHP_FUNCTION(iconv_mime_encode)
! 2054: {
! 2055: const char *field_name = NULL;
! 2056: int field_name_len;
! 2057: const char *field_value = NULL;
! 2058: int field_value_len;
! 2059: zval *pref = NULL;
! 2060: zval tmp_zv, *tmp_zv_p = NULL;
! 2061: smart_str retval = {0};
! 2062: php_iconv_err_t err;
! 2063:
! 2064: const char *in_charset = ICONVG(internal_encoding);
! 2065: const char *out_charset = in_charset;
! 2066: long line_len = 76;
! 2067: const char *lfchars = "\r\n";
! 2068: php_iconv_enc_scheme_t scheme_id = PHP_ICONV_ENC_SCHEME_BASE64;
! 2069:
! 2070: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a",
! 2071: &field_name, &field_name_len, &field_value, &field_value_len,
! 2072: &pref) == FAILURE) {
! 2073:
! 2074: RETURN_FALSE;
! 2075: }
! 2076:
! 2077: if (pref != NULL) {
! 2078: zval **ppval;
! 2079:
! 2080: if (zend_hash_find(Z_ARRVAL_P(pref), "scheme", sizeof("scheme"), (void **)&ppval) == SUCCESS) {
! 2081: if (Z_TYPE_PP(ppval) == IS_STRING && Z_STRLEN_PP(ppval) > 0) {
! 2082: switch (Z_STRVAL_PP(ppval)[0]) {
! 2083: case 'B': case 'b':
! 2084: scheme_id = PHP_ICONV_ENC_SCHEME_BASE64;
! 2085: break;
! 2086:
! 2087: case 'Q': case 'q':
! 2088: scheme_id = PHP_ICONV_ENC_SCHEME_QPRINT;
! 2089: break;
! 2090: }
! 2091: }
! 2092: }
! 2093:
! 2094: if (zend_hash_find(Z_ARRVAL_P(pref), "input-charset", sizeof("input-charset"), (void **)&ppval) == SUCCESS) {
! 2095: if (Z_STRLEN_PP(ppval) >= ICONV_CSNMAXLEN) {
! 2096: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2097: RETURN_FALSE;
! 2098: }
! 2099:
! 2100: if (Z_TYPE_PP(ppval) == IS_STRING && Z_STRLEN_PP(ppval) > 0) {
! 2101: in_charset = Z_STRVAL_PP(ppval);
! 2102: }
! 2103: }
! 2104:
! 2105:
! 2106: if (zend_hash_find(Z_ARRVAL_P(pref), "output-charset", sizeof("output-charset"), (void **)&ppval) == SUCCESS) {
! 2107: if (Z_STRLEN_PP(ppval) >= ICONV_CSNMAXLEN) {
! 2108: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2109: RETURN_FALSE;
! 2110: }
! 2111:
! 2112: if (Z_TYPE_PP(ppval) == IS_STRING && Z_STRLEN_PP(ppval) > 0) {
! 2113: out_charset = Z_STRVAL_PP(ppval);
! 2114: }
! 2115: }
! 2116:
! 2117: if (zend_hash_find(Z_ARRVAL_P(pref), "line-length", sizeof("line-length"), (void **)&ppval) == SUCCESS) {
! 2118: zval val, *pval = *ppval;
! 2119:
! 2120: if (Z_TYPE_P(pval) != IS_LONG) {
! 2121: val = *pval;
! 2122: zval_copy_ctor(&val);
! 2123: convert_to_long(&val);
! 2124: pval = &val;
! 2125: }
! 2126:
! 2127: line_len = Z_LVAL_P(pval);
! 2128:
! 2129: if (pval == &val) {
! 2130: zval_dtor(&val);
! 2131: }
! 2132: }
! 2133:
! 2134: if (zend_hash_find(Z_ARRVAL_P(pref), "line-break-chars", sizeof("line-break-chars"), (void **)&ppval) == SUCCESS) {
! 2135: if (Z_TYPE_PP(ppval) != IS_STRING) {
! 2136: tmp_zv = **ppval;
! 2137: zval_copy_ctor(&tmp_zv);
! 2138: convert_to_string(&tmp_zv);
! 2139:
! 2140: lfchars = Z_STRVAL(tmp_zv);
! 2141:
! 2142: tmp_zv_p = &tmp_zv;
! 2143: } else {
! 2144: lfchars = Z_STRVAL_PP(ppval);
! 2145: }
! 2146: }
! 2147: }
! 2148:
! 2149: err = _php_iconv_mime_encode(&retval, field_name, field_name_len,
! 2150: field_value, field_value_len, line_len, lfchars, scheme_id,
! 2151: out_charset, in_charset);
! 2152: _php_iconv_show_error(err, out_charset, in_charset TSRMLS_CC);
! 2153:
! 2154: if (err == PHP_ICONV_ERR_SUCCESS) {
! 2155: if (retval.c != NULL) {
! 2156: RETVAL_STRINGL(retval.c, retval.len, 0);
! 2157: } else {
! 2158: RETVAL_EMPTY_STRING();
! 2159: }
! 2160: } else {
! 2161: smart_str_free(&retval);
! 2162: RETVAL_FALSE;
! 2163: }
! 2164:
! 2165: if (tmp_zv_p != NULL) {
! 2166: zval_dtor(tmp_zv_p);
! 2167: }
! 2168: }
! 2169: /* }}} */
! 2170:
! 2171: /* {{{ proto string iconv_mime_decode(string encoded_string [, int mode, string charset])
! 2172: Decodes a mime header field */
! 2173: PHP_FUNCTION(iconv_mime_decode)
! 2174: {
! 2175: char *encoded_str;
! 2176: int encoded_str_len;
! 2177: char *charset = ICONVG(internal_encoding);
! 2178: int charset_len = 0;
! 2179: long mode = 0;
! 2180:
! 2181: smart_str retval = {0};
! 2182:
! 2183: php_iconv_err_t err;
! 2184:
! 2185: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls",
! 2186: &encoded_str, &encoded_str_len, &mode, &charset, &charset_len) == FAILURE) {
! 2187:
! 2188: RETURN_FALSE;
! 2189: }
! 2190:
! 2191: if (charset_len >= ICONV_CSNMAXLEN) {
! 2192: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2193: RETURN_FALSE;
! 2194: }
! 2195:
! 2196: err = _php_iconv_mime_decode(&retval, encoded_str, encoded_str_len, charset, NULL, mode);
! 2197: _php_iconv_show_error(err, charset, "???" TSRMLS_CC);
! 2198:
! 2199: if (err == PHP_ICONV_ERR_SUCCESS) {
! 2200: if (retval.c != NULL) {
! 2201: RETVAL_STRINGL(retval.c, retval.len, 0);
! 2202: } else {
! 2203: RETVAL_EMPTY_STRING();
! 2204: }
! 2205: } else {
! 2206: smart_str_free(&retval);
! 2207: RETVAL_FALSE;
! 2208: }
! 2209: }
! 2210: /* }}} */
! 2211:
! 2212: /* {{{ proto array iconv_mime_decode_headers(string headers [, int mode, string charset])
! 2213: Decodes multiple mime header fields */
! 2214: PHP_FUNCTION(iconv_mime_decode_headers)
! 2215: {
! 2216: const char *encoded_str;
! 2217: int encoded_str_len;
! 2218: char *charset = ICONVG(internal_encoding);
! 2219: int charset_len = 0;
! 2220: long mode = 0;
! 2221:
! 2222: php_iconv_err_t err = PHP_ICONV_ERR_SUCCESS;
! 2223:
! 2224: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls",
! 2225: &encoded_str, &encoded_str_len, &mode, &charset, &charset_len) == FAILURE) {
! 2226:
! 2227: RETURN_FALSE;
! 2228: }
! 2229:
! 2230: if (charset_len >= ICONV_CSNMAXLEN) {
! 2231: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2232: RETURN_FALSE;
! 2233: }
! 2234:
! 2235: array_init(return_value);
! 2236:
! 2237: while (encoded_str_len > 0) {
! 2238: smart_str decoded_header = {0};
! 2239: char *header_name = NULL;
! 2240: size_t header_name_len = 0;
! 2241: char *header_value = NULL;
! 2242: size_t header_value_len = 0;
! 2243: char *p, *limit;
! 2244: const char *next_pos;
! 2245:
! 2246: if (PHP_ICONV_ERR_SUCCESS != (err = _php_iconv_mime_decode(&decoded_header, encoded_str, encoded_str_len, charset, &next_pos, mode))) {
! 2247: smart_str_free(&decoded_header);
! 2248: break;
! 2249: }
! 2250:
! 2251: if (decoded_header.c == NULL) {
! 2252: break;
! 2253: }
! 2254:
! 2255: limit = decoded_header.c + decoded_header.len;
! 2256: for (p = decoded_header.c; p < limit; p++) {
! 2257: if (*p == ':') {
! 2258: *p = '\0';
! 2259: header_name = decoded_header.c;
! 2260: header_name_len = (p - decoded_header.c) + 1;
! 2261:
! 2262: while (++p < limit) {
! 2263: if (*p != ' ' && *p != '\t') {
! 2264: break;
! 2265: }
! 2266: }
! 2267:
! 2268: header_value = p;
! 2269: header_value_len = limit - p;
! 2270:
! 2271: break;
! 2272: }
! 2273: }
! 2274:
! 2275: if (header_name != NULL) {
! 2276: zval **elem, *new_elem;
! 2277:
! 2278: if (zend_hash_find(Z_ARRVAL_P(return_value), header_name, header_name_len, (void **)&elem) == SUCCESS) {
! 2279: if (Z_TYPE_PP(elem) != IS_ARRAY) {
! 2280: MAKE_STD_ZVAL(new_elem);
! 2281: array_init(new_elem);
! 2282:
! 2283: Z_ADDREF_PP(elem);
! 2284: add_next_index_zval(new_elem, *elem);
! 2285:
! 2286: zend_hash_update(Z_ARRVAL_P(return_value), header_name, header_name_len, (void *)&new_elem, sizeof(new_elem), NULL);
! 2287:
! 2288: elem = &new_elem;
! 2289: }
! 2290: add_next_index_stringl(*elem, header_value, header_value_len, 1);
! 2291: } else {
! 2292: add_assoc_stringl_ex(return_value, header_name, header_name_len, header_value, header_value_len, 1);
! 2293: }
! 2294: }
! 2295: encoded_str_len -= next_pos - encoded_str;
! 2296: encoded_str = next_pos;
! 2297:
! 2298: smart_str_free(&decoded_header);
! 2299: }
! 2300:
! 2301: if (err != PHP_ICONV_ERR_SUCCESS) {
! 2302: _php_iconv_show_error(err, charset, "???" TSRMLS_CC);
! 2303: zval_dtor(return_value);
! 2304: RETVAL_FALSE;
! 2305: }
! 2306: }
! 2307: /* }}} */
! 2308:
! 2309: /* {{{ proto string iconv(string in_charset, string out_charset, string str)
! 2310: Returns str converted to the out_charset character set */
! 2311: PHP_NAMED_FUNCTION(php_if_iconv)
! 2312: {
! 2313: char *in_charset, *out_charset, *in_buffer, *out_buffer;
! 2314: size_t out_len;
! 2315: int in_charset_len = 0, out_charset_len = 0, in_buffer_len;
! 2316: php_iconv_err_t err;
! 2317:
! 2318: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss",
! 2319: &in_charset, &in_charset_len, &out_charset, &out_charset_len, &in_buffer, &in_buffer_len) == FAILURE)
! 2320: return;
! 2321:
! 2322: if (in_charset_len >= ICONV_CSNMAXLEN || out_charset_len >= ICONV_CSNMAXLEN) {
! 2323: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2324: RETURN_FALSE;
! 2325: }
! 2326:
! 2327: err = php_iconv_string(in_buffer, (size_t)in_buffer_len,
! 2328: &out_buffer, &out_len, out_charset, in_charset);
! 2329: _php_iconv_show_error(err, out_charset, in_charset TSRMLS_CC);
! 2330: if (out_buffer != NULL) {
! 2331: RETVAL_STRINGL(out_buffer, out_len, 0);
! 2332: } else {
! 2333: RETURN_FALSE;
! 2334: }
! 2335: }
! 2336: /* }}} */
! 2337:
! 2338: /* {{{ proto string ob_iconv_handler(string contents, int status)
! 2339: Returns str in output buffer converted to the iconv.output_encoding character set */
! 2340: PHP_FUNCTION(ob_iconv_handler)
! 2341: {
! 2342: char *out_buffer, *content_type, *mimetype = NULL, *s;
! 2343: zval *zv_string;
! 2344: size_t out_len;
! 2345: int mimetype_alloced = 0;
! 2346: long status;
! 2347:
! 2348: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &zv_string, &status) == FAILURE)
! 2349: return;
! 2350:
! 2351: convert_to_string(zv_string);
! 2352:
! 2353: if (SG(sapi_headers).mimetype &&
! 2354: strncasecmp(SG(sapi_headers).mimetype, "text/", 5) == 0) {
! 2355: if ((s = strchr(SG(sapi_headers).mimetype,';')) == NULL){
! 2356: mimetype = SG(sapi_headers).mimetype;
! 2357: } else {
! 2358: mimetype = estrndup(SG(sapi_headers).mimetype, s-SG(sapi_headers).mimetype);
! 2359: mimetype_alloced = 1;
! 2360: }
! 2361: } else if (SG(sapi_headers).send_default_content_type) {
! 2362: mimetype =(SG(default_mimetype) ? SG(default_mimetype) : SAPI_DEFAULT_MIMETYPE);
! 2363: }
! 2364: if (mimetype != NULL) {
! 2365: php_iconv_err_t err = php_iconv_string(Z_STRVAL_P(zv_string),
! 2366: Z_STRLEN_P(zv_string), &out_buffer, &out_len,
! 2367: ICONVG(output_encoding), ICONVG(internal_encoding));
! 2368: _php_iconv_show_error(err, ICONVG(output_encoding), ICONVG(internal_encoding) TSRMLS_CC);
! 2369: if (out_buffer != NULL) {
! 2370: int len;
! 2371: char *p = strstr(ICONVG(output_encoding), "//");
! 2372: if (p) {
! 2373: len = spprintf(&content_type, 0, "Content-Type:%s; charset=%.*s", mimetype, (int)(p - ICONVG(output_encoding)), ICONVG(output_encoding));
! 2374: } else {
! 2375: len = spprintf(&content_type, 0, "Content-Type:%s; charset=%s", mimetype, ICONVG(output_encoding));
! 2376: }
! 2377: if (content_type && sapi_add_header(content_type, len, 0) != FAILURE) {
! 2378: SG(sapi_headers).send_default_content_type = 0;
! 2379: }
! 2380: if (mimetype_alloced) {
! 2381: efree(mimetype);
! 2382: }
! 2383: RETURN_STRINGL(out_buffer, out_len, 0);
! 2384: }
! 2385: if (mimetype_alloced) {
! 2386: efree(mimetype);
! 2387: }
! 2388: }
! 2389:
! 2390: zval_dtor(return_value);
! 2391: *return_value = *zv_string;
! 2392: zval_copy_ctor(return_value);
! 2393: }
! 2394: /* }}} */
! 2395:
! 2396: /* {{{ proto bool iconv_set_encoding(string type, string charset)
! 2397: Sets internal encoding and output encoding for ob_iconv_handler() */
! 2398: PHP_FUNCTION(iconv_set_encoding)
! 2399: {
! 2400: char *type, *charset;
! 2401: int type_len, charset_len =0, retval;
! 2402:
! 2403: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &type, &type_len, &charset, &charset_len) == FAILURE)
! 2404: return;
! 2405:
! 2406: if (charset_len >= ICONV_CSNMAXLEN) {
! 2407: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Charset parameter exceeds the maximum allowed length of %d characters", ICONV_CSNMAXLEN);
! 2408: RETURN_FALSE;
! 2409: }
! 2410:
! 2411: if(!strcasecmp("input_encoding", type)) {
! 2412: retval = zend_alter_ini_entry("iconv.input_encoding", sizeof("iconv.input_encoding"), charset, charset_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
! 2413: } else if(!strcasecmp("output_encoding", type)) {
! 2414: retval = zend_alter_ini_entry("iconv.output_encoding", sizeof("iconv.output_encoding"), charset, charset_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
! 2415: } else if(!strcasecmp("internal_encoding", type)) {
! 2416: retval = zend_alter_ini_entry("iconv.internal_encoding", sizeof("iconv.internal_encoding"), charset, charset_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
! 2417: } else {
! 2418: RETURN_FALSE;
! 2419: }
! 2420:
! 2421: if (retval == SUCCESS) {
! 2422: RETURN_TRUE;
! 2423: } else {
! 2424: RETURN_FALSE;
! 2425: }
! 2426: }
! 2427: /* }}} */
! 2428:
! 2429: /* {{{ proto mixed iconv_get_encoding([string type])
! 2430: Get internal encoding and output encoding for ob_iconv_handler() */
! 2431: PHP_FUNCTION(iconv_get_encoding)
! 2432: {
! 2433: char *type = "all";
! 2434: int type_len = sizeof("all")-1;
! 2435:
! 2436: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &type, &type_len) == FAILURE)
! 2437: return;
! 2438:
! 2439: if (!strcasecmp("all", type)) {
! 2440: array_init(return_value);
! 2441: add_assoc_string(return_value, "input_encoding", ICONVG(input_encoding), 1);
! 2442: add_assoc_string(return_value, "output_encoding", ICONVG(output_encoding), 1);
! 2443: add_assoc_string(return_value, "internal_encoding", ICONVG(internal_encoding), 1);
! 2444: } else if (!strcasecmp("input_encoding", type)) {
! 2445: RETVAL_STRING(ICONVG(input_encoding), 1);
! 2446: } else if (!strcasecmp("output_encoding", type)) {
! 2447: RETVAL_STRING(ICONVG(output_encoding), 1);
! 2448: } else if (!strcasecmp("internal_encoding", type)) {
! 2449: RETVAL_STRING(ICONVG(internal_encoding), 1);
! 2450: } else {
! 2451: RETURN_FALSE;
! 2452: }
! 2453:
! 2454: }
! 2455: /* }}} */
! 2456:
! 2457: /* {{{ iconv stream filter */
! 2458: typedef struct _php_iconv_stream_filter {
! 2459: iconv_t cd;
! 2460: int persistent;
! 2461: char *to_charset;
! 2462: size_t to_charset_len;
! 2463: char *from_charset;
! 2464: size_t from_charset_len;
! 2465: char stub[128];
! 2466: size_t stub_len;
! 2467: } php_iconv_stream_filter;
! 2468: /* }}} iconv stream filter */
! 2469:
! 2470: /* {{{ php_iconv_stream_filter_dtor */
! 2471: static void php_iconv_stream_filter_dtor(php_iconv_stream_filter *self)
! 2472: {
! 2473: iconv_close(self->cd);
! 2474: pefree(self->to_charset, self->persistent);
! 2475: pefree(self->from_charset, self->persistent);
! 2476: }
! 2477: /* }}} */
! 2478:
! 2479: /* {{{ php_iconv_stream_filter_ctor() */
! 2480: static php_iconv_err_t php_iconv_stream_filter_ctor(php_iconv_stream_filter *self,
! 2481: const char *to_charset, size_t to_charset_len,
! 2482: const char *from_charset, size_t from_charset_len, int persistent)
! 2483: {
! 2484: if (NULL == (self->to_charset = pemalloc(to_charset_len + 1, persistent))) {
! 2485: return PHP_ICONV_ERR_ALLOC;
! 2486: }
! 2487: self->to_charset_len = to_charset_len;
! 2488: if (NULL == (self->from_charset = pemalloc(from_charset_len + 1, persistent))) {
! 2489: pefree(self->to_charset, persistent);
! 2490: return PHP_ICONV_ERR_ALLOC;
! 2491: }
! 2492: self->from_charset_len = from_charset_len;
! 2493:
! 2494: memcpy(self->to_charset, to_charset, to_charset_len);
! 2495: self->to_charset[to_charset_len] = '\0';
! 2496: memcpy(self->from_charset, from_charset, from_charset_len);
! 2497: self->from_charset[from_charset_len] = '\0';
! 2498:
! 2499: if ((iconv_t)-1 == (self->cd = iconv_open(self->to_charset, self->from_charset))) {
! 2500: pefree(self->from_charset, persistent);
! 2501: pefree(self->to_charset, persistent);
! 2502: return PHP_ICONV_ERR_UNKNOWN;
! 2503: }
! 2504: self->persistent = persistent;
! 2505: self->stub_len = 0;
! 2506: return PHP_ICONV_ERR_SUCCESS;
! 2507: }
! 2508: /* }}} */
! 2509:
! 2510: /* {{{ php_iconv_stream_filter_append_bucket */
! 2511: static int php_iconv_stream_filter_append_bucket(
! 2512: php_iconv_stream_filter *self,
! 2513: php_stream *stream, php_stream_filter *filter,
! 2514: php_stream_bucket_brigade *buckets_out,
! 2515: const char *ps, size_t buf_len, size_t *consumed,
! 2516: int persistent TSRMLS_DC)
! 2517: {
! 2518: php_stream_bucket *new_bucket;
! 2519: char *out_buf = NULL;
! 2520: size_t out_buf_size;
! 2521: char *pd, *pt;
! 2522: size_t ocnt, prev_ocnt, icnt, tcnt;
! 2523: size_t initial_out_buf_size;
! 2524:
! 2525: if (ps == NULL) {
! 2526: initial_out_buf_size = 64;
! 2527: icnt = 1;
! 2528: } else {
! 2529: initial_out_buf_size = buf_len;
! 2530: icnt = buf_len;
! 2531: }
! 2532:
! 2533: out_buf_size = ocnt = prev_ocnt = initial_out_buf_size;
! 2534: if (NULL == (out_buf = pemalloc(out_buf_size, persistent))) {
! 2535: return FAILURE;
! 2536: }
! 2537:
! 2538: pd = out_buf;
! 2539:
! 2540: if (self->stub_len > 0) {
! 2541: pt = self->stub;
! 2542: tcnt = self->stub_len;
! 2543:
! 2544: while (tcnt > 0) {
! 2545: if (iconv(self->cd, &pt, &tcnt, &pd, &ocnt) == (size_t)-1) {
! 2546: #if ICONV_SUPPORTS_ERRNO
! 2547: switch (errno) {
! 2548: case EILSEQ:
! 2549: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): invalid multibyte sequence", self->from_charset, self->to_charset);
! 2550: goto out_failure;
! 2551:
! 2552: case EINVAL:
! 2553: if (ps != NULL) {
! 2554: if (icnt > 0) {
! 2555: if (self->stub_len >= sizeof(self->stub)) {
! 2556: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): insufficient buffer", self->from_charset, self->to_charset);
! 2557: goto out_failure;
! 2558: }
! 2559: self->stub[self->stub_len++] = *(ps++);
! 2560: icnt--;
! 2561: pt = self->stub;
! 2562: tcnt = self->stub_len;
! 2563: } else {
! 2564: tcnt = 0;
! 2565: break;
! 2566: }
! 2567: }
! 2568: break;
! 2569:
! 2570: case E2BIG: {
! 2571: char *new_out_buf;
! 2572: size_t new_out_buf_size;
! 2573:
! 2574: new_out_buf_size = out_buf_size << 1;
! 2575:
! 2576: if (new_out_buf_size < out_buf_size) {
! 2577: /* whoa! no bigger buckets are sold anywhere... */
! 2578: if (NULL == (new_bucket = php_stream_bucket_new(stream, out_buf, (out_buf_size - ocnt), 1, persistent TSRMLS_CC))) {
! 2579: goto out_failure;
! 2580: }
! 2581:
! 2582: php_stream_bucket_append(buckets_out, new_bucket TSRMLS_CC);
! 2583:
! 2584: out_buf_size = ocnt = initial_out_buf_size;
! 2585: if (NULL == (out_buf = pemalloc(out_buf_size, persistent))) {
! 2586: return FAILURE;
! 2587: }
! 2588: pd = out_buf;
! 2589: } else {
! 2590: if (NULL == (new_out_buf = perealloc(out_buf, new_out_buf_size, persistent))) {
! 2591: if (NULL == (new_bucket = php_stream_bucket_new(stream, out_buf, (out_buf_size - ocnt), 1, persistent TSRMLS_CC))) {
! 2592: goto out_failure;
! 2593: }
! 2594:
! 2595: php_stream_bucket_append(buckets_out, new_bucket TSRMLS_CC);
! 2596: return FAILURE;
! 2597: }
! 2598: pd = new_out_buf + (pd - out_buf);
! 2599: ocnt += (new_out_buf_size - out_buf_size);
! 2600: out_buf = new_out_buf;
! 2601: out_buf_size = new_out_buf_size;
! 2602: }
! 2603: } break;
! 2604:
! 2605: default:
! 2606: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): unknown error", self->from_charset, self->to_charset);
! 2607: goto out_failure;
! 2608: }
! 2609: #else
! 2610: if (ocnt == prev_ocnt) {
! 2611: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): unknown error", self->from_charset, self->to_charset);
! 2612: goto out_failure;
! 2613: }
! 2614: #endif
! 2615: }
! 2616: prev_ocnt = ocnt;
! 2617: }
! 2618: memmove(self->stub, pt, tcnt);
! 2619: self->stub_len = tcnt;
! 2620: }
! 2621:
! 2622: while (icnt > 0) {
! 2623: if ((ps == NULL ? iconv(self->cd, NULL, NULL, &pd, &ocnt):
! 2624: iconv(self->cd, (char **)&ps, &icnt, &pd, &ocnt)) == (size_t)-1) {
! 2625: #if ICONV_SUPPORTS_ERRNO
! 2626: switch (errno) {
! 2627: case EILSEQ:
! 2628: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): invalid multibyte sequence", self->from_charset, self->to_charset);
! 2629: goto out_failure;
! 2630:
! 2631: case EINVAL:
! 2632: if (ps != NULL) {
! 2633: if (icnt > sizeof(self->stub)) {
! 2634: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): insufficient buffer", self->from_charset, self->to_charset);
! 2635: goto out_failure;
! 2636: }
! 2637: memcpy(self->stub, ps, icnt);
! 2638: self->stub_len = icnt;
! 2639: ps += icnt;
! 2640: icnt = 0;
! 2641: } else {
! 2642: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): unexpected octet values", self->from_charset, self->to_charset);
! 2643: goto out_failure;
! 2644: }
! 2645: break;
! 2646:
! 2647: case E2BIG: {
! 2648: char *new_out_buf;
! 2649: size_t new_out_buf_size;
! 2650:
! 2651: new_out_buf_size = out_buf_size << 1;
! 2652:
! 2653: if (new_out_buf_size < out_buf_size) {
! 2654: /* whoa! no bigger buckets are sold anywhere... */
! 2655: if (NULL == (new_bucket = php_stream_bucket_new(stream, out_buf, (out_buf_size - ocnt), 1, persistent TSRMLS_CC))) {
! 2656: goto out_failure;
! 2657: }
! 2658:
! 2659: php_stream_bucket_append(buckets_out, new_bucket TSRMLS_CC);
! 2660:
! 2661: out_buf_size = ocnt = initial_out_buf_size;
! 2662: if (NULL == (out_buf = pemalloc(out_buf_size, persistent))) {
! 2663: return FAILURE;
! 2664: }
! 2665: pd = out_buf;
! 2666: } else {
! 2667: if (NULL == (new_out_buf = perealloc(out_buf, new_out_buf_size, persistent))) {
! 2668: if (NULL == (new_bucket = php_stream_bucket_new(stream, out_buf, (out_buf_size - ocnt), 1, persistent TSRMLS_CC))) {
! 2669: goto out_failure;
! 2670: }
! 2671:
! 2672: php_stream_bucket_append(buckets_out, new_bucket TSRMLS_CC);
! 2673: return FAILURE;
! 2674: }
! 2675: pd = new_out_buf + (pd - out_buf);
! 2676: ocnt += (new_out_buf_size - out_buf_size);
! 2677: out_buf = new_out_buf;
! 2678: out_buf_size = new_out_buf_size;
! 2679: }
! 2680: } break;
! 2681:
! 2682: default:
! 2683: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): unknown error", self->from_charset, self->to_charset);
! 2684: goto out_failure;
! 2685: }
! 2686: #else
! 2687: if (ocnt == prev_ocnt) {
! 2688: php_error_docref(NULL TSRMLS_CC, E_WARNING, "iconv stream filter (\"%s\"=>\"%s\"): unknown error", self->from_charset, self->to_charset);
! 2689: goto out_failure;
! 2690: }
! 2691: #endif
! 2692: } else {
! 2693: if (ps == NULL) {
! 2694: break;
! 2695: }
! 2696: }
! 2697: prev_ocnt = ocnt;
! 2698: }
! 2699:
! 2700: if (out_buf_size - ocnt > 0) {
! 2701: if (NULL == (new_bucket = php_stream_bucket_new(stream, out_buf, (out_buf_size - ocnt), 1, persistent TSRMLS_CC))) {
! 2702: goto out_failure;
! 2703: }
! 2704: php_stream_bucket_append(buckets_out, new_bucket TSRMLS_CC);
! 2705: } else {
! 2706: pefree(out_buf, persistent);
! 2707: }
! 2708: *consumed += buf_len - icnt;
! 2709:
! 2710: return SUCCESS;
! 2711:
! 2712: out_failure:
! 2713: pefree(out_buf, persistent);
! 2714: return FAILURE;
! 2715: }
! 2716: /* }}} php_iconv_stream_filter_append_bucket */
! 2717:
! 2718: /* {{{ php_iconv_stream_filter_do_filter */
! 2719: static php_stream_filter_status_t php_iconv_stream_filter_do_filter(
! 2720: php_stream *stream, php_stream_filter *filter,
! 2721: php_stream_bucket_brigade *buckets_in,
! 2722: php_stream_bucket_brigade *buckets_out,
! 2723: size_t *bytes_consumed, int flags TSRMLS_DC)
! 2724: {
! 2725: php_stream_bucket *bucket = NULL;
! 2726: size_t consumed = 0;
! 2727: php_iconv_stream_filter *self = (php_iconv_stream_filter *)filter->abstract;
! 2728:
! 2729: while (buckets_in->head != NULL) {
! 2730: bucket = buckets_in->head;
! 2731:
! 2732: php_stream_bucket_unlink(bucket TSRMLS_CC);
! 2733:
! 2734: if (php_iconv_stream_filter_append_bucket(self, stream, filter,
! 2735: buckets_out, bucket->buf, bucket->buflen, &consumed,
! 2736: php_stream_is_persistent(stream) TSRMLS_CC) != SUCCESS) {
! 2737: goto out_failure;
! 2738: }
! 2739:
! 2740: php_stream_bucket_delref(bucket TSRMLS_CC);
! 2741: }
! 2742:
! 2743: if (flags != PSFS_FLAG_NORMAL) {
! 2744: if (php_iconv_stream_filter_append_bucket(self, stream, filter,
! 2745: buckets_out, NULL, 0, &consumed,
! 2746: php_stream_is_persistent(stream) TSRMLS_CC) != SUCCESS) {
! 2747: goto out_failure;
! 2748: }
! 2749: }
! 2750:
! 2751: if (bytes_consumed != NULL) {
! 2752: *bytes_consumed = consumed;
! 2753: }
! 2754:
! 2755: return PSFS_PASS_ON;
! 2756:
! 2757: out_failure:
! 2758: if (bucket != NULL) {
! 2759: php_stream_bucket_delref(bucket TSRMLS_CC);
! 2760: }
! 2761: return PSFS_ERR_FATAL;
! 2762: }
! 2763: /* }}} */
! 2764:
! 2765: /* {{{ php_iconv_stream_filter_cleanup */
! 2766: static void php_iconv_stream_filter_cleanup(php_stream_filter *filter TSRMLS_DC)
! 2767: {
! 2768: php_iconv_stream_filter_dtor((php_iconv_stream_filter *)filter->abstract);
! 2769: pefree(filter->abstract, ((php_iconv_stream_filter *)filter->abstract)->persistent);
! 2770: }
! 2771: /* }}} */
! 2772:
! 2773: static php_stream_filter_ops php_iconv_stream_filter_ops = {
! 2774: php_iconv_stream_filter_do_filter,
! 2775: php_iconv_stream_filter_cleanup,
! 2776: "convert.iconv.*"
! 2777: };
! 2778:
! 2779: /* {{{ php_iconv_stream_filter_create */
! 2780: static php_stream_filter *php_iconv_stream_filter_factory_create(const char *name, zval *params, int persistent TSRMLS_DC)
! 2781: {
! 2782: php_stream_filter *retval = NULL;
! 2783: php_iconv_stream_filter *inst;
! 2784: char *from_charset = NULL, *to_charset = NULL;
! 2785: size_t from_charset_len, to_charset_len;
! 2786:
! 2787: if ((from_charset = strchr(name, '.')) == NULL) {
! 2788: return NULL;
! 2789: }
! 2790: ++from_charset;
! 2791: if ((from_charset = strchr(from_charset, '.')) == NULL) {
! 2792: return NULL;
! 2793: }
! 2794: ++from_charset;
! 2795: if ((to_charset = strpbrk(from_charset, "/.")) == NULL) {
! 2796: return NULL;
! 2797: }
! 2798: from_charset_len = to_charset - from_charset;
! 2799: ++to_charset;
! 2800: to_charset_len = strlen(to_charset);
! 2801:
! 2802: if (from_charset_len >= ICONV_CSNMAXLEN || to_charset_len >= ICONV_CSNMAXLEN) {
! 2803: return NULL;
! 2804: }
! 2805:
! 2806: if (NULL == (inst = pemalloc(sizeof(php_iconv_stream_filter), persistent))) {
! 2807: return NULL;
! 2808: }
! 2809:
! 2810: if (php_iconv_stream_filter_ctor(inst, to_charset, to_charset_len, from_charset, from_charset_len, persistent) != PHP_ICONV_ERR_SUCCESS) {
! 2811: pefree(inst, persistent);
! 2812: return NULL;
! 2813: }
! 2814:
! 2815: if (NULL == (retval = php_stream_filter_alloc(&php_iconv_stream_filter_ops, inst, persistent))) {
! 2816: php_iconv_stream_filter_dtor(inst);
! 2817: pefree(inst, persistent);
! 2818: }
! 2819:
! 2820: return retval;
! 2821: }
! 2822: /* }}} */
! 2823:
! 2824: /* {{{ php_iconv_stream_register_factory */
! 2825: static php_iconv_err_t php_iconv_stream_filter_register_factory(TSRMLS_D)
! 2826: {
! 2827: static php_stream_filter_factory filter_factory = {
! 2828: php_iconv_stream_filter_factory_create
! 2829: };
! 2830:
! 2831: if (FAILURE == php_stream_filter_register_factory(
! 2832: php_iconv_stream_filter_ops.label,
! 2833: &filter_factory TSRMLS_CC)) {
! 2834: return PHP_ICONV_ERR_UNKNOWN;
! 2835: }
! 2836: return PHP_ICONV_ERR_SUCCESS;
! 2837: }
! 2838: /* }}} */
! 2839:
! 2840: /* {{{ php_iconv_stream_unregister_factory */
! 2841: static php_iconv_err_t php_iconv_stream_filter_unregister_factory(TSRMLS_D)
! 2842: {
! 2843: if (FAILURE == php_stream_filter_unregister_factory(
! 2844: php_iconv_stream_filter_ops.label TSRMLS_CC)) {
! 2845: return PHP_ICONV_ERR_UNKNOWN;
! 2846: }
! 2847: return PHP_ICONV_ERR_SUCCESS;
! 2848: }
! 2849: /* }}} */
! 2850: /* }}} */
! 2851: #endif
! 2852:
! 2853: /*
! 2854: * Local variables:
! 2855: * tab-width: 4
! 2856: * c-basic-offset: 4
! 2857: * End:
! 2858: * vim600: sw=4 ts=4 fdm=marker
! 2859: * vim<600: sw=4 ts=4
! 2860: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iconv.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / iconv