static void php_bencode_decode_int(zval *return_value, char *str, size_t *pos, size_t *str_len) /* {{{ */
{
int len = 0;
double d;
smart_str buf = {0};
(*pos)++;
while (*pos < *str_len && str[*pos] != PHP_BENCODE_END_STRUCTURE) {
smart_str_appendc(&buf, str[*pos]);
(*pos)++;
len++;
}
smart_str_0(&buf);
if (str[*pos] != PHP_BENCODE_END_STRUCTURE) {
smart_str_free(&buf);
zend_error(E_WARNING, "Invaild bencoded-integer, expected 'e'.");
RETURN_NULL();
}
(*pos)++;
ZVAL_STRINGL(return_value, ZSTR_VAL(buf.s), len);
d = zend_strtod(ZSTR_VAL(buf.s), NULL);
if (d <= ZEND_LONG_MAX && d >= ZEND_LONG_MIN) {
convert_to_long(return_value);
}
smart_str_free(&buf);
}
SAPI_API SAPI_POST_HANDLER_FUNC(php_std_post_handler)
{
zval *arr = (zval *) arg;
php_stream *s = SG(request_info).request_body;
post_var_data_t post_data;
if (s && SUCCESS == php_stream_rewind(s)) {
memset(&post_data, 0, sizeof(post_data));
while (!php_stream_eof(s)) {
char buf[BUFSIZ] = {0};
size_t len = php_stream_read(s, buf, BUFSIZ);
if (len && len != (size_t) -1) {
smart_str_appendl(&post_data.str, buf, len);
if (SUCCESS != add_post_vars(arr, &post_data, 0)) {
smart_str_free(&post_data.str);
return;
}
}
if (len != BUFSIZ){
break;
}
}
if (post_data.str.s) {
add_post_vars(arr, &post_data, 1);
smart_str_free(&post_data.str);
}
}
}
zval * cpMD5(zval *arr) {//pass in array , out md5 zval
smart_str ser_data = {0};
cp_serialize(&ser_data, arr);
zval fun_name, **args[1], *retval, *str;
CP_ZVAL_STRING(&fun_name, "md5", 0);
CP_MAKE_STD_ZVAL(str);
#if PHP_MAJOR_VERSION < 7
CP_ZVAL_STRINGL(str, ser_data.c, ser_data.len, 1);
#else
zend_string *str_data = ser_data.s;
CP_ZVAL_STRINGL(str, str_data->val, str_data->len, 1);
#endif
args[0] = &str;
if (cp_call_user_function_ex(CG(function_table), NULL, &fun_name, &retval, 1, args, 0, NULL TSRMLS_CC) != SUCCESS)
{
cp_zval_ptr_dtor(&str);
smart_str_free(&ser_data);
return NULL;
}
cp_zval_ptr_dtor(&str);
smart_str_free(&ser_data);
return retval;
}
/** {{{ to_indexed
*/
static zval * to_indexed(zval * keys, char * query, int len) {
zval * sql = NULL;
char ch = 0;
int i = 0;
smart_str skey = {NULL, 0, 0};
smart_str ssql = {NULL, 0, 0};
for(i=0; i<len; i++) {
ch = *(query + i);
if (ch == ':') {
for (i++; i < len; i++) {
ch = *(query + i);
/* [a-zA-Z0-9_]+ */
if ((ch > 96 && ch < 123)
|| (ch > 64 && ch < 91)
|| (ch > 47 && ch < 58)
|| ch == 95
) {
smart_str_appendc(&skey, ch);
} else {
break;
}
}
smart_str_appendc(&ssql, '?');
smart_str_appendc(&ssql, ch);
smart_str_0(&skey);
if (ssql.len) {
add_next_index_stringl(keys, skey.c, skey.len, 1);
}
smart_str_free(&skey);
} else {
smart_str_appendc(&ssql, ch);
}
}
MAKE_STD_ZVAL(sql);
if (ssql.len) {
ZVAL_STRINGL(sql, ssql.c, ssql.len, 1);
}else{
ZVAL_STRINGL(sql, "", 0, 1);
}
smart_str_free(&skey);
smart_str_free(&ssql);
return sql;
}
PHPAPI static void php_discuz_auth_encode(smart_str *buf, const char *str, int str_len, const char *key, int keylen, long expiry)
{
char keya[33], keyb[33], keyc[DISCUZ_AUTH_CKEYLEN+1], cryptkey[65]={0};
char ret[100], retmd5[33];
char *pc;
struct timeval tp = {0};
smart_str strbuf = {0};
if (gettimeofday(&tp, NULL)) {
return;
}
snprintf(ret, 100, "%.8F %ld", tp.tv_usec / MICRO_IN_SEC, tp.tv_sec);
php_md5(retmd5, ret, strlen(ret));
bzero(keyc, sizeof(keyc));
memcpy(keyc, retmd5 + 32 - DISCUZ_AUTH_CKEYLEN, DISCUZ_AUTH_CKEYLEN);
php_discuz_auth_initkey(keya, keyb, cryptkey, keyc, key, keylen);
//$string = sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
smart_str_appendl(&strbuf, str, str_len);
smart_str_appendl(&strbuf, keyb, 32);
php_md5(retmd5, strbuf.c, strbuf.len);
smart_str_free(&strbuf);
snprintf(ret, sizeof(ret), "%010d", expiry ? expiry + time(NULL) : 0);
smart_str_appendl(&strbuf, ret, 10);
smart_str_appendl(&strbuf, retmd5, 16);
smart_str_appendl(&strbuf, str, str_len);
pc = (unsigned char *)safe_emalloc(strbuf.len, sizeof(char), 1);
php_discuz_authcode(pc, strbuf.c, strbuf.len, cryptkey);
//return $keyc.str_replace('=', '', base64_encode($result));
char *result;
int retlen;
result = php_base64_encode((unsigned char*)pc, strbuf.len, &retlen);
efree(pc);
int index, to;
for(index = 0, to = 0; index <= retlen; index++) {
if(*(result+index) != '=') {
*(result+to) = *(result+index);
to++;
}
}
smart_str_appendl(buf, keyc, DISCUZ_AUTH_CKEYLEN);
smart_str_appendl(buf, result, retlen - (index - to));
smart_str_free(&strbuf);
}
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
php_json_encoder encoder;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|ll", ¶meter, &options, &depth) == FAILURE) {
return;
}
php_json_encode_init(&encoder);
encoder.max_depth = (int)depth;
encoder.error_code = PHP_JSON_ERROR_NONE;
php_json_encode_zval(&buf, parameter, (int)options, &encoder);
JSON_G(error_code) = encoder.error_code;
if (encoder.error_code != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
RETURN_FALSE;
}
smart_str_0(&buf); /* copy? */
if (buf.s) {
RETURN_NEW_STR(buf.s);
}
RETURN_EMPTY_STRING();
}
/* {{{ */
static inline zend_string* php_memoize_scope(const zval *This, const zend_function *function) {
if (!function->common.scope) {
return NULL;
}
if (Z_TYPE_P(This) != IS_OBJECT) {
return zend_string_copy(function->common.scope->name);
} else {
smart_str smart = {0};
php_serialize_data_t data;
if (Z_OBJCE_P(This)->serialize == zend_class_serialize_deny) {
return PHP_MEMOIZE_SCOPE_FAILURE;
}
PHP_VAR_SERIALIZE_INIT(data);
php_var_serialize(&smart, (zval*) This, &data);
PHP_VAR_SERIALIZE_DESTROY(data);
if (EG(exception)) {
smart_str_free(&smart);
zend_clear_exception();
return PHP_MEMOIZE_SCOPE_FAILURE;
}
return smart.s;
}
return NULL;
} /* }}} */
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
php_json_encoder encoder;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
ZEND_PARSE_PARAMETERS_START(1, 3)
Z_PARAM_ZVAL_DEREF(parameter)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(options)
Z_PARAM_LONG(depth)
ZEND_PARSE_PARAMETERS_END();
php_json_encode_init(&encoder);
encoder.max_depth = (int)depth;
encoder.error_code = PHP_JSON_ERROR_NONE;
php_json_encode_zval(&buf, parameter, (int)options, &encoder);
JSON_G(error_code) = encoder.error_code;
if (encoder.error_code != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
RETURN_FALSE;
}
smart_str_0(&buf); /* copy? */
if (buf.s) {
RETURN_NEW_STR(buf.s);
}
RETURN_EMPTY_STRING();
}
inline void mmc_buffer_free(mmc_buffer_t *buffer) /* {{{ */
{
if (buffer->value.c != NULL) {
smart_str_free(&(buffer->value));
}
memset(buffer, 0, sizeof(*buffer));
}
static inline long
hs_response_recv(php_stream *stream, char *recv, size_t size TSRMLS_DC)
{
long ret;
#ifdef HS_DEBUG
long i;
smart_str debug = {0};
#endif
ret = php_stream_read(stream, recv, size);
if (ret <= 0) {
return -1;
}
recv[size] = '\0';
#ifdef HS_DEBUG
for (i = 0; i < ret; i++) {
if ((unsigned char)recv[i] == HS_CODE_NULL) {
smart_str_appendl_ex(&debug, "\\0", strlen("\\0"), 1);
} else {
smart_str_appendc(&debug, recv[i]);
}
}
smart_str_0(&debug);
php_printf("[handlersocket] (recv) %ld : \"%s\"", ret, debug.c);
smart_str_free(&debug);
#endif
return ret;
}
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|ll", ¶meter, &options, &depth) == FAILURE) {
return;
}
JSON_G(error_code) = PHP_JSON_ERROR_NONE;
JSON_G(encode_max_depth) = (int)depth;
php_json_encode(&buf, parameter, (int)options);
if (JSON_G(error_code) != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
ZVAL_FALSE(return_value);
} else {
smart_str_0(&buf); /* copy? */
ZVAL_NEW_STR(return_value, buf.s);
}
}
static void php_bencode_decode_str(zval *return_value, char *str, size_t *pos, size_t *str_len) /* {{{ */
{
size_t len = 0;
smart_str buf = {0};
while (*pos < *str_len && str[*pos] != ':') {
smart_str_appendc(&buf, str[*pos]);
(*pos)++;
}
if (str[*pos] != ':') {
zend_error(E_WARNING, "Invaild bencoded-string, expected semicolon, stop at position %u.", *pos);
RETURN_NULL();
}
(*pos)++;
smart_str_0(&buf);
len = atoi(ZSTR_VAL(buf.s));
smart_str_free(&buf);
if (len > 0 && *pos + len - 1 < *str_len) {
size_t i;
for (i = 0; i < len; i++, (*pos)++) {
smart_str_appendc(&buf, str[*pos]);
}
smart_str_0(&buf);
RETVAL_STR(buf.s);
} else {
RETVAL_EMPTY_STRING();
}
}
ZEND_METHOD(Vedis, msetnx)
{
zval **val, *members;
int key_len;
HashPosition pos;
size_t n;
VEDIS_PARAM(MSETNX, 6);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
&members) == FAILURE) {
return;
}
VEDIS_SELF(intern);
n = zend_hash_num_elements(HASH_OF(members));
if (n == 0) {
RETURN_FALSE;
}
VEDIS_ARGS_INIT(n * 2);
zend_hash_internal_pointer_reset_ex(HASH_OF(members), &pos);
while (zend_hash_get_current_data_ex(HASH_OF(members),
(void **)&val, &pos) == SUCCESS) {
char *str_key;
uint str_key_len;
long num_key;
int flags;
flags = zend_hash_get_current_key_ex(HASH_OF(members),
&str_key, &str_key_len,
&num_key, 0, &pos);
if (flags == HASH_KEY_NON_EXISTANT) {
break;
}
if (Z_TYPE_PP(val) != IS_STRING) {
convert_to_string(*val);
}
if (flags == HASH_KEY_IS_STRING) {
VEDIS_ARGS_STRING(str_key, str_key_len - 1);
} else {
smart_str buf = {0};
smart_str_append_long(&buf, num_key);
smart_str_0(&buf);
VEDIS_ARGS_STRING(buf.c, buf.len);
smart_str_free(&buf);
}
VEDIS_ARGS_STRING(Z_STRVAL_PP(val), Z_STRLEN_PP(val));
zend_hash_move_forward_ex(HASH_OF(members), &pos);
}
VEDIS_ARGS_EXEC(RETURN_FALSE);
VEDIS_RETURN_BOOL();
}
static int php_url_scanner_ex_deactivate(int type)
{
url_adapt_state_ex_t *ctx;
if (type) {
ctx = &BG(url_adapt_session_ex);
} else {
ctx = &BG(url_adapt_output_ex);
}
smart_str_free(&ctx->result);
smart_str_free(&ctx->buf);
smart_str_free(&ctx->tag);
smart_str_free(&ctx->arg);
smart_str_free(&ctx->attr_val);
return SUCCESS;
}
void cp_ser_and_setdis(zval *arr) {
smart_str ser_data = {0};
cp_serialize(&ser_data, arr);
#if PHP_MAJOR_VERSION < 7
memcpy(CPGL.ping_mem_addr + CP_PING_MD5_LEN + CP_PING_PID_LEN, ser_data.c, ser_data.len);
#else
zend_string *str = ser_data.s;
memcpy(CPGL.ping_mem_addr + CP_PING_MD5_LEN + CP_PING_PID_LEN, str->val, str->len);
#endif
smart_str_free(&ser_data);
}
CPINLINE zval * cpMD5(zval *arr) {//pass in array , out md5 zval
smart_str ser_data = {0};
cp_serialize(&ser_data, arr);
zval fun_name, **args[1], *retval, *str;
ZVAL_STRING(&fun_name, "md5", 0);
MAKE_STD_ZVAL(str);
ZVAL_STRINGL(str, ser_data.c, ser_data.len, 1);
args[0] = &str;
if (call_user_function_ex(CG(function_table), NULL, &fun_name, &retval, 1, args, 0, NULL TSRMLS_CC) != SUCCESS)
{
zval_ptr_dtor(&str);
smart_str_free(&ser_data);
return NULL;
}
zval_ptr_dtor(&str);
smart_str_free(&ser_data);
return retval;
}
void log_end(cpClient* cli)
{
if (CPGS->max_hold_time_to_log)
{
static struct timeval log_end;
gettimeofday(&log_end, NULL);
int ms = 1000 * (log_end.tv_sec - cli->log_start.tv_sec) + (log_end.tv_usec - cli->log_start.tv_usec) / 1000;
if (CPGS->max_hold_time_to_log <= ms)
{
if (!client_open_log)
{
client_open_log = 1;
cpLog_init(CPGS->log_file);
}
smart_str_appendl(&cli->slow_log_tmp, MAX_HOLD_END_STR, sizeof (MAX_HOLD_END_STR) - 1);
#if PHP_MAJOR_VERSION < 7
cpLog("%s\n\n", cli->slow_log_tmp.c);
#else
cpLog("%s\n\n", ZSTR_VAL(cli->slow_log_tmp.s));
#endif
smart_str_free(&cli->slow_log_tmp);
}
}
if (CPGS->max_data_size_to_log && CPGS->max_data_size_to_log <= cli->current_len)
{
if (!client_open_log)
{
client_open_log = 1;
cpLog_init(CPGS->log_file);
}
smart_str_appendl(&cli->big_data_tmp, MAX_DATA_END_STR, sizeof (MAX_DATA_END_STR) - 1);
#if PHP_MAJOR_VERSION < 7
cpLog("%s\n\n", cli->big_data_tmp.c);
#else
cpLog("%s\n\n", ZSTR_VAL(cli->big_data_tmp.s));
#endif
smart_str_free(&cli->big_data_tmp);
}
}
ONPHP_METHOD(DBField, toDialectString)
{
smart_str string = {0};
zval *table, *field, *dialect, *cast, *quoted;
ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);
table = ONPHP_READ_PROPERTY(getThis(), "table");
field = ONPHP_READ_PROPERTY(getThis(), "field");
cast = ONPHP_READ_PROPERTY(getThis(), "cast");
// either null or instance of DialectString
if (Z_TYPE_P(table) == IS_OBJECT) {
zval *tmp;
ONPHP_CALL_METHOD_1(table, "todialectstring", &tmp, dialect);
onphp_append_zval_to_smart_string(&string, tmp);
zval_ptr_dtor(&tmp);
smart_str_appendc(&string, '.');
}
ONPHP_CALL_METHOD_1(dialect, "quotefield", "ed, field);
onphp_append_zval_to_smart_string(&string, quoted);
zval_ptr_dtor("ed);
smart_str_0(&string);
if (Z_STRLEN_P(cast)) {
zval *tmp, *out;
ALLOC_INIT_ZVAL(tmp);
ZVAL_STRINGL(tmp, string.c, string.len, 1);
ONPHP_CALL_METHOD_2_NORET(dialect, "tocasted", &out, tmp, cast);
ZVAL_FREE(tmp);
smart_str_free(&string);
if (EG(exception)) {
return;
}
RETURN_ZVAL(out, 1, 1);
}
RETURN_STRINGL(string.c, string.len, 0);
}
void shmcache_free_serialize_output(struct shmcache_serialize_output *output)
{
switch (output->value->options) {
case SHMCACHE_SERIALIZER_IGBINARY:
efree(output->value->data);
break;
case SHMCACHE_SERIALIZER_MSGPACK:
case SHMCACHE_SERIALIZER_PHP:
smart_str_free(output->buf);
break;
default:
break;
}
}
PHPAPI char *php_url_scanner_adapt_single_url(const char *url, size_t urllen, const char *name, const char *value, size_t *newlen, int encode)
{
char *result;
smart_str surl = {0};
smart_str buf = {0};
smart_str url_app = {0};
zend_string *encoded;
smart_str_appendl(&surl, url, urllen);
if (encode) {
encoded = php_raw_url_encode(name, strlen(name));
smart_str_appendl(&url_app, ZSTR_VAL(encoded), ZSTR_LEN(encoded));
zend_string_free(encoded);
} else {
smart_str_appends(&url_app, name);
}
smart_str_appendc(&url_app, '=');
if (encode) {
encoded = php_raw_url_encode(value, strlen(value));
smart_str_appendl(&url_app, ZSTR_VAL(encoded), ZSTR_LEN(encoded));
zend_string_free(encoded);
} else {
smart_str_appends(&url_app, value);
}
append_modified_url(&surl, &buf, &url_app, PG(arg_separator).output);
smart_str_0(&buf);
if (newlen) *newlen = ZSTR_LEN(buf.s);
result = estrndup(ZSTR_VAL(buf.s), ZSTR_LEN(buf.s));
smart_str_free(&url_app);
smart_str_free(&buf);
return result;
}
static char *url_adapt_ext(const char *src, size_t srclen, size_t *newlen, zend_bool do_flush, url_adapt_state_ex_t *ctx)
{
char *retval;
xx_mainloop(ctx, src, srclen);
if (!ctx->result.s) {
smart_str_appendl(&ctx->result, "", 0);
*newlen = 0;
} else {
*newlen = ZSTR_LEN(ctx->result.s);
}
smart_str_0(&ctx->result);
if (do_flush) {
smart_str_append(&ctx->result, ctx->buf.s);
*newlen += ZSTR_LEN(ctx->buf.s);
smart_str_free(&ctx->buf);
smart_str_free(&ctx->val);
smart_str_free(&ctx->attr_val);
}
retval = estrndup(ZSTR_VAL(ctx->result.s), ZSTR_LEN(ctx->result.s));
smart_str_free(&ctx->result);
return retval;
}
static inline void php_url_scanner_session_handler_impl(char *output, size_t output_len, char **handled_output, size_t *handled_output_len, int mode, int type)
{
size_t len;
url_adapt_state_ex_t *url_state;
if (type) {
url_state = &BG(url_adapt_session_ex);
} else {
url_state = &BG(url_adapt_output_ex);
}
if (ZSTR_LEN(url_state->url_app.s) != 0) {
*handled_output = url_adapt_ext(output, output_len, &len, (zend_bool) (mode & (PHP_OUTPUT_HANDLER_END | PHP_OUTPUT_HANDLER_CONT | PHP_OUTPUT_HANDLER_FLUSH | PHP_OUTPUT_HANDLER_FINAL) ? 1 : 0), url_state);
if (sizeof(uint32_t) < sizeof(size_t)) {
if (len > UINT_MAX)
len = UINT_MAX;
}
*handled_output_len = len;
} else if (ZSTR_LEN(url_state->url_app.s) == 0) {
url_adapt_state_ex_t *ctx = url_state;
if (ctx->buf.s && ZSTR_LEN(ctx->buf.s)) {
smart_str_append(&ctx->result, ctx->buf.s);
smart_str_appendl(&ctx->result, output, output_len);
*handled_output = estrndup(ZSTR_VAL(ctx->result.s), ZSTR_LEN(ctx->result.s));
*handled_output_len = ZSTR_LEN(ctx->buf.s) + output_len;
smart_str_free(&ctx->buf);
smart_str_free(&ctx->result);
} else {
*handled_output = estrndup(output, *handled_output_len = output_len);
}
} else {
*handled_output = NULL;
}
}
/* {{{ php serializer */
PHP_APCU_API int APC_SERIALIZER_NAME(php) (APC_SERIALIZER_ARGS)
{
smart_str strbuf = {0};
php_serialize_data_t var_hash;
PHP_VAR_SERIALIZE_INIT(var_hash);
php_var_serialize(&strbuf, (zval*) value, &var_hash);
PHP_VAR_SERIALIZE_DESTROY(var_hash);
if(strbuf.s->val) {
*buf = (unsigned char *)estrndup(ZSTR_VAL(strbuf.s), ZSTR_LEN(strbuf.s));
*buf_len = ZSTR_LEN(strbuf.s);
smart_str_free(&strbuf);
return 1;
}
return 0;
} /* }}} */
PHP_METHOD(TypeCollection, __toString)
{
cassandra_type *self;
smart_str string = PHP5TO7_SMART_STR_INIT;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_TYPE(getThis());
php_cassandra_type_string(self, &string TSRMLS_CC);
smart_str_0(&string);
PHP5TO7_RETVAL_STRING(PHP5TO7_SMART_STR_VAL(string));
smart_str_free(&string);
}
void cpLogVar(zval *var)
{
smart_str buf = {0};
smart_str *buf_p = &buf;
php_var_export_ex(var, 3, buf_p);//level 3? maybe 1 is enough
#if PHP_MAJOR_VERSION < 7
if ((buf_p)->c) { \
(buf_p)->c[(buf_p)->len] = '\0'; \
}
char *s1 = buf_p->c;
#else
if (buf_p->s) {
ZSTR_VAL(buf_p->s)[ZSTR_LEN(buf_p->s)] = '\0';
}
char *s1 = ZSTR_VAL(buf_p->s);
#endif
cpLog("%s", s1);
smart_str_free(buf_p);
}
/**
* Serializes php variables without using the PHP userland
*/
void phalcon_serialize(zval *return_value, zval *var) {
php_serialize_data_t var_hash;
smart_str buf = {0};
PHP_VAR_SERIALIZE_INIT(var_hash);
php_var_serialize(&buf, var, &var_hash);
PHP_VAR_SERIALIZE_DESTROY(var_hash);
if (EG(exception)) {
smart_str_free(&buf);
RETURN_FALSE;
}
if (buf.s) {
RETURN_STR(buf.s);
} else {
RETURN_NULL();
}
}
/* ERRORS */
static void do_from_to_zval_err(struct err_s *err,
zend_llist *keys,
const char *what_conv,
const char *fmt,
va_list ap)
{
smart_str path = {0};
const char **node;
char *user_msg;
int user_msg_size;
zend_llist_position pos;
if (err->has_error) {
return;
}
for (node = zend_llist_get_first_ex(keys, &pos);
node != NULL;
node = zend_llist_get_next_ex(keys, &pos)) {
smart_str_appends(&path, *node);
smart_str_appends(&path, " > ");
}
if (path.s && path.s->len > 3) {
path.s->len -= 3;
}
smart_str_0(&path);
user_msg_size = vspprintf(&user_msg, 0, fmt, ap);
err->has_error = 1;
err->level = E_WARNING;
spprintf(&err->msg, 0, "error converting %s data (path: %s): %.*s",
what_conv,
path.s && *path.s->val != '\0' ? path.s->val : "unavailable",
user_msg_size, user_msg);
err->should_free = 1;
efree(user_msg);
smart_str_free(&path);
}
static PHP_MINFO_FUNCTION(dba)
{
dba_handler *hptr;
smart_str handlers = {0};
for(hptr = handler; hptr->name; hptr++) {
smart_str_appends(&handlers, hptr->name);
smart_str_appendc(&handlers, ' ');
}
php_info_print_table_start();
php_info_print_table_row(2, "DBA support", "enabled");
if (handlers.c) {
smart_str_0(&handlers);
php_info_print_table_row(2, "Supported handlers", handlers.c);
smart_str_free(&handlers);
} else {
php_info_print_table_row(2, "Supported handlers", "none");
}
php_info_print_table_end();
}
/**
* Filter identifiers string like variables or database columns/tables
*/
void phalcon_filter_identifier(zval *return_value, zval *param){
int i;
char ch;
zval copy = {};
smart_str filtered_str = {0};
int use_copy = 0;
if (Z_TYPE_P(param) != IS_STRING) {
use_copy = zend_make_printable_zval(param, ©);
if (use_copy) {
param = ©
}
}
for (i = 0; i < Z_STRLEN_P(param); i++) {
ch = Z_STRVAL_P(param)[i];
if (ch == '\0') {
break;
}
if (isalnum(ch) || ch == '_') {
smart_str_appendc(&filtered_str, ch);
}
}
if (use_copy) {
zval_ptr_dtor(param);
}
smart_str_0(&filtered_str);
if (filtered_str.s) {
RETURN_NEW_STR(filtered_str.s);
} else {
smart_str_free(&filtered_str);
RETURN_EMPTY_STRING();
}
}
PHPAPI static int php_discuz_auth_decode(char *buf, const char *str, size_t str_len, const char *key, size_t keylen){
char keya[33], keyb[33], keyc[DISCUZ_AUTH_CKEYLEN+1], cryptkey[65]={0};
unsigned char *base64result;
int retlen;
time_t expiry;
char md5salt[16], md5buf[33], *authcodebuf;
smart_str strbuf = {0};
memcpy(keyc, str, DISCUZ_AUTH_CKEYLEN);
php_discuz_auth_initkey(keya, keyb, cryptkey, keyc, key, keylen);
base64result = php_base64_decode((unsigned char*)(str + DISCUZ_AUTH_CKEYLEN), str_len-DISCUZ_AUTH_CKEYLEN, &retlen);
authcodebuf = (unsigned char *)safe_emalloc(retlen, sizeof(char), 1);
php_discuz_authcode((unsigned char *)authcodebuf, base64result, retlen, cryptkey);
//expiry
bzero(md5buf, sizeof(md5buf));
memcpy(md5buf, authcodebuf, 10);
expiry = atoi(md5buf);
//md5
memcpy(md5salt, authcodebuf + 10, 16);
//if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
smart_str_appendl(&strbuf, authcodebuf + 26, retlen - 26);
smart_str_appendl(&strbuf, keyb, 32);
php_md5(md5buf, strbuf.c, strbuf.len);
smart_str_free(&strbuf);
if((expiry == 0 || expiry - time(NULL) > 0) && memcmp(md5salt, md5buf, 16) == 0){
memcpy(buf, authcodebuf + 26, retlen-26);
efree(authcodebuf);
return retlen-26;
}
efree(authcodebuf);
return 0;
}
