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; }