inline int wrapper_zend_hash_get_current_key(HashTable *ht, char **key, uint *idx, ulong *num) { zval str_key; ZVAL_STRING(&str_key, *key); int type = zend_hash_get_current_key(ht, &Z_STR(str_key), (zend_ulong*) num); *key = Z_STR(str_key)->val; return type; }
void *merge_php_config(apr_pool_t *p, void *base_conf, void *new_conf) { php_conf_rec *d = base_conf, *e = new_conf, *n = NULL; php_dir_entry *pe; php_dir_entry *data; char *str; uint str_len; ulong num_index; n = create_php_config(p, "merge_php_config"); zend_hash_copy(&n->config, &e->config, NULL, NULL, sizeof(php_dir_entry)); phpapdebug((stderr, "Merge dir (%p)+(%p)=(%p)\n", base_conf, new_conf, n)); for (zend_hash_internal_pointer_reset(&d->config); zend_hash_get_current_key(&d->config, &str, &str_len, &num_index) == HASH_KEY_IS_STRING; zend_hash_move_forward(&d->config)) { pe = NULL; zend_hash_get_current_data(&d->config, (void **) &data); if ((pe = zend_hash_find(&n->config, str, str_len) != NULL) != NULL) { if (pe->status >= data->status) continue; } zend_hash_update(&n->config, str, str_len, data, sizeof(*data), NULL); phpapdebug((stderr, "ADDING/OVERWRITING %s (%d vs. %d)\n", str, data->status, pe?pe->status:-1)); } return n; }
inline int sw_zend_hash_get_current_key(HashTable *ht, char **key, uint32_t *keylen, ulong *num) { zval str_key; int type = zend_hash_get_current_key(ht, &Z_STR(str_key), (zend_ulong* ) num); *key = Z_STRVAL(str_key); *keylen = Z_STRLEN(str_key); return type; }
PHP_METHOD(MIME, load) { zval *array, *arg, retval; /* Fetch allowHEAD */ MAKE_STD_ZVAL(array); array_init_size(array, 2); add_next_index_stringl(array, "Pancake\\Config", sizeof("Pancake\\Config") - 1, 1); add_next_index_stringl(array, "get", 3, 1); MAKE_STD_ZVAL(arg); Z_TYPE_P(arg) = IS_STRING; Z_STRLEN_P(arg) = 4; Z_STRVAL_P(arg) = estrndup("mime", 4); call_user_function(CG(function_table), NULL, array, &retval, 1, &arg TSRMLS_CC); if(Z_TYPE(retval) != IS_ARRAY) { zend_error(E_ERROR, "Bad MIME type array - Please check Pancake MIME type configuration"); } ALLOC_HASHTABLE(PANCAKE_GLOBALS(mimeTable)); zend_hash_init(PANCAKE_GLOBALS(mimeTable), 0, NULL, ZVAL_PTR_DTOR, 0); zval **data, **ext; char *key; for(zend_hash_internal_pointer_reset(Z_ARRVAL(retval)); zend_hash_get_current_data(Z_ARRVAL(retval), (void**) &data) == SUCCESS && zend_hash_get_current_key(Z_ARRVAL(retval), &key, NULL, 0) == HASH_KEY_IS_STRING; zend_hash_move_forward(Z_ARRVAL(retval))) { for(zend_hash_internal_pointer_reset(Z_ARRVAL_PP(data)); zend_hash_get_current_data(Z_ARRVAL_PP(data), (void**) &ext) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_PP(data))) { zval *zkey; MAKE_STD_ZVAL(zkey); Z_TYPE_P(zkey) = IS_STRING; Z_STRLEN_P(zkey) = strlen(key); Z_STRVAL_P(zkey) = estrndup(key, Z_STRLEN_P(zkey)); zend_hash_add(PANCAKE_GLOBALS(mimeTable), Z_STRVAL_PP(ext), Z_STRLEN_PP(ext), (void*) &zkey, sizeof(zval*), NULL); } } MAKE_STD_ZVAL(PANCAKE_GLOBALS(defaultMimeType)); Z_TYPE_P(PANCAKE_GLOBALS(defaultMimeType)) = IS_STRING; Z_STRLEN_P(PANCAKE_GLOBALS(defaultMimeType)) = sizeof("application/octet-stream") - 1; Z_STRVAL_P(PANCAKE_GLOBALS(defaultMimeType)) = estrndup("application/octet-stream", sizeof("application/octet-stream") - 1); free: zval_dtor(&retval); zval_ptr_dtor(&array); zval_ptr_dtor(&arg); }
PHP_METHOD(Rows, key) { ulong key; char* string; cassandra_rows* self = NULL; if (zend_parse_parameters_none() == FAILURE) return; self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_hash_get_current_key(Z_ARRVAL_P(self->rows), &string, &key, 0) == HASH_KEY_IS_LONG) RETURN_LONG(key); }
/* {{{ php_ini_activate_config */ PHPAPI void php_ini_activate_config(HashTable *source_hash, int modify_type, int stage) { zend_string *str; zval *data; zend_ulong num_index; /* Walk through config hash and alter matching ini entries using the values found in the hash */ for (zend_hash_internal_pointer_reset(source_hash); zend_hash_get_current_key(source_hash, &str, &num_index) == HASH_KEY_IS_STRING; zend_hash_move_forward(source_hash) ) { data = zend_hash_get_current_data(source_hash); zend_alter_ini_entry_ex(str, Z_STR_P(data), modify_type, stage, 0); } }
/* {{{ pip_zobject_to_pyobject(zval **obj) Convert a PHP (Zend) object to a Python object */ PyObject * pip_zobject_to_pyobject(zval **obj) { PyObject *dict, *item, *str; zval **entry; char *string_key; long num_key; /* * At this point, we represent a PHP object as a dictionary of * its properties. In the future, we may provide a true object * conversion (which is entirely possible, but it's more work * that I plan on doing right now). */ dict = PyDict_New(); /* Start at the beginning of the object properties hash */ zend_hash_internal_pointer_reset(Z_OBJPROP_PP(obj)); /* Iterate over the hash's elements */ while (zend_hash_get_current_data(Z_OBJPROP_PP(obj), (void **)&entry) == SUCCESS) { /* Convert the PHP value to its Python equivalent (recursion) */ item = pip_zval_to_pyobject(entry); switch (zend_hash_get_current_key(Z_OBJPROP_PP(obj), &string_key, &num_key, 0)) { case HASH_KEY_IS_STRING: PyDict_SetItemString(dict, string_key, item); break; case HASH_KEY_IS_LONG: str = PyString_FromFormat("%d", num_key); PyObject_SetItem(dict, str, item); Py_DECREF(str); break; case HASH_KEY_NON_EXISTANT: php_error(E_ERROR, "No array key"); break; } /* Advance to the next entry */ zend_hash_move_forward(Z_OBJPROP_PP(obj)); } return dict; }
void apply_config(void *dummy) { php_conf_rec *d = dummy; char *str; uint str_len; php_dir_entry *data; for (zend_hash_internal_pointer_reset(&d->config); zend_hash_get_current_key(&d->config, &str, &str_len, NULL) == HASH_KEY_IS_STRING; zend_hash_move_forward(&d->config)) { zend_hash_get_current_data(&d->config, (void **) &data); phpapdebug((stderr, "APPLYING (%s)(%s)\n", str, data->value)); if (zend_alter_ini_entry(str, str_len, data->value, data->value_len, data->status, data->htaccess?PHP_INI_STAGE_HTACCESS:PHP_INI_STAGE_ACTIVATE) == FAILURE) { phpapdebug((stderr, "..FAILED\n")); } } }
/* {{{ pip_hash_to_dict(zval **hash) Convert a PHP hash to a Python dictionary */ PyObject * pip_hash_to_dict(zval **hash) { PyObject *dict, *item, *integer; zval **entry; char *string_key; long num_key = 0; /* Make sure we were given a PHP hash */ if (Z_TYPE_PP(hash) != IS_ARRAY) { return NULL; } /* Create a new empty dictionary */ dict = PyDict_New(); /* Let's start at the very beginning, a very good place to start. */ zend_hash_internal_pointer_reset(Z_ARRVAL_PP(hash)); /* Iterate over the hash's elements */ while (zend_hash_get_current_data(Z_ARRVAL_PP(hash), (void **)&entry) == SUCCESS) { /* Convert the PHP value to its Python equivalent (recursion) */ item = pip_zval_to_pyobject(entry); /* Assign the item with the appropriate key type (string or integer) */ switch (zend_hash_get_current_key(Z_ARRVAL_PP(hash), &string_key, &num_key, 0)) { case HASH_KEY_IS_STRING: PyDict_SetItemString(dict, string_key, item); break; case HASH_KEY_IS_LONG: integer = PyInt_FromLong(num_key); PyDict_SetItem(dict, integer, item); Py_DECREF(integer); break; } /* Advance to the next entry */ zend_hash_move_forward(Z_ARRVAL_PP(hash)); } return dict; }
char *owsrequest_getenv(const char *name, void *thread_context) { zval **val, **ppzval; zval *cookie_result, *key; HashTable *cookies; char *string_key = NULL, *cookie_tmp; ulong num_key; int numElements, i = 0; TSRMLS_FETCH_FROM_CTX(thread_context); if (STRING_EQUAL(name, "HTTP_COOKIE")) { cookies = PG(http_globals)[TRACK_VARS_COOKIE]->value.ht; numElements = zend_hash_num_elements(cookies); MAKE_STD_ZVAL(cookie_result); ZVAL_STRING(cookie_result, "",1); for(zend_hash_internal_pointer_reset(cookies); zend_hash_has_more_elements(cookies) == SUCCESS; zend_hash_move_forward(cookies), ++i) { zend_hash_get_current_data(cookies, (void **)&ppzval); zend_hash_get_current_key(cookies, &string_key, &num_key, 1); cookie_tmp = malloc((strlen(string_key)+Z_STRLEN_PP(ppzval)+3) * sizeof(char)); sprintf(cookie_tmp, "%s=%s;",string_key,Z_STRVAL_PP(ppzval)); MAKE_STD_ZVAL(key); ZVAL_STRING(key, cookie_tmp,1); add_string_to_string(cookie_result,cookie_result, key); zval_dtor(key); free(cookie_tmp); } return Z_STRVAL_P(cookie_result); } else { zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC); if ( PG(http_globals)[TRACK_VARS_SERVER] && (zend_hash_find(PG(http_globals)[TRACK_VARS_SERVER]->value.ht, name, strlen(name)+1, (void **) &val) == SUCCESS) && (Z_TYPE_PP(val) == IS_STRING)) { return Z_STRVAL_PP(val); } } return NULL; }
/** {{{ proto public Yaf_Config_Simple::key(void) */ PHP_METHOD(yaf_config_simple, key) { zval *prop; zend_string *string; ulong index; prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL); zend_hash_get_current_key(Z_ARRVAL_P(prop), &string, &index); switch(zend_hash_get_current_key_type(Z_ARRVAL_P(prop))) { case HASH_KEY_IS_LONG: RETURN_LONG(index); break; case HASH_KEY_IS_STRING: RETURN_STR(zend_string_copy(string)); break; default: RETURN_FALSE; } }
PHP_METHOD(jz_data, key) { zval *prop; zend_string *string; zend_ulong index; prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL); zend_hash_get_current_key(Z_ARRVAL_P(prop), &string, &index); switch(zend_hash_get_current_key_type(Z_ARRVAL_P(prop))) { case HASH_KEY_IS_LONG: RETURN_LONG(index); break; case HASH_KEY_IS_STRING: RETURN_STR(zend_string_copy(string)); break; default: RETURN_FALSE; } }
static void php_print_gpcse_array(char *name, uint name_length ELS_DC) { zval **data, **tmp, tmp2; char *string_key; ulong num_key; if (zend_hash_find(&EG(symbol_table), name, name_length+1, (void **) &data)!=FAILURE && ((*data)->type==IS_ARRAY)) { zend_hash_internal_pointer_reset((*data)->value.ht); while (zend_hash_get_current_data((*data)->value.ht, (void **) &tmp) == SUCCESS) { PUTS("<TR VALIGN=\"baseline\" BGCOLOR=\"" PHP_CONTENTS_COLOR "\">"); PUTS("<TD BGCOLOR=\"" PHP_ENTRY_NAME_COLOR "\"><B>"); PUTS(name); PUTS("[\""); switch (zend_hash_get_current_key((*data)->value.ht, &string_key, &num_key, 0)) { case HASH_KEY_IS_STRING: zend_html_puts(string_key, strlen(string_key)); break; case HASH_KEY_IS_LONG: php_printf("%ld",num_key); break; } PUTS("\"]</B></TD><TD>"); if ((*tmp)->type == IS_ARRAY) { PUTS("<PRE>"); zend_print_zval_r(*tmp, 0); PUTS("</PRE>"); } else if ((*tmp)->type != IS_STRING) { tmp2 = **tmp; zval_copy_ctor(&tmp2); convert_to_string(&tmp2); zend_html_puts(tmp2.value.str.val, tmp2.value.str.len); zval_dtor(&tmp2); } else { zend_html_puts((*tmp)->value.str.val, (*tmp)->value.str.len); } PUTS(" </TD></TR>\n"); zend_hash_move_forward((*data)->value.ht); } } }
/* {{{ xslt_make_array() Make an XSLT array (char **) from a zval array (HashTable *) */ extern void xslt_make_array(zval **zarr, char ***carr) { zval **current; HashTable *arr; int idx = 0; arr = HASH_OF(*zarr); if (! arr) { php_error(E_WARNING, "Invalid argument or parameter array to %s", get_active_function_name()); return; } *carr = emalloc((zend_hash_num_elements(arr) * 2) + 1); for (zend_hash_internal_pointer_reset(arr); zend_hash_get_current_data(arr, (void **) ¤t) == SUCCESS; zend_hash_move_forward(arr)) { char *string_key = NULL; ulong num_key; int type; SEPARATE_ZVAL(current); convert_to_string_ex(current); type = zend_hash_get_current_key(arr, &string_key, &num_key, 0); if (type == HASH_KEY_IS_LONG) { php_error(E_WARNING, "Invalid argument or parameter array to %s", get_active_function_name()); return; } (*carr)[idx++] = estrdup(string_key); (*carr)[idx++] = estrndup(Z_STRVAL_PP(current), Z_STRLEN_PP(current)); } (*carr)[idx] = NULL; }
/** * Used for readdir() on an opendir()ed phar directory handle */ static size_t phar_dir_read(php_stream *stream, char *buf, size_t count) /* {{{ */ { size_t to_read; HashTable *data = (HashTable *)stream->abstract; zend_string *str_key; zend_ulong unused; if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key(data, &str_key, &unused)) { return 0; } zend_hash_move_forward(data); to_read = MIN(ZSTR_LEN(str_key), count); if (to_read == 0 || count < ZSTR_LEN(str_key)) { return 0; } memset(buf, 0, sizeof(php_stream_dirent)); memcpy(((php_stream_dirent *) buf)->d_name, ZSTR_VAL(str_key), to_read); ((php_stream_dirent *) buf)->d_name[to_read + 1] = '\0'; return sizeof(php_stream_dirent); }
static bool getMocData(zval* z_this_ptr, const char* classname, const QMetaObject* superdata, QString* meta_stringdata, uint* signature) { /* // - reads all methods defined in a class // - see zend_compile.h for types // - case sensitive // - types need to be matched zend_class_entry* ce_ = Z_OBJCE_P(this_ptr); HashTable* function_table = &Z_OBJCE_P(this_ptr)->function_table; zend_hash_internal_pointer_reset(function_table); zval** prop; union _zend_function *fbc; if (zend_hash_num_elements( function_table ) > 0) { while(zend_hash_has_more_elements(function_table) == SUCCESS) { zend_hash_get_current_data(function_table,(void**)&fbc); zend_hash_move_forward(function_table); QByteArray name( (*fbc).common.function_name ); if( !name.contains("__destruct") && !name.contains("__construct") && !name.contains("__toString") && !name.contains("proxyMethod") && !name.contains("staticProxyMethod") && !name.contains("emit") ){ for( int i=0; i<(*fbc).common.num_args; i++) { qDebug() <<"++ "<< (*fbc).common.arg_info[i].name <<","<< (*fbc).common.arg_info[i].array_type_hint; } qDebug() << (*fbc).common.function_name;// << fbc->internal_function->function_name; } } } */ /// - readout the slots table zval **slotdata; zval *zslot; zslot = zend_read_property(Z_OBJCE_P(z_this_ptr),z_this_ptr,"slots",5,1); zval *zsignal; zsignal = zend_read_property(Z_OBJCE_P(z_this_ptr),z_this_ptr,"signals",7,1); if((zslot)->type==IS_ARRAY && (zsignal)->type==IS_ARRAY ) { HashTable* slots_hash = HASH_OF(zslot); HashTable* signals_hash = HASH_OF(zsignal); char* assocKey; ulong numKey; int signaturecount = 2 + strlen(classname); #ifdef MOC_DEBUG QString qr; pDebug( PHPQt::Moc ) << "+== begin metaobject dump ==+\n"; pDebug( PHPQt::Moc ) << "\t" << classname << "\n\t1 0 0 0 " << zend_hash_num_elements(slots_hash)+zend_hash_num_elements(signals_hash) << " 10 0 0 0 0" << endl << endl; #endif /// - write class signature signature[0] = 1; signature[4] = zend_hash_num_elements(slots_hash)+zend_hash_num_elements(signals_hash); signature[5] = 10; /// - write classname meta_stringdata->append(classname); meta_stringdata->append(QChar::Null); meta_stringdata->append(QChar::Null); int i = 10; zend_hash_internal_pointer_reset(signals_hash); while(zend_hash_has_more_elements(signals_hash) == SUCCESS) { /// - read slot from hashtable zend_hash_get_current_key(signals_hash,&assocKey,&numKey,0); zend_hash_get_current_data(signals_hash,(void**)&slotdata); #ifdef MOC_DEBUG qr.append(Z_STRVAL_PP(slotdata)); qr.append(" "); pDebug( PHPQt::Moc ) << "\t" << signaturecount << "8 8 8 0x05 ::s" << endl; #endif meta_stringdata->append(Z_STRVAL_PP(slotdata)); meta_stringdata->append(QChar::Null); zend_hash_move_forward(signals_hash); /// - write signal signature signature[i++] = signaturecount; signature[i++] = 8; signature[i++] = 8; signature[i++] = 8; signature[i++] = 0x05; signaturecount += strlen(Z_STRVAL_PP(slotdata)) + 1; } zend_hash_internal_pointer_reset(slots_hash); while(zend_hash_has_more_elements(slots_hash) == SUCCESS) { /// - read slot from hashtable zend_hash_get_current_key(slots_hash,&assocKey,&numKey,0); zend_hash_get_current_data(slots_hash,(void**)&slotdata); #ifdef MOC_DEBUG qr.append(Z_STRVAL_PP(slotdata)); qr.append(" "); pDebug( PHPQt::Moc ) << "\t" << signaturecount << "8 8 8 0x0a ::s" << endl; #endif meta_stringdata->append(Z_STRVAL_PP(slotdata)); meta_stringdata->append(QChar::Null); zend_hash_move_forward(slots_hash); /// - write slot signature signature[i++] = signaturecount; signature[i++] = 8; signature[i++] = 8; signature[i++] = 8; signature[i++] = 0x0a; signaturecount += strlen(Z_STRVAL_PP(slotdata)) + 1; } // TODO freeing this crashs // efree( assocKey ); #ifdef MOC_DEBUG pDebug( PHPQt::Moc ) << qr << endl; #endif pDebug( PHPQt::Moc ) << "+== end metaobject dump ==+" << endl; return true; } else { return false; } } // getMocData
void skyray_http_protocol_send_headers(skyray_http_protocol_t *self, skyray_http_message_t *message) { zval *zconnection = NULL; zconnection = skyray_http_message_get_header(message, intern_str_connection, 1); zend_array *ht = &message->headers; zend_array *headers; zend_string *name; zend_string *value; skyray_buffer_t header_s; skyray_buffer_init(&header_s, 2048); if (!skyray_http_message_has_header(message, intern_str_server)) { skyray_buffer_appendl(&header_s, ZEND_STRL("Server: Skyray Http Server\r\n")); } if (!skyray_http_message_has_header(message, intern_str_date)) { time_t tm; time(&tm); char *buf = ctime(&tm); skyray_buffer_appendl(&header_s, ZEND_STRL("Date: ")); skyray_buffer_appendl(&header_s, buf, strlen(buf) - 1); skyray_buffer_appendl(&header_s, ZEND_STRL("\r\n")); } zend_hash_internal_pointer_reset(ht); while(zend_hash_has_more_elements(ht) == SUCCESS) { zend_hash_get_current_key(ht, &name, NULL); headers = Z_ARR_P(zend_hash_get_current_data(ht)); zend_hash_internal_pointer_reset(headers); while(zend_hash_has_more_elements(headers) == SUCCESS) { value = Z_STR_P(zend_hash_get_current_data(headers)); skyray_buffer_appendl(&header_s, name->val, name->len); skyray_buffer_appendl(&header_s, ZEND_STRL(": ")); skyray_buffer_appendl(&header_s, value->val, value->len); skyray_buffer_appendl(&header_s, ZEND_STRL("\r\n")); zend_hash_move_forward(headers); } zend_hash_move_forward(ht); } self->close = 0; if (!zconnection) { if (http_should_keep_alive(&self->parser)) { skyray_buffer_appendl(&header_s, ZEND_STRL("Connection: keep-alive\r\n")); } else { skyray_buffer_appendl(&header_s, ZEND_STRL("Connection: close\r\n")); self->close = 1; } } else if (strcasecmp(Z_STR_P(zconnection)->val, "close") == 0) { self->close = 1; } self->chunked = 0; if (!skyray_http_message_has_header(message, intern_str_content_length)) { skyray_buffer_appendl(&header_s, ZEND_STRL("Transfer-Encoding: chunked\r\n")); self->chunked = 1; } skyray_buffer_appendl(&header_s, ZEND_STRL("\r\n")); skyray_stream_write(skyray_stream_from_obj(self->stream), header_s.buf); skyray_buffer_release(&header_s); }
void dump_dot(void) { int x, print_header, key_type; int *block_num; int c = 0, len = 0, flag_ho; long index, key_len; char *block_name = NULL; char *time_buff = pvt_get_time(); smart_str str_dot_func = {0}; TSRMLS_FETCH(); char *tmp_buff = NULL; tmp_buff = pvt_sprintf(tpl_dot[0], time_buff); fprintf(PVT_G(trace_file_f_dot), "%s", tmp_buff); efree(time_buff); efree(tmp_buff); if (PVT_G(pvt_graph_fold)) { hide_functions(); } /* Iterate through all blocks/nodes */ for (zend_hash_internal_pointer_reset(PVT_G(block_summary)); zend_hash_has_more_elements(PVT_G(block_summary)) == SUCCESS; zend_hash_move_forward(PVT_G(block_summary))) { key_type = zend_hash_get_current_key(PVT_G(block_summary), &block_name, &index, 0); if (key_type == HASH_KEY_IS_STRING) { key_len = strlen(block_name); } zend_hash_get_current_data(PVT_G(block_summary), (void*) &block_num); print_header = 1; int flag_started = 0; int flag_break = 0; int flag_nop = 0; flag_ho = 1; size_t ret_len; /* Iterate through all functions */ for (x = 0; x < PVT_G(funcs)->len; x++) { if (PVT_G(funcs)->file_id[x] == *block_num) { flag_started = 1; if (print_header) { if (PVT_G(funcs)->type[x] == 2 && flag_ho) { char *ret; php_basename( PVT_G(funcs)->file_name[x], strlen(PVT_G(funcs)->file_name[x]), NULL, 0, &ret, &ret_len TSRMLS_CC ); char *escaped_str = php_escape_html_entities( block_name, strlen(block_name), &len, 0, ENT_QUOTES, NULL TSRMLS_CC ); /* Print the block header */ fprintf(PVT_G(trace_file_f_dot), tpl_point_func[0], *block_num, PVT_G(funcs)->line[x], *block_num, PVT_G(funcs)->file_name[x], PVT_G(funcs)->line[x], ret, escaped_str, PVT_G(funcs)->func_id[x] ); flag_ho = 0; efree(ret); efree(escaped_str); } } } if (PVT_G(funcs)->stack[x] <= PVT_G(dot_funcs_i)->file_id[c] && flag_started) { if (0 == print_header) { flag_break = 1; } else { flag_break = 0; } } if (0 == flag_started) { continue; } if ((PVT_G(funcs)->stack[x]-1) != PVT_G(dot_funcs_i)->file_id[c]) { if (!flag_break) { continue; } else { flag_nop = 1; } } if (flag_nop != 1) { flag_nop = 0; if (print_header) { print_header = 0; } if (PVT_G(dot_funcs_i)->empty[c]) { flag_started = 0; break; } /* Check if function repeats */ if (0 == PVT_G(funcs)->hide[x] || !PVT_G(pvt_graph_fold)) { if (2 == PVT_G(funcs)->type[x]) { /* This is USER function */ char *escaped_str = php_escape_html_entities( PVT_G(funcs)->func_name[x], strlen(PVT_G(funcs)->func_name[x]), &len, 0, ENT_QUOTES, NULL TSRMLS_CC ); fprintf(PVT_G(trace_file_f_dot), tpl_point_func[1], PVT_G(funcs)->line[x], PVT_G(funcs)->line[x], escaped_str, PVT_G(funcs)->func_id[x] ); efree(escaped_str); char *tmp_buff = pvt_sprintf( tpl_relation_func[0], *block_num, PVT_G(funcs)->line[x], PVT_G(funcs)->file_id[x], PVT_G(funcs)->file_id[x], PVT_G(funcs)->func_id[x] ); smart_str_appends(&str_dot_func, tmp_buff); efree(tmp_buff); } else { /* This is ZEND function */ char *escaped_str = php_escape_html_entities( PVT_G(funcs)->func_name[x], strlen(PVT_G(funcs)->func_name[x]), &len, 0, ENT_QUOTES, NULL TSRMLS_CC ); fprintf(PVT_G(trace_file_f_dot), tpl_point_func[2], PVT_G(funcs)->line[x], (1 == PVT_G(funcs)->is_evil[x] ? "d63333" : "e0ebcc"), escaped_str, PVT_G(funcs)->func_id[x] ); efree(escaped_str); } } /* end if (0 ==... */ } /* end if (flag_nop... */ if (flag_break) { if (!flag_nop) { flag_break = 0; flag_started = 0; break; } } } /* end for (x... */ c++; fprintf(PVT_G(trace_file_f_dot), "</TABLE>>\n]\n"); } smart_str_0(&str_dot_func); if (str_dot_func.c != NULL) { fprintf(PVT_G(trace_file_f_dot), "%s", str_dot_func.c); } smart_str_free(&str_dot_func); fprintf(PVT_G(trace_file_f_dot), "\n}\n"); fclose(PVT_G(trace_file_f_dot)); }
/** * Create a opendir() directory stream handle by iterating over each of the * files in a phar and retrieving its relative path. From this, construct * a list of files/directories that are "in" the directory represented by dir */ static php_stream *phar_make_dirstream(char *dir, HashTable *manifest) /* {{{ */ { HashTable *data; size_t dirlen = strlen(dir); char *entry, *found, *save; zend_string *str_key; uint32_t keylen; zend_ulong unused; ALLOC_HASHTABLE(data); zend_hash_init(data, 64, NULL, NULL, 0); if ((*dir == '/' && dirlen == 1 && (manifest->nNumOfElements == 0)) || (dirlen >= sizeof(".phar")-1 && !memcmp(dir, ".phar", sizeof(".phar")-1))) { /* make empty root directory for empty phar */ /* make empty directory for .phar magic directory */ efree(dir); return php_stream_alloc(&phar_dir_ops, data, NULL, "r"); } zend_hash_internal_pointer_reset(manifest); while (FAILURE != zend_hash_has_more_elements(manifest)) { if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key(manifest, &str_key, &unused)) { break; } keylen = ZSTR_LEN(str_key); if (keylen <= (uint32_t)dirlen) { if (keylen == 0 || keylen < (uint32_t)dirlen || !strncmp(ZSTR_VAL(str_key), dir, dirlen)) { if (SUCCESS != zend_hash_move_forward(manifest)) { break; } continue; } } if (*dir == '/') { /* root directory */ if (keylen >= sizeof(".phar")-1 && !memcmp(ZSTR_VAL(str_key), ".phar", sizeof(".phar")-1)) { /* do not add any magic entries to this directory */ if (SUCCESS != zend_hash_move_forward(manifest)) { break; } continue; } if (NULL != (found = (char *) memchr(ZSTR_VAL(str_key), '/', keylen))) { /* the entry has a path separator and is a subdirectory */ entry = (char *) safe_emalloc(found - ZSTR_VAL(str_key), 1, 1); memcpy(entry, ZSTR_VAL(str_key), found - ZSTR_VAL(str_key)); keylen = found - ZSTR_VAL(str_key); entry[keylen] = '\0'; } else { entry = (char *) safe_emalloc(keylen, 1, 1); memcpy(entry, ZSTR_VAL(str_key), keylen); entry[keylen] = '\0'; } goto PHAR_ADD_ENTRY; } else { if (0 != memcmp(ZSTR_VAL(str_key), dir, dirlen)) { /* entry in directory not found */ if (SUCCESS != zend_hash_move_forward(manifest)) { break; } continue; } else { if (ZSTR_VAL(str_key)[dirlen] != '/') { if (SUCCESS != zend_hash_move_forward(manifest)) { break; } continue; } } } save = ZSTR_VAL(str_key); save += dirlen + 1; /* seek to just past the path separator */ if (NULL != (found = (char *) memchr(save, '/', keylen - dirlen - 1))) { /* is subdirectory */ save -= dirlen + 1; entry = (char *) safe_emalloc(found - save + dirlen, 1, 1); memcpy(entry, save + dirlen + 1, found - save - dirlen - 1); keylen = found - save - dirlen - 1; entry[keylen] = '\0'; } else { /* is file */ save -= dirlen + 1; entry = (char *) safe_emalloc(keylen - dirlen, 1, 1); memcpy(entry, save + dirlen + 1, keylen - dirlen - 1); entry[keylen - dirlen - 1] = '\0'; keylen = keylen - dirlen - 1; } PHAR_ADD_ENTRY: if (keylen) { phar_add_empty(data, entry, keylen); } efree(entry); if (SUCCESS != zend_hash_move_forward(manifest)) { break; } } if (FAILURE != zend_hash_has_more_elements(data)) { efree(dir); if (zend_hash_sort(data, phar_compare_dir_name, 0) == FAILURE) { FREE_HASHTABLE(data); return NULL; } return php_stream_alloc(&phar_dir_ops, data, NULL, "r"); } else { efree(dir); return php_stream_alloc(&phar_dir_ops, data, NULL, "r"); } }
PHP_COUCHBASE_LOCAL void php_couchbase_store_multi_impl_oo(INTERNAL_FUNCTION_PARAMETERS) { lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; time_t exp = {0}; long expire = 0; zval *akeys; long persist_to = 0; long replicate_to = 0; struct observe_entry *entries; int numkeys; lcb_store_cmd_t *cmds; lcb_store_cmd_t **commands; int ii; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_OO, "a|lll", &akeys, &expire, &persist_to, &replicate_to); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, expire, &exp) == -1) { /* Incorrect expiry time */ return; } if (validate_simple_observe_clause(couchbase_res->handle, persist_to, replicate_to TSRMLS_CC) == -1) { /* Exception already thrown */ return; } numkeys = zend_hash_num_elements(Z_ARRVAL_P(akeys)); if (numkeys == 0) { zend_throw_exception(cb_illegal_key_exception, "No items specified", 0 TSRMLS_CC); return ; } entries = ecalloc(numkeys, sizeof(struct observe_entry)); commands = ecalloc(numkeys, sizeof(lcb_store_cmd_t *)); cmds = ecalloc(numkeys, sizeof(lcb_store_cmd_t)); /* link the command pointers */ for (ii = 0; ii < numkeys; ++ii) { commands[ii] = cmds + ii; } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; array_init(ctx->rv); for (ii = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), ++ii) { char *key = NULL; uint klen; size_t payload_len = 0; char *payload; unsigned int flags = 0; zval **ppzval; if (zend_hash_get_current_key_type(Z_ARRVAL_P(akeys)) != HASH_KEY_IS_STRING) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_illegal_key_exception, "Invalid key specified (not a string)", 0 TSRMLS_CC); return ; } zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, NULL, 0); if ((klen = strlen(key)) == 0) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_illegal_key_exception, "Invalid key specified (empty string)", 0 TSRMLS_CC); return ; } if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_exception, "Failed to get data for key", 0 TSRMLS_CC); return ; } payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { /* Shouldn't we call an exception? */ RETURN_FALSE; } if (couchbase_res->prefix_key_len) { char *new_key; klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key); key = new_key; } entries[ii].nkey = klen; entries[ii].key = emalloc(klen); memcpy(entries[ii].key, key, klen); cmds[ii].v.v0.operation = LCB_SET; cmds[ii].v.v0.key = entries[ii].key; cmds[ii].v.v0.nkey = klen; cmds[ii].v.v0.bytes = payload; cmds[ii].v.v0.nbytes = payload_len; cmds[ii].v.v0.flags = flags; cmds[ii].v.v0.exptime = exp; if (couchbase_res->prefix_key_len) { efree(key); } } retval = lcb_store(couchbase_res->handle, ctx, numkeys, (const lcb_store_cmd_t * const *)commands); couchbase_res->seqno += numkeys; pcbc_start_loop(couchbase_res); /* * Time to release the payloads... */ for (ii = 0; ii < numkeys; ++ii) { efree((void *)cmds[ii].v.v0.bytes); } efree(cmds); efree(commands); if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); release_entry_array(entries, numkeys); RETURN_FALSE; } /* * The item was stored successfully. Did the user want to wait until * it was persisted/replicated? */ if (persist_to != 0 || replicate_to != 0) { int ii = 0; for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value)); zend_hash_has_more_elements(Z_ARRVAL_P(return_value)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(return_value)), ++ii) { zval **curr_cas; zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void **)&curr_cas); if (Z_STRLEN_PP(curr_cas)) { entries[ii].cas = strtoull(Z_STRVAL_PP(curr_cas), 0, 10); } else { /* @todo what to do here? */ fprintf(stderr, "wtf!\n"); } } retval = simple_observe(couchbase_res->handle, entries, numkeys, persist_to, replicate_to); couchbase_res->rc = retval; if (retval != LCB_SUCCESS) { if (retval == LCB_ETIMEDOUT) { zend_throw_exception(cb_timeout_exception, "Timed out waiting for the objects to persist", 0 TSRMLS_CC); } else { char errmsg[256]; snprintf(errmsg, sizeof(errmsg), "An error occured while waiting for the objects to persist: %s", lcb_strerror(couchbase_res->handle, retval)); zend_throw_exception(cb_lcb_exception, errmsg, 0 TSRMLS_CC); } } else { int currsize = 4096; char *errmsg = malloc(currsize); int offset = sprintf(errmsg, "The following documents was mutated:"); int errors = 0; for (ii = 0; ii < numkeys; ++ii) { if (entries[ii].mutated) { if ((offset + entries[ii].nkey + 3) > currsize) { char *p = realloc(errmsg, currsize * 2); if (p) { currsize *= 2; errmsg = p; } } if ((offset + entries[ii].nkey + 3) < currsize) { offset += sprintf(errmsg + offset, " \""); memcpy(errmsg + offset, entries[ii].key, entries[ii].nkey); offset += entries[ii].nkey; offset += sprintf(errmsg + offset, "\""); } errors = 1; } } if (errors) { zend_throw_exception(cb_key_mutated_exception, errmsg, 0 TSRMLS_CC); } free(errmsg); } } release_entry_array(entries, numkeys); efree(ctx); }
PHP_COUCHBASE_LOCAL void php_couchbase_store_impl(INTERNAL_FUNCTION_PARAMETERS, lcb_storage_t op, int multi) { lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; time_t exp = {0}; unsigned int flags = 0; char *payload, *cas = NULL; size_t payload_len = 0; unsigned long long cas_v = 0; long expire = 0, cas_len = 0; char *key = NULL; if (!multi) { char *key = NULL; zval *value; long klen = 0; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_FUNCTIONAL, "sz|ls", &key, &klen, &value, &expire, &cas, &cas_len); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, expire, &exp) == -1) { /* Incorrect expiry time */ return; } if (!klen) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_illegal_key_exception, "No key specified: Empty key"); return; } if (cas) { char *e; cas_v = (lcb_cas_t)strtoull(cas, &e, 10); if (*e != '\0') { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_illegal_key_exception, "Invalid CAS specified"); return; } } payload = php_couchbase_zval_to_payload(value, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { RETURN_FALSE; } if (couchbase_res->prefix_key_len) { klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key); } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; couchbase_res->seqno += 1; { lcb_store_cmd_t cmd; lcb_store_cmd_t *commands[] = { &cmd }; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = op; cmd.v.v0.key = key; cmd.v.v0.nkey = klen; cmd.v.v0.bytes = payload; cmd.v.v0.nbytes = payload_len; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exp; cmd.v.v0.cas = (uint64_t)cas_v; retval = lcb_store(couchbase_res->handle, ctx, 1, (const lcb_store_cmd_t * const *)commands); } efree(payload); if (couchbase_res->prefix_key_len) { efree(key); } if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } } else { /* multi */ zval *akeys, **ppzval; char *key = NULL; uint klen = 0; ulong idx; int key_type, nkey = 0; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_FUNCTIONAL, "a|l", &akeys, &expire); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, expire, &exp) == -1) { /* Incorrect expiry time */ return; } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; array_init(ctx->rv); for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys))) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { continue; } switch ((key_type = zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, &idx, 0))) { case HASH_KEY_IS_LONG: spprintf(&key, 0, "%ld", idx); break; case HASH_KEY_IS_STRING: break; default: continue; } if (!(klen = strlen(key))) { continue; } payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { RETURN_FALSE; } if (couchbase_res->prefix_key_len) { char *new_key; klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key); if (key_type == HASH_KEY_IS_LONG) { efree(key); } key = new_key; } { lcb_store_cmd_t cmd; lcb_store_cmd_t *commands[] = { &cmd }; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = op; cmd.v.v0.key = key; cmd.v.v0.nkey = klen; cmd.v.v0.bytes = payload; cmd.v.v0.nbytes = payload_len; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exp; retval = lcb_store(couchbase_res->handle, ctx, 1, (const lcb_store_cmd_t * const *)commands); } efree(payload); if (couchbase_res->prefix_key_len || HASH_KEY_IS_LONG == key_type) { efree(key); } if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } nkey++; } if (!nkey) { efree(ctx); return; } couchbase_res->seqno += nkey; } { pcbc_start_loop(couchbase_res); if (IS_ARRAY != Z_TYPE_P(return_value)) { if (LCB_SUCCESS != ctx->res->rc) { RETVAL_FALSE; switch (op) { case LCB_ADD: if (LCB_KEY_EEXISTS == ctx->res->rc) { break; } case LCB_APPEND: case LCB_PREPEND: if (LCB_NOT_STORED == ctx->res->rc) { break; } case LCB_REPLACE: case LCB_SET: if (LCB_KEY_ENOENT == ctx->res->rc) { break; } if (cas && LCB_KEY_EEXISTS == ctx->res->rc) { break; } default: couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to store a value to server: %s", lcb_strerror(couchbase_res->handle, ctx->res->rc)); break; } } } efree(ctx); } }