static PHP_FUNCTION(global_name) { char *name = NULL; int name_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &name, &name_len) == FAILURE) { return; } if (GLOBAL_G(name)) { if (name) { /* GLOBAL_G(name) is about to be overwritten, * so we can give its current value away */ RETVAL_STRINGL(GLOBAL_G(name), GLOBAL_G(name_len), 0); } else { /* Read-only operation, so we need to make a new copy */ RETVAL_STRINGL(GLOBAL_G(name), GLOBAL_G(name_len), 1); } } if (name) { GLOBAL_G(name) = estrndup(name, name_len); GLOBAL_G(name_len) = name_len; } }
/* {{{ Qconf::getHostNative( .. ) */ static PHP_METHOD(Qconf, getHostNative) { char *path, *idc; size_t path_len, idc_len; int i; long get_flags = QCONF_WAIT; int ret = 0; string_vector_t nodes; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &path, &path_len, &idc, &idc_len, &get_flags) == FAILURE) { RETURN_NULL(); } ret = init_string_vector(&nodes); if (QCONF_OK != ret) { RETVAL_NULL(); } if (QCONF_NOWAIT == get_flags) { ret = qconf_aget_batch_keys_native(path, &nodes, idc); } else { ret = qconf_get_batch_keys_native(path, &nodes, idc); } if (QCONF_OK == ret) { if (nodes.count == 0) { RETVAL_STRINGL("", 0, 1); } else { unsigned int r = rand() % nodes.count; size_t node_len = strlen(nodes.data[r]); RETVAL_STRINGL(nodes.data[r], node_len, 1); } destroy_string_vector(&nodes); } else { RETVAL_NULL(); } return; }
/* {{{ proto string SolrUtils::queryPhrase(string unescaped) Prepares a phrase from an unescaped lucene string. */ PHP_METHOD(SolrUtils, queryPhrase) { solr_char_t *unescaped = NULL; solr_string_t sbuilder; long int unescaped_length = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &unescaped, &unescaped_length) == FAILURE) { RETURN_FALSE; } if (!unescaped_length) { RETURN_NULL(); } memset(&sbuilder, 0, sizeof(solr_string_t)); solr_string_appendc(&sbuilder, '"'); solr_escape_query_chars(&sbuilder, unescaped, unescaped_length); solr_string_appendc(&sbuilder, '"'); RETVAL_STRINGL(sbuilder.str, sbuilder.len, 1); solr_string_free(&sbuilder); }
/* {{{ proto string MarkdownDocument::transformFragment(string $markdown_fragment [, int $flags = 0 ]) */ PHP_METHOD(markdowndoc, transformFragment) { char *markdown; int markdown_len; long flags = 0; char *out = NULL; int out_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &markdown, &markdown_len, &flags) == FAILURE) { RETURN_FALSE; } if (markdown_len == 0) { RETURN_EMPTY_STRING(); } out_len = mkd_line(markdown, markdown_len, &out, (mkd_flag_t) flags); if (out_len < 0) { zend_throw_exception(spl_ce_RuntimeException, "Error parsing the fragment", 0 TSRMLS_CC); RETVAL_FALSE; } else { RETVAL_STRINGL(out, out_len, 0); } if (Z_TYPE_P(return_value) == IS_BOOL && out != NULL) { efree(out); } }
U_CFUNC PHP_FUNCTION(intltz_get_id) { TIMEZONE_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_get_id: bad arguments", 0); RETURN_FALSE; } TIMEZONE_METHOD_FETCH_OBJECT; UnicodeString id_us; to->utimezone->getID(id_us); char *id = NULL; int id_len = 0; intl_convert_utf16_to_utf8(&id, &id_len, id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to)); INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8"); RETVAL_STRINGL(id, id_len); //??? efree(id); }
U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id) { char *str_id; size_t str_id_len; zend_long index; intl_error_reset(NULL); if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl", &str_id, &str_id_len, &index) == FAILURE || index < (zend_long)INT32_MIN || index > (zend_long)INT32_MAX) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_get_equivalent_id: bad arguments", 0); RETURN_FALSE; } UErrorCode status = UErrorCode(); UnicodeString id; if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0); RETURN_FALSE; } const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index); char *str; int str_len; intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status); INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: " "could not convert resulting time zone id to UTF-16"); RETVAL_STRINGL(str, str_len); //???? efree(str); }
U_CFUNC PHP_FUNCTION(rbbi_get_rules) { BREAKITER_METHOD_INIT_VARS; object = getThis(); if (zend_parse_parameters_none() == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "rbbi_get_rules: bad arguments", 0); RETURN_FALSE; } BREAKITER_METHOD_FETCH_OBJECT; char *str; int str_len; const UnicodeString rules = fetch_rbbi(bio)->getRules(); if (intl_charFromString(rules, &str, &str_len, BREAKITER_ERROR_CODE_P(bio)) == FAILURE) { intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio), "rbbi_hash_code: Error converting result to UTF-8 string", 0); RETURN_FALSE; } RETVAL_STRINGL(str, str_len); //??? efree(str); }
/** * Gets last dispatched controller name * * @return string */ PHP_METHOD(Phalcon_Mvc_Dispatcher, getControllerName){ zval *is_exact; int i_exact; phalcon_read_property_this(&is_exact, getThis(), SL("_isExactControllerName"), PH_NOISY TSRMLS_CC); i_exact = zend_is_true(is_exact); zval_ptr_dtor(&is_exact); if (!i_exact) { RETURN_MEMBER(this_ptr, "_handlerName"); } phalcon_return_property_quick(return_value, getThis(), SL("_handlerName"), zend_inline_hash_func(SS("_handlerName")) TSRMLS_CC); if (likely(Z_TYPE_P(return_value) == IS_STRING) && Z_STRLEN_P(return_value) > 1) { char *c = Z_STRVAL_P(return_value); int len = Z_STRLEN_P(return_value); memmove(c, c+1, len-1); c[len-1] = 0; c = erealloc(c, len); if (likely(c != NULL)) { RETVAL_STRINGL(c, len-1, 0); } } }
static void php_intl_idn_to(INTERNAL_FUNCTION_PARAMETERS, const char *domain, int32_t domain_len, uint32_t option, int mode) { UChar* ustring = NULL; int ustring_len = 0; UErrorCode status; char *converted_utf8; size_t converted_utf8_len; UChar converted[MAXPATHLEN]; int32_t converted_ret_len; /* convert the string to UTF-16. */ status = U_ZERO_ERROR; intl_convert_utf8_to_utf16(&ustring, &ustring_len, domain, domain_len, &status); if (U_FAILURE(status)) { intl_error_set_code(NULL, status); /* Set error messages. */ intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 0 ); if (ustring) { efree(ustring); } RETURN_FALSE; } else { UParseError parse_error; status = U_ZERO_ERROR; if (mode == INTL_IDN_TO_ASCII) { converted_ret_len = uidna_IDNToASCII(ustring, ustring_len, converted, MAXPATHLEN, (int32_t)option, &parse_error, &status); } else { converted_ret_len = uidna_IDNToUnicode(ustring, ustring_len, converted, MAXPATHLEN, (int32_t)option, &parse_error, &status); } efree(ustring); if (U_FAILURE(status)) { intl_error_set( NULL, status, "idn_to_ascii: cannot convert to ASCII", 0 ); RETURN_FALSE; } status = U_ZERO_ERROR; intl_convert_utf16_to_utf8(&converted_utf8, &converted_utf8_len, converted, converted_ret_len, &status); if (U_FAILURE(status)) { /* Set global error code. */ intl_error_set_code(NULL, status); /* Set error messages. */ intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 ); efree(converted_utf8); RETURN_FALSE; } } /* return the allocated string, not a duplicate */ RETVAL_STRINGL(converted_utf8, converted_utf8_len); //???? efree(converted_utf8); }
static ZEND_FUNCTION(lz4_compress) { zval *data; char *output; int output_len, data_len; zend_bool high = 0; char *extra = NULL; int extra_len = -1; int offset = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bs", &data, &high, &extra, &extra_len) == FAILURE) { RETURN_FALSE; } if (Z_TYPE_P(data) != IS_STRING) { zend_error(E_WARNING, "lz4_compress : expects parameter to be string."); RETURN_FALSE; } if (extra && extra_len > 0) { offset = extra_len; } else { offset = sizeof(int); } data_len = Z_STRLEN_P(data); output = (char *)emalloc(LZ4_compressBound(data_len) + offset); if (!output) { zend_error(E_WARNING, "lz4_compress : memory error"); RETURN_FALSE; } if (extra && extra_len > 0) { memcpy(output, extra, offset); } else { /* Set the data length */ memcpy(output, &data_len, offset); } if (high) { output_len = LZ4_compressHC(Z_STRVAL_P(data), output + offset, data_len); } else { output_len = LZ4_compress(Z_STRVAL_P(data), output + offset, data_len); } if (output_len <= 0) { RETVAL_FALSE; } else { RETVAL_STRINGL(output, output_len + offset, 1); } efree(output); }
static ZEND_FUNCTION(snappy_uncompress) { zval *data; char *output = NULL; size_t output_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { RETURN_FALSE; } if (Z_TYPE_P(data) != IS_STRING) { zend_error(E_WARNING, "snappy_uncompress : expects parameter to be string."); RETURN_FALSE; } if (snappy_uncompressed_length(Z_STRVAL_P(data), Z_STRLEN_P(data), &output_len) != SNAPPY_OK) { zend_error(E_WARNING, "snappy_uncompress : output length error"); RETURN_FALSE; } output = (char *)emalloc(output_len); if (!output) { zend_error(E_WARNING, "snappy_uncompress : memory error"); RETURN_FALSE; } if (snappy_uncompress(Z_STRVAL_P(data), Z_STRLEN_P(data), output, &output_len) == SNAPPY_OK) { #if ZEND_MODULE_API_NO >= 20141001 RETVAL_STRINGL(output, output_len); #else RETVAL_STRINGL(output, output_len, 1); #endif } else { zend_error(E_WARNING, "snappy_uncompress : data error"); RETVAL_FALSE; } efree(output); }
/* {{{ php_converter_default_callback */ static void php_converter_default_callback(zval *return_value, zval *zobj, zend_long reason, zval *error) { ZVAL_DEREF(error); zval_dtor(error); ZVAL_LONG(error, U_ZERO_ERROR); /* Basic functionality so children can call parent::toUCallback() */ switch (reason) { case UCNV_UNASSIGNED: case UCNV_ILLEGAL: case UCNV_IRREGULAR: { php_converter_object *objval = (php_converter_object*)CONV_GET(zobj); char chars[127]; int8_t chars_len = sizeof(chars); UErrorCode uerror = U_ZERO_ERROR; if(!objval->src) { php_converter_throw_failure(objval, U_INVALID_STATE_ERROR, "Source Converter has not been initialized yet"); chars[0] = 0x1A; chars[1] = 0; chars_len = 1; ZVAL_LONG(error, U_INVALID_STATE_ERROR); RETVAL_STRINGL(chars, chars_len); return; } /* Yes, this is fairly wasteful at first glance, * but considering that the alternative is to store * what's sent into setSubstChars() and the fact * that this is an extremely unlikely codepath * I'd rather take the CPU hit here, than waste time * storing a value I'm unlikely to use. */ ucnv_getSubstChars(objval->src, chars, &chars_len, &uerror); if (U_FAILURE(uerror)) { THROW_UFAILURE(objval, "ucnv_getSubstChars", uerror); chars[0] = 0x1A; chars[1] = 0; chars_len = 1; ZVAL_LONG(error, uerror); } RETVAL_STRINGL(chars, chars_len); } } }
static ZEND_FUNCTION(lz4_uncompress) { zval *data; int output_len, data_size; char *output; long max_size = -1, offset = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ll", &data, &max_size, &offset) == FAILURE) { RETURN_FALSE; } if (Z_TYPE_P(data) != IS_STRING) { zend_error(E_WARNING, "lz4_uncompress : expects parameter to be string."); RETURN_FALSE; } if (max_size > 0) { data_size = max_size; if (!offset) { offset = sizeof(int); } } else { /* Get data length */ offset = sizeof(int); memcpy(&data_size, Z_STRVAL_P(data), offset); } if (data_size < 0) { zend_error(E_WARNING, "lz4_uncompress : allocate size error"); RETURN_FALSE; } output = (char *)emalloc(data_size + 1); if (!output) { zend_error(E_WARNING, "lz4_uncompress : memory error"); RETURN_FALSE; } output_len = LZ4_decompress_safe(Z_STRVAL_P(data) + offset, output, Z_STRLEN_P(data) - offset, data_size); if (output_len <= 0) { zend_error(E_WARNING, "lz4_uncompress : data error"); RETVAL_FALSE; } else { RETVAL_STRINGL(output, output_len, 1); } efree(output); }
/* {{{ proto string tidy_get_output() Return a string representing the parsed tidy markup */ static PHP_FUNCTION(tidy_get_output) { TidyBuffer output; TIDY_FETCH_OBJECT; tidyBufInit(&output); tidySaveBuffer(obj->ptdoc->doc, &output); FIX_BUFFER(&output); RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0); tidyBufFree(&output); }
/* {{{ Qconf::getConf( .. ) */ static PHP_METHOD(Qconf, getConf) { char *path, *idc; size_t path_len, idc_len; long get_flags = QCONF_WAIT; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &path, &path_len, &idc, &idc_len, &get_flags) == FAILURE) { RETURN_NULL(); } char buf[QCONF_CONF_BUF_MAX_LEN]; int buf_len = 0; int ret = 0; if (QCONF_NOWAIT == get_flags) { ret = qconf_aget_conf(path, buf, sizeof(buf), idc); } else { ret = qconf_get_conf(path, buf, sizeof(buf), idc); } buf_len = strlen(buf); if (QCONF_OK == ret) { #if PHP_VERSION_ID >= 70000 RETVAL_STRINGL(buf, buf_len); #else RETVAL_STRINGL(buf, buf_len, 1); #endif } else { RETURN_NULL(); } return; }
/* {{{ proto string Timestamp::__toString() Returns [increment:timestamp] */ PHP_METHOD(Timestamp, __toString) { php_phongo_timestamp_t *intern; char *retval; int retval_len; intern = (php_phongo_timestamp_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { return; } retval_len = spprintf(&retval, 0, "[%d:%d]", intern->increment, intern->timestamp); RETVAL_STRINGL(retval, retval_len, 0); }
/* {{{ proto string UTCDatetime::__toString() Returns the string representation of the UTCDatetime */ PHP_METHOD(UTCDatetime, __toString) { php_phongo_utcdatetime_t *intern; char *tmp; int tmp_len; intern = (php_phongo_utcdatetime_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { return; } tmp_len = spprintf(&tmp, 0, "%lld", intern->milliseconds); RETVAL_STRINGL(tmp, tmp_len, 0); }
U_CFUNC PHP_FUNCTION(intltz_get_display_name) { zend_bool daylight = 0; zend_long display_type = TimeZone::LONG; const char *locale_str = NULL; size_t dummy = 0; TIMEZONE_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O|bls!", &object, TimeZone_ce_ptr, &daylight, &display_type, &locale_str, &dummy) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_get_display_name: bad arguments", 0); RETURN_FALSE; } bool found = false; for (int i = 0; !found && i < sizeof(display_types)/sizeof(*display_types); i++) { if (display_types[i] == display_type) found = true; } if (!found) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_get_display_name: wrong display type", 0); RETURN_FALSE; } if (!locale_str) { locale_str = intl_locale_get_default(); } TIMEZONE_METHOD_FETCH_OBJECT; UnicodeString result; to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type, Locale::createFromName(locale_str), result); char *str; int str_len; intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to)); INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: " "could not convert resulting time zone id to UTF-16"); RETVAL_STRINGL(str, str_len); //???? efree(str); }
static ZEND_FUNCTION(horde_lz4_uncompress) { zval *data; int data_len = 0; int header_offset = (sizeof(headerid) + sizeof(int)); int output_len; char *output, *p; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { RETURN_FALSE; } if (Z_TYPE_P(data) != IS_STRING) { zend_error(E_WARNING, "horde_lz4_uncompress: compressed data must be a string."); RETURN_FALSE; } p = Z_STRVAL_P(data); /* Check for header information. */ if (p[0] == headerid) { memcpy(&data_len, p + sizeof(headerid), sizeof(int)); } /* Header information not found. */ if (data_len <= 0) { RETURN_FALSE; } output = (char *)emalloc(data_len + 1); if (!output) { RETURN_FALSE; } output_len = LZ4_uncompress(p + header_offset, output, data_len); if (output_len <= 0) { RETVAL_FALSE; } else { RETVAL_STRINGL(output, data_len, 1); } efree(output); }
static ZEND_FUNCTION(horde_lz4_compress) { zval *data; char *output; int header_offset = (sizeof(headerid) + sizeof(int)); int output_len, data_len; zend_bool high = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &data, &high) == FAILURE) { RETURN_FALSE; } if (Z_TYPE_P(data) != IS_STRING) { zend_error(E_WARNING, "horde_lz4_compress: uncompressed data must be a string."); RETURN_FALSE; } data_len = Z_STRLEN_P(data); output = (char *)emalloc(LZ4_compressBound(data_len) + header_offset); if (!output) { zend_error(E_WARNING, "horde_lz4_compress: memory error"); RETURN_FALSE; } *output = headerid; memcpy(output + sizeof(headerid), &data_len, sizeof(int)); if (high) { output_len = LZ4_compressHC(Z_STRVAL_P(data), output + header_offset, data_len); } else { output_len = LZ4_compress(Z_STRVAL_P(data), output + header_offset, data_len); } if (output_len <= 0) { RETVAL_FALSE; } else { RETVAL_STRINGL(output, output_len + header_offset, 1); } efree(output); }
/* {{{ proto array GmagickPixel::getColor([boolean as_array = false, normalise_array = false]) Returns the color of the pixel */ PHP_METHOD(gmagickpixel, getcolor) { php_gmagickpixel_object *internp; zend_bool as_array = 0, normalise_array = 0; /* Parse parameters given to function */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|bb", &as_array, &normalise_array) == FAILURE) { return; } internp = Z_GMAGICKPIXEL_OBJ_P(getThis()); if (!as_array) { char *buffer, *color_string; int len; color_string = PixelGetColorAsString(internp->pixel_wand); len = spprintf(&buffer, 50, "rgb(%s)", color_string); GMAGICK_FREE_MEMORY(char *, color_string); RETVAL_STRINGL(buffer, len); efree(buffer); return; } else { array_init(return_value); if (normalise_array == 1) { add_assoc_double(return_value, "r", PixelGetRed(internp->pixel_wand)); add_assoc_double(return_value, "g", PixelGetGreen(internp->pixel_wand)); add_assoc_double(return_value, "b", PixelGetBlue(internp->pixel_wand)); } else { double red, green, blue; red = PixelGetRed(internp->pixel_wand ) * 255; green = PixelGetGreen(internp->pixel_wand ) * 255; blue = PixelGetBlue(internp->pixel_wand ) * 255; add_assoc_long(return_value, "r", (int)(red > 0.0 ? red + 0.5 : red - 0.5)); add_assoc_long(return_value, "g", (int)(green > 0.0 ? green + 0.5 : green - 0.5)); add_assoc_long(return_value, "b", (int)(blue > 0.0 ? blue + 0.5 : blue - 0.5)); } return; } }
U_CFUNC PHP_FUNCTION(intltz_get_canonical_id) { char *str_id; size_t str_id_len; zval *is_systemid = NULL; intl_error_reset(NULL); if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z", &str_id, &str_id_len, &is_systemid) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_get_canonical_id: bad arguments", 0); RETURN_FALSE; } UErrorCode status = UErrorCode(); UnicodeString id; if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, "intltz_get_canonical_id: could not convert time zone id to UTF-16", 0); RETURN_FALSE; } UnicodeString result; UBool isSystemID; TimeZone::getCanonicalID(id, result, isSystemID, status); INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID"); char *str; int str_len; intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status); INTL_CHECK_STATUS(status, "intltz_get_canonical_id: could not convert time zone id to UTF-16"); RETVAL_STRINGL(str, str_len); //???? efree(str); if (is_systemid) { /* by-ref argument passed */ ZVAL_DEREF(is_systemid); zval_dtor(is_systemid); ZVAL_BOOL(is_systemid, isSystemID); } }
/* {{{ proto bool SessionHandler::read(string id) Wraps the old read handler */ PHP_METHOD(SessionHandler, read) { char *key, *val; int key_len, val_len; PS_SANITY_CHECK_IS_OPEN; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) { return; } if (PS(default_mod)->s_read(&PS(mod_data), key, &val, &val_len TSRMLS_CC) == FAILURE) { RETVAL_FALSE; return; } RETVAL_STRINGL(val, val_len, 1); efree(val); return; }
/* {{{ proto string datefmt_get_timezone_id(IntlDateFormatter $mf) * Get formatter timezone_id. */ U_CFUNC PHP_FUNCTION(datefmt_get_timezone_id) { char *str; size_t str_len; DATE_FORMAT_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, IntlDateFormatter_ce_ptr ) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_get_timezone_" "id: unable to parse input params", 0); RETURN_FALSE; } DATE_FORMAT_METHOD_FETCH_OBJECT; UnicodeString res = UnicodeString(); fetch_datefmt(dfo)->getTimeZone().getID(res); intl_charFromString(res, &str, &str_len, &INTL_DATA_ERROR_CODE(dfo)); INTL_METHOD_CHECK_STATUS(dfo, "Could not convert time zone id to UTF-8"); RETVAL_STRINGL(str, str_len); //???? efree(str); }
/** * Gets HTTP raw request body * * @return string */ PHP_METHOD(Phalcon_Http_Request, getRawBody){ zval *raw; if (SG(request_info).raw_post_data) { RETURN_STRINGL(SG(request_info).raw_post_data, SG(request_info).raw_post_data_length, 1); } phalcon_read_property_this(&raw, getThis(), SL("_rawBody"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(raw) == IS_STRING) { RETURN_ZVAL(raw, 1, 1); } else if (sapi_module.read_post) { int read_bytes; char *buf = emalloc(8192); smart_str raw_data = { NULL, 0, 0 }; while ((read_bytes = sapi_module.read_post(buf, 8192 TSRMLS_CC)) > 0) { smart_str_appendl(&raw_data, buf, read_bytes); SG(read_post_bytes) += read_bytes; } efree(buf); if (raw_data.c) { smart_str_0(&raw_data); RETVAL_STRINGL(raw_data.c, raw_data.len, 0); } else { RETVAL_EMPTY_STRING(); } phalcon_update_property_this(getThis(), SL("_rawBody"), return_value TSRMLS_CC); } else { RETURN_EMPTY_STRING(); } }
/* {{{ proto string SolrUtils::escapeQueryChars(string unescaped) Escapes the lucene string */ PHP_METHOD(SolrUtils, escapeQueryChars) { solr_char_t *unescaped = NULL; solr_string_t sbuilder; COMPAT_ARG_SIZE_T unescaped_length = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &unescaped, &unescaped_length) == FAILURE) { RETURN_FALSE; } if (!unescaped_length) { RETURN_NULL(); } memset(&sbuilder, 0, sizeof(solr_string_t)); solr_escape_query_chars(&sbuilder, unescaped, unescaped_length); RETVAL_STRINGL(sbuilder.str, sbuilder.len); solr_string_free(&sbuilder); }
static void php_tidy_quick_repair(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_file) { char *enc = NULL; size_t enc_len = 0; zend_bool use_include_path = 0; TidyDoc doc; TidyBuffer *errbuf; zend_string *data, *arg1; zval *config = NULL; if (is_file) { if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &arg1, &config, &enc, &enc_len, &use_include_path) == FAILURE) { RETURN_FALSE; } if (!(data = php_tidy_file_to_mem(ZSTR_VAL(arg1), use_include_path))) { RETURN_FALSE; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zsb", &arg1, &config, &enc, &enc_len, &use_include_path) == FAILURE) { RETURN_FALSE; } data = arg1; } if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(data))) { php_error_docref(NULL, E_WARNING, "Input string is too long"); RETURN_FALSE; } doc = tidyCreate(); errbuf = emalloc(sizeof(TidyBuffer)); tidyBufInit(errbuf); if (tidySetErrorBuffer(doc, errbuf) != 0) { tidyBufFree(errbuf); efree(errbuf); tidyRelease(doc); php_error_docref(NULL, E_ERROR, "Could not set Tidy error buffer"); } tidyOptSetBool(doc, TidyForceOutput, yes); tidyOptSetBool(doc, TidyMark, no); TIDY_SET_DEFAULT_CONFIG(doc); if (config) { TIDY_APPLY_CONFIG_ZVAL(doc, config); } if(enc_len) { if (tidySetCharEncoding(doc, enc) < 0) { php_error_docref(NULL, E_WARNING, "Could not set encoding '%s'", enc); RETVAL_FALSE; } } if (data) { TidyBuffer buf; tidyBufInit(&buf); tidyBufAttach(&buf, (byte *) ZSTR_VAL(data), (uint)ZSTR_LEN(data)); if (tidyParseBuffer(doc, &buf) < 0) { php_error_docref(NULL, E_WARNING, "%s", errbuf->bp); RETVAL_FALSE; } else { if (tidyCleanAndRepair(doc) >= 0) { TidyBuffer output; tidyBufInit(&output); tidySaveBuffer (doc, &output); FIX_BUFFER(&output); RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0); tidyBufFree(&output); } else { RETVAL_FALSE; } } } if (is_file) { zend_string_release(data); } tidyBufFree(errbuf); efree(errbuf); tidyRelease(doc); }
/* {{{ * common code shared by display_xyz functions to get the value from ICU }}} */ static void get_icu_disp_value_src_php( char* tag_name, INTERNAL_FUNCTION_PARAMETERS) { char* loc_name = NULL; int loc_name_len = 0; char* disp_loc_name = NULL; int disp_loc_name_len = 0; UChar* disp_name = NULL; int32_t disp_name_len = 0; char* mod_loc_name = NULL; int32_t buflen = 512; UErrorCode status = U_ZERO_ERROR; char* utf8value = NULL; int utf8value_len = 0; char* msg = NULL; int grOffset = 0; intl_error_reset( NULL TSRMLS_CC ); if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &loc_name, &loc_name_len , &disp_loc_name ,&disp_loc_name_len ) == FAILURE) { spprintf(&msg , 0, "locale_get_display_%s : unable to parse input params", tag_name ); intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, msg , 1 TSRMLS_CC ); efree(msg); RETURN_FALSE; } if(loc_name_len == 0) { loc_name = INTL_G(default_locale); } if( tag_name != DISP_NAME ){ /* Handle grandfathered languages */ grOffset = findOffset( LOC_GRANDFATHERED , loc_name ); if( grOffset >= 0 ){ if( strcmp(tag_name , LOC_LANG_TAG)==0 ){ mod_loc_name = getPreferredTag( loc_name ); } else { /* Since Grandfathered, no value, do nothing, retutn NULL */ RETURN_FALSE; } } } /* end of if != LOC_CANONICAL_TAG */ if( mod_loc_name==NULL ){ mod_loc_name = estrdup( loc_name ); } /* Get the disp_value for the given locale */ do{ disp_name = erealloc( disp_name , buflen ); disp_name_len = buflen; /* Check if disp_loc_name passed , if not use default locale */ if( !disp_loc_name){ disp_loc_name = estrdup(INTL_G(default_locale)); } if( strcmp(tag_name , LOC_LANG_TAG)==0 ){ buflen = uloc_getDisplayLanguage ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status); } else if( strcmp(tag_name , LOC_SCRIPT_TAG)==0 ){ buflen = uloc_getDisplayScript ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status); } else if( strcmp(tag_name , LOC_REGION_TAG)==0 ){ buflen = uloc_getDisplayCountry ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status); } else if( strcmp(tag_name , LOC_VARIANT_TAG)==0 ){ buflen = uloc_getDisplayVariant ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status); } else if( strcmp(tag_name , DISP_NAME)==0 ){ buflen = uloc_getDisplayName ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status); } if( U_FAILURE( status ) ) { if( status == U_BUFFER_OVERFLOW_ERROR ) { status = U_ZERO_ERROR; continue; } spprintf(&msg, 0, "locale_get_display_%s : unable to get locale %s", tag_name , tag_name ); intl_error_set( NULL, status, msg , 1 TSRMLS_CC ); efree(msg); if( disp_name){ efree( disp_name ); } if( mod_loc_name){ efree( mod_loc_name ); } RETURN_FALSE; } } while( buflen > disp_name_len ); if( mod_loc_name){ efree( mod_loc_name ); } /* Convert display locale name from UTF-16 to UTF-8. */ intl_convert_utf16_to_utf8( &utf8value, &utf8value_len, disp_name, buflen, &status ); efree( disp_name ); if( U_FAILURE( status ) ) { spprintf(&msg, 0, "locale_get_display_%s :error converting display name for %s to UTF-8", tag_name , tag_name ); intl_error_set( NULL, status, msg , 1 TSRMLS_CC ); efree(msg); RETURN_FALSE; } RETVAL_STRINGL( utf8value, utf8value_len , FALSE); }
/* {{{ php_exec * If type==0, only last line of output is returned (exec) * If type==1, all lines will be printed and last lined returned (system) * If type==2, all lines will be saved to given array (exec with &$array) * If type==3, output will be printed binary, no lines will be saved or returned (passthru) * */ PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value) { FILE *fp; char *buf; size_t l = 0; int pclose_return; char *b, *d=NULL; php_stream *stream; size_t buflen, bufl = 0; #if PHP_SIGCHILD void (*sig_handler)() = NULL; #endif #if PHP_SIGCHILD sig_handler = signal (SIGCHLD, SIG_DFL); #endif #ifdef PHP_WIN32 fp = VCWD_POPEN(cmd, "rb"); #else fp = VCWD_POPEN(cmd, "r"); #endif if (!fp) { php_error_docref(NULL, E_WARNING, "Unable to fork [%s]", cmd); goto err; } stream = php_stream_fopen_from_pipe(fp, "rb"); buf = (char *) emalloc(EXEC_INPUT_BUF); buflen = EXEC_INPUT_BUF; if (type != 3) { b = buf; while (php_stream_get_line(stream, b, EXEC_INPUT_BUF, &bufl)) { /* no new line found, let's read some more */ if (b[bufl - 1] != '\n' && !php_stream_eof(stream)) { if (buflen < (bufl + (b - buf) + EXEC_INPUT_BUF)) { bufl += b - buf; buflen = bufl + EXEC_INPUT_BUF; buf = erealloc(buf, buflen); b = buf + bufl; } else { b += bufl; } continue; } else if (b != buf) { bufl += b - buf; } if (type == 1) { PHPWRITE(buf, bufl); if (php_output_get_level() < 1) { sapi_flush(); } } else if (type == 2) { /* strip trailing whitespaces */ l = bufl; while (l >= 1 && l-- && isspace(((unsigned char *)buf)[l])); if (l != (bufl - 1)) { bufl = l + 1; buf[bufl] = '\0'; } add_next_index_stringl(array, buf, bufl); } b = buf; } if (bufl) { /* strip trailing whitespaces if we have not done so already */ if ((type == 2 && buf != b) || type != 2) { l = bufl; while (l >= 1 && l-- && isspace(((unsigned char *)buf)[l])); if (l != (bufl - 1)) { bufl = l + 1; buf[bufl] = '\0'; } if (type == 2) { add_next_index_stringl(array, buf, bufl); } } /* Return last line from the shell command */ RETVAL_STRINGL(buf, bufl); } else { /* should return NULL, but for BC we return "" */ RETVAL_EMPTY_STRING(); } } else { while((bufl = php_stream_read(stream, buf, EXEC_INPUT_BUF)) > 0) { PHPWRITE(buf, bufl); } } pclose_return = php_stream_close(stream); efree(buf); done: #if PHP_SIGCHILD if (sig_handler) { signal(SIGCHLD, sig_handler); } #endif if (d) { efree(d); } return pclose_return; err: pclose_return = -1; goto done; }
U_CFUNC PHP_FUNCTION(datefmt_format_object) { zval *object, *format = NULL; const char *locale_str = NULL; size_t locale_len; bool pattern = false; UDate date; TimeZone *timeZone = NULL; UErrorCode status = U_ZERO_ERROR; DateFormat *df = NULL; Calendar *cal = NULL; DateFormat::EStyle dateStyle = DateFormat::kDefault, timeStyle = DateFormat::kDefault; if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|zs!", &object, &format, &locale_str, &locale_len) == FAILURE) { RETURN_FALSE; } if (!locale_str) { locale_str = intl_locale_get_default(); } if (format == NULL || Z_TYPE_P(format) == IS_NULL) { //nothing } else if (Z_TYPE_P(format) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(format); HashPosition pos = {0}; zval *z; if (zend_hash_num_elements(ht) != 2) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_format_object: bad format; if array, it must have " "two elements", 0); RETURN_FALSE; } zend_hash_internal_pointer_reset_ex(ht, &pos); z = zend_hash_get_current_data_ex(ht, &pos); if (!valid_format(z)) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_format_object: bad format; the date format (first " "element of the array) is not valid", 0); RETURN_FALSE; } dateStyle = (DateFormat::EStyle)Z_LVAL_P(z); zend_hash_move_forward_ex(ht, &pos); z = zend_hash_get_current_data_ex(ht, &pos); if (!valid_format(z)) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_format_object: bad format; the time format (" "second element of the array) is not valid", 0); RETURN_FALSE; } timeStyle = (DateFormat::EStyle)Z_LVAL_P(z); } else if (Z_TYPE_P(format) == IS_LONG) { if (!valid_format(format)) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_format_object: the date/time format type is invalid", 0); RETURN_FALSE; } dateStyle = timeStyle = (DateFormat::EStyle)Z_LVAL_P(format); } else { convert_to_string_ex(format); if (Z_STRLEN_P(format) == 0) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_format_object: the format is empty", 0); RETURN_FALSE; } pattern = true; } //there's no support for relative time in ICU yet timeStyle = (DateFormat::EStyle)(timeStyle & ~DateFormat::kRelative); zend_class_entry *instance_ce = Z_OBJCE_P(object); if (instanceof_function(instance_ce, Calendar_ce_ptr)) { Calendar *obj_cal = calendar_fetch_native_calendar(object); if (obj_cal == NULL) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_format_object: bad IntlCalendar instance: " "not initialized properly", 0); RETURN_FALSE; } timeZone = obj_cal->getTimeZone().clone(); date = obj_cal->getTime(status); if (U_FAILURE(status)) { intl_error_set(NULL, status, "datefmt_format_object: error obtaining instant from " "IntlCalendar", 0); RETVAL_FALSE; goto cleanup; } cal = obj_cal->clone(); } else if (instanceof_function(instance_ce, php_date_get_date_ce())) { if (intl_datetime_decompose(object, &date, &timeZone, NULL, "datefmt_format_object") == FAILURE) { RETURN_FALSE; } cal = new GregorianCalendar(Locale::createFromName(locale_str), status); if (U_FAILURE(status)) { intl_error_set(NULL, status, "datefmt_format_object: could not create GregorianCalendar", 0); RETVAL_FALSE; goto cleanup; } } else { intl_error_set(NULL, status, "datefmt_format_object: the passed object " "must be an instance of either IntlCalendar or DateTime", 0); RETURN_FALSE; } if (pattern) { df = new SimpleDateFormat( UnicodeString(Z_STRVAL_P(format), Z_STRLEN_P(format), UnicodeString::kInvariant), Locale::createFromName(locale_str), status); if (U_FAILURE(status)) { intl_error_set(NULL, status, "datefmt_format_object: could not create SimpleDateFormat", 0); RETVAL_FALSE; goto cleanup; } } else { df = DateFormat::createDateTimeInstance(dateStyle, timeStyle, Locale::createFromName(locale_str)); if (df == NULL) { /* according to ICU sources, this should never happen */ intl_error_set(NULL, status, "datefmt_format_object: could not create DateFormat", 0); RETVAL_FALSE; goto cleanup; } } //must be in this order (or have the cal adopt the tz) df->adoptCalendar(cal); cal = NULL; df->adoptTimeZone(timeZone); timeZone = NULL; { char *ret_str; int ret_str_len; UnicodeString result = UnicodeString(); df->format(date, result); if (intl_charFromString(result, &ret_str, &ret_str_len, &status) == FAILURE) { intl_error_set(NULL, status, "datefmt_format_object: error converting result to UTF-8", 0); RETVAL_FALSE; goto cleanup; } RETVAL_STRINGL(ret_str, ret_str_len); //??? efree(ret_str); } cleanup: delete df; delete timeZone; delete cal; }